public async Task <string> Update(UpdateRoleInput input)
{
input.CheckDataAnnotations().CheckValidResult();
await _roleDomainService.Update(input);
return("更新角色信息成功");
}
public void Update(UpdateRoleInput input)
{
input.Validate();
Sys_Role role = this.DbContext.QueryByKey <Sys_Role>(input.Id, true);
role.NotNull("角色不存在");
this.MapValueFromInput(role, input);
string[] permissionIds = input.GetPermissionIds();
List <Sys_RoleAuthorize> roleAuthorizeEntitys = this.CreateRoleAuthorizes(role.Id, permissionIds);
this.DbContext.DoWithTransaction(() =>
{
this.DbContext.Update(role);
this.DbContext.Delete <Sys_RoleAuthorize>(a => a.RoleId == role.Id);
foreach (var roleAuthorizeEntity in roleAuthorizeEntitys)
{
this.DbContext.Insert(roleAuthorizeEntity);
}
});
}
public async Task UpdateRoleAsync(UpdateRoleInput input)
{
var role = await _roleRepository.GetAsync(input.Role.Id);
input.Role.MapTo(role);
await _roleManager.UpdateAsync(role);
}
public ResponseInfoModel EditInfo([FromBody] UpdateRoleInput input)
{
ResponseInfoModel json = new ResponseInfoModel()
{
Success = 1, Result = new object()
};
try
{
CheckModelState();
if (!_roleService.EditInfo(input))
{
json.Success = 0;
json.Result = LocalizationConst.UpdateFail;
}
else
{
_logService.Insert(new Log()
{
ActionContent = LocalizationConst.Update,
SourceType = _moduleName,
SourceID = input.ID,
LogTime = DateTime.Now,
LogUserID = input.ID,
LogIPAddress = IPHelper.GetIPAddress,
});
}
}
catch (Exception e)
{
DisposeUserFriendlyException(e, ref json, "api/role/editInfo", LocalizationConst.UpdateFail);
}
return(json);
}
public IHttpActionResult UpdateRole(UpdateRoleInput input)
{
Init();
input.AccessToken = ApiSession.AccessToken;
UpdateRoleOutput output = _rolesSvc.UpdateRole(input);
return(Ok(output));
}
public async Task <UpdateRoleOutput> UpdateRole(UpdateRoleInput input)
{
var role = _roleManager.GetRole(input.Id);
role.DisplayName = input.DisplayName;
role.Describe = input.Describe;
return(new UpdateRoleOutput());
}
public async Task <string> Update(UpdateRoleInput input)
{
input.CheckDataAnnotations().CheckValidResult();
CheckIsAllOrg(input);
//_session.CheckLoginUserDataPermision(input.DataPermissionType,"您设置的角色的数据权限大于您拥有数据权限,系统不允许该操作");
await _roleDomainService.Update(input);
return("更新角色信息成功");
}
public async Task <string> Update(UpdateRoleInput input)
{
input.CheckDataAnnotations().CheckValidResult();
var role = await _roleRepository.SingleOrDefaultAsync(p => p.Id == input.Id);
if (role == null)
{
throw new UserFriendlyException($"不存在{input.Id}的角色信息");
}
role = input.MapTo(role);
await _roleRepository.UpdateAsync(role);
return("更新角色成功");
}
public async Task Update(UpdateRoleInput input)
{
var role = await _roleRepository.GetAsync(input.Id);
if (input.Name != role.Name)
{
var exsitRole = await _roleRepository.FirstOrDefaultAsync(p => p.Name == input.Name);
if (exsitRole != null)
{
throw new BusinessException($"系统中已经存在{input.Name}的角色");
}
}
role = input.MapTo(role);
await _roleRepository.UpdateAsync(role);
}
public async Task <IActionResult> UpdateRoleAsync([FromRoute] Guid id, [FromBody] UpdateRoleInput input)
{
if (id != input.Id)
{
return(BadRequest());
}
var permissionIds = input.PermissionIds.Select(x => (GuidRequired)x);
var request = new UpdateRoleRequest
{
Id = input.Id,
Name = input.Name,
IsEnabled = input.IsEnabled,
};
request.PermissionIds.AddRange(permissionIds);
var response = await _authorizationClient.UpdateRoleAsync(request);
return(NoContent());
}
public UpdateRoleOutput UpdateRole(UpdateRoleInput input)
{
try
{
RestHTTP http = new RestHTTP();
RestRequest req = new RestRequest("api/roles/update", RestSharp.Method.POST);
req.AddHeader("Content-Type", "application/json");
req.AddHeader("Authorization", "Bearer " + input.AccessToken);
req.AddJsonBody(input);
UpdateRoleOutput response = http.HttpPost <UpdateRoleOutput>(req);
return(response);
}
catch (Exception ex)
{
WriteLogFile.Append("UpdateRole : ");
WriteLogFile.Append(ex.Message);
WriteLogFile.Append(ex.StackTrace);
}
return(null);
}
public async Task Update(UpdateRoleInput input)
{
var role = await _roleRepository.GetAsync(input.Id);
if (input.Name != role.Name)
{
var exsitRole = await _roleRepository.FirstOrDefaultAsync(p => p.Name == input.Name);
if (exsitRole != null)
{
throw new BusinessException($"系统中已经存在{input.Name}的角色");
}
}
role = input.MapTo(role);
await UnitOfWorkAsync(async (conn, trans) =>
{
await _roleRepository.UpdateAsync(role, conn, trans);
//var queryOperationSql = "SELECT o.* FROM `Operation` as o LEFT JOIN Permission as p ON o.PermissionId = p.Id AND p.IsDeleted = 0 AND o.IsDeleted = 0 WHERE o.PermissionId IN @PermissionIds";
//var operations = await conn.QueryAsync<Operation>(queryOperationSql, new { PermissionIds = input.PermissionIds }, transaction: trans);
//if (!operations.Any(p => p.Mold == Shared.Operations.OperationMold.Query || p.Mold == Shared.Operations.OperationMold.Look))
//{
// throw new BusinessException($"分配的权限至少要包含查询或是查看类型操作");
//}
await _rolePermissionRepository.DeleteAsync(p => p.RoleId == input.Id, conn, trans);
foreach (var permissionId in input.PermissionIds)
{
var permission = await _permissionRepository.SingleOrDefaultAsync(p => p.Id == permissionId);
if (permission == null)
{
throw new BusinessException($"不存在Id为{permissionId}的权限信息");
}
await _rolePermissionRepository.InsertAsync(new RolePermission()
{
PermissionId = permissionId, RoleId = input.Id
}, conn, trans);
}
}, Connection);
}
//[ValidateAntiForgeryToken]
public ActionResult Update(UpdateRoleInput input)
{
input.Validate();
var services = CreateService <IAccountAppService>();
Sys_Role role = services.GetById <Sys_Role>(input.Id);
role.NotNull("角色不存在");
AceMapper.Map(input, role);
string[] permissionIds = input.GetPermissionIds();
List <Sys_RoleAuthorize> roleAuthorizeEntitys = CreateRoleAuthorizes(role.Id, permissionIds);
role.LastModifyTime = DateTime.Now;
role.LastModifyUserId = CurrentSession.UserId;
services.Update(role);
services.DeleteSys_RoleAuthorize(role.Id);
foreach (var roleAuthorizeEntity in roleAuthorizeEntitys)
{
services.Insert(roleAuthorizeEntity);
}
return(UpdateSuccessMsg());
}
public bool EditInfo(UpdateRoleInput input)
{
Role role = db.Roles.Find(input.ID);
role = input.MapTo(role);
db.Entry <Role>(role).State = EntityState.Modified;
var removeNavList = db.RoleNavActions.Where(a => a.RoleID == input.ID);
db.RoleNavActions.RemoveRange(removeNavList);
List <RoleNavAction> roleNavActions = new List <RoleNavAction>();
if (!string.IsNullOrEmpty(input.Nav_SelActions))
{
string[] NavSelActionArr = input.Nav_SelActions.Split(',');
foreach (var nav in NavSelActionArr)
{
if (!string.IsNullOrWhiteSpace(nav))
{
var arr = nav.Split('_');
roleNavActions.Add(new RoleNavAction()
{
Action_Code = arr[1],
CreateTime = DateTime.Now,
Nav_Code = arr[0],
Role = role
});
}
}
}
var removeCateList = db.RoleArticleCategoryActions.Where(a => a.RoleID == input.ID);
db.RoleArticleCategoryActions.RemoveRange(removeCateList);
List <RoleArticleCategoryAction> roleArticleCategoryActions = new List <RoleArticleCategoryAction>();
if (!string.IsNullOrEmpty(input.Cate_SelActions))
{
string[] CateSelActionArr = input.Cate_SelActions.Split(',');
foreach (var cate in CateSelActionArr)
{
if (!string.IsNullOrWhiteSpace(cate))
{
var arr = cate.Split('_');
roleArticleCategoryActions.Add(new RoleArticleCategoryAction()
{
ActionCode = arr[1],
ArticleCategoryID = Convert.ToInt32(arr[0]),
Role = role,
CreateTime = DateTime.Now
});
}
}
}
db.RoleNavActions.AddRange(roleNavActions);
db.RoleArticleCategoryActions.AddRange(roleArticleCategoryActions);
return(db.SaveChanges() > 0);
}
public IActionResult Update(int id, [FromBody] UpdateRoleInput role)
{
role.Id = id;
_roleService.Update(role);
return(Created("", new { role.Id }));
}
public async Task <IdentityRoleDto> UpdateAsync(UpdateRoleInput input)
{
return(await _identityRoleAppService.UpdateAsync(input.RoleId, input.RoleInfo));
}
//[ValidateAntiForgeryToken]
public ActionResult Update(UpdateRoleInput input)
{
this.CreateService <IRoleAppService>().Update(input);
return(this.UpdateSuccessMsg());
}
public async Task Update(UpdateRoleInput input)
{
CheckUserDefinedDataPermission(input.DataPermissionType, input.DataPermissionOrgIds);
using (var locker = await _lockerProvider.CreateLockAsync("UpdateRole"))
{
await locker.Lock(async() =>
{
var role = await _roleRepository.GetAsync(input.Id, false);
if (role.DataPermissionType == DataPermissionType.UserDefined &&
_session.UserId != role.CreatorUserId)
{
throw new BusinessException("自定义数据权限的角色只允许用户创建者自己修改");
}
if (input.Identification != role.Identification)
{
var exsitRole =
await _roleRepository.FirstOrDefaultAsync(p => p.Identification == input.Identification,
false);
if (exsitRole != null)
{
throw new BusinessException($"系统中已经存在{input.Identification}的角色");
}
}
role = input.MapTo(role);
await UnitOfWorkAsync(async(conn, trans) =>
{
await _roleRepository.UpdateAsync(role, conn, trans);
var deleteSql = "DELETE FROM RolePermission WHERE RoleId=@RoleId AND TenantId=@TenantId";
await conn.ExecuteAsync(deleteSql, new { RoleId = role.Id, TenantId = _session.TenantId }, trans);
await _rolePermissionRepository.DeleteAsync(p => p.RoleId == role.Id, conn, trans);
await _roleDataPermissionOrgRelationRepository.DeleteAsync(p => p.RoleId == role.Id, conn,
trans);
await _roleOrganizationRepository.DeleteAsync(p => p.RoleId == role.Id, conn, trans);
var insertSql =
"INSERT INTO RolePermission(PermissionId,RoleId,CreateTime,CreateBy,TenantId) VALUES(@PermissionId,@RoleId,@CreationTime,@CreatorUserId,@TenantId)";
var rolePermissions = new List <RolePermission>();
foreach (var permissionId in input.PermissionIds)
{
rolePermissions.Add(new RolePermission
{
PermissionId = permissionId,
RoleId = role.Id,
CreationTime = DateTime.Now,
CreatorUserId = _session.UserId,
TenantId = _session.TenantId
});
}
await conn.ExecuteAsync(insertSql, rolePermissions, trans);
if (!input.IsAllOrg)
{
foreach (var orgId in input.OrgIds)
{
var roleOrg = new RoleOrganization()
{
RoleId = role.Id, OrgId = orgId
};
await _roleOrganizationRepository.InsertAsync(roleOrg, conn, trans);
}
}
if (input.DataPermissionType == DataPermissionType.UserDefined)
{
var insertDataPermissionOrgSql =
"INSERT INTO RoleDataPermissionOrgRelation(RoleId,OrgId,CreateTime,CreateBy,TenantId) VALUES(@RoleId,@OrgId,@CreationTime,@CreatorUserId,@TenantId)";
var dataPermissionOrgDatas = new List <RoleDataPermissionOrgRelation>();
foreach (var orgId in input.DataPermissionOrgIds)
{
dataPermissionOrgDatas.Add(new RoleDataPermissionOrgRelation()
{
RoleId = role.Id,
OrgId = orgId,
CreationTime = DateTime.Now,
CreatorUserId = _session.UserId,
TenantId = _session.TenantId
});
}
await conn.ExecuteAsync(insertDataPermissionOrgSql, dataPermissionOrgDatas, trans);
}
await RemoveRoleCheckPemissionCache(role.Id);
}, Connection);
});
}
}
public ActionResult Update(UpdateRoleInput input)
{
this.Service.Update(input);
return(this.UpdateSuccessMsg());
}
