Merge remote-tracking branch 'remotes/origin/master' into dev

# Conflicts:
#	src/Backend/Jp.Infra.CrossCutting.Database/DbSettingsConfig.cs
#	src/Backend/Jp.UserManagement/appsettings.json
#	src/Frontend/Jp.UI.SSO/appsettings.json

Author: brunobritodev

.gitignore

@@ -253,4 +253,5 @@ docs/_build
 docs/.vscode
 
 # Log files
-**/*log*.txt
+**/*log*.txt
+*.db

admin-ui.dockerfile

@@ -1,5 +1,5 @@
 # base image
-FROM node:10-alpine as builder
+FROM node:12.7-alpine as builder
 
 # install and cache app dependencies
 COPY ["src/Frontend/Jp.AdminUI/package.json", "./"]
@@ -24,7 +24,7 @@ RUN npm run ng build -- --configuration=docker
 ##################
 
 # base image
-FROM nginx:1.13.3-alpine
+FROM nginx:1.17.2-alpine
 
 ## Remove default nginx website
 RUN rm -rf /usr/share/nginx/html/*

src/Backend/Jp.Infra.CrossCutting.Database/DbSettingsConfig.cs

@@ -4,6 +4,7 @@
 using Jp.Infra.Data.PostgreSQL.Configuration;
 using Jp.Infra.Data.Sql.Configuration;
 using Microsoft.AspNetCore.Identity;
+using Jp.Infra.Data.Sqlite.Configuration;
 using Microsoft.Extensions.Configuration;
 using Microsoft.Extensions.DependencyInjection;
 
@@ -26,10 +27,10 @@ public static void ConfigureDatabase(this IServiceCollection services, IConfigur
                 case "POSTGRESQL":
                     services.AddIdentityPostgreSql(connString);
                     break;
+                case "SQLITE":
+                    services.AddIdentitySqlite(connString);
+                    break;
             }
-            services.AddIdentity<UserIdentity, UserIdentityRole>()
-                .AddEntityFrameworkStores<ApplicationIdentityContext>()
-                .AddDefaultTokenProviders();
         }
 
         public static void ConfigureIdentityServerDatabase(this IIdentityServerBuilder builder, IConfiguration configuration)
@@ -47,6 +48,9 @@ public static void ConfigureIdentityServerDatabase(this IIdentityServerBuilder b
                 case "POSTGRESQL":
                     builder.UseIdentityServerPostgreSqlDatabase(connString);
                     break;
+                case "SQLITE":
+                    builder.UseIdentityServerSqlite(connString);
+                    break;
             }
         }
     }

src/Backend/Jp.Infra.CrossCutting.Database/Jp.Infra.CrossCutting.Database.csproj

@@ -16,6 +16,7 @@
   <ItemGroup>
     <ProjectReference Include="..\Jp.Infra.Data.MySql\Jp.Infra.Data.MySql.csproj" />
     <ProjectReference Include="..\Jp.Infra.Data.PostgreSQL\Jp.Infra.Data.PostgreSQL.csproj" />
+    <ProjectReference Include="..\Jp.Infra.Data.Sqlite\Jp.Infra.Data.Sqlite.csproj" />
     <ProjectReference Include="..\Jp.Infra.Data.Sql\Jp.Infra.Data.Sql.csproj" />
   </ItemGroup>
 </Project>

src/Backend/Jp.Infra.Data.Sqlite/Configuration/IdentityConfig.cs

@@ -0,0 +1,34 @@
+using IdentityServer4.EntityFramework.Options;
+using Jp.Infra.CrossCutting.Identity.Context;
+using Jp.Infra.CrossCutting.Identity.Entities.Identity;
+using Jp.Infra.Data.Context;
+using Microsoft.AspNetCore.Identity;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using System.Reflection;
+
+namespace Jp.Infra.Data.Sqlite.Configuration
+{
+    public static class IdentityConfig
+    {
+        public static IServiceCollection AddIdentitySqlite(this IServiceCollection services, string connectionString)
+        {
+            var migrationsAssembly = typeof(IdentityConfig).GetTypeInfo().Assembly.GetName().Name;
+
+            var operationalStoreOptions = new OperationalStoreOptions();
+            services.AddSingleton(operationalStoreOptions);
+
+            var storeOptions = new ConfigurationStoreOptions();
+            services.AddSingleton(storeOptions);
+
+            services.AddEntityFrameworkSqlite().AddDbContext<ApplicationIdentityContext>(options => options.UseSqlite(connectionString, sql => sql.MigrationsAssembly(migrationsAssembly)));
+            services.AddDbContext<JpContext>(options => options.UseSqlite(connectionString, sql => sql.MigrationsAssembly(migrationsAssembly)));
+            services.AddDbContext<EventStoreContext>(options => options.UseSqlite(connectionString, sql => sql.MigrationsAssembly(migrationsAssembly)));
+
+            services.AddIdentity<UserIdentity, UserIdentityRole>()
+                .AddEntityFrameworkStores<ApplicationIdentityContext>()
+                .AddDefaultTokenProviders();
+            return services;
+        }
+    }
+}

src/Backend/Jp.Infra.Data.Sqlite/Configuration/IdentityServerConfig.cs

@@ -0,0 +1,34 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using System.Reflection;
+
+namespace Jp.Infra.Data.Sqlite.Configuration
+{
+    public static class IdentityServerConfig
+    {
+        public static IIdentityServerBuilder UseIdentityServerSqlite(this IIdentityServerBuilder builder, string connectionString)
+        {
+            var migrationsAssembly = typeof(IdentityServerConfig).GetTypeInfo().Assembly.GetName().Name;
+
+            // this adds the config data from DB (clients, resources)
+            builder.AddConfigurationStore(options =>
+                {
+                    options.ConfigureDbContext = b =>
+                        b.UseSqlite(connectionString, sql => sql.MigrationsAssembly(migrationsAssembly));
+                })
+                // this adds the operational data from DB (codes, tokens, consents)
+                .AddOperationalStore(options =>
+                {
+                    options.ConfigureDbContext = b =>
+                        b.UseSqlite(connectionString, sql => sql.MigrationsAssembly(migrationsAssembly));
+
+                    // this enables automatic token cleanup. this is optional.
+                    options.EnableTokenCleanup = true;
+                    options.TokenCleanupInterval = 15; // frequency in seconds to cleanup stale grants. 15 is useful during debugging
+                });
+
+            return builder;
+        }
+
+    }
+}

src/Backend/Jp.Infra.Data.Sqlite/Jp.Infra.Data.Sqlite.csproj

@@ -0,0 +1,19 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" Version="2.2.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Jp.Infra.CrossCutting.Identity\Jp.Infra.CrossCutting.Identity.csproj" />
+    <ProjectReference Include="..\Jp.Infra.Data\Jp.Infra.Data.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Folder Include="Migrations\" />
+  </ItemGroup>
+</Project>

src/Backend/Jp.Infra.Data.Sqlite/Migrations/EventStore/20190828141939_Initial.Designer.cs

@@ -0,0 +1,33 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace Jp.Infra.Data.Sqlite.Migrations.EventStore
+{
+    public partial class Initial : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "StoredEvent",
+                columns: table => new
+                {
+                    Id = table.Column<Guid>(nullable: false),
+                    Action = table.Column<string>(type: "varchar(100)", nullable: true),
+                    AggregateId = table.Column<string>(nullable: true),
+                    CreationDate = table.Column<DateTime>(nullable: false),
+                    Data = table.Column<string>(nullable: true),
+                    User = table.Column<string>(nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_StoredEvent", x => x.Id);
+                });
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "StoredEvent");
+        }
+    }
+}

src/Backend/Jp.Infra.Data.Sqlite/Migrations/EventStore/20190828141939_Initial.cs

@@ -0,0 +1,44 @@
+// <auto-generated />
+using System;
+using Jp.Infra.Data.Context;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+
+namespace Jp.Infra.Data.Sqlite.Migrations.EventStore
+{
+    [DbContext(typeof(EventStoreContext))]
+    partial class EventStoreContextModelSnapshot : ModelSnapshot
+    {
+        protected override void BuildModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "2.2.6-servicing-10079");
+
+            modelBuilder.Entity("Jp.Domain.Core.Events.StoredEvent", b =>
+                {
+                    b.Property<Guid>("Id")
+                        .ValueGeneratedOnAdd();
+
+                    b.Property<string>("AggregateId");
+
+                    b.Property<string>("Data");
+
+                    b.Property<string>("MessageType")
+                        .HasColumnName("Action")
+                        .HasColumnType("varchar(100)");
+
+                    b.Property<DateTime>("Timestamp")
+                        .HasColumnName("CreationDate");
+
+                    b.Property<string>("User");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("StoredEvent");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}