public async Task <Role> CreateAsync(string name)
{
var role = new Role {
Name = name
};
await roleRepository.AddAsync(role);
await dataContext.SaveChangesAsync();
return(role);
}
public virtual async Task <Result> Create(RoleCreateRequestDto dto)
{
//验证请求数据合法性
var result = dto.Valid();
if (!result.Success)
{
return(result);
}
//调用领域服务
var createResult = await IocManager.Instance.Resolve <RoleCreateService>()
.Create(dto.Name, dto.RoleId, dto.Description, AuthContextService.CurrentUser.Guid, dto.Permissions);
if (!createResult.Success)
{
return(createResult);
}
//数据持久化
_operateLog.Record(ASFPermissions.RoleCreate, dto, "Success"); //记录日志
await _roleRepository.AddAsync(createResult.Data);
return(Result.ReSuccess());
}
public async Task <ApiRequestResult> AddAsync(RoleDto dto)
{
var command = dto.EntityMap <RoleDto, Role>();
await _roleRepository.AddAsync(command);
return(ApiRequestResult.Success("添加成功"));
}
public async Task <MainRoleResponse> AddRole(RoleRequest roleRequest)
{
var role = _mapper.Map <Roles>(roleRequest);
try
{
var isExist = _roleRepository.GetRolesByIdAndName(roleRequest);
if (role.RoleId == 0 && isExist.Result == null)
{
role.CreatedBy = roleRequest.UserId.ToString();
var dataRole = await _roleRepository.AddAsync(role);
//_response.Message = dataRole == null ? Constants.Role_Not_Created : Constants.Role_Created_Success;
}
else
{
_response.Message = Constants.Role_Already_Exists;
_response.Status = false; return(_response);
}
_response.Message = Constants.Role_Created_Success;
_response.Status = true;
}
catch (Exception)
{
_response.Status = false;
_response.Message = Constants.DEFAULT_ERROR_MSG;
}
return(_response);
}
public async Task <bool> Handle(CreateRoleCommand request, CancellationToken cancellationToken)
{
var role = new Role()
{
Name = request.Name,
Desc = request.Desc,
Users = request.UserIds.Select(uid => new User()
{
Id = uid
}).ToList()
};
await _roleRepository.AddAsync(role);
if (await Commit())
{
request.Id = role.Id;
var key = GirvsEntityCacheDefaults <Role> .ByIdCacheKey.Create(role.Id.ToString());
_bus.RaiseEvent(new RemoveCacheEvent(key), cancellationToken);
_bus.RaiseEvent(new RemoveCacheListEvent(GirvsEntityCacheDefaults <Role> .ListCacheKey.Create()),
cancellationToken);
}
return(true);
}
public async Task <BaseResponse> CreateRoleAsync(CreateRoleRequestModel model)
{
var roleExists = await _roleRepository.ExistsAsync(u => u.Name == model.Name);
if (roleExists)
{
throw new BadRequestException($"Role with name '{model.Name}' already exists.");
}
var role = new Role
{
Id = Guid.NewGuid(),
Name = model.Name,
Description = model.Description
};
await _roleRepository.AddAsync(role);
await _roleRepository.SaveChangesAsync();
return(new BaseResponse
{
Status = true,
Message = "Role created successfully"
});
}
public async Task <IdentityResult> CreateAsync(Role role, CancellationToken cancellationToken)
{
role.Id = !string.IsNullOrEmpty(role.Id) ? role.Id : DataUtil.GenerateUniqueId();
await _roleRepository.AddAsync(role);
return(IdentityResult.Success);
}
public async Task <RoleDto> addAsync(RoleDto roleDto)
{
var role1 = roleDto.RoleDtoToRole();
var role2 = await _roleRepository.AddAsync(role1);
return(role2.RoleToRoleDto());
}
public async Task <Result> Create([FromBody] RoleCreateRequestDto dto)
{
//验证请求数据合法性
var result = dto.Valid();
if (!result.Success)
{
return(result);
}
//调用领域服务
int createOfAccountId = HttpContext.User.UserId();
var createResult = await this._serviceProvider.GetRequiredService <RoleCreateService>()
.Create(dto.Name, dto.Description, createOfAccountId, dto.Permissions);
if (!createResult.Success)
{
return(createResult);
}
//数据持久化
_operateLog.Record(ASFPermissions.RoleCreate, dto, "Success"); //记录日志
await _roleRepository.AddAsync(createResult.Data);
await _unitOfWork.CommitAsync(autoRollback : true);
return(Result.ReSuccess());
}
public async Task CreateAsync(Role role)
{
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
await _roleRepository.AddAsync(role);
}
public async Task<IResultModel> Add(RoleAddModel model)
{
if (await _repository.Exists(model.Name))
return ResultModel.HasExists;
var entity = _mapper.Map<RoleEntity>(model);
var result = await _repository.AddAsync(entity);
return ResultModel.Result(result);
}
public async Task HandleAsync(CreateRoleCommand command, CancellationToken cancellationToken = default)
{
var nameIsNotTakenVerificationResult = await _roleVerificationService.VerifyNameIsNotTakenAsync(command.Name);
if (!nameIsNotTakenVerificationResult.Success)
{
throw new ConflictException(nameIsNotTakenVerificationResult.Errors);
}
var role = _mapper.Map <CreateRoleCommand, Role>(command);
await _roleRepository.AddAsync(role);
}
protected override async Task CustomSeedAsync()
{
var roles = new List <string>
{
"SUPER_ADMIN",
"GESTION_UTILISATEUR", "CREATION_UTILISATEUR", "CONSULTATION_UTILISATEUR",
"GESTION_INTERVENANT", "CONSULTATION_INTERVENANT",
"GESTION_FORMATION", "CONSULTATION_FORMATION",
};
await Task.WhenAll(roles.Select(r => _roleRepository.AddAsync(new Role(r))));
}
public async Task <ActionResult> AddNewRole(SaveRoleResource saveRoleResource)
{
var role = mapper.Map <Role>(saveRoleResource);
await roleRepository.AddAsync(role);
await unitOfWork.SaveAsync();
var categoryResource = mapper.Map <KeyValuePairResource>(role);
return(Ok(categoryResource));
}
public async Task <IdentityResult> CreateAsync(Role role, CancellationToken cancellationToken)
{
try
{
await _roleRepository.AddAsync(role);
return(await Task.FromResult(IdentityResult.Success).ConfigureAwait(false));
}
catch (Exception)
{
throw;
}
}
public async Task <IResultModel> Add(RoleAddModel model)
{
if (await _repository.Exists(model.Name))
{
return(ResultModel.HasExists);
}
var moduleInfo = _mapper.Map <Role>(model);
var result = await _repository.AddAsync(moduleInfo);
return(ResultModel.Result(result));
}
public async Task AddAsync(AddRoleCommand command)
{
command.Name = command.Name.ToLower();
var role = await _repository.GetAsync(command.Name);
if (!(role is null))
{
throw new RoleException($"Role name: {command.Name} exist.");
}
await _repository.AddAsync(new Role { Name = command.Name });
}
public async Task <GenericResponse <Role> > SaveAsync(Role role)
{
try{
await roleRepository.AddAsync(role);
await unityOfWork.CompleteAsync();
return(new GenericResponse <Role>(role));
}
catch (Exception ex) {
return(new GenericResponse <Role>($"Error while saving role. Message:{ex.Message}"));
}
}
public async Task <bool> Create(Role entity)
{
await _roleRepository.AddAsync(entity);
try
{
await _unitOfWork.Commit();
return(true);
}
catch (Exception)
{
return(false);
}
}
public async Task <bool> AddAsync(Role role)
{
bool result = false;
if (role != null && !await _roleRepository.NameExistsAsync(role.Name))
{
role.NewEntity();
await _roleRepository.AddAsync(role);
result = true;
}
return(result);
}
public async Task <RoleResponse> SaveAsync(Role role)
{
try
{
await roleRepository.AddAsync(role);
await unitOfWork.CompleteAsync();
return(new RoleResponse(role));
}
catch (Exception ex)
{
return(new RoleResponse($"Error when saving the role: {ex.Message}"));
}
}
public async Task <RoleResponse> SaveAsync(Role role)
{
try
{
await _roleRepository.AddAsync(role);
await _unitOfWork.CompleteAsync();
return(new RoleResponse(role));
}
catch (Exception ex)
{
return(new RoleResponse($"An error ocurred while saving role: {ex.Message}"));
}
}
public async Task <RoleResponse> SaveAsync(Role role)
{
try
{
await roleRepository.AddAsync(role);
await unitOfWork.CompleteAsync();
return(new RoleResponse(role));
}
catch (Exception ex)
{
return(new RoleResponse($"Ошибка при сохранении Роли: {ex.Message}"));
}
}
public async Task <SaveRoleResponse> SaveAsync(Role role)
{
try
{
await _roleRepository.AddAsync(role);
await _unitOfWork.CompleteAsync();
return(new SaveRoleResponse(role));
}
catch (Exception ex)
{
// Do some logging stuff
return(new SaveRoleResponse($"An error occurred when saving the Department: {ex.Message}"));
}
}
public async Task AddAsync_Should_Add_Role()
{
var role = new Role(Guid.NewGuid(), Array.Empty <byte>(), "RoleRepositoryTestAddAsync");
var roleEntity = new RoleEntity
{
Id = role.Id,
Name = role.Name,
RowVersion = role.RowVersion.ToArray()
};
_mapperMock.Setup(x => x.Map <Role, RoleEntity>(It.IsAny <Role>()))
.Returns(roleEntity);
Func <Task> result = async() => await _repository.AddAsync(role);
await result.Should().NotThrowAsync <Exception>();
var addedRole = await _context.Roles.FindAsync(role.Id);
addedRole.Should().NotBeNull();
}
public async Task <IResultModel> Install(SystemInstallModel model)
{
await _moduleInfoService.Sync();
await _permissionService.Sync(model.Permissions);
var role = new RoleEntity
{
Name = "系统管理员"
};
await _roleRepository.AddAsync(role);
var account = new AccountEntity
{
UserName = "******",
Password = "******",
Name = "管理员"
};
await _accountRepository.AddAsync(account);
await _accountRoleRepository.AddAsync(new AccountRoleEntity { AccountId = account.Id, RoleId = role.Id });
UpdateConfig(new SystemConfigModel
{
Title = "腾迪权限管理系统",
Auditing = false,
Toolbar = new SystemToolbar
{
Fullscreen = true,
Skin = true,
Logout = true,
UserInfo = true
}
});
return(ResultModel.Success());
}
public override async Task <int> HandleCommand(InsertRoleCommand request, CancellationToken cancellationToken)
{
var id = 0;
using (var conn = DALHelper.GetConnection())
{
conn.Open();
using (var trans = conn.BeginTransaction())
{
try
{
request.Model.CreatedDate = DateTime.Now;
request.Model.CreatedBy = request.LoginSession.Id;
request.Model.ModifiedDate = DateTime.Now;
request.Model.ModifiedBy = request.LoginSession.Id;
id = await roleRepository.AddAsync(request.Model);
}
catch (Exception ex)
{
throw ex;
}
finally
{
if (id > 0)
{
trans.Commit();
}
else
{
try { trans.Rollback(); } catch { }
}
}
}
}
return(id);
}
public async Task <IResultModel> Install(SystemInstallModel model)
{
await _moduleInfoService.Sync();
await _permissionService.Sync(model.Permissions);
var role = new Role
{
Name = "系统管理员"
};
await _roleRepository.AddAsync(role);
await _accountService.Add(new AccountAddModel
{
UserName = "******",
Password = "******",
Name = "管理员",
Roles = new List <Guid> {
role.Id
}
});
UpdateConfig(new SystemConfigModel
{
Title = "通用权限管理系统",
Auditing = false,
Toolbar = new SystemToolbar
{
Fullscreen = true,
Skin = true
}
});
return(ResultModel.Success());
}
public async Task CreateRoleAsync(Role Role)
{
await roleRepository.AddAsync(Role);
}
public async Task AddAsync(Role entity)
{
await _roleRepository.AddAsync(entity);
}
