+
+In cobigen, there is a fixed setup of JAVASE-1.8 in maven, which leads to the odd that no matter which Java is currently used, eclipse keeps showing JAVASE-1.8. A temporary reconfiguration of JRE in build path will also be overwritten by a maven update.
+
+
+
+Eclipse has a fixed list of execution environments, which is automatically matched with the current most suitable installed JRE, in our case JDK-8 by default. The matching JRE is the actual one, which is used to compile no matter which name eclipse shows
+
+
+
+
+As that, to move to 11, just setup the match JRE of JAVASE-1.8 to 11 or any version you need
+
diff --git a/docs/modules/ROOT/pages/cobigen.wiki/_Footer.adoc b/docs/modules/ROOT/pages/cobigen.wiki/_Footer.adoc
new file mode 100644
index 00000000..3936aa07
--- /dev/null
+++ b/docs/modules/ROOT/pages/cobigen.wiki/_Footer.adoc
@@ -0,0 +1,12 @@
+**Disclaimer**
+
+If you discover any documentation bugs or would like to request new content, please raise them as an link:https://github.com/devonfw/cobigen/issues[issue] or create a pull request.
+Contributions to this wiki are done through the main repo under the folder link:https://github.com/devonfw/cobigen/tree/main/documentation[documentation].
+
+**License**
+
+image:http://i.creativecommons.org/l/by-nd/4.0/88x31.png[]
+
+This documentation is licensed under the link:http://creativecommons.org/licenses/by-nd/4.0/[Creative Commons License (`Attribution-NoDerivatives 4.0 International`)]
+
+//To change the footnote in the pdf, change https://github.com/devonfw/devonfw-docgen/blob/master/src/main/docbook/xsl/cobigen-pdf.xsl
diff --git a/docs/modules/ROOT/pages/cobigen.wiki/_Sidebar.adoc b/docs/modules/ROOT/pages/cobigen.wiki/_Sidebar.adoc
new file mode 100644
index 00000000..799d50a9
--- /dev/null
+++ b/docs/modules/ROOT/pages/cobigen.wiki/_Sidebar.adoc
@@ -0,0 +1,50 @@
+=== Overview
+* link:Home.adocroduction]
+* link:Guide-to-the-Reader.adoc[Guide to the Reader]
+* link:cobigen-usecases.adoc[General CobiGen Use Cases]
+
+==== HowTo's
+* link:howto_angular-client-generation.adoc[Angular Client Generation]
+* link:howto_ionic-client-generation.adoc[Ionic Client Generation]
+* link:howto_EA-client-generation.adoc[Enterprise Architect UML diagram Generation]
+* link:howto_Cobigen-CLI-generation.adoc[CobiGen CLI Manual]
+* link:howto_update_CobiGen.adoc[Update CobiGen]
+* link:howto_devon4net.adoc[.Net generation]
+* link:howto_Release-creation.adoc[Release creation]
+* link:howto_create-external-plugin.adoc[External plugin creation]
+* link:howto-devonfw-ide-CobiGen-PoC-E2E.adoc[End to End POC Code generation using Entity class]
+* link:howto-devonfw-CobiGen-OpenAPI.adoc[End to End POC Code generation using OpenAPI]
+* link:howto-devonfw-adapt_template.adoc[Adapt Template from CobiGen]
+
+=== Configuration
+* link:cobigen-core_configuration.adoc[CobiGen Configuration]
+* link:cobigen-maven_configuration.adoc[Maven Build Plug-in Configuration]
+
+=== Eclipse Integration
+* link:cobigen-eclipse_installation.adoc[Installation]
+* link:cobigen-eclipse_usage.adoc[Usage]
+* link:cobigen-eclipse_logging.adoc[Logging]
+
+=== Core Plug-ins
+* link:cobigen-templates_helpful-links.adoc[Helpful Links]
+* link:cobigen-javaplugin.adoc[Java Plug-in]
+* link:cobigen-xmlplugin.adoc[XML Plug-in]
+* link:cobigen-propertyplugin.adoc[Property Plug-in]
+* link:cobigen-textmerger.adoc[Text Merger Plug-in]
+* link:cobigen-jsonplugin.adoc[JSON Plug-in]
+* link:cobigen-htmlplugin.adoc[HTML Plug-in]
+* link:cobigen-tsplugin.adoc[TypeScript Plug-in]
+* link:cobigen-openapiplugin.adoc[OpenAPI Plug-in]
+
+=== CobiGen Development
+* link:mgmt_ide-setup.adoc[Dev IDE Setup]
+* link:mgmt__release_and_deployment_process.adoc[Release and Deployment Process]
+* link:cobigen-documentation.adoc[Maintaining Documentation]
+* link:mgmt_dependency-and-license-tracking.adoc[License tracking of dependencies]
+* link:guide_dev_troubleshooting.adoc[Troubleshooting]
+* link:setup-jre.adoc[Setup JRE in eclipse]
+
+==== Implementation Docs
+* link:eclipse-plugin_development.adoc[Eclipse-Plugin Development]
+* link:cobigen-core_development.adoc[Core Development]
+* link:howto_create-a-new-plugin.adoc[Adding new plugin]
diff --git a/docs/modules/ROOT/pages/cobigen.wiki/cobigen-core_configuration.adoc b/docs/modules/ROOT/pages/cobigen.wiki/cobigen-core_configuration.adoc
new file mode 100644
index 00000000..6eedbdff
--- /dev/null
+++ b/docs/modules/ROOT/pages/cobigen.wiki/cobigen-core_configuration.adoc
@@ -0,0 +1,353 @@
+:toc:
+toc::[]
+
+==Configuration
+
+CobiGen is maintaining a home directory further referenced in this documentation as `$cghome`, which is used to maintain temporary or transient data. The home folder is determined with the following location fall-back:
+
+1. System environment variable `COBIGEN_HOME` (e.g. `C:\project\ide\conf\cobigen-home`)
+2. `.cobigen` directory in OS user home (e.g. `~/.cobigen`)
+
+The actual configuration of CobiGen is maintained by a single folder or jar. The location can be configured with respect to the implemented configuration fall-back mechanism. CobiGen will search for the location of the configuration in the following order:
+
+1. A configuration jar or directory, which is passed to CobiGen by the Maven or Eclipse integration or any other program using the CobiGen programming interface:
+1.1. the Maven integration allows to configure a jar dependency to be included in the currently running classpath _(of interest for link:cobigen-maven_configuration#plugin-injection-since-v3.adoc[maven configuration]_
+1.2. the Eclipse integration allows to specify a `CobiGen_Templates` project in the eclipse workspace
+2. The file `$cghome/.cobigen` exists and the property `templates` is set to a valid configuration (e.g. `templates=C:\project\ide\conf\templates` or `templates=C:\project\ide\conf\templates.jar`) _Hint: Check for log entry like `Value of property templates in $cghome/.cobigen is invalid` to identify an invalid configuration which is not taken up as expected_
+3. The folder `$cghome/templates/CobiGen_Templates` exists
+4. The lexicographical sorted first configuration jar of the following path pattern `$cghome/templates/templates-([^-]+)-(\\d+\\.?)+.jar` if exists (e.g. `templates-devon4j-2020.04.001`)
+5. CobiGen will automatically download the latest jar configuration from maven central with `groupId` `com.devonfw.cobigen` and `artifactId` `templates-devon4j` and take it like described in 4.
+
+
+Within the configuration jar or directory you will find the following structure:
+
+```
+CobiGen_Templates
+ |- templateFolder1
+ |- templates.xml
+ |- templateFolder2
+ |- templates.xml
+ |- context.xml
+```
+
+Find some examples https://github.com/devonfw/cobigen/tree/master/cobigen-templates[here].
+
+== Context Configuration
+
+The context configuration (`context.xml`) always has the following root structure:
+
+.Context Configuration
+```xml
+
+Brooklyn
277 Bedford Avenue,
Brooklyn, NY 11211,
New York, USA
+
+
+
+
+
+
+ Getting Started with EF Core on ASP.NET Core with an Existing Database
+
+
+
+
+
+ 5 minutes to read
+ Contributors
+
+
+
+
+
+ -
+
+ 
+ 
+
+
+
+
+
Important
The .NET Core SDK no longer supports project.json or Visual Studio 2015. Everyone doing .NET Core development is encouraged to migrate from project.json to csproj and Visual Studio 2017.+
+
+
In this walkthrough, you will build an ASP.NET Core MVC application that performs basic data access using Entity Framework. You will use reverse engineering to create an Entity Framework model based on an existing database.+ + +
+ +Prerequisites
+The following prerequisites are needed to complete this walkthrough:+ + +
+-
+
- Visual Studio 2017 15.3 with these workloads:
-
+
- ASP.NET and web development (under Web & Cloud) +
- .NET Core cross-platform development (under Other Toolsets) +
+ - .NET Core 2.0 SDK. +
- Blogging database ++ + +
Blogging database
+This tutorial uses a Blogging database on your LocalDb instance as the existing database.+ + +
+Tip
If you have already created the Blogging database as part of another tutorial, you can skip these steps.+ + +
+-
+
- Open Visual Studio +
- Tools -> Connect to Database... +
- Select Microsoft SQL Server and click Continue +
- Enter (localdb)\mssqllocaldb as the Server Name +
- Enter master as the Database Name and click OK +
- The master database is now displayed under Data Connections in Server Explorer +
- Right-click on the database in Server Explorer and select New Query +
- Copy the script, listed below, into the query editor +
- Right-click on the query editor and select Execute ++ + +
SQL
CREATE DATABASE [Blogging];
+GO
+
+USE [Blogging];
+GO
+
+CREATE TABLE [Blog] (
+ [BlogId] int NOT NULL IDENTITY,
+ [Url] nvarchar(max) NOT NULL,
+ CONSTRAINT [PK_Blog] PRIMARY KEY ([BlogId])
+);
+GO
+
+CREATE TABLE [Post] (
+ [PostId] int NOT NULL IDENTITY,
+ [BlogId] int NOT NULL,
+ [Content] nvarchar(max),
+ [Title] nvarchar(max),
+ CONSTRAINT [PK_Post] PRIMARY KEY ([PostId]),
+ CONSTRAINT [FK_Post_Blog_BlogId] FOREIGN KEY ([BlogId]) REFERENCES [Blog] ([BlogId]) ON DELETE CASCADE
+);
+GO
+
+INSERT INTO [Blog] (Url) VALUES
+('http://blogs.msdn.com/dotnet'),
+('http://blogs.msdn.com/webdev'),
+('http://blogs.msdn.com/visualstudio')
+GO
+Create a new project
+-
+
- Open Visual Studio 2017 +
- File -> New -> Project... +
- From the left menu select Installed -> Templates -> Visual C# -> Web +
- Select the ASP.NET Core Web Application (.NET Core) project template +
- Enter EFGetStarted.AspNetCore.ExistingDb as the name and click OK +
- Wait for the New ASP.NET Core Web Application dialog to appear +
- Under ASP.NET Core Templates 2.0 select the Web Application (Model-View-Controller) +
- Ensure that Authentication is set to No Authentication +
- Click OK ++ + +
Install Entity Framework
+To use EF Core, install the package for the database provider(s) you want to target. This walkthrough uses SQL Server. For a list of available providers see Database Providers.3 +
+-
+
Tools > NuGet Package Manager > Package Manager Console
+
+Run
+Install-Package Microsoft.EntityFrameworkCore.SqlServer
+2
+
We will be using some Entity Framework Tools to create a model from the database. So we will install the tools package as well:+ + +
+-
+
- Run
Install-Package Microsoft.EntityFrameworkCore.Tools
++
+
+
We will be using some ASP.NET Core Scaffolding tools to create controllers and views later on. So we will install this design package as well:+ + +
+-
+
- Run
Install-Package Microsoft.VisualStudio.Web.CodeGeneration.Design
++
+
+
Reverse engineer your model
+Now it's time to create the EF model based on your existing database.+ + +
+-
+
- Tools –> NuGet Package Manager –> Package Manager Console +
- Run the following command to create a model from the existing database. If you receive an error stating
The term 'Scaffold-DbContext' is not recognized as the name of a cmdlet, then close and reopen Visual Studio.
+19
+
console
Scaffold-DbContext "Server=(localdb)\mssqllocaldb;Database=Blogging;Trusted_Connection=True;" Microsoft.EntityFrameworkCore.SqlServer -OutputDir Models
+The reverse engineer process created entity classes (Blog.cs & Post.cs) and a derived context (BloggingContext.cs) based on the schema of the existing database.+
+
+
The entity classes are simple C# objects that represent the data you will be querying and saving.+ + +
+C#
using System;
+using System.Collections.Generic;
+
+namespace EFGetStarted.AspNetCore.ExistingDb.Models
+{
+ public partial class Blog
+ {
+ public Blog()
+ {
+ Post = new HashSet<Post>();
+ }
+
+ public int BlogId { get; set; }
+ public string Url { get; set; }
+
+ public virtual ICollection<Post> Post { get; set; }
+ }
+}
+The context represents a session with the database and allows you to query and save instances of the entity classes.+ + +
+ +C#
public partial class BloggingContext : DbContext
+{
+ public virtual DbSet<Blog> Blog { get; set; }
+ public virtual DbSet<Post> Post { get; set; }
+
+ protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+ {
+ if (!optionsBuilder.IsConfigured)
+ {
+ #warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
+ optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=Blogging;Trusted_Connection=True;");
+ }
+ }
+
+ protected override void OnModelCreating(ModelBuilder modelBuilder)
+ {
+ modelBuilder.Entity<Blog>(entity =>
+ {
+ entity.Property(e => e.Url).IsRequired();
+ });
+
+ modelBuilder.Entity<Post>(entity =>
+ {
+ entity.HasOne(d => d.Blog)
+ .WithMany(p => p.Post)
+ .HasForeignKey(d => d.BlogId);
+ });
+ }
+}
+Register your context with dependency injection
+The concept of dependency injection is central to ASP.NET Core. Services (such as BloggingContext) are registered with dependency injection during application startup. Components that require these services (such as your MVC controllers) are then provided these services via constructor parameters or properties. For more information on dependency injection see the Dependency Injection article on the ASP.NET site.+
+
+
Remove inline context configuration
+In ASP.NET Core, configuration is generally performed in Startup.cs. To conform to this pattern, we will move configuration of the database provider to Startup.cs.1 +
+-
+
- Open
Models\BloggingContext.cs
+ - Delete the
OnConfiguring(...)method
+2
+
C#
protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
+{
+ #warning To protect potentially sensitive information in your connection string, you should move it out of source code. See http://go.microsoft.com/fwlink/?LinkId=723263 for guidance on storing connection strings.
+ optionsBuilder.UseSqlServer(@"Server=(localdb)\mssqllocaldb;Database=Blogging;Trusted_Connection=True;");
+}
+-
+
- Add the following constructor, which will allow configuration to be passed into the context by dependency injection ++ + +
C#
public BloggingContext(DbContextOptions<BloggingContext> options)
+ : base(options)
+{ }
+Register and configure your context in Startup.cs
+In order for our MVC controllers to make use of BloggingContext we are going to register it as a service.+
+
+
-
+
- Open Startup.cs +
- Add the following
usingstatements at the start of the file
++
+
+
C#
using EFGetStarted.AspNetCore.ExistingDb.Models;
+using Microsoft.EntityFrameworkCore;
+Now we can use the AddDbContext(...) method to register it as a service.+
+
+
-
+
- Locate the
ConfigureServices(...)method
+ - Add the following code to register the context as a service ++ + +
C#
// This method gets called by the runtime. Use this method to add services to the container.
+public void ConfigureServices(IServiceCollection services)
+{
+ services.AddMvc();
+
+ var connection = @"Server=(localdb)\mssqllocaldb;Database=Blogging;Trusted_Connection=True;";
+ services.AddDbContext<BloggingContext>(options => options.UseSqlServer(connection));
+}
+Tip
In a real application you would typically put the connection string in a configuration file. For the sake of simplicity, we are defining it in code. For more information, see Connection Strings.+ + +
+Create a controller
+Next, we'll enable scaffolding in our project.+ + +
+-
+
- Right-click on the Controllers folder in Solution Explorer and select Add -> Controller... +
- Select Full Dependencies and click Add +
- You can ignore the instructions in the
ScaffoldingReadMe.txtfile that opens
+2
+
Now that scaffolding is enabled, we can scaffold a controller for the Blog entity.+
+
+
-
+
- Right-click on the Controllers folder in Solution Explorer and select Add -> Controller... +
- Select MVC Controller with views, using Entity Framework and click Ok +
- Set Model class to Blog and Data context class to BloggingContext +
- Click Add +3 +
Run the application
+You can now run the application to see it in action.+ + +
+-
+
- Debug -> Start Without Debugging +
- The application will build and open in a web browser +
- Navigate to
/Blogs
+ - Click Create New +
- Enter a Url for the new blog and click Create ++ + +
+
+
+
+
+
+