public RolePermissionService(IRoleRepository roleRepository, IPermissionRepository permissionRepository, IUnitOfWork unitOfWork, AppDbContext dbContext, IRolePermissionRepository rolePermission, IMapper mapper)
{
_unitOfWork = unitOfWork;
_mapper = mapper;
_permissionRepository = permissionRepository;
_dbContext = dbContext;
_rolePermission = rolePermission;
_roleRepository = roleRepository;
}
public RoleManager(
IRoleRepository roleRepository,
IRolePermissionRepository rolePermissionRepository,
IPermissionManager permissionManager)
{
_roleRepository = roleRepository;
_rolePermissionRepository = rolePermissionRepository;
_permissionManager = permissionManager;
}
public AuthorizationService(IRolePermissionRepository rolePermissionRepository,
IOrganizationUserPermissionRepository organizationUserPermissionRepository,
IOrganizationUserRoleRepository organizationUserRoleRepository
)
{
this.rolePermissionRepository = rolePermissionRepository;
this.organizationUserPermissionRepository = organizationUserPermissionRepository;
this.organizationUserRoleRepository = organizationUserRoleRepository;
}
public RoleService(RoleManager <Role> roleManager, IRolePermissionRepository rolePermissionRepository,
IPermissionRepository permissionRepository, ISystemAreaRepository systemAreaRepository, IRolePermissionsCache rolePermissionsCache)
{
_roleManager = roleManager;
_rolePermissionRepository = rolePermissionRepository;
_permissionRepository = permissionRepository;
_systemAreaRepository = systemAreaRepository;
_rolePermissionsCache = rolePermissionsCache;
}
public UserService(UserManager <User> userManager, RoleManager <Role> roleManager,
SignInManager <User> signInManager, IRolePermissionsCache rolePermissionsCache, IUserRoleRepository userRoleRepository, IRolePermissionRepository rolePermissionRepository)
{
_userManager = userManager;
_roleManager = roleManager;
_signInManager = signInManager;
_rolePermissionsCache = rolePermissionsCache;
_userRoleRepository = userRoleRepository;
_rolePermissionRepository = rolePermissionRepository;
}
public UserManager(IHandler handler)
{
this.handler = handler;
this.permissionRepository = handler.Storage.GetRepository <IPermissionRepository>();
this.roleRepository = handler.Storage.GetRepository <IRoleRepository>();
this.rolePermissionRepository = handler.Storage.GetRepository <IRolePermissionRepository>();
this.userRepository = handler.Storage.GetRepository <IUserRepository>();
this.userRoleRepository = handler.Storage.GetRepository <IUserRoleRepository>();
this.credentialTypeRepository = handler.Storage.GetRepository <ICredentialTypeRepository>();
this.credentialRepository = handler.Storage.GetRepository <ICredentialRepository>();
}
public RoleService(IUnitOfWork unitOfWork, IRoleRepository roleRep,
IUserRepository userRep,
IRolePermissionRepository rolePermissionRep,
IUserRoleRelRepository usrRoleRelRep)
: base(unitOfWork)
{
_roleRepository = roleRep;
_userRepository = userRep;
_rolePermissionRep = rolePermissionRep;
_usrRoleRelRep = usrRoleRelRep;
}
public RolePermissionFace(IRoleRepository roleRepository,
IRolePermissionRepository rolePermissionRepository,
IPermissionRepository permissionRepository,
ISysUserRoleRepository sysUserRoleRepository)
{
_roleRepository = roleRepository;
_rolePermissionRepository = rolePermissionRepository;
_permissionRepository = permissionRepository;
_sysUserRoleRepository = sysUserRoleRepository;
_unitOfWork = _roleRepository.UnitOfWork;
}
public DefaultUserManager(IHttpContextAccessor httpContextAccessor, IStorage storage)
{
this.httpContextAccessor = httpContextAccessor;
this.storage = storage;
this.permissionRepository = this.storage.GetRepository <IPermissionRepository>();
this.roleRepository = this.storage.GetRepository <IRoleRepository>();
this.rolePermissionRepository = this.storage.GetRepository <IRolePermissionRepository>();
this.userRepository = this.storage.GetRepository <IUserRepository>();
this.userRoleRepository = this.storage.GetRepository <IUserRoleRepository>();
this.credentialTypeRepository = this.storage.GetRepository <ICredentialTypeRepository>();
this.credentialRepository = this.storage.GetRepository <ICredentialRepository>();
}
public PermissionsController(IPermissionRepository permissionRepository,
IRolePermissionRepository rolePermissionRepository,
IRoleMemberRepository roleMemberRepository,
IUserRepository userRepository,
IUnitOfWork unitOfWork)
{
_permissionRepository = permissionRepository;
_rolePermissionRepository = rolePermissionRepository;
_roleMemberRepository = roleMemberRepository;
_userRepository = userRepository;
_unitOfWork = unitOfWork;
}
public RoleService(
IUser user,
IMapper mapper,
IRoleRepository roleRepository,
IRolePermissionRepository rolePermissionRepository
)
{
_user = user;
_mapper = mapper;
_roleRepository = roleRepository;
_rolePermissionRepository = rolePermissionRepository;
}
public PermissionService(
IMapper mapper,
ICache cache,
IPermissionRepository permissionRepository,
IRolePermissionRepository rolePermissionRepository
)
{
_mapper = mapper;
_cache = cache;
_permissionRepository = permissionRepository;
_rolePermissionRepository = rolePermissionRepository;
}
public AccountController(GridDataContext dataContext,
IUserRepository userRepository,
IRoleMemberRepository roleMemberRepository,
IRolePermissionRepository rolePermissionRepository,
IUnitOfWork unitOfWork)
{
_dataContext = dataContext;
_userRepository = userRepository;
_rolePermissionRepository = rolePermissionRepository;
_roleMemberRepository = roleMemberRepository;
_unitOfWork = unitOfWork;
}
/// <summary>
/// First, check that a role with this name doesn't already exist.
///
/// Second, save new data into database.
/// </summary>
/// <param name="storage_">Storage interface provided by services container.</param>
/// <param name="roleManager_">Roles manager object.</param>
/// <param name="model_">A <see cref="SaveNewRoleAndGrantsViewModel" /> object.</param>
/// <returns>Null if success, otherwise error message.</returns>
public static async Task <string> CheckAndSaveNewRoleAndGrantsAsync(IStorage storage_, RoleManager <IdentityRole <string> > roleManager_, SaveNewRoleAndGrantsViewModel model_)
{
if (await UpdateRoleAndGrants.CheckThatRoleOfThisNameExistsAsync(roleManager_, model_.RoleName))
{
return("A role with this name already exists");
}
if (model_.Extensions == null || !model_.Extensions.Any())
{
return("At least one extension must be selected");
}
try
{
// Convert the string to the enum
if (Enum.TryParse <Common.Enums.Permission>(model_.PermissionValue, true, out var permissionEnumValue))
{
var permissionEntity = storage_.GetRepository <IPermissionRepository>().Find(permissionEnumValue);
// Save the Role
IdentityRole <string> identityRole = new IdentityRole <string>
{
// Auto-incremented ID
Name = model_.RoleName
};
await roleManager_.CreateAsync(identityRole);
// Save the role-extension-permission link
if (model_.Extensions != null)
{
IRolePermissionRepository repo = storage_.GetRepository <IRolePermissionRepository>();
foreach (string extension in model_.Extensions)
{
repo.Create(new RolePermission
{
RoleId = identityRole.Id,
PermissionId = permissionEntity.Id,
Extension = extension
});
}
}
}
await storage_.SaveAsync();
return(null);
}
catch (Exception e)
{
return($"{e.Message} {e.StackTrace}");
}
}
public ModuleService(IUnitOfWork unitOfWork, IModuleRepository moduleRep,
IUserRepository usrRep,
IRolePermissionRepository rolePermissionRep,
IRoleRepository roleRep,
IOperationRepository optRep)
: base(unitOfWork)
{
_moduleRepository = moduleRep;
_usrRepository = usrRep;
_rolePermissionRep = rolePermissionRep;
_roleRep = roleRep;
_optRep = optRep;
}
public RoleController(
IRoleRepository roleMgmtRepository,
IPermissionRepository permissionRepository,
IRolePermissionRepository rolePermissionRepository,
IOptions <ApiDefaultValueConfig> config,
ILogger <RoleController> logger,
IMapper mapper) : base(logger, mapper)
{
_rr = roleMgmtRepository;
_pr = permissionRepository;
_rpr = rolePermissionRepository;
_logger = logger;
}
public async Task <IActionResult> DeleteRoleExtensionLink(string roleName_, string scope_)
{
string roleId = (await _roleManager.FindByNameAsync(roleName_)).Id;
IRolePermissionRepository repo = Storage.GetRepository <IRolePermissionRepository>();
if (repo.FindBy(roleId, scope_) != null)
{
repo.Delete(roleId, scope_);
Storage.Save();
return(new JsonResult(true));
}
return(new JsonResult(false));
}
public PermissionService(
AppConfig appConfig,
IPermissionRepository permissionRepository,
IRoleRepository roleRepository,
IRolePermissionRepository rolePermissionRepository,
ITenantRepository tenantRepository
)
{
_appConfig = appConfig;
_permissionRepository = permissionRepository;
_roleRepository = roleRepository;
_rolePermissionRepository = rolePermissionRepository;
_tenantRepository = tenantRepository;
}
public RoleService(IMapper mapper, IRoleRepository repository, IRoleMenuRepository roleMenuRepository, IAccountRoleRepository accountRoleRepository, IAccountService accountService, IMenuRepository menuRepository, AdminDbContext dbContext, ICacheHandler cacheHandler, IRolePageRepository pageRepository, IRoleButtonRepository buttonRepository1, IRolePermissionRepository permissionRepository)
{
_mapper = mapper;
_repository = repository;
_roleMenuRepository = roleMenuRepository;
_accountRoleRepository = accountRoleRepository;
_accountService = accountService;
_menuRepository = menuRepository;
_dbContext = dbContext;
_cacheHandler = cacheHandler;
_pageRepository = pageRepository;
_buttonRepository = buttonRepository1;
_permissionRepository = permissionRepository;
}
public TenantService(
ITenantRepository tenantRepository,
IRoleRepository roleRepository,
IUserRepository userRepository,
IUserRoleRepository userRoleRepository,
IRolePermissionRepository rolePermissionRepository
)
{
_tenantRepository = tenantRepository;
_roleRepository = roleRepository;
_userRepository = userRepository;
_userRoleRepository = userRoleRepository;
_rolePermissionRepository = rolePermissionRepository;
}
public UserService(
AppConfig appConfig,
IUserRepository userRepository,
IUserRoleRepository userRoleRepository,
IRolePermissionRepository rolePermissionRepository,
ITenantRepository tenantRepository
)
{
_appConfig = appConfig;
_userRepository = userRepository;
_userRoleRepository = userRoleRepository;
_rolePermissionRepository = rolePermissionRepository;
_tenantRepository = tenantRepository;
}
public OperationService(IUnitOfWork unitOfWork,
IOperationRepository optRepository, IRoleRepository roleRepository,
IModuleRepository moduleRepository, IRolePermissionRepository rolePerRepository,
IUserRoleRelRepository usrRoleRelRepository,
IUserRepository usrRepository)
: base(unitOfWork)
{
_optRepository = optRepository;
_roleRepository = roleRepository;
_moduleRepository = moduleRepository;
_rolePerRepository = rolePerRepository;
_usrRoleRelRepository = usrRoleRelRepository;
_usrRepository = usrRepository;
}
public AuthService(
IUser user,
ICache cache,
IUserToken userToken,
IUserRepository userRepository,
IRolePermissionRepository rolePermissionRepository
)
{
_user = user;
_cache = cache;
_userToken = userToken;
_userRepository = userRepository;
_rolePermissionRepository = rolePermissionRepository;
}
protected void addSubmit_Click(object sender, EventArgs e)
{
//check for nulls
if ((String.IsNullOrEmpty(addRoleIDTextBox.Text)) ||
(String.IsNullOrEmpty(addObjectTextBox.Text)) ||
(String.IsNullOrEmpty(addUpdateTextBox.Text)) ||
(String.IsNullOrEmpty(addViewTextBox.Text)) ||
(String.IsNullOrEmpty(addCreateTextBox.Text)) ||
(String.IsNullOrEmpty(addDeleteTextBox.Text)))
{
//return a error message
errorLabel.Text = "Please enter a valid value for all fields";
errorLabel.Visible = true;
}
else
{
try
{
IRolePermissionRepository rolePermRepo = RepositoryFactory.Get <IRolePermissionRepository>();
RolePermission addMe = new RolePermission();
addMe.obj_create = int.Parse(addCreateTextBox.Text);
addMe.obj_delete = int.Parse(addDeleteTextBox.Text);
addMe.obj_update = int.Parse(addUpdateTextBox.Text);
addMe.obj_view = int.Parse(addViewTextBox.Text);
addMe.@object = addObjectTextBox.Text;
addMe.roleID = int.Parse(addRoleIDTextBox.Text);
rolePermRepo.AddRolePermission(addMe);
rolePermRepo.SubmitChanges();
//return a validation message
errorLabel.Text = "New Permission has been added";
errorLabel.Visible = true;
//hide the panel
addPanel.Visible = false;
}
catch (Exception)
{
//error message
errorLabel.Text = "Database error when adding role permission";
errorLabel.Visible = true;
}
updateRolePermissionTable();
}
}
protected void editSubmit_Click(object sender, EventArgs e)
{
//check for nulls
if ((String.IsNullOrEmpty(editRoleIDTextBox.Text)) ||
(String.IsNullOrEmpty(editObjectTextBox.Text)) ||
(String.IsNullOrEmpty(editUpdateTextBox.Text)) ||
(String.IsNullOrEmpty(editViewTextBox.Text)) ||
(String.IsNullOrEmpty(editCreateTextBox.Text)) ||
(String.IsNullOrEmpty(editDeleteTextBox.Text)))
{
//return a error message
errorLabel.Text = "Please enter a valid value for all fields";
errorLabel.Visible = true;
}
else
{
try
{
IRolePermissionRepository rolePermRepo = RepositoryFactory.Get <IRolePermissionRepository>();
RolePermission editMe = rolePermRepo.GetById(int.Parse(editPermLabel.Text));
editMe.obj_create = int.Parse(editCreateTextBox.Text);
editMe.obj_delete = int.Parse(editDeleteTextBox.Text);
editMe.obj_update = int.Parse(editUpdateTextBox.Text);
editMe.obj_view = int.Parse(editViewTextBox.Text);
editMe.@object = editObjectTextBox.Text;
editMe.roleID = int.Parse(editRoleIDTextBox.Text);
//rolePermRepo.editRolePermission(editMe);
rolePermRepo.SubmitChanges();
//return a validation message
errorLabel.Text = "Permission has been editted";
errorLabel.Visible = true;
//hide the panel
editPanel.Visible = false;
}
catch (Exception)
{
//error message
errorLabel.Text = "Database error when editing role permission";
errorLabel.Visible = true;
}
updateRolePermissionTable();
}
}
public RetrieveUserInfoDomainService(
IUserRoleRepository userRoleRepository,
IUserInUserGroupRepository userInUserGroupRepository,
IUserGroupInRoleRepository userGroupInRoleRepository,
IRolePermissionRepository rolePermissionRepository,
IPermissionMenuRepository permissionMenuRepository,
IPermissionActorRepository permissionActorRepository)
{
_userRoleRepository = userRoleRepository;
_userInUserGroupRepository = userInUserGroupRepository;
_userGroupInRoleRepository = userGroupInRoleRepository;
_rolePermissionRepository = rolePermissionRepository;
_permissionMenuRepository = permissionMenuRepository;
_permissionActorRepository = permissionActorRepository;
}
[HttpGet] // TODO change to POST
public async Task <IActionResult> UpdateRolePermission(string roleName_, string permissionId_, string scope_)
{
string roleId = (await _roleManager.FindByNameAsync(roleName_)).Id;
IRolePermissionRepository repo = Storage.GetRepository <IRolePermissionRepository>();
repo.Delete(roleId, scope_);
if (!string.IsNullOrEmpty(permissionId_.ToLowerInvariant()))
{
repo.Create(new RolePermission {
RoleId = roleId, PermissionId = permissionId_.UppercaseFirst(), Scope = scope_
});
}
Storage.Save();
return(new JsonResult(true));
}
public UserService(
IUser user,
ICache cache,
IMapper mapper,
IUserRepository userRepository,
IUserRoleRepository userRoleRepository,
IRolePermissionRepository rolePermissionRepository
)
{
_user = user;
_cache = cache;
_mapper = mapper;
_userRepository = userRepository;
_userRoleRepository = userRoleRepository;
_rolePermissionRepository = rolePermissionRepository;
}
/// <summary>
/// First, check that a role with this name doesn't already exist.
/// Second, save new data into database.
/// </summary>
/// <param name="model_">Model with role name and grant data (extensions and permission level)</param>
/// <param name="roleManager_"></param>
/// <param name="storage_"></param>
/// <returns>Not null when something failed, else null when save went ok</returns>
public static async Task <string> CheckAndSaveNewRoleAndGrants(SaveNewRoleAndGrantsViewModel model_, RoleManager <IdentityRole <string> > roleManager_, IStorage storage_)
{
if (await UpdateRole.CheckThatRoleOfThisNameExists(roleManager_, model_.RoleName))
{
return("A role with this name already exists");
}
try
{
// Convert the string to the enum
var permissionEnum = Enum.Parse <Security.Common.Enums.Permission>(model_.Permission, true);
// Save the Role
IdentityRole <string> identityRole = new IdentityRole <string>
{
// Auto-incremented ID
Name = model_.RoleName
};
await roleManager_.CreateAsync(identityRole);
// Save the role-extension-permission link
if (model_.Extensions != null)
{
IRolePermissionRepository repo = storage_.GetRepository <IRolePermissionRepository>();
foreach (string extension in model_.Extensions)
{
repo.Create(new RolePermission
{
RoleId = identityRole.Id, PermissionId = permissionEnum.ToString(), Scope = extension
});
}
}
storage_.Save();
return(null);
}
catch (Exception e)
{
return($"{e.Message} {e.StackTrace}");
}
}
public RoleService(IMapper mapper
, DbContext dbContext
, ILoginInfo loginInfo
, IRoleRepository roleRepository
, IMenuRepository menuRepository
, IMenuButtonRepository menuButtonRepository
, IPermissionRepository permissionRepository
, IRoleMenuRepository roleMenuRepository
, IRolePermissionRepository rolePermissionRepository
)
{
_mapper = mapper;
_dbContext = dbContext;
_loginInfo = loginInfo;
_roleRepository = roleRepository;
_menuRepository = menuRepository;
_menuButtonRepository = menuButtonRepository;
_permissionRepository = permissionRepository;
_roleMenuRepository = roleMenuRepository;
_rolePermissionRepository = rolePermissionRepository;
}
public RolePermissionService(IRolePermissionRepository repository)
{
_repository = repository;
}
