public async Task <UserRoleDto> AddAsync(UserRoleDto userRoleDto)
{
var userRole1 = userRoleDto.UserRoleDtoToUserRole();
var userRole2 = await _userRoleRepository.AddAsync(userRole1);
return(userRole2.UserRoleToUserRoleDto());
}
public async Task AddToRoleAsync(ApplicationUser user, string roleName)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (string.IsNullOrWhiteSpace(roleName))
{
throw new ArgumentException("Invalid role name");
}
var role = await((IRoleStore <Role, String>) this).FindByNameAsync(roleName);
if (role == null)
{
throw new InvalidOperationException("Role with this name doesn't exist");
}
await _userRoleRepository.AddAsync(new UserRole
{
UserId = user.Id,
RoleId = role.Id
});
}
public async Task <ResponseBase <bool> > Create(string userId, string roleId)
{
await _userRoleRepository.AddAsync(new IdentityUserRole <string>() { RoleId = roleId, UserId = userId });
return(new ResponseBase <bool>()
{
Result = true
});
}
public async Task <UserRole> AddAsync(UserRolePostDto entity)
{
UserRolePostDtoValidator validator = new UserRolePostDtoValidator();
ValidationResult results = validator.Validate(entity);
if (!results.IsValid)
{
throw new ValidationException("UserRolePostDTO", string.Join(". ", results.Errors));
}
return(await userRoleRepository.AddAsync(mapper.Map <UserRole>(entity)));
}
public async Task <ServiceResult> AddUser(UserDto userModel)
{
userModel.Id = await _userRepository.AddAsyncById(new User {
Email = userModel.Email,
FirstName = userModel.FirstName,
LastName = userModel.LastName,
Password = _cryptographyService.ComputeHash(userModel.Password)
});
await _userRoleRepository.AddAsync(new UserRole()
{
RoleId = (int)userModel.Role, UserId = userModel.Id
});
return(new ServiceResult(ServiceResultStatus.Success, null, _localizer.Localize("New user created successfully.")));
}
private void AddUserToRole(User user, int roleId)
{
var role = _roleRepository.GetSingle(roleId);
if (role == null)
{
throw new Exception("Role could not be found.");
}
var userRole = new UserRole
{
RoleId = role.Id,
UserId = user.Id
};
_userRoleRepository.AddAsync(userRole);
_userRepository.CommitAsync();
}
public async Task <UserDto> UpdateUserAsync2(int userId, UserUpdateDto userUpdateDto)
{
using (var transaction = await _userRoleRepository.Context.Database.BeginTransactionAsync())
{
try
{
var user = await _userRepository.FindAsync(userId);
if (user == null)
{
throw new Exception($"user not found for userId = {userId}");
}
user.LastName = userUpdateDto.LastName;
var user2 = await _userRepository.UpdateAsync(user);
var userRole = _userRoleRepository.GetAll(x => x.UserId == userId);
_userRoleRepository.Delete(userRole);
foreach (var item in userUpdateDto.RoleDtos)
{
await _userRoleRepository.AddAsync(new UserRole
{
RoleId = item.Id.Value,
UserId = userId
});
}
//transaction.Commit();
return(user2.UserToUserDtoForResultUpdate());
}
catch (Exception ex)
{
//transaction.Rollback();
//Log Error ex.message;
throw ex;;
}
}
}
public override async Task <IdentityResult> AddToRoleAsync(User user, string role)
{
try
{
//get role
var myroles = await _roleRepository.GetSingleDataByConditionAsync(new { Name = role });
if (myroles != null)
{
UserRole userRole = new UserRole
{
RoleId = myroles.Id,
UserId = user.Id
};
await _userRoleRepository.AddAsync(userRole);
}
return(await Task.FromResult(IdentityResult.Success));
}
catch (Exception)
{
throw;
}
}
public async Task <ResultEntity> AddUserRole(UserRole userRole)
{
var resultEntity = new ResultEntity();
var user = await _userRepository.GetByIdAsync(userRole.UserId);
if (user != null && "sysadmin,secadmin,audadmin".Contains(user.UserName))
{
resultEntity.Message = "系统预设角色，不允许此操作";
return(resultEntity);
}
if (await ExistUserRole(userRole))
{
resultEntity.Message = "已经存在的角色，请勿重复添加！";
}
else
{
await _userRoleRepository.AddAsync(userRole);
resultEntity.Success = true;
}
return(resultEntity);
}
public async Task <bool> PromotedToAdmin(PromotedToAdminDto dto)
{
try
{
var user = await _userRepo.FindAsync(dto.UserId, AbortToken);
if (user == null)
{
return(true);
}
var userCurrentRole = await _userRoleRepo.GetUserRoles(dto.UserId, AbortToken);
if (!userCurrentRole.Any(s => s.RoleName == "admin"))
{
await _userRoleRepo.AddAsync(UserRole.Create(user.Id, "admin"));
}
return(true);
}
catch
{
return(false);
}
}
public async Task <UserRole> Create(UserRole userRole)
{
await _repository.AddAsync(userRole);
return(userRole);
}
public async Task AddAsync(UserRoleModel model)
{
await _repository.AddAsync(UserRoleFactory.Create(model, _userId));
await _unitOfWork.SaveChangesAsync();
}
public async Task CreateAsync(UserRole role)
{
await _roleRepo.AddAsync(MapTo <UserRoleDB>(role));
}
