MainProject/Config/permissions.json

@@ -4,7 +4,7 @@
             "System": "base",
             "RolePermissionModuleOperations": [
                 {
-                    "Module": "role",
+                    "Module": "roles",
                     "Operations": [
                         { "Operation": "create", "Roles": [] },
                         { "Operation": "read", "Roles": [] },
@@ -15,7 +15,7 @@
                     ]
                 },
                 {
-                    "Module": "user",
+                    "Module": "users",
                     "Operations": [
                         { "Operation": "create", "Roles": [] },
                         { "Operation": "read", "Roles": [] },

MainProject/Services/PermissionService.cs

@@ -60,19 +60,28 @@ public interface IPermissionService
     );
     Task<bool?> DeleteRolePermissionSystemModuleOperationAsync(RolePermissionSystemModuleOperation permission);
 
-    Task<List<string>?> CreatePermissionsOnStartupAsync();
+    List<string> CreatePermissionsOnStartupAsync();
 
 }
 
 public class PermissionService : BaseService, IPermissionService
 {
     private readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger();
+    private readonly CommonDbMethodsUtils _commonDbMethodsUtils;
+
     public PermissionService(
         IHttpContextAccessor httpContextAccessor,
         IConfiguration configuration,
         SqlServerContext sqlServerContext
     ) : base(httpContextAccessor, configuration, sqlServerContext)
-    { }
+    {
+        _commonDbMethodsUtils = new CommonDbMethodsUtils(sqlServerContext);
+    }
+
+    private IQueryable<Role> GetRoleByNameQueryable(string name)
+    {
+        return _commonDbMethodsUtils.GetRoleByNameQueryable(name);
+    }
 
     private IQueryable<PermissionSystem> GetPermissionSystemsQueryable()
     {
@@ -640,12 +649,608 @@ public class PermissionService : BaseService, IPermissionService
 
 
 
-    public async Task<List<string>?> CreatePermissionsOnStartupAsync()
+    #region "CreatePermissionOnStartup"
+
+    private static List<string?>? GetSystemNamesFromFile(PermissionsFile permissionsFile)
+    {
+        return permissionsFile?.PermissionInfos?.Where(x => x.System != null).Select(x => x.System)?.ToList();
+    }
+
+    private static List<string?>? GetModulesNamesFromFile(PermissionsFile permissionsFile)
+    {
+        return permissionsFile?.PermissionInfos?
+            .Where(x => x.RolePermissionModuleOperations != null)
+            .SelectMany(x => x.RolePermissionModuleOperations!)
+            .Select(y => y.Module)
+            .Distinct()
+            .ToList();
+    }
+
+    private static List<string?>? GetModulesNamesFromPermissionInfo(PermissionInfo permissionInfo)
+    {
+        return permissionInfo.RolePermissionModuleOperations?
+            .Select(y => y.Module)
+            .Distinct()
+            .ToList();
+    }
+
+    private static List<string?>? GetOperationsNamesFromFile(PermissionInfo permissionInfo)
+    {
+        return permissionInfo?.RolePermissionModuleOperations?
+            .Where(x => x != null)
+            .Where(x => x.Operations != null)
+            .SelectMany(y => y.Operations!)
+            .Select(z => z.Operation)
+            .Distinct()
+            .ToList();
+    }
+
+    private (List<PermissionSystem>, List<string>) HandlePermissionSystemOnStartup(PermissionsFile permissionsFile)
+    {
+        List<string> newPermissions = [];
+        List<string> systemNames = [];
+        List<PermissionSystem> permissionSystemList = [];
+
+        List<string?>? systems = GetSystemNamesFromFile(permissionsFile);
+        if (systems != null && systems.Count > 0)
+        {
+            foreach (var system in systems)
+            {
+                if (!String.IsNullOrEmpty(system))
+                {
+                    systemNames.Add(system);
+                }
+            }
+        }
+
+        foreach (var system in systemNames)
+        {
+            PermissionSystem? permissionSystem = this.GetPermissionSystemByNameAsync(system).Result;
+            if (permissionSystem == null)
+            {
+                permissionSystem = this.CreatePermissionSystemAsync(system, true).Result;
+                newPermissions.Add($"Added new PermissionSystem => {permissionSystem?.Name}");
+            }
+            if (permissionSystem != null)
+            {
+                permissionSystemList.Add(permissionSystem);
+            }
+        }
+
+        return (permissionSystemList, newPermissions);
+    }
+
+    private (List<PermissionModule>, List<string>) HandlePermissionModuleOnStartup(PermissionsFile permissionsFile)
+    {
+        List<string> newPermissions = [];
+        List<string> moduleNames = [];
+        List<PermissionModule> permissionModuleList = [];
+
+        List<string?>? modules = GetModulesNamesFromFile(permissionsFile);
+
+        if (modules != null && modules.Count > 0)
+        {
+            foreach (var module in modules)
+            {
+                if (!String.IsNullOrEmpty(module))
+                {
+                    moduleNames.Add(module);
+                }
+            }
+        }
+
+        foreach (var module in moduleNames)
+        {
+            PermissionModule? permissionModule = this.GetPermissionModuleByNameAsync(module).Result;
+            if (permissionModule == null)
+            {
+                permissionModule = this.CreatePermissionModuleAsync(module, true).Result;
+                newPermissions.Add($"Added new PermissionModule => {permissionModule?.Name}");
+            }
+            if (permissionModule != null)
+            {
+                permissionModuleList.Add(permissionModule);
+            }
+        }
+
+        return (permissionModuleList, newPermissions);
+    }
+
+    private (List<PermissionOperation>, List<string>) HandlePermissionOperationOnStartup(PermissionsFile permissionsFile)
+    {
+        List<string> newPermissions = [];
+        List<string> operationNames = [];
+        List<PermissionOperation> permissionOperationList = [];
+
+        List<string?>? operations = permissionsFile.PermissionInfos?
+            .Where(x => x.RolePermissionModuleOperations != null)
+            .SelectMany(x => x.RolePermissionModuleOperations!)
+            .Where(x => x.Operations != null)
+            .SelectMany(y => y.Operations!)
+            .Select(z => z.Operation)
+            .Distinct()
+            .ToList();
+
+        if (operations != null && operations.Count > 0)
+        {
+            foreach (var operation in operations)
+            {
+                if (!String.IsNullOrEmpty(operation))
+                {
+                    operationNames.Add(operation);
+                }
+            }
+        }
+
+        foreach (var operation in operationNames)
+        {
+            PermissionOperation? permissionOperation = this.GetPermissionOperationByNameAsync(operation).Result;
+            if (permissionOperation == null)
+            {
+                permissionOperation = this.CreatePermissionOperationAsync(operation).Result;
+                newPermissions.Add($"Added new PermissionOperation => {permissionOperation?.Name}");
+            }
+            if (permissionOperation != null)
+            {
+                permissionOperationList.Add(permissionOperation);
+            }
+        }
+
+        return (permissionOperationList, newPermissions);
+    }
+
+    private async Task<List<Role>> HandleRolesOnStartup(PermissionsFile permissionsFile)
+    {
+        List<string> roleNames = [];
+        List<Role> rolesList = [];
+
+        List<string>? roles = permissionsFile.PermissionInfos?
+            .Where(x => x.RolePermissionModuleOperations != null)?
+            .SelectMany(x => x.RolePermissionModuleOperations!)?
+            .Where(x => x.Operations != null)?
+            .SelectMany(y => y.Operations!)?
+            .Where(z => z.Roles != null)?
+            .SelectMany(z => z.Roles!)?
+            .Where(z => z != null)?
+            .Distinct()?
+            .ToList();
+
+        if (roles != null && roles.Count > 0)
+        {
+            foreach (var role in roles)
+            {
+                if (!String.IsNullOrEmpty(role))
+                {
+                    roleNames.Add(role);
+                }
+            }
+        }
+
+        foreach (var roleName in roleNames)
+        {
+            Role? role = await this.GetRoleByNameQueryable(roleName).FirstOrDefaultAsync();
+            if (role == null)
+            {
+                Role tempRole = new()
+                {
+                    CreationTime = DateTime.UtcNow,
+                    IsDeleted = false,
+                    Guid = Guid.NewGuid().ToString(),
+                    Name = roleName,
+                    IsNotEditable = false
+                };
+                using var transaction = await _sqlServerContext.Database.BeginTransactionAsync();
+                try
+                {
+                    await _sqlServerContext.Roles.AddAsync(tempRole);
+                    await _sqlServerContext.SaveChangesAsync();
+                    await transaction.CommitAsync();
+                    role = tempRole;
+                }
+                catch (Exception exception)
+                {
+                    await transaction.RollbackAsync();
+                    Logger.Error(exception, $"[RoleService][CreateRoleAsync]");
+                    throw new CreateException($"An error occurred while saving the role for transaction ID {transaction.TransactionId}.", exception);
+                }
+
+                Logger.Info($"Added new Role => {role?.Name}");
+            }
+            if (role != null)
+            {
+                rolesList.Add(role);
+            }
+        }
+
+        return rolesList;
+    }
+
+    private (List<PermissionSystemModule>, List<string>) HandlePermissionSystemModulesOnStartup(PermissionSystem permissionSystem, List<PermissionModule> permissionModules)
+    {
+        List<string> newPermissions = [];
+        List<PermissionSystemModule> permissionSystemModuleList = [];
+
+        foreach (var permissionModule in permissionModules)
+        {
+            PermissionSystemModule? permissionSystemModule = this.GetPermissionSystemModulesQueryable()?
+                .Where(x =>
+                    x.PermissionSystemId == permissionSystem!.Id &&
+                    x.PermissionModuleId == permissionModule.Id
+                )?.FirstOrDefault();
+            if (permissionSystemModule == null)
+            {
+                permissionSystemModule = this.CreatePermissionSystemModuleAsync(permissionSystem!, permissionModule, true).Result;
+                newPermissions.Add($"Added new PermissionSystemModule => {permissionSystem?.Name}.{permissionModule?.Name}");
+            }
+            if (permissionSystemModule != null)
+            {
+                permissionSystemModuleList.Add(permissionSystemModule);
+            }
+        }
+
+        return (permissionSystemModuleList, newPermissions);
+    }
+
+    private (List<PermissionSystemModule>, List<string>) HandlePermissionSystemModuleOnStartup
+    (
+        PermissionsFile permissionsFile,
+        List<PermissionSystem> permissionSystems,
+        List<PermissionModule> allPermissionModules,
+        PermissionInfo permissionInfo
+    )
+    {
+        List<string> newPermissions = [];
+        List<PermissionSystemModule> permissionSystemModuleList = [];
+
+        PermissionSystem? permissionSystem = permissionSystems.FirstOrDefault(x => x.Name == permissionInfo.System);
+        if (permissionSystem != null)
+        {
+            List<string?>? modules = GetModulesNamesFromFile(permissionsFile);
+            if (modules != null && modules.Count > 0)
+            {
+                List<PermissionModule> permissionModules = allPermissionModules.Where(x => modules.Contains(x.Name)).ToList();
+                if (permissionModules != null && permissionModules.Count > 0)
+                {
+                    (permissionSystemModuleList, newPermissions) = this.HandlePermissionSystemModulesOnStartup(permissionSystem, permissionModules);
+                }
+            }
+        }
+
+        return (permissionSystemModuleList, newPermissions);
+    }
+    private (List<PermissionSystemModule>, List<string>) HandlePermissionSystemModuleOnStartup(
+        PermissionsFile permissionsFile,
+        List<PermissionSystem> permissionSystems,
+        List<PermissionModule> allPermissionModules
+    )
+    {
+        List<string> newPermissions = [];
+        List<PermissionSystemModule> permissionSystemModuleList = [];
+
+        if (permissionsFile?.PermissionInfos != null)
+        {
+            foreach (var permissionInfo in permissionsFile!.PermissionInfos!)
+            {
+                if (!String.IsNullOrEmpty(permissionInfo.System))
+                {
+                    var modulesNames = GetModulesNamesFromPermissionInfo(permissionInfo);
+                    if (modulesNames != null && modulesNames.Count > 0)
+                    {
+                        List<PermissionModule> permissionModules = allPermissionModules.Where(x => modulesNames.Contains(x.Name)).ToList() ?? [];
+                        (permissionSystemModuleList, newPermissions) = this.HandlePermissionSystemModuleOnStartup(permissionsFile, permissionSystems, permissionModules, permissionInfo);
+                    }
+                }
+            }
+        }
+
+        return (permissionSystemModuleList, newPermissions);
+    }
+
+    private (List<PermissionSystemModuleOperation>, List<string>) HandlePermissionSystemModuleOperationOnStartup
+    (
+        PermissionSystemModule permissionSystemModule,
+        List<PermissionOperation> permissionOperations
+    )
+    {
+        List<string> newPermissions = [];
+        List<PermissionSystemModuleOperation> permissionSystemModuleOperationList = [];
+
+        foreach (var permissionOperation in permissionOperations)
+        {
+            PermissionSystemModuleOperation? permissionSystemModuleOperation = this.GetPermissionSystemModuleOperationsQueryable()?
+                .FirstOrDefault(x =>
+                    x.PermissionSystemModuleId == permissionSystemModule!.Id &&
+                    x.PermissionOperationId == permissionOperation.Id
+                );
+            if (permissionSystemModuleOperation == null)
+            {
+                permissionSystemModuleOperation = this.CreatePermissionSystemModuleOperationAsync(permissionSystemModule!, permissionOperation, true).Result;
+                newPermissions.Add($"Added new PermissionSystemModuleOperation => {permissionSystemModuleOperation?.PermissionSystemModule?.PermissionSystem?.Name}.{permissionSystemModuleOperation?.PermissionSystemModule?.PermissionModule?.Name}.{permissionSystemModuleOperation?.PermissionOperation?.Name}");
+            }
+            if (permissionSystemModuleOperation != null)
+            {
+                permissionSystemModuleOperationList.Add(permissionSystemModuleOperation!);
+            }
+        }
+
+        return (permissionSystemModuleOperationList, newPermissions);
+    }
+
+    private (List<PermissionSystemModuleOperation>, List<string>) HandlePermissionSystemModuleOperationOnStartup
+    (
+        List<PermissionSystemModule> permissionSystemModulesList,
+        List<PermissionOperation> allPermissionOperations,
+        PermissionInfo permissionInfo
+    )
+    {
+        List<string> newPermissions = [];
+        List<string> tmpPermissions = [];
+        List<PermissionSystemModuleOperation> permissionSystemModuleOperationList = [];
+        List<PermissionSystemModuleOperation> tmpPermissionSystemModuleOperationList = [];
+
+        if (permissionInfo != null && permissionInfo.RolePermissionModuleOperations != null)
+        {
+            foreach (var rolePermissionModuleOperation in permissionInfo.RolePermissionModuleOperations)
+            {
+                PermissionSystemModule? permissionSystemModule = permissionSystemModulesList.FirstOrDefault(x => x.PermissionModule.Name == rolePermissionModuleOperation.Module);
+                if (permissionSystemModule != null)
+                {
+                    var operationsNames = rolePermissionModuleOperation.Operations?.Select(x => x.Operation).ToList();
+                    if (operationsNames != null && operationsNames.Count > 0)
+                    {
+                        List<PermissionOperation> permissionOperations = allPermissionOperations.Where(x => operationsNames.Contains(x.Name)).ToList();
+                        (tmpPermissionSystemModuleOperationList, tmpPermissions) = this.HandlePermissionSystemModuleOperationOnStartup(permissionSystemModule, permissionOperations);
+                        newPermissions.AddRange(tmpPermissions);
+                        permissionSystemModuleOperationList.AddRange(tmpPermissionSystemModuleOperationList);
+                    }
+                }
+            }
+        }
+
+        return (permissionSystemModuleOperationList, newPermissions);
+    }
+
+    private (List<PermissionSystemModuleOperation>, List<string>) HandlePermissionSystemModuleOperationOnStartup
+    (
+        PermissionsFile permissionsFile,
+        List<PermissionSystemModule> permissionSystemModules,
+        List<PermissionOperation> allPermissionOperation
+    )
+    {
+        List<string> newPermissions = [];
+        List<string> tmpPermissions = [];
+        List<PermissionSystemModuleOperation> permissionSystemModuleOperationList = [];
+        List<PermissionSystemModuleOperation> tmpPermissionSystemModuleOperationList = [];
+
+        if (permissionsFile.PermissionInfos != null)
+        {
+            foreach (var permissionInfo in permissionsFile.PermissionInfos!)
+            {
+                if (!String.IsNullOrEmpty(permissionInfo.System))
+                {
+                    // Get all PermissionSystemModules by System.Name
+                    List<PermissionSystemModule> permissionSystemModulesList = permissionSystemModules
+                        .Where(x => x.PermissionSystem.Name == permissionInfo.System).ToList();
+
+                    if (permissionSystemModulesList != null && permissionSystemModulesList.Count > 0)
+                    {
+                        (tmpPermissionSystemModuleOperationList, tmpPermissions) = this.HandlePermissionSystemModuleOperationOnStartup
+                        (
+                            permissionSystemModulesList,
+                            allPermissionOperation,
+                            permissionInfo
+                        );
+                        newPermissions.AddRange(tmpPermissions);
+                        permissionSystemModuleOperationList.AddRange(tmpPermissionSystemModuleOperationList);
+                    }
+                }
+            }
+        }
+
+        return (permissionSystemModuleOperationList, newPermissions);
+    }
+
+    private (List<RolePermissionSystemModuleOperation>, List<string>) HandleRolePermissionSystemModuleOperationOnStartup
+    (
+        List<PermissionSystemModuleOperation> allPermissionSystemModuleOperationsBySystem,
+        List<Role> allRoles,
+        PermissionInfo permissionInfo
+    )
+    {
+        List<string> newPermissions = [];
+        List<string> tmpPermissions = [];
+        List<RolePermissionSystemModuleOperation> rolePermissionSystemModuleOperationList = [];
+        List<RolePermissionSystemModuleOperation> tmpRolePermissionSystemModuleOperationList = [];
+
+        if (permissionInfo != null && permissionInfo.RolePermissionModuleOperations != null)
+        {
+            foreach (var rolePermissionModuleOperation in permissionInfo.RolePermissionModuleOperations)
+            {
+                List<PermissionSystemModuleOperation>? allPermissionSystemModuleOperationsBySystemModule = allPermissionSystemModuleOperationsBySystem
+                    .Where(x => x.PermissionSystemModule.PermissionModule.Name == rolePermissionModuleOperation.Module)
+                    .ToList();
+                if (allPermissionSystemModuleOperationsBySystemModule != null && allPermissionSystemModuleOperationsBySystemModule.Count > 0)
+                {
+                    var operationsNames = rolePermissionModuleOperation.Operations?.Select(x => x.Operation).ToList();
+                    if (operationsNames != null && operationsNames.Count > 0)
+                    {
+                        List<PermissionSystemModuleOperation> permissionSystemModuleOperations = allPermissionSystemModuleOperationsBySystemModule
+                            .Where(x => operationsNames.Contains(x.PermissionOperation.Name)).ToList();
+                        (tmpRolePermissionSystemModuleOperationList, tmpPermissions) = this.HandleRolePermissionSystemModuleOperationOnStartup(
+                            permissionSystemModuleOperations,
+                            allRoles,
+                            rolePermissionModuleOperation
+                        );
+                        newPermissions.AddRange(tmpPermissions);
+                        rolePermissionSystemModuleOperationList.AddRange(tmpRolePermissionSystemModuleOperationList);
+                    }
+                }
+            }
+        }
+
+        return (rolePermissionSystemModuleOperationList, newPermissions);
+    }
+
+    private (List<RolePermissionSystemModuleOperation>, List<string>) HandleRolePermissionSystemModuleOperationOnStartup
+    (
+        List<PermissionSystemModuleOperation> permissionSystemModuleOperations,
+        List<Role> allRoles,
+        RolePermissionModuleOperation rolePermissionModuleOperation
+    )
+    {
+        List<string> newPermissions = [];
+        List<string> tmpPermissions = [];
+        List<RolePermissionSystemModuleOperation> rolePermissionSystemModuleOperationList = [];
+        List<RolePermissionSystemModuleOperation> tmpRolePermissionSystemModuleOperationList = [];
+
+        if (permissionSystemModuleOperations != null && permissionSystemModuleOperations.Count > 0 &&
+            allRoles != null && allRoles.Count > 0 && rolePermissionModuleOperation?.Operations != null &&
+            rolePermissionModuleOperation.Operations.Count > 0
+        )
+        {
+            foreach (var operationInfo in rolePermissionModuleOperation.Operations)
+            {
+                PermissionSystemModuleOperation? permissionSystemModuleOperation = permissionSystemModuleOperations
+                    .FirstOrDefault(x => x.PermissionOperation.Name == operationInfo.Operation);
+                if (permissionSystemModuleOperation != null && operationInfo.Roles != null && operationInfo.Roles.Count > 0)
+                {
+                    var roles = allRoles.Where(x => operationInfo.Roles.Contains(x.Name)).ToList();
+                    if (roles != null && roles.Count > 0)
+                    {
+                        foreach (var roleName in operationInfo.Roles)
+                        {
+                            (tmpRolePermissionSystemModuleOperationList, tmpPermissions) = this.HandleRolePermissionSystemModuleOperationOnStartup
+                            (
+                                roles, roleName, permissionSystemModuleOperation
+                            );
+                            newPermissions.AddRange(tmpPermissions);
+                            rolePermissionSystemModuleOperationList.AddRange(tmpRolePermissionSystemModuleOperationList);
+                        }
+
+                    }
+                }
+            }
+        }
+
+        return (rolePermissionSystemModuleOperationList, newPermissions);
+    }
+
+    private (List<RolePermissionSystemModuleOperation>, List<string>) HandleRolePermissionSystemModuleOperationOnStartup
+    (
+        List<Role> roles, string roleName, PermissionSystemModuleOperation permissionSystemModuleOperation
+    )
+    {
+        List<string> newPermissions = [];
+        List<RolePermissionSystemModuleOperation> rolePermissionSystemModuleOperationList = [];
+
+        Role? role = roles.FirstOrDefault(x => x.Name == roleName);
+        if (role != null)
+        {
+            RolePermissionSystemModuleOperation? rolePermissionSystemModuleOperation = this._sqlServerContext.RolePermissionSystemModuleOperations?
+                .FirstOrDefault(x => x.RoleId == role.Id && x.PermissionSystemModuleOperationId == permissionSystemModuleOperation!.Id);
+            if (rolePermissionSystemModuleOperation == null)
+            {
+                rolePermissionSystemModuleOperation = this.CreateRolePermissionSystemModuleOperationAsync(role, permissionSystemModuleOperation!, true).Result;
+                if (rolePermissionSystemModuleOperation != null)
+                {
+                    newPermissions.Add($"Added new RolePermissionSystemModuleOperation => " +
+                        $"{permissionSystemModuleOperation?.PermissionSystemModule?.PermissionSystem?.Name}." +
+                        $"{permissionSystemModuleOperation?.PermissionSystemModule?.PermissionModule?.Name}." +
+                        $"{permissionSystemModuleOperation?.PermissionOperation?.Name} for role {role.Name}");
+                }
+                if (rolePermissionSystemModuleOperation != null)
+                {
+                    rolePermissionSystemModuleOperationList.Add(rolePermissionSystemModuleOperation!);
+                }
+            }
+        }
+
+        return (rolePermissionSystemModuleOperationList, newPermissions);
+    }
+
+    private (List<RolePermissionSystemModuleOperation>, List<string>) HandleRolePermissionSystemModuleOperationOnStartup
+    (
+        PermissionsFile permissionsFile,
+        List<PermissionSystemModuleOperation> allPermissionSystemModuleOperations,
+        List<Role> allRoles
+    )
+    {
+        List<string> newPermissions = [];
+        List<string> tmpPermissions = [];
+        List<RolePermissionSystemModuleOperation> rolePermissionSystemModuleOperationList = [];
+        List<RolePermissionSystemModuleOperation> tmpRolePermissionSystemModuleOperationList = [];
+
+        if (permissionsFile.PermissionInfos != null)
+        {
+            foreach (var permissionInfo in permissionsFile.PermissionInfos!)
+            {
+                if (!String.IsNullOrEmpty(permissionInfo.System))
+                {
+                    // Get all PermissionSystemModuleOperations by System.Name
+                    List<PermissionSystemModuleOperation> allPermissionSystemModuleOperationsBySystem = allPermissionSystemModuleOperations
+                        .Where(x => x.PermissionSystemModule.PermissionSystem.Name == permissionInfo.System).ToList();
+
+                    if (allPermissionSystemModuleOperationsBySystem != null && allPermissionSystemModuleOperationsBySystem.Count > 0)
+                    {
+                        (tmpRolePermissionSystemModuleOperationList, tmpPermissions) = this.HandleRolePermissionSystemModuleOperationOnStartup
+                        (
+                            allPermissionSystemModuleOperationsBySystem,
+                            allRoles,
+                            permissionInfo
+                        );
+                        newPermissions.AddRange(tmpPermissions);
+                        rolePermissionSystemModuleOperationList.AddRange(tmpRolePermissionSystemModuleOperationList);
+                    }
+                }
+            }
+        }
+
+        return (rolePermissionSystemModuleOperationList, newPermissions);
+
+    }
+
+    public List<string> CreatePermissionsOnStartupAsync()
     {
         try
         {
-            List<string>? newPermissions = null;
-            PermissionsFile? permissionsFile = FileUtils.ConvertFileToObject<PermissionsFile>(System.AppDomain.CurrentDomain.BaseDirectory + this._appSettings.PermissionsSettings.FilePath);
+            List<string> tmpPermissions = [];
+            List<string> newPermissions = [];
+            PermissionsFile? permissionsFile = FileUtils.ConvertFileToObject<PermissionsFile>(System.AppDomain.CurrentDomain.BaseDirectory + this._appSettings?.PermissionsSettings?.FilePath);
+
+            List<PermissionSystem> permissionSystemList = [];
+            List<PermissionModule> permissionModuleList = [];
+            List<PermissionOperation> permissionOperationList = [];
+            List<PermissionSystemModule> permissionSystemModuleList = [];
+            List<PermissionSystemModuleOperation> permissionSystemModuleOperationList = [];
+            List<RolePermissionSystemModuleOperation> rolePermissionSystemModuleOperationList = [];
+
+            if (permissionsFile != null && permissionsFile.PermissionInfos != null && permissionsFile.PermissionInfos.Count > 0)
+            {
+                (permissionSystemList, tmpPermissions) = this.HandlePermissionSystemOnStartup(permissionsFile);
+                newPermissions.AddRange(tmpPermissions);
+
+                (permissionModuleList, tmpPermissions) = this.HandlePermissionModuleOnStartup(permissionsFile);
+                newPermissions.AddRange(tmpPermissions);
+
+                (permissionOperationList, tmpPermissions) = this.HandlePermissionOperationOnStartup(permissionsFile);
+                newPermissions.AddRange(tmpPermissions);
+
+                (permissionSystemModuleList, tmpPermissions) = this.HandlePermissionSystemModuleOnStartup(permissionsFile, permissionSystemList, permissionModuleList);
+                newPermissions.AddRange(tmpPermissions);
+
+                (permissionSystemModuleOperationList, tmpPermissions) = this.HandlePermissionSystemModuleOperationOnStartup(permissionsFile, permissionSystemModuleList, permissionOperationList);
+                newPermissions.AddRange(tmpPermissions);
+
+                List<Role> roles = this.HandleRolesOnStartup(permissionsFile).Result;
+
+                (rolePermissionSystemModuleOperationList, tmpPermissions) = this.HandleRolePermissionSystemModuleOperationOnStartup(
+                    permissionsFile,
+                    permissionSystemModuleOperationList,
+                    roles
+                );
+                newPermissions.AddRange(tmpPermissions);
+            }
+
             return newPermissions;
         }
         catch (Exception exception)
@@ -655,5 +1260,11 @@ public class PermissionService : BaseService, IPermissionService
         }
 
     }
-}
 
+
+
+    #endregion
+
+
+
+}

MainProject/Services/RoleService.cs

@@ -5,6 +5,7 @@ using BasicDotnetTemplate.MainProject.Models.Api.Common.Exceptions;
 using BasicDotnetTemplate.MainProject.Models.Api.Data.Role;
 using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
 using Microsoft.EntityFrameworkCore;
+using BasicDotnetTemplate.MainProject.Utils;
 
 namespace BasicDotnetTemplate.MainProject.Services;
 
@@ -22,22 +23,24 @@ public interface IRoleService
 public class RoleService : BaseService, IRoleService
 {
     private readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger();
+    private readonly CommonDbMethodsUtils _commonDbMethodsUtils;
+
     public RoleService(
         IHttpContextAccessor httpContextAccessor,
         IConfiguration configuration,
         SqlServerContext sqlServerContext
     ) : base(httpContextAccessor, configuration, sqlServerContext)
-    { }
+    {
+        _commonDbMethodsUtils = new CommonDbMethodsUtils(sqlServerContext);
+    }
 
     private IQueryable<Role> GetRolesQueryable()
     {
-        return this._sqlServerContext.Roles.Where(x => !x.IsDeleted);
+        return _commonDbMethodsUtils.GetRolesQueryable();
     }
     private IQueryable<Role> GetRoleByNameQueryable(string name)
     {
-        return this.GetRolesQueryable().Where(x =>
-            x.Name.ToString() == name.ToString()
-        );
+        return _commonDbMethodsUtils.GetRoleByNameQueryable(name);
     }
 
 

MainProject/Utils/CommonDbMethodsUtils.cs

@@ -0,0 +1,32 @@
+using System;
+using System.Security.Cryptography;
+using System.Text;
+using BasicDotnetTemplate.MainProject.Core.Database;
+using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
+
+namespace BasicDotnetTemplate.MainProject.Utils;
+public class CommonDbMethodsUtils
+{
+    private readonly SqlServerContext _sqlServerContext;
+
+    public CommonDbMethodsUtils(SqlServerContext sqlServerContext)
+    {
+        _sqlServerContext = sqlServerContext;
+    }
+
+
+    public IQueryable<Role> GetRolesQueryable()
+    {
+        return this._sqlServerContext.Roles.Where(x => !x.IsDeleted);
+    }
+
+    public IQueryable<Role> GetRoleByNameQueryable(string name)
+    {
+        return this.GetRolesQueryable().Where(x =>
+            x.Name.ToString() == name.ToString()
+        );
+    }
+
+
+}
+

MainProject/Utils/FileUtils.cs.cs

@@ -1,16 +1,5 @@
-using System;
-using System.IO;
 using System.Text.Json;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.OpenApi.Models;
-using MongoDB.Driver;
 using NLog;
-using BasicDotnetTemplate.MainProject.Core.Database;
-using BasicDotnetTemplate.MainProject.Core.Middlewares;
-using BasicDotnetTemplate.MainProject.Models.Settings;
-using BasicDotnetTemplate.MainProject.Services;
-using BasicDotnetTemplate.MainProject.Models.Api.Data.Role;
-using BasicDotnetTemplate.MainProject.Models.Database.SqlServer;
 
 
 
@@ -19,6 +8,10 @@ namespace BasicDotnetTemplate.MainProject.Utils;
 public static class FileUtils
 {
     private static readonly NLog.Logger Logger = NLog.LogManager.GetCurrentClassLogger();
+    private static readonly JsonSerializerOptions jsonSerializerOptions = new()
+    {
+        PropertyNameCaseInsensitive = true
+    };
 
     public static T? ConvertFileToObject<T>(string? filePath = "")
     {
@@ -38,10 +31,7 @@ public static class FileUtils
         {
             string fileContent = File.ReadAllText(filePath);
 
-            return JsonSerializer.Deserialize<T>(fileContent, new JsonSerializerOptions
-            {
-                PropertyNameCaseInsensitive = true 
-            });
+            return JsonSerializer.Deserialize<T>(fileContent, jsonSerializerOptions);
         }
         catch (JsonException ex)
         {

MainProject/Utils/ProgramUtils.cs

@@ -277,13 +277,17 @@ public static class ProgramUtils
         Logger.Info("[ProgramUtils][CreatePermissions] Adding permissions...");
         using (var scope = app.Services.CreateScope())
         {
-            var permissionService = scope.ServiceProvider.GetRequiredService<IPermissionService>;
+            Func<IPermissionService?> permissionService = scope.ServiceProvider.GetRequiredService<IPermissionService>;
             if (permissionService != null)
             {
                 var isValidThread = Task.Run(() => permissionService!.Invoke()?.CreatePermissionsOnStartupAsync());
                 if (isValidThread.Result != null)
                 {
-                    Logger.Info("[ProgramUtils][CreatePermissions] Done permissions");
+                    foreach (var result in isValidThread.Result)
+                    {
+                        var currentResult = String.IsNullOrEmpty(result) ? "No permission tracked" : result;
+                        Logger.Info($"[ProgramUtils][CreatePermissions] => {currentResult}");
+                    }
                 }
                 else
                 {