From 760ea09f83bbe54aa5565580fb59fabd4e63dafa Mon Sep 17 00:00:00 2001
From: Hesam Asnaashari <46031836+ilhesam@users.noreply.github.com>
Date: Fri, 20 Jan 2023 10:15:56 +0330
Subject: [PATCH] refac - remove build service provider

---
 src/Common/uBeac.Core.Common/IDataSeeder.cs   |  6 ++
 src/Examples/Identity.MongoDB.API/Program.cs  |  2 +
 .../Extensions/RoleExtensions.cs              | 59 ++++------------
 .../Extensions/UnitExtensions.cs              | 67 +++++--------------
 .../Extensions/UnitTypeExtensions.cs          | 54 ++++-----------
 .../Extensions/UserExtensions.cs              | 55 ++++-----------
 .../uBeac.Core.Identity/Seeders/RoleSeeder.cs | 38 +++++++++++
 .../uBeac.Core.Identity/Seeders/UnitSeeder.cs | 41 ++++++++++++
 .../Seeders/UnitTypeSeeder.cs                 | 38 +++++++++++
 .../uBeac.Core.Identity/Seeders/UserSeeder.cs | 46 +++++++++++++
 .../uBeac.Core.Logging/AppContextEnricher.cs  | 33 ---------
 .../ApplicationExtensions.cs                  | 18 ++++-
 12 files changed, 241 insertions(+), 216 deletions(-)
 create mode 100644 src/Common/uBeac.Core.Common/IDataSeeder.cs
 create mode 100644 src/Identity/uBeac.Core.Identity/Seeders/RoleSeeder.cs
 create mode 100644 src/Identity/uBeac.Core.Identity/Seeders/UnitSeeder.cs
 create mode 100644 src/Identity/uBeac.Core.Identity/Seeders/UnitTypeSeeder.cs
 create mode 100644 src/Identity/uBeac.Core.Identity/Seeders/UserSeeder.cs
 delete mode 100644 src/Logging/uBeac.Core.Logging/AppContextEnricher.cs

diff --git a/src/Common/uBeac.Core.Common/IDataSeeder.cs b/src/Common/uBeac.Core.Common/IDataSeeder.cs
new file mode 100644
index 00000000..869a5e24
--- /dev/null
+++ b/src/Common/uBeac.Core.Common/IDataSeeder.cs
@@ -0,0 +1,6 @@
+namespace uBeac;
+
+public interface IDataSeeder
+{
+    Task SeedAsync(CancellationToken cancellationToken = default);
+}
diff --git a/src/Examples/Identity.MongoDB.API/Program.cs b/src/Examples/Identity.MongoDB.API/Program.cs
index 133eca42..00a186e5 100644
--- a/src/Examples/Identity.MongoDB.API/Program.cs
+++ b/src/Examples/Identity.MongoDB.API/Program.cs
@@ -107,6 +107,8 @@
 
 var app = builder.Build();
 
+app.SeedData();
+
 app.UseHttpsRedirection();
 app.UseHstsOnProduction(builder.Environment);
 app.UseCorsPolicy(corsPolicyOptions);
diff --git a/src/Identity/uBeac.Core.Identity/Extensions/RoleExtensions.cs b/src/Identity/uBeac.Core.Identity/Extensions/RoleExtensions.cs
index 7f38d55e..a60e5189 100644
--- a/src/Identity/uBeac.Core.Identity/Extensions/RoleExtensions.cs
+++ b/src/Identity/uBeac.Core.Identity/Extensions/RoleExtensions.cs
@@ -1,5 +1,7 @@
 using Microsoft.AspNetCore.Identity;
+using uBeac;
 using uBeac.Identity;
+using uBeac.Identity.Seeders;
 
 namespace Microsoft.Extensions.DependencyInjection;
 
@@ -35,12 +37,10 @@ public static IdentityBuilder AddIdentityRole<TRoleKey, TRole>(this IdentityBuil
         if (configureOptions is not null)
         {
             // Register options
-            var options = builder.Services.RegisterRoleOptions(configureOptions);
+            builder.Services.RegisterRoleOptions(configureOptions);
 
             // Insert default values
-            builder.Services.BuildServiceProvider().CreateScope().ServiceProvider
-                .GetRequiredService<IRoleService<TRoleKey, TRole>>()
-                .InsertDefaultRoles(options.DefaultValues);
+            builder.Services.AddScoped<IDataSeeder, RoleSeeder<TRoleKey, TRole>>();
         }
 
         return builder;
@@ -49,7 +49,6 @@ public static IdentityBuilder AddIdentityRole<TRoleKey, TRole>(this IdentityBuil
     public static IdentityBuilder AddIdentityRole<TRole>(this IdentityBuilder builder, Action<RoleOptions<TRole>> configureOptions = default)
         where TRole : Role
     {
-
         // Configure AspNetIdentity
         builder
             .AddRoles<TRole>()
@@ -59,12 +58,10 @@ public static IdentityBuilder AddIdentityRole<TRole>(this IdentityBuilder builde
         if (configureOptions is not null)
         {
             // Register options
-            var options = builder.Services.RegisterRoleOptions(configureOptions);
-
+            builder.Services.RegisterRoleOptions(configureOptions);
+            
             // Insert default values
-            builder.Services.BuildServiceProvider().CreateScope().ServiceProvider
-                .GetRequiredService<IRoleService<TRole>>()
-                .InsertDefaultRoles(options.DefaultValues);
+            builder.Services.AddScoped<IDataSeeder, RoleSeeder<TRole>>();
         }
 
         return builder;
@@ -74,12 +71,12 @@ private static RoleOptions<TRoleKey, TRole> RegisterRoleOptions<TRoleKey, TRole>
         where TRoleKey : IEquatable<TRoleKey>
         where TRole : Role<TRoleKey>
     {
+        var options = new RoleOptions<TRoleKey, TRole>();
+        configureOptions(options);
+        
         // Register IOptions<RoleOptions<,>>
         services.Configure(configureOptions);
 
-        // Get RoleOptions<,> from ServiceProvider
-        var options = services.BuildServiceProvider().GetRequiredService<Options.IOptions<RoleOptions<TRoleKey, TRole>>>().Value;
-
         // Register RoleOptions<,> without IOptions
         services.AddSingleton<RoleOptions<TRoleKey, TRole>>(options);
 
@@ -89,43 +86,15 @@ private static RoleOptions<TRoleKey, TRole> RegisterRoleOptions<TRoleKey, TRole>
     private static RoleOptions<TRole> RegisterRoleOptions<TRole>(this IServiceCollection services, Action<RoleOptions<TRole>> configureOptions)
         where TRole : Role
     {
+        var options = new RoleOptions<TRole>();
+        configureOptions(options);
+        
         // Register IOptions<RoleOptions<,>>
         services.Configure(configureOptions);
 
-        // Get RoleOptions<,> from ServiceProvider
-        var options = services.BuildServiceProvider().GetRequiredService<Options.IOptions<RoleOptions<TRole>>>().Value;
-
         // Register RoleOptions<,> without IOptions
         services.AddSingleton<RoleOptions<TRole>>(options);
 
         return options;
     }
-
-    private static void InsertDefaultRoles<TRoleKey, TRole>(this IRoleService<TRoleKey, TRole> service, IEnumerable<TRole> values)
-        where TRoleKey : IEquatable<TRoleKey>
-        where TRole : Role<TRoleKey>
-    {
-        if (values is null || values.Any() is false) return;
-        foreach (var role in values)
-        {
-            try
-            {
-                // If role was not inserted before, insert it
-                if (service.Exists(role.Name).Result is false)
-                {
-                    service.Create(role).Wait();
-                }
-            }
-            catch (Exception)
-            {
-                // ignored
-            }
-        }
-    }
-
-    private static void InsertDefaultRoles<TRole>(this IRoleService<TRole> service, IEnumerable<TRole> values)
-        where TRole : Role
-    {
-        service.InsertDefaultRoles<Guid, TRole>(values);
-    }
-}
\ No newline at end of file
+}
diff --git a/src/Identity/uBeac.Core.Identity/Extensions/UnitExtensions.cs b/src/Identity/uBeac.Core.Identity/Extensions/UnitExtensions.cs
index 79b0ec52..b4f3da87 100644
--- a/src/Identity/uBeac.Core.Identity/Extensions/UnitExtensions.cs
+++ b/src/Identity/uBeac.Core.Identity/Extensions/UnitExtensions.cs
@@ -1,5 +1,7 @@
 using Microsoft.AspNetCore.Identity;
+using uBeac;
 using uBeac.Identity;
+using uBeac.Identity.Seeders;
 
 namespace Microsoft.Extensions.DependencyInjection;
 
@@ -29,12 +31,10 @@ public static IdentityBuilder AddIdentityUnit<TUnitKey, TUnit>(this IdentityBuil
         if (configureOptions is not null)
         {
             // Register options
-            var options = builder.Services.RegisterUnitOptions(configureOptions);
+            builder.Services.RegisterUnitOptions(configureOptions);
 
             // Insert default values
-            builder.Services.BuildServiceProvider().CreateScope().ServiceProvider
-                .GetRequiredService<IUnitService<TUnitKey, TUnit>>()
-                .InsertDefaultUnits(options.DefaultValues);
+            builder.Services.AddScoped<IDataSeeder, UnitSeeder<TUnitKey, TUnit>>();
         }
 
         return builder;
@@ -46,12 +46,10 @@ public static IdentityBuilder AddIdentityUnit<TUnit>(this IdentityBuilder builde
         if (configureOptions is not null)
         {
             // Register options
-            var options = builder.Services.RegisterUnitOptions(configureOptions);
+            builder.Services.RegisterUnitOptions(configureOptions);
 
             // Insert default values
-            builder.Services.BuildServiceProvider().CreateScope().ServiceProvider
-                .GetRequiredService<IUnitService<TUnit>>()
-                .InsertDefaultUnits(options.DefaultValues);
+            builder.Services.AddScoped<IDataSeeder, UnitSeeder<TUnit>>();
         }
 
         return builder;
@@ -61,12 +59,12 @@ private static UnitOptions<TUnitKey, TUnit> RegisterUnitOptions<TUnitKey, TUnit>
         where TUnitKey : IEquatable<TUnitKey>
         where TUnit : Unit<TUnitKey>
     {
+        var options = new UnitOptions<TUnitKey, TUnit>();
+        configureOptions(options);
+
         // Register IOptions<UnitOptions<,>>
         services.Configure(configureOptions);
-
-        // Get UnitOptions<,> from ServiceProvider
-        var options = services.BuildServiceProvider().GetRequiredService<Options.IOptions<UnitOptions<TUnitKey, TUnit>>>().Value;
-
+        
         // Register UnitOptions<,> without IOptions
         services.AddSingleton<UnitOptions<TUnitKey, TUnit>>(options);
 
@@ -76,50 +74,15 @@ private static UnitOptions<TUnitKey, TUnit> RegisterUnitOptions<TUnitKey, TUnit>
     private static UnitOptions<TUnit> RegisterUnitOptions<TUnit>(this IServiceCollection services, Action<UnitOptions<TUnit>> configureOptions)
         where TUnit : Unit
     {
+        var options = new UnitOptions<TUnit>();
+        configureOptions(options);
+
         // Register IOptions<UnitOptions<,>>
         services.Configure(configureOptions);
-
-        // Get UnitOptions<,> from ServiceProvider
-        var options = services.BuildServiceProvider().GetRequiredService<Options.IOptions<UnitOptions<TUnit>>>().Value;
-
+        
         // Register UnitOptions<,> without IOptions
         services.AddSingleton<UnitOptions<TUnit>>(options);
 
         return options;
     }
-
-    private static void InsertDefaultUnits<TUnitKey, TUnit>(this IUnitService<TUnitKey, TUnit> service, IEnumerable<TUnit> values)
-        where TUnitKey : IEquatable<TUnitKey>
-        where TUnit : Unit<TUnitKey>
-    {
-        if (values is null || values.Any() is false) return;
-
-        // Insert default values
-        foreach (var unit in values)
-        {
-            try
-            {
-                // If unit was not inserted before, insert it
-                if (service.Exists(unit.Code, unit.Type).Result is false)
-                {
-                    // Set parent id
-                    var parent = unit.GetParentUnit();
-                    if (parent != null) unit.ParentUnitId = parent.Id;
-
-                    // Insert
-                    service.Create(unit).Wait();
-                }
-            }
-            catch (Exception)
-            {
-                // ignored
-            }
-        }
-    }
-
-    private static void InsertDefaultUnits<TUnit>(this IUnitService<TUnit> service, IEnumerable<TUnit> values)
-        where TUnit : Unit
-    {
-        service.InsertDefaultUnits<Guid, TUnit>(values);
-    }
-}
\ No newline at end of file
+}
diff --git a/src/Identity/uBeac.Core.Identity/Extensions/UnitTypeExtensions.cs b/src/Identity/uBeac.Core.Identity/Extensions/UnitTypeExtensions.cs
index 7e74861d..0fad25ee 100644
--- a/src/Identity/uBeac.Core.Identity/Extensions/UnitTypeExtensions.cs
+++ b/src/Identity/uBeac.Core.Identity/Extensions/UnitTypeExtensions.cs
@@ -1,5 +1,7 @@
 using Microsoft.AspNetCore.Identity;
+using uBeac;
 using uBeac.Identity;
+using uBeac.Identity.Seeders;
 
 namespace Microsoft.Extensions.DependencyInjection;
 
@@ -29,12 +31,10 @@ public static IdentityBuilder AddIdentityUnitType<TUnitTypeKey, TUnitType>(this
         if (configureOptions is not null)
         {
             // Register options
-            var options = builder.Services.RegisterUnitTypeOptions(configureOptions);
+            builder.Services.RegisterUnitTypeOptions(configureOptions);
 
             // Insert default values
-            builder.Services.BuildServiceProvider().CreateScope().ServiceProvider
-                .GetRequiredService<IUnitTypeService<TUnitTypeKey, TUnitType>>()
-                .InsertDefaultUnitTypes(options.DefaultValues);
+            builder.Services.AddScoped<IDataSeeder, UnitTypeSeeder<TUnitTypeKey, TUnitType>>();
         }
 
         return builder;
@@ -46,12 +46,10 @@ public static IdentityBuilder AddIdentityUnitType<TUnitType>(this IdentityBuilde
         if (configureOptions is not null)
         {
             // Register options
-            var options = builder.Services.RegisterUnitTypeOptions(configureOptions);
+            builder.Services.RegisterUnitTypeOptions(configureOptions);
 
             // Insert default values
-            builder.Services.BuildServiceProvider().CreateScope().ServiceProvider
-                .GetRequiredService<IUnitTypeService<TUnitType>>()
-                .InsertDefaultUnitTypes(options.DefaultValues);
+            builder.Services.AddScoped<IDataSeeder, UnitTypeSeeder<TUnitType>>();
         }
 
         return builder;
@@ -61,12 +59,12 @@ private static UnitTypeOptions<TUnitTypeKey, TUnitType> RegisterUnitTypeOptions<
         where TUnitTypeKey : IEquatable<TUnitTypeKey>
         where TUnitType : UnitType<TUnitTypeKey>
     {
+        var options = new UnitTypeOptions<TUnitTypeKey, TUnitType>();
+        configureOptions(options);
+
         // Register IOptions<UnitTypeOptions<,>>
         services.Configure(configureOptions);
 
-        // Get UnitTypeOptions<,> from ServiceProvider
-        var options = services.BuildServiceProvider().GetRequiredService<Options.IOptions<UnitTypeOptions<TUnitTypeKey, TUnitType>>>().Value;
-
         // Register UnitTypeOptions<,> without IOptions
         services.AddSingleton<UnitTypeOptions<TUnitTypeKey, TUnitType>>(options);
 
@@ -76,43 +74,15 @@ private static UnitTypeOptions<TUnitTypeKey, TUnitType> RegisterUnitTypeOptions<
     private static UnitTypeOptions<TUnitType> RegisterUnitTypeOptions<TUnitType>(this IServiceCollection services, Action<UnitTypeOptions<TUnitType>> configureOptions)
         where TUnitType : UnitType
     {
+        var options = new UnitTypeOptions<TUnitType>();
+        configureOptions(options);
+
         // Register IOptions<UnitTypeOptions<,>>
         services.Configure(configureOptions);
 
-        // Get UnitTypeOptions<,> from ServiceProvider
-        var options = services.BuildServiceProvider().GetRequiredService<Options.IOptions<UnitTypeOptions<TUnitType>>>().Value;
-
         // Register UnitTypeOptions<,> without IOptions
         services.AddSingleton<UnitTypeOptions<TUnitType>>(options);
 
         return options;
     }
-
-    private static void InsertDefaultUnitTypes<TUnitTypeKey, TUnitType>(this IUnitTypeService<TUnitTypeKey, TUnitType> service, IEnumerable<TUnitType> values)
-        where TUnitTypeKey : IEquatable<TUnitTypeKey>
-        where TUnitType : UnitType<TUnitTypeKey>
-    {
-        if (values is null || values.Any() is false) return;
-        foreach (var unitType in values)
-        {
-            try
-            {
-                // If unit type was not inserted before, insert it
-                if (service.Exists(unitType.Code).Result is false)
-                {
-                    service.Create(unitType).Wait();
-                }
-            }
-            catch (Exception)
-            {
-                // ignored
-            }
-        }
-    }
-
-    private static void InsertDefaultUnitTypes<TUnitType>(this IUnitTypeService<TUnitType> service, IEnumerable<TUnitType> values)
-        where TUnitType : UnitType
-    {
-        service.InsertDefaultUnitTypes<Guid, TUnitType>(values);
-    }
 }
\ No newline at end of file
diff --git a/src/Identity/uBeac.Core.Identity/Extensions/UserExtensions.cs b/src/Identity/uBeac.Core.Identity/Extensions/UserExtensions.cs
index 7bec7ede..24f75e33 100644
--- a/src/Identity/uBeac.Core.Identity/Extensions/UserExtensions.cs
+++ b/src/Identity/uBeac.Core.Identity/Extensions/UserExtensions.cs
@@ -1,6 +1,8 @@
 using Microsoft.AspNetCore.Identity;
 using Microsoft.Extensions.Configuration;
+using uBeac;
 using uBeac.Identity;
+using uBeac.Identity.Seeders;
 
 namespace Microsoft.Extensions.DependencyInjection;
 
@@ -39,13 +41,10 @@ public static IdentityBuilder AddIdentityUser<TUserKey, TUser>(this IServiceColl
         if (configureOptions is not null)
         {
             // Register options
-            var options = builder.Services.RegisterUserOptions(configureOptions);
+            builder.Services.RegisterUserOptions(configureOptions);
 
             // Insert default values
-            var scope = builder.Services.BuildServiceProvider().CreateScope();
-            var userService = scope.ServiceProvider.GetRequiredService<IUserService<TUserKey, TUser>>();
-            var userRoleService = scope.ServiceProvider.GetRequiredService<IUserRoleService<TUserKey, TUser>>();
-            userService.InsertAdminUserAndAssignRole(userRoleService, options.AdminRole, options.AdminUser, options.AdminPassword);
+            builder.Services.AddScoped<IDataSeeder, UserSeeder<TUserKey, TUser>>();
         }
 
         return builder;
@@ -65,13 +64,10 @@ public static IdentityBuilder AddIdentityUser<TUser>(this IServiceCollection ser
         if (configureOptions is not null)
         {
             // Register options
-            var options = builder.Services.RegisterUserOptions(configureOptions);
+            builder.Services.RegisterUserOptions(configureOptions);
 
             // Insert default values
-            var scope = builder.Services.BuildServiceProvider().CreateScope();
-            var userService = scope.ServiceProvider.GetRequiredService<IUserService<TUser>>();
-            var userRoleService = scope.ServiceProvider.GetRequiredService<IUserRoleService<TUser>>();
-            userService.InsertAdminUserAndAssignRole(userRoleService, options.AdminRole, options.AdminUser, options.AdminPassword);
+            builder.Services.AddScoped<IDataSeeder, UserSeeder<TUser>>();
         }
 
         return builder;
@@ -113,12 +109,12 @@ private static UserOptions<TUserKey, TUser> RegisterUserOptions<TUserKey, TUser>
         where TUserKey : IEquatable<TUserKey>
         where TUser : User<TUserKey>
     {
+        var options = new UserOptions<TUserKey, TUser>();
+        configureOptions(options);
+
         // Register IOptions<UserOptions<,>>
         services.Configure(configureOptions);
 
-        // Get UserOptions<,> from ServiceProvider
-        var options = services.BuildServiceProvider().GetRequiredService<Options.IOptions<UserOptions<TUserKey, TUser>>>().Value;
-
         // Register UserOptions<,> without IOptions
         services.AddSingleton<UserOptions<TUserKey, TUser>>(options);
 
@@ -128,42 +124,15 @@ private static UserOptions<TUserKey, TUser> RegisterUserOptions<TUserKey, TUser>
     private static UserOptions<TUser> RegisterUserOptions<TUser>(this IServiceCollection services, Action<UserOptions<TUser>> configureOptions)
         where TUser : User
     {
+        var options = new UserOptions<TUser>();
+        configureOptions(options);
+
         // Register IOptions<UserOptions<,>>
         services.Configure(configureOptions);
 
-        // Get UserOptions<,> from ServiceProvider
-        var options = services.BuildServiceProvider().GetRequiredService<Options.IOptions<UserOptions<TUser>>>().Value;
-
         // Register UserOptions<,> without IOptions
         services.AddSingleton<UserOptions<TUser>>(options);
 
         return options;
     }
-
-    private static void InsertAdminUserAndAssignRole<TUserKey, TUser>(this IUserService<TUserKey, TUser> userService, IUserRoleService<TUserKey, TUser> userRoleService, string role, TUser user, string password)
-        where TUserKey : IEquatable<TUserKey>
-        where TUser : User<TUserKey>
-    {
-        if (user is null || password is null) return;
-
-        // If user was not inserted before, insert it
-        try
-        {
-            if (userService.ExistsUserName(user.UserName).Result is false)
-            {
-                userService.Create(user, password).Wait();
-                if (role is not null) userRoleService.AddRoles(user.Id, new List<string> { role }).Wait();
-            }
-        }
-        catch (Exception)
-        {
-            // ignored
-        }
-    }
-
-    private static void InsertAdminUserAndAssignRole<TUser>(this IUserService<TUser> userService, IUserRoleService<TUser> userRoleService, string role, TUser user, string password)
-        where TUser : User
-    {
-        userService.InsertAdminUserAndAssignRole<Guid, TUser>(userRoleService, role, user, password);
-    }
 }
\ No newline at end of file
diff --git a/src/Identity/uBeac.Core.Identity/Seeders/RoleSeeder.cs b/src/Identity/uBeac.Core.Identity/Seeders/RoleSeeder.cs
new file mode 100644
index 00000000..2d64d8d5
--- /dev/null
+++ b/src/Identity/uBeac.Core.Identity/Seeders/RoleSeeder.cs
@@ -0,0 +1,38 @@
+namespace uBeac.Identity.Seeders;
+
+public class RoleSeeder<TKey, TRole> : IDataSeeder
+    where TKey : IEquatable<TKey>
+    where TRole : Role<TKey>
+{
+    private readonly IRoleService<TKey, TRole> _roleService;
+    private readonly RoleOptions<TKey, TRole> _roleOptions;
+
+    public RoleSeeder(IRoleService<TKey, TRole> roleService, RoleOptions<TKey, TRole> roleOptions)
+    {
+        _roleService = roleService;
+        _roleOptions = roleOptions;
+    }
+
+    public async Task SeedAsync(CancellationToken cancellationToken = default)
+    {
+        var data = _roleOptions.DefaultValues?.ToList();
+
+        if (data is null || data.Any() is false) return;
+
+        foreach (var role in data)
+        {
+            if (await _roleService.Exists(role.Name, cancellationToken) is false)
+            {
+                await _roleService.Create(role, cancellationToken);
+            }
+        }
+    }
+}
+
+public class RoleSeeder<TRole> : RoleSeeder<Guid, TRole>
+    where TRole : Role
+{
+    public RoleSeeder(IRoleService<TRole> roleService, RoleOptions<TRole> roleOptions) : base(roleService, roleOptions)
+    {
+    }
+}
diff --git a/src/Identity/uBeac.Core.Identity/Seeders/UnitSeeder.cs b/src/Identity/uBeac.Core.Identity/Seeders/UnitSeeder.cs
new file mode 100644
index 00000000..8d74d214
--- /dev/null
+++ b/src/Identity/uBeac.Core.Identity/Seeders/UnitSeeder.cs
@@ -0,0 +1,41 @@
+namespace uBeac.Identity.Seeders;
+
+public class UnitSeeder<TKey, TUnit> : IDataSeeder
+    where TKey : IEquatable<TKey>
+    where TUnit : Unit<TKey>
+{
+    private readonly IUnitService<TKey, TUnit> _unitService;
+    private readonly UnitOptions<TKey, TUnit> _unitOptions;
+
+    public UnitSeeder(IUnitService<TKey, TUnit> unitService, UnitOptions<TKey, TUnit> unitOptions)
+    {
+        _unitService = unitService;
+        _unitOptions = unitOptions;
+    }
+
+    public async Task SeedAsync(CancellationToken cancellationToken = default)
+    {
+        var data = _unitOptions.DefaultValues?.ToList();
+
+        if (data is null || data.Any() is false) return;
+
+        foreach (var unit in data)
+        {
+            if (await _unitService.Exists(unit.Code, unit.Type, cancellationToken) is false)
+            {
+                var parent = unit.GetParentUnit();
+                if (parent != null) unit.ParentUnitId = parent.Id;
+
+                await _unitService.Create(unit, cancellationToken);
+            }
+        }
+    }
+}
+
+public class UnitSeeder<TUnit> : UnitSeeder<Guid, TUnit>
+    where TUnit : Unit
+{
+    public UnitSeeder(IUnitService<TUnit> unitService, UnitOptions<TUnit> unitOptions) : base(unitService, unitOptions)
+    {
+    }
+}
diff --git a/src/Identity/uBeac.Core.Identity/Seeders/UnitTypeSeeder.cs b/src/Identity/uBeac.Core.Identity/Seeders/UnitTypeSeeder.cs
new file mode 100644
index 00000000..289aa25e
--- /dev/null
+++ b/src/Identity/uBeac.Core.Identity/Seeders/UnitTypeSeeder.cs
@@ -0,0 +1,38 @@
+namespace uBeac.Identity.Seeders;
+
+public class UnitTypeSeeder<TKey, TUnitType> : IDataSeeder
+    where TKey : IEquatable<TKey>
+    where TUnitType : UnitType<TKey>
+{
+    private readonly IUnitTypeService<TKey, TUnitType> _unitTypeService;
+    private readonly UnitTypeOptions<TKey, TUnitType> _unitTypeOptions;
+
+    public UnitTypeSeeder(IUnitTypeService<TKey, TUnitType> unitTypeService, UnitTypeOptions<TKey, TUnitType> unitTypeOptions)
+    {
+        _unitTypeService = unitTypeService;
+        _unitTypeOptions = unitTypeOptions;
+    }
+
+    public async Task SeedAsync(CancellationToken cancellationToken = default)
+    {
+        var data = _unitTypeOptions.DefaultValues?.ToList();
+
+        if (data is null || data.Any() is false) return;
+
+        foreach (var unitType in data)
+        {
+            if (await _unitTypeService.Exists(unitType.Code, cancellationToken) is false)
+            {
+                await _unitTypeService.Create(unitType, cancellationToken);
+            }
+        }
+    }
+}
+
+public class UnitTypeSeeder<TUnitType> : UnitTypeSeeder<Guid, TUnitType>
+    where TUnitType : UnitType
+{
+    public UnitTypeSeeder(IUnitTypeService<TUnitType> unitTypeService, UnitTypeOptions<TUnitType> unitTypeOptions) : base(unitTypeService, unitTypeOptions)
+    {
+    }
+}
diff --git a/src/Identity/uBeac.Core.Identity/Seeders/UserSeeder.cs b/src/Identity/uBeac.Core.Identity/Seeders/UserSeeder.cs
new file mode 100644
index 00000000..48bf98c2
--- /dev/null
+++ b/src/Identity/uBeac.Core.Identity/Seeders/UserSeeder.cs
@@ -0,0 +1,46 @@
+namespace uBeac.Identity.Seeders;
+
+public class UserSeeder<TKey, TUser> : IDataSeeder
+    where TKey : IEquatable<TKey>
+    where TUser : User<TKey>
+{
+    private readonly IUserService<TKey, TUser> _userService;
+    private readonly IUserRoleService<TKey, TUser> _userRoleService;
+    private readonly UserOptions<TKey, TUser> _userOptions;
+
+    public UserSeeder(IUserService<TKey, TUser> userService, IUserRoleService<TKey, TUser> userRoleService, UserOptions<TKey, TUser> userOptions)
+    {
+        _userService = userService;
+        _userRoleService = userRoleService;
+        _userOptions = userOptions;
+    }
+
+    public async Task SeedAsync(CancellationToken cancellationToken = default)
+    {
+        var adminUser = _userOptions.AdminUser;
+        var adminPassword = _userOptions.AdminPassword;
+
+        await CreateAdminUser(adminUser, adminPassword, cancellationToken);
+    }
+
+    public async Task CreateAdminUser(TUser user, string password, CancellationToken cancellationToken = default)
+    {
+        var role = _userOptions.AdminRole;
+
+        if (user is null || password is null || role is null) return;
+
+        if (await _userService.ExistsUserName(user.UserName, cancellationToken) is false)
+        {
+            await _userService.Create(user, password, cancellationToken);
+            await _userRoleService.AddRoles(user.Id, new List<string> { role }, cancellationToken);
+        }
+    }
+}
+
+public class UserSeeder<TUser> : UserSeeder<Guid, TUser>
+    where TUser : User
+{
+    public UserSeeder(IUserService<TUser> userService, IUserRoleService<TUser> userRoleService, UserOptions<TUser> userOptions) : base(userService, userRoleService, userOptions)
+    {
+    }
+}
diff --git a/src/Logging/uBeac.Core.Logging/AppContextEnricher.cs b/src/Logging/uBeac.Core.Logging/AppContextEnricher.cs
deleted file mode 100644
index 356f1315..00000000
--- a/src/Logging/uBeac.Core.Logging/AppContextEnricher.cs
+++ /dev/null
@@ -1,33 +0,0 @@
-using Microsoft.Extensions.DependencyInjection;
-using Serilog.Configuration;
-using Serilog.Core;
-using Serilog.Events;
-using uBeac;
-
-namespace Serilog;
-
-public class AppContextEnricher : ILogEventEnricher
-{
-    protected readonly IServiceCollection Services;
-
-    public AppContextEnricher(IServiceCollection services)
-    {
-        Services = services;
-    }
-
-    public void Enrich(LogEvent logEvent, ILogEventPropertyFactory propertyFactory)
-    {
-        var context = Services.BuildServiceProvider().CreateScope().ServiceProvider.GetRequiredService<IApplicationContext>();
-        logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty("TraceId", context.TraceId));
-        logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty("SessionId", context.SessionId));
-        logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty("UserName", context.UserName));
-        logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty("UserIp", context.UserIp));
-        logEvent.AddPropertyIfAbsent(propertyFactory.CreateProperty("Language", context.Language));
-    }
-}
-
-public static class AppContextEnricherExtensions
-{
-    public static LoggerConfiguration WithAppContext(this LoggerEnrichmentConfiguration enrichmentConfiguration, IServiceCollection services)
-        => enrichmentConfiguration.With(new AppContextEnricher(services));
-}
\ No newline at end of file
diff --git a/src/Web/uBeac.Core.Web.Common/ApplicationExtensions.cs b/src/Web/uBeac.Core.Web.Common/ApplicationExtensions.cs
index 8f5d52a6..ab476652 100644
--- a/src/Web/uBeac.Core.Web.Common/ApplicationExtensions.cs
+++ b/src/Web/uBeac.Core.Web.Common/ApplicationExtensions.cs
@@ -1,5 +1,7 @@
 using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
+using uBeac;
 using uBeac.Web;
 
 namespace Microsoft.AspNetCore.Builder;
@@ -21,4 +23,18 @@ public static IApplicationBuilder UseHstsOnProduction(this IApplicationBuilder a
 
         return app;
     }
-}
\ No newline at end of file
+
+    public static IApplicationBuilder SeedData(this IApplicationBuilder app)
+    {
+        var seeders = app.ApplicationServices.CreateScope()
+            .ServiceProvider
+            .GetServices<IDataSeeder>();
+        
+        foreach (var seeder in seeders)
+        {
+            seeder.SeedAsync().Wait();
+        }
+
+        return app;
+    }
+}