public async Task <BaseResponse> AddRoleAsync(RoleAddDto req, string account, string GroupId)
{
BaseResponse rm = new BaseResponse();
//检查该组织下该部门下是否存在相同的角色
var r = await IsExist(a => a.RoleName == req.Name /*&& a.GroupId == req.gr*/);
if (r)
{
rm.Success = false;
rm.Message = "该部门下存在相同名称的角色，请确认";
return(rm);
}
try
{
var role = _mapper.Map <RoleModel>(req);
role.Create = account;
role.GroupId = GroupId;
await _role.AddAsync(role);
rm = new HandleResponse <int> {
Key = role.Id, Success = true, Message = "添加角色成功"
};
_log.LogInformation($"{account}创建角色{req.Name},角色编号为{role.Id}成功");
}
catch (Exception ex)
{
rm.Success = false;
rm.Message = "添加角色失败";
_log.LogError($"{account}创建角色{req.Name}失败，失败原因:{ex.Message}->{ex.StackTrace}->{ex.InnerException}");
}
return(rm);
}
public async Task <ActionResult <BaseResponse> > AddRole(string GroupId, [FromBody] RoleAddDto req)
{
string Account = User.Claims.FirstOrDefault(a => a.Type == "Account").Value;
var rm = await _rs.AddRoleAsync(req, Account, GroupId);
return(rm);
}
public async Task <DResult <int> > AddRole([FromBody] RoleAddDto roleAddDto)
{
try
{
return(DResult.Succ(businessRole.AddRole(roleAddDto)));
}
catch (Exception ex)
{
Logger.Error(ex.ToString());
return(DResult.Error <int>(ExceptionParse.ParseString(ex.Message), 500));
}
}
public async Task <ActionResult <ApiResponse <Role> > > Add(RoleAddDto dto)
{
try
{
var role = _mapper.Map <Role>(dto);
var createdRole = await _roleService.Add(role);
return(createdRole.CreateSuccessResponse("Role created successfully!"));
}
catch (Exception exception)
{
return(BadRequest(exception.CreateErrorResponse()));
}
}
public async Task <IActionResult> AddRole(
RoleAddDto dto
)
{
try
{
var responsePayload = await _rolesService.AddRoleAsync(dto);
return(Ok(responsePayload));
}
catch (Exception ex)
{
return(BadRequest(new { ex.Message }));
}
}
/// <summary>
/// 添加角色
/// </summary>
/// <param name="roleAddDto"></param>
/// <returns></returns>
public int AddRole(RoleAddDto roleAddDto)
{
var systemCode = IocUnity.Get <RepositorySystem>().GetCode(roleAddDto.SystemId);
TRole role = new TRole {
Id = IdentityHelper.NewSequentialGuid().ToString("N"),
OriginalCode = string.IsNullOrEmpty(roleAddDto.Code)?null:roleAddDto.Code,
Code = string.IsNullOrEmpty(roleAddDto.Code) ? null : $"{systemCode}-{roleAddDto.Code}",
Name = roleAddDto.Name,
State = roleAddDto.State,
SystemId = roleAddDto.SystemId,
ItemId = roleAddDto.ItemId,
JsonItem = roleAddDto.JsonItem
};
if (roleAddDto.Items.IsNullOrEmpty() && roleAddDto.Items.Count > 0)
{
IList <TRelationRoleItem> roleItems = new List <TRelationRoleItem>();
foreach (var d in roleAddDto.Items)
{
TRelationRoleItem relation = new TRelationRoleItem
{
Id = IdentityHelper.NewSequentialGuid().ToString("N"),
RoleId = role.Id,
ItemId = d,
CreateTime = DateTime.Now,
UpdateTime = null
};
roleItems.Add(relation);
}
int count = 0;
IocUnity.Get <BaseData <TRelationRoleItem> >().DapperRepository.ExcuteTransaction(c =>
{
count = IocUnity.Get <RepositoryRole>().Insert(role);
IocUnity.Get <BaseData <TRelationRoleItem> >().Insert(roleItems);
});
return(count);
}
return(IocUnity.Get <RepositoryRole>().Insert(role));
}
public async Task <RoleReturnDto> AddRoleAsync(RoleAddDto dto)
{
var roleInDb =
await(await _roleRepository.GetAllAsync(d => d.Name == dto.RoleName))
.FirstOrDefaultAsync();
if (roleInDb != null)
{
throw new ObjectAlreadyExistException("Role with such name already added.");
}
var userForDb = new Role
{
Name = dto.RoleName,
};
var user = (await _roleRepository.InsertAsync(userForDb));
return(user.ToRoleReturnDto());
//throw new NotImplementedException();
}
