public RoleUpdateHandler(GlobalSolusindoDb db, tblM_User user, RoleValidator roleValidator, RoleFactory roleFactory, RoleQuery roleQuery, AccessControl accessControl) : base(db, user)
{
this.roleValidator = roleValidator;
this.roleFactory = roleFactory;
this.roleQuery = roleQuery;
this.roleEntryDataProvider = new RoleEntryDataProvider(db, user, accessControl, roleQuery);
}
public JsonResult GetAllRoles([DataSourceRequest] DataSourceRequest req)
{
try
{
var command = new RoleQuery
{
};
var response = _identityClient.GetRoles(command);
var result = response.Result.Select(res => new RoleViewModel
{
Id = res.Id,
Name = res.Name,
Desc = res.Description
}).ToList().OrderByDescending(i => i.Id).ToDataSourceResult(req);
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
Log(LogMode.Error, $"There is an error while getting the role data!", e);
var model = new RoleViewModel();
return(Json(model));
}
}
public IEnumerable <Role> GetAll()
{
using (var connection = context.CreateConnection())
{
return(connection.Query <Role>(RoleQuery.All()));
}
}
public void Delete(Guid id)
{
using (var connection = context.CreateConnection())
{
connection.Execute(RoleQuery.Delete(id));
}
}
public PagedResponse <RoleDto> Execute(RoleQuery request)
{
var query = Context.Roles.AsQueryable();
query = query.Where(r => r.IsDeleted == false);
if (request.Name != null)
{
query = query.Where(r => r.Name.ToLower().Contains(request.Name.ToLower()));
}
var totalCount = query.Count();
query = query.Skip((request.PageNumber - 1) * request.PerPage).Take(request.PerPage);
var pagesCount = (int)Math.Ceiling((double)totalCount / request.PerPage);
return(new PagedResponse <RoleDto>
{
CurrentPage = request.PageNumber,
PagesCount = pagesCount,
TotalCount = totalCount,
Data = query.Select(r => new RoleDto
{
Id = r.Id,
Name = r.Name
})
});
}
/// <summary>
///获取分页的角色列表，以及查询的用户id的所有角色选中状态
/// </summary>
/// <param name="query"></param>
/// <param name="userId"></param>
/// <returns></returns>
public ActionResult QueryByUser(RoleQuery query, Guid userId)
{
SetPage(query);
var result = _roleService.Query(query, userId).Convert(p => p.ToGridVm());
return(ToDataGridResult(result, result.TotalCount));
}
public async Task <Metadata <RoleViewModel> > GetAll(RoleQuery query)
{
Metadata <RoleViewModel> res = new Metadata <RoleViewModel>();
//var data = context.Roles.Include("RoleScreen");
List <RoleViewModel> dataRoles = new List <RoleViewModel>();
if (_httpContext.User.Identity.Name == "root")
{
dataRoles = context.Roles.Select(x => new RoleViewModel()
{
RoleID = x.roleid,
RoleName = x.rolename,
IsEnabled = x.isenabled,
StringRoleID = x.roleid.ToString().ToBase64(),
CountScreen = context.RoleScreen.Where(y => y.roleid == x.roleid).Count(p => p.rolescreenid > 0)
}).ToList();
}
else
{
dataRoles = context.Roles.Where(x => x.roleid > 1).Select(x => new RoleViewModel()
{
RoleID = x.roleid,
RoleName = x.rolename,
IsEnabled = x.isenabled,
StringRoleID = x.roleid.ToString().ToBase64(),
CountScreen = context.RoleScreen.Where(y => y.roleid == x.roleid).Count(p => p.rolescreenid > 0)
}).ToList();
}
res.data.Roles = dataRoles.OrderBy(s => s.RoleName).ToList();
res.status = true;
return(await Task.FromResult(res));
}
public IEnumerable <Role> Search(RoleQuery query)
{
var result = new List <Role>();
using (var command = Context.Connection.GenerateCommand(
"admdata.search_role",
new { id = query.Id, name = query.Name, curruserid = query.UserId }))
{
using (var reader = command.ExecuteReaderSafety())
{
while (reader.Read())
{
result.Add(
new Role
{
Id = reader.GetFieldValue <Guid>("Id"),
Name = reader.GetFieldValue <string>("Name"),
Activities = GetActivitiesByReader(reader)
});
}
}
}
return(result);
}
public Role GetById(Guid id)
{
using (var connection = context.CreateConnection())
{
return(connection.Query <Role>(RoleQuery.ById(id)).SingleOrDefault());
}
}
public QueryContainer(RoleQuery roleQuery, UserQuery userQuery, OrganizationUnitQuery organizationUnitQuery)
{
AddField(roleQuery.GetFieldType());
AddField(organizationUnitQuery.GetFieldType());
AddField(userQuery.GetFieldType());
}
public Role Update(Role role)
{
using (var connection = context.CreateConnection())
{
connection.Execute(RoleQuery.Update(role));
return(role);
}
}
public MenuGenerator(GlobalSolusindoDb db)
{
this.db = db;
roleQuery = new RoleQuery(db);
roleGroupQuery = new RoleGroupQuery(db);
mappingUserRoleQuery = new MappingUserToRoleGroupQuery(db);
mappingRoleToRoleGroupQuery = new MappingRoleToRoleGroupQuery(db);
}
public async Task <IHttpActionResult> Get([FromUri] RoleQuery query)
{
query = query ?? new RoleQuery();
if (query.JustNames)
{
return(Ok(await _roleManager.Roles.Where(x => !x.IsSystematic).Select(x => x.Name).ToListAsync()));
}
return(Ok(await _roleManager.Roles.Where(x => !x.IsSystematic).ToListAsync()));
}
public PagedData <Role> Query(int page, int pageSize, RoleQuery query)
{
var sql = "SELECT * FROM [Role] WHERE 1=1";
if (!string.IsNullOrEmpty(query.RoleName))
{
sql += " AND Name=@RoleName";
}
return(_fetcher.QueryPaged <Role>(sql, "Id", page, pageSize, query));
}
public SystemController(ILogEventTask logEventTask, IUserTask userTask, RoleQuery companyRoleQuery,
UserQuery userQuery, IRoleTask roleTask, IAcquireTask acquireTask)
{
this.userTask = userTask;
this.logEventTask = logEventTask;
this.roleQuery = companyRoleQuery;
this.userQuery = userQuery;
this.roleTask = roleTask;
this.acquireTask = acquireTask;
}
public IHttpActionResult Get(int id)
{
ThrowIfUserHasNoRole(readRole);
using (RoleQuery roleQuery = new RoleQuery(Db))
{
var data = roleQuery.GetByPrimaryKey(id);
SaveLog("Role", "Get", JsonConvert.SerializeObject(new { primaryKey = id }));
return(Ok(new SuccessResponse(data)));
}
}
// GET: Roles
public ActionResult Index(string sortOrder, string searchString, RoleQuery query)
{
ViewBag.RoleSortParam = string.IsNullOrEmpty(sortOrder) ? "role_desc" : "";
ViewBag.CurrentSortOrder = sortOrder;
ViewBag.CurrentFilter = searchString;
var roles = _getRoles.Execute(query);
return(View(roles));
}
public async Task <ActionResult> Index(RoleQuery query)
{
if (!await this.Authorizer.AuthorizeAsync(RolePermissions.View))
{
this.Unauthorized();
}
var collection = await this.CommandFactory.Create <PagedRolesCommand>().Setup(query).AsPagingResultAsync();
return(this.View(collection));
}
public IActionResult Get([FromQuery] RoleQuery query)
{
try
{
return(Ok(_getRolesCommand.Execute(query)));
}
catch (EntityNotFoundException)
{
return(NotFound());
}
}
public ActionResult <IEnumerable <RoleDto> > Get([FromQuery] RoleQuery query)
{
try
{
return(Ok(_getRoles.Execute(query)));
}
catch (NotFoundException)
{
return(NotFound());
}
}
public IHttpActionResult Get(int id)
{
string accessType = "Role_ViewAll";
ThrowIfUserCannotAccess(accessType);
using (RoleQuery roleQuery = new RoleQuery(Db))
{
var data = roleQuery.GetByPrimaryKey(id);
SaveLog("Role", "Get", JsonConvert.SerializeObject(new { primaryKey = id }));
return(Ok(new SuccessResponse(data)));
}
}
public void GetAllRolesShouldBeSuccessful()
{
_context.Add(CreateRole());
_context.SaveChanges();
var mapper = _fixture.GetMapper(new RoleProfile());
var query = new RoleQuery(_context, mapper);
var result = query.GetRoles();
result.ShouldNotBeNull();
result.Length.ShouldBeGreaterThanOrEqualTo(1);
result.First().Code.ShouldBe("testRole");
}
public Role Create(Role role)
{
if (role.Id == Guid.Empty)
{
role.Id = Guid.NewGuid();
}
using (var connection = context.CreateConnection())
{
connection.Execute(RoleQuery.Insert(role));
return(role);
}
}
public List<Role> GetRolesByProcess()
{
var query = new RoleQuery();
query.ProcessGUID = "5c5041fc-ab7f-46c0-85a5-6250c3aea375";
query.Version = "1";
var hostUrl = ConfigurationManager.AppSettings["WebApiHostUrl"];
var url = string.Format("http://{0}/sfmvc/api/wf/QueryProcessRoleUserList", hostUrl);
var clientHelper = HttpClientHelper.CreateHelper(url);
var roleList = clientHelper.Query<RoleQuery, Role>(query);
return roleList;
}
public async Task <List <RoleDto> > GetRoleList(RoleQuery query)
{
var roles = await DbContext.Select <SysRole>()
.WhereIf(query.CurrentRoleLevel.HasValue, x => x.Level > query.CurrentRoleLevel)
.OrderBy(a => a.Level)
.ToListAsync(a => new RoleDto
{
Id = a.Id,
Name = a.Name,
UserCount = (int)DbContext.Select <SysUser>().Where(b => b.RoleLevel == a.Level && b.Enabled == true).Count()
});
return(roles);
}
public MessageModel <PageModel <SysRole> > GetUserByPage([FromQuery] RoleQuery roleQuery)
{
var list = _roleServer.GetRoleListByPage(roleQuery, out int Total);
return(new MessageModel <PageModel <SysRole> >()
{
success = true,
msg = "数据获取成功",
response = new PageModel <SysRole>()
{
TotalCount = Total,
data = list.ToList(),
}
});
}
/// <summary>
/// 根据当前用户角色，获取可以操作得角色列表
/// </summary>
/// <returns></returns>
public async Task <List <RoleSelectOutput> > GetRoleListByCurrentRole()
{
var query = new RoleQuery()
{
CurrentRoleLevel = _currentUser.RoleLevel
};
query.OrderBy(a => a.Level);
var roles = await _roleRep.GetListAsync(query);
var result = roles.Adapt <List <RoleSelectOutput> >();
return(result);
}
/// <summary>
/// 获取角色列表
/// </summary>
/// <returns></returns>
public async Task <List <RoleOutput> > GetList()
{
var query = new RoleQuery();
if (_currentUser.RoleLevel != (int)RoleLevel.SuperAdministrator) //超级管理员能看见所有，其他用户只能看见比自己等级低的用户列表
{
query.CurrentRoleLevel = _currentUser.RoleLevel;
}
var roles = await _roleRep.GetRoleList(query);
var result = roles.Adapt <List <RoleOutput> >();
return(result);
}
/// <summary>
/// 角色列表查询
/// </summary>
/// <param name="page"></param>
/// <param name="pageSize"></param>
/// <param name="query"></param>
/// <returns></returns>
public ActionResult Index(RoleQuery query)
{
if (!WebAppContext.Current.User.RoleTypeIs(RoleType.超级管理员))
{
return(RedirectToAction("NoPermission", "Home"));
}
var viewModel = new IndexViewModel
{
Query = query,
Items = Enum.GetNames(typeof(RoleType)).ToList()
};
return(View("~/Views/SystemSetting/Role/Index.cshtml", viewModel));
}
/// <summary>
/// 分页获取角色列表实现
/// </summary>
/// <param name="roleQuery"></param>
/// <param name="Total"></param>
/// <returns></returns>
public List <SysRole> GetRoleListByPage(RoleQuery roleQuery, out int Total)
{
var query = ExpressionBuilder.True <SysRole>();
query = query.And(m => m.IsDrop == false);
if (roleQuery.stateEnum != StateEnum.All)
{
query = query.And(m => m.RoletState == roleQuery.stateEnum);
}
if (!roleQuery.Name.IsNullOrEmpty())
{
query = query.And(m => m.Name.Contains(roleQuery.Name.Trim()));
}
Total = _roleRepositoty.Count(query);
return(_roleRepositoty.PageBy(roleQuery.PageIndex, roleQuery.PageSize, query).ToList());
}
// GET: Roles
public ActionResult Index([FromQuery] RoleQuery query)
{
try
{
return(View(executor.ExecuteQuery(getRoles, query)));
}
catch (EntityNotAllowedException)
{
return(RedirectToAction("PageNotFound", "Redirections"));
}
catch (Exception e)
{
TempData["error"] = e.Message;
}
return(RedirectToAction("Home", "Index"));
}
public ResponseResult<List<Role>> QueryProcessRoleUserList(RoleQuery query)
{
var result = ResponseResult<List<Role>>.Default();
try
{
var wfService = new WorkflowService();
var roleList = wfService.GetRoleUserListByProcess(query.ProcessGUID, query.Version).ToList();
result = ResponseResult<List<Role>>.Success(roleList, "成功获取流程定义的角色用户数据！");
}
catch (System.Exception ex)
{
result = ResponseResult<List<Role>>.Error(string.Format(
"获取流程定义的角色用户数据失败, 异常信息:{0}",
ex.Message));
}
return result;
}
