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; }