public static IServiceCollection AddSecurity(this IServiceCollection instance, SecurityDependencySettings dependencySettings)
{
if (dependencySettings == null)
{
SystemBaseException.DependencySettingsIsNull <SecurityDependencySettings>();
}
if (dependencySettings.UseRepositoryCaching)
{
instance
.AddSingleton <IApplicationRepository, CachedApplicationRepository>()
.AddSingleton <IModuleRepository, CachedModuleRepository>()
.AddSingleton <IPermissionRepository, CachedPermissionRepository>()
.AddSingleton <IPermissionScopeRepository, CachedPermissionScopeRepository>()
.AddSingleton <IPlatformRepository, CachedPlatformRepository>()
.AddSingleton <IUserRepository, CachedUserRepository>();
}
else
{
instance
.AddSingleton <IApplicationRepository, ApplicationRepository>()
.AddSingleton <IModuleRepository, ModuleRepository>()
.AddSingleton <IPermissionRepository, PermissionRepository>()
.AddSingleton <IPermissionScopeRepository, PermissionScopeRepository>()
.AddSingleton <IPlatformRepository, PlatformRepository>()
.AddSingleton <IUserRepository, UserRepository>();
}
return(instance);
}
private async Task SaveUserPermissionAsync(UserPermission userPermission, Permission.SaveResultBase result, SqlConnection connection, SqlTransaction transaction = default, CancellationToken cancellationToken = default)
{
var _userPermission = await _saveUserPermissionCommandProvider.ExecuteAsync(userPermission, connection, transaction, cancellationToken);
if (_userPermission is null)
{
throw SystemBaseException.VariableIsNull <UserPermission>(nameof(_userPermission));
}
result.UserPermissions.Add(_userPermission);
}
public static async Task <Module> GetModuleAsync(this ModulePermission instance, IModuleRepository repository, CancellationToken cancellationToken = default)
{
if (instance is null)
{
return(null);
}
if (repository is null)
{
throw SystemBaseException.RepositoryIsNull <IModuleRepository>();
}
var moduleId = instance.ModuleId;
if (moduleId > 0)
{
var module = await repository.GetAsync(moduleId ?? 0, cancellationToken);
instance.Module = module;
return(module);
}
return(null);
}
public static async Task <Application> GetApplicationAsync(this Module instance, IApplicationRepository repository, CancellationToken cancellationToken = default)
{
if (instance is null)
{
return(null);
}
if (repository is null)
{
throw SystemBaseException.RepositoryIsNull <IApplicationRepository>();
}
var applicationId = instance.ApplicationId;
if (applicationId > 0)
{
var application = await repository.GetAsync(applicationId ?? 0, cancellationToken);
instance.Application = application;
return(application);
}
return(null);
}
public static async Task <PermissionScope> GetScopeAsync(this Permission instance, IPermissionScopeRepository repository, CancellationToken cancellationToken = default)
{
if (instance is null)
{
return(null);
}
if (repository is null)
{
throw SystemBaseException.RepositoryIsNull <IPermissionScopeRepository>();
}
var scopeId = instance.ScopeId;
if (scopeId > 0)
{
var scope = await repository.GetAsync(scopeId ?? 0, cancellationToken);
instance.Scope = scope;
return(scope);
}
return(null);
}
public static async Task <Platform> GetPlatformAsync(this Application instance, IPlatformRepository repository, CancellationToken cancellationToken = default)
{
if (instance is null)
{
return(null);
}
if (repository is null)
{
throw SystemBaseException.RepositoryIsNull <IPlatformRepository>();
}
var platformId = instance.PlatformId;
if (platformId > 0)
{
var platform = await repository.GetAsync(platformId ?? 0, cancellationToken);
instance.Platform = platform;
return(platform);
}
return(null);
}
