public async Task <IdentityResult> CreateAsync(ApplicationRole role, CancellationToken cancellationToken) { if (role == null) { throw new ArgumentNullException(nameof(role)); } if (!Constants.RoleName.GetAllValues <string>().Contains(role.Name)) { return(IdentityResult.Failed(_identityErrorDescriber.InvalidRoleName(role.Name))); } var roleEntity = new IdentityRoleEntity { Name = role.Name }; try { if (await _appDb.RoleRepository.RoleNameExistsAsync(role.Name, cancellationToken)) { return(IdentityResult.Failed(_identityErrorDescriber.DuplicateRoleName(role.Name))); } await _appDb.GenericRepository.SaveEntityAsync(roleEntity, true, false, cancellationToken); role.Id = roleEntity.Id; } catch (Exception) { _logger.LogError($"Role name '{role.Name}' could not be created"); return(IdentityResult.Failed(_identityErrorDescriber.DefaultError())); } return(IdentityResult.Success); }
/// <summary> Finds the roles in this collection. </summary> /// <param name="role"> The role. </param> /// <returns> /// An enumerator that allows foreach to be used to process the roles in this collection. /// </returns> public virtual IEnumerable <int> FindByRole(IdentityRoleEntity role) { var command = SqlBuilder.SelectByFilter(EntityType, nameof(IdentityUserRoleEntity.RoleId), new[] { nameof(IdentityUserRoleEntity.UserId) }); return(UnitOfWork.Connection.Query <int>(command, new { RoleId = role.Id }, UnitOfWork.Transaction)); }
/// <summary> Sets role name asynchronous. </summary> /// <param name="role"> The role. </param> /// <param name="roleName"> Name of the role. </param> /// <param name="cancellationToken"> The cancellation token. </param> /// <returns> A Task. </returns> public Task SetRoleNameAsync(IdentityRoleEntity role, string roleName, CancellationToken cancellationToken) { return(Task.Factory.StartNew(() => { role.Name = roleName; UnitOfWork.RoleRepository.Update(role); }, cancellationToken)); }
/// <summary>Can delete activity.</summary> public virtual void CanDeleteActivityRole() { var role = new IdentityRoleEntity { ApplicationId = 0, Description = "MyRole", Identifier = Guid.NewGuid(), NormalizedName = "myrole", Name = "MyRole" }; using (var iUow = _identityDataService.StartUnitOfWork()) { role = iUow.RoleRepository.Add(role); iUow.Commit(); } try { using (var uow = DataService.StartUnitOfWork()) { var activity = new ActivityEntity { Name = "MyActivity", ResourceName = "MyResource", ResourceDisplayName = "MyDisplayName", GroupName = "MyGroupName", GroupDisplayName = "MyGroupDisplayName" }; activity = uow.ActivityRepository.Add(activity); var aRole = new ActivityRoleEntity { ActivityId = activity.Id, RoleId = role.Id, Allow = true }; uow.ActivityRoleRepository.Add(aRole); aRole.Allow = false; uow.ActivityRoleRepository.Delete(aRole); Assert.AreEqual(null, uow.ActivityRoleRepository.Get(aRole.Id)); } } finally { using (var iUow = _identityDataService.StartUnitOfWork()) { iUow.RoleRepository.Delete(role); iUow.Commit(); } } }
public virtual void CanUpdateUserRole() { using (var uow = DataService.StartUnitOfWork()) { var user = new IdentityUserEntity { Identifier = Guid.NewGuid(), Name = "Achim Schnell", NormalizedName = "ACHIM SCHNELL", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", AccessFailedCount = 0, ApplicationId = 0, EmailConfirmed = true, IsAnonymous = false, LastActivityDate = DateTime.Now }; uow.UserRepository.Add(user); var user2 = new IdentityUserEntity { Identifier = Guid.NewGuid(), Name = "Stefan Schnell", NormalizedName = "STEFAN SCHNELL", Email = "*****@*****.**", NormalizedEmail = "*****@*****.**", AccessFailedCount = 0, ApplicationId = 0, EmailConfirmed = true, IsAnonymous = false, LastActivityDate = DateTime.Now }; uow.UserRepository.Add(user2); var role = new IdentityRoleEntity { Identifier = Guid.NewGuid(), Name = "DummyRole", ApplicationId = 0, Description = "DummyRole", NormalizedName = "dummyrole" }; uow.RoleRepository.Add(role); var userRole = new IdentityUserRoleEntity { UserId = user.Id, RoleId = role.Id }; userRole = uow.UserRoleRepository.Add(userRole); userRole.UserId = user2.Id; uow.UserRoleRepository.Update(userRole); Assert.AreEqual(userRole.UserId, uow.UserRoleRepository.Get(userRole.Id).UserId); } }
/// <summary> Deletes the asynchronous. </summary> /// <param name="role"> The role. </param> /// <param name="cancellationToken"> The cancellation token. </param> /// <returns> A Task<IdentityResult> </returns> public Task <IdentityResult> DeleteAsync(IdentityRoleEntity role, CancellationToken cancellationToken) { return(Task <IdentityResult> .Factory.StartNew(() => { try { UnitOfWork.RoleRepository.Delete(role); return IdentityResult.Success; } catch (Exception) { return IdentityResult.Failed(); } }, cancellationToken)); }
public virtual void CanAddAndFindByIds() { using (var uow = DataService.StartUnitOfWork()) { var role = new IdentityRoleEntity { Identifier = Guid.NewGuid(), Name = "DummyRole", ApplicationId = 0, Description = "DummyRole", NormalizedName = "dummyrole" }; uow.RoleRepository.Add(role); Assert.AreEqual(1, uow.RoleRepository.FindByIds(new[] { role.Id }).Count()); } }
/// <summary> Can add and get role. </summary> public virtual void CanAddAndGetRoleByIdentifier() { using (var uow = DataService.StartUnitOfWork()) { var role = new IdentityRoleEntity { Identifier = Guid.NewGuid(), Name = "DummyRole", ApplicationId = 0, Description = "DummyRole", NormalizedName = "dummyrole" }; uow.RoleRepository.Add(role); Assert.AreEqual(role.Name, uow.RoleRepository.Get(role.Identifier.ToString()).Name); } }
public IActionResult AddRole(RoleAddModel model) { if (ModelState.IsValid) { using (var uow = _identityDataService.StartUnitOfWork()) { var role = new IdentityRoleEntity { ApplicationId = 0, Name = model.Name, Description = model.Description, Identifier = Guid.NewGuid(), NormalizedName = model.Name.ToUpper() }; uow.RoleRepository.Add(role); uow.Commit(); return(RedirectToAction(nameof(ManageRoles))); } } return(View(model)); }
/// <summary> Gets normalized role name asynchronous. </summary> /// <param name="role"> The role. </param> /// <param name="cancellationToken"> The cancellation token. </param> /// <returns> The normalized role name asynchronous. </returns> public Task <string> GetNormalizedRoleNameAsync(IdentityRoleEntity role, CancellationToken cancellationToken) { return(Task.FromResult(role.NormalizedName)); }
/// <summary> Gets role identifier asynchronous. </summary> /// <param name="role"> The role. </param> /// <param name="cancellationToken"> The cancellation token. </param> /// <returns> The role identifier asynchronous. </returns> public Task <string> GetRoleIdAsync(IdentityRoleEntity role, CancellationToken cancellationToken) { return(Task.FromResult(role.Identifier.ToString())); }
/// <summary>Can add and get activities.</summary> public virtual void CanAddAndGetActivityRoles() { var activity1 = new ActivityEntity { Name = "MyActivity 1", ResourceName = "MyResource", ResourceDisplayName = "MyDisplayName", GroupName = "MyGroupName", GroupDisplayName = "MyGroupDisplayName" }; var activity2 = new ActivityEntity { Name = "MyActivity 2", ResourceName = "MyResource", ResourceDisplayName = "MyDisplayName", GroupName = "MyGroupName", GroupDisplayName = "MyGroupDisplayName" }; var role = new IdentityRoleEntity { ApplicationId = 0, Description = "MyRole", Identifier = Guid.NewGuid(), NormalizedName = "myrole", Name = "MyRole" }; using (var iUow = _identityDataService.StartUnitOfWork()) { role = iUow.RoleRepository.Add(role); iUow.Commit(); } try { using (var uow = DataService.StartUnitOfWork()) { activity1 = uow.ActivityRepository.Add(activity1); activity2 = uow.ActivityRepository.Add(activity2); var aRoles = new[] { new ActivityRoleEntity { ActivityId = activity1.Id, RoleId = role.Id, Allow = true }, new ActivityRoleEntity { ActivityId = activity2.Id, RoleId = role.Id, Allow = true } }; uow.ActivityRoleRepository.AddRange(aRoles); Assert.AreEqual(aRoles.Length, uow.ActivityRoleRepository.GetAll().Count()); } } finally { using (var iUow = _identityDataService.StartUnitOfWork()) { iUow.RoleRepository.Delete(role); iUow.Commit(); } } }
/// <summary> /// Finds the roles in this collection. /// </summary> /// <param name="role"> The role. </param> /// <returns> /// An enumerator that allows foreach to be used to process the roles in this collection. /// </returns> public IEnumerable <int> FindByRole(IdentityRoleEntity role) { return(Collection.Find(e => e.RoleId == role.Id).Select(e => e.UserId)); }