/// <summary>
/// 新增
/// </summary>
/// <param name="roleRequestDto"></param>
/// <returns></returns>
public async Task <bool> CreateAsync(RoleRequestDto roleRequestDto)
{
var role = roleRequestDto.MapToCreateEntity <RoleRequestDto, Role>();
await RoleValidatorsFilter.DoValidationAsync(_roleRespository, role, ValidatorTypeConstants.Create);
return(await _roleRespository.InsertAsync(role));
}
public async Task <IHttpActionResult> UpdateRole(RoleRequestDto model)
{
var controllerEndpoint = _configurationManager.GetByKey("IS.UpdateRole");
var response = await PutAsync(controllerEndpoint, model);
return(ResponseMessage(response));
}
/// <summary>
/// 修改
/// </summary>
/// <param name="roleRequestDto"></param>
/// <returns></returns>
public async Task <bool> ModifyAsync(RoleRequestDto roleRequestDto)
{
var role = await _roleRespository.FirstOrDefaultAsync(e => e.Id == roleRequestDto.Id);
var entity = roleRequestDto.MapToModifyEntity <RoleRequestDto, Role>(role);
await RoleValidatorsFilter.DoValidationAsync(_roleRespository, entity, ValidatorTypeConstants.Modify);
return(await _roleRespository.UpdateAsync(entity));
}
/// <summary>
/// 修改
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <JsonResponse> Modify(RoleRequestDto input)
{
input.InitModifyRequest();
var resJson = await _applicationEnginee.TryTransactionAsync(async() =>
{
await _roleAppService.ModifyAsync(input);
});
return(resJson);
}
public async Task <IActionResult> UpdateRole(Guid RoleId, RoleRequestDto model)
{
try
{
await _roleService.UpdateRole(RoleId, model);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <IActionResult> CreateRole(RoleRequestDto request)
{
try
{
await _roleService.CreateRole(request);
return(Ok());
}
catch (AppException ex)
{
return(BadRequest(new { message = ex.Message }));
}
}
public async Task <IHttpActionResult> CreateRole(RoleRequestDto model)
{
var controllerEndpoint = _configurationManager.GetByKey("IS.CreateRole");
var response = await PostAsync(controllerEndpoint, model);
if (!response.IsSuccessStatusCode)
{
return(ResponseMessage(response));
}
var role = response.Content.ReadAsAsync <RoleResponse>().Result;
return(Ok(role));
}
public async Task <RoleDto> QueryRole(RoleRequestDto request)
{
var rep = _freeSql.GetRepository <Role>();
var res = await rep.Select.IncludeMany(rol => rol.Users)
.WhereIf(request.Id != null, x => x.Id == request.Id)
.WhereIf(request.Version != null, x => x.Version == request.Version)
.WhereIf(!string.IsNullOrWhiteSpace(request.CreateBy), x => x.CreateBy.Contains(request.CreateBy))
.WhereIf(!string.IsNullOrWhiteSpace(request.UpdateBy), x => x.UpdateBy.Contains(request.UpdateBy))
.WhereIf(request.IsDeleted != null, x => x.IsDeleted == request.IsDeleted)
.WhereIf(!string.IsNullOrWhiteSpace(request.Name), x => x.Name.Contains(request.Name))
.WhereIf(!string.IsNullOrWhiteSpace(request.Code), x => x.Code.Contains(request.Code))
.WhereIf(!string.IsNullOrWhiteSpace(request.Descriptions), x => x.Descriptions.Contains(request.Descriptions))
.ToOneAsync <RoleDto>();
return(res);
}
public async Task <ApplicationRole> CreateRole(RoleRequestDto request)
{
return(await ProcessRequest(async() =>
{
var role = await _unitOfWork.Role.FindByNameAsync(request.Name);
if (role != null)
{
throw new AppException(_logger, $"Role Name: {request.Name} is already taken");
}
role = _mapper.Map <ApplicationRole>(request);
role.NormalizedName = role.Name.ToUpper();
role.Name = role.NormalizedName.ToLower();
await _unitOfWork.Role.CreateAsync(role);
await _unitOfWork.SaveAsync();
return role;
}));
}
public async Task UpdateRole(Guid RoleId, RoleRequestDto request)
{
await ProcessRequest(async() =>
{
var role = await _unitOfWork.Role.FindByIdAsync(RoleId);
if (role == null)
{
throw new AppException(_logger, "Role not found");
}
if (!await _unitOfWork.Role.GetByAnyConditionAsync(x => x.Name == request.Name && x.Id != RoleId))
{
if (!string.IsNullOrEmpty(request.Name))
{
role.Name = request.Name.ToLower();
}
else
{
role.Name = role.Name;
}
if (!string.IsNullOrEmpty(request.Description))
{
role.Description = request.Description;
}
else
{
role.Description = role.Description;
}
_unitOfWork.Role.Update(role);
await _unitOfWork.SaveAsync();
}
else
{
throw new AppException(_logger, $"Role Name: {request.Name} is already taken");
}
});
}
