public async Task <IEnumerable <GetPositionOutput> > GetPositionsByDeptId(long deptId)
{
var positions = await _positionRepository.GetAllAsync(p => p.DeptId == deptId);
var positionOutputs = positions.MapTo <IEnumerable <GetPositionOutput> >();
foreach (var positionOutput in positionOutputs)
{
var wordbookAppServiceProxy = GetService <IWordbookAppService>();
var positionLevleInfo = await wordbookAppServiceProxy.GetWordbookItemByKey(
OrganizationConstant.PositionPositionLevelWordbookCode, positionOutput.PositionLevelKey);
if (positionLevleInfo != null)
{
positionOutput.PositionLevelName = positionLevleInfo.Value;
}
var positionFunctionInfo = await wordbookAppServiceProxy.GetWordbookItemByKey(
OrganizationConstant.PositionFunctionWordbookCode, positionOutput.FunctionKey);
if (positionFunctionInfo != null)
{
positionOutput.FunctionName = positionFunctionInfo.Value;
}
}
return(positionOutputs);
}
public async Task Delete(long permissionId)
{
var menu = await _menuRepository.SingleOrDefaultAsync(p => p.PermissionId == permissionId);
if (menu == null)
{
throw new BusinessException($"不存在PermissionId为{permissionId}的菜单信息");
}
var allNeedDeleteMenus = await _menuRepository.GetAllAsync(p => p.Code.Contains(menu.Code));
await UnitOfWorkAsync(async (conn, trans) => {
await _menuRepository.DeleteAsync(p => p.Code.Contains(menu.Code), conn, trans);
foreach (var needDeleteMenu in allNeedDeleteMenus)
{
await _permissionRepository.DeleteAsync(p => p.Id == needDeleteMenu.PermissionId, conn, trans);
var operations = await _operationRepository.GetAllAsync(p => p.MenuId == needDeleteMenu.Id);
await _operationRepository.DeleteAsync(p => p.MenuId == needDeleteMenu.Id, conn, trans);
if (operations.Any())
{
foreach (var operation in operations)
{
await _operationActionRepository.DeleteAsync(p => p.OperationId == operation.Id, conn, trans);
await _permissionRepository.DeleteAsync(p => p.Id == operation.PermissionId, conn, trans);
}
}
}
}, Connection);
}
public async Task DeleteCorporation(long orgId)
{
var corporation = await _corporationRepository.SingleOrDefaultAsync(p => p.OrgId == orgId);
var orgInfo = await _organizationRepository.SingleOrDefaultAsync(p => p.Id == orgId);
if (corporation == null || orgInfo == null)
{
throw new BusinessException($"系统中不存在OrgId为{orgId}的企业信息");
}
var children = await _organizationRepository.GetAllAsync(p => p.ParentId == orgInfo.Id);
if (children.Any())
{
throw new BusinessException($"请先删除子公司信息");
}
var departments = await _departmentRepository.GetAllAsync(p => p.OrgId == orgInfo.Id);
if (departments.Any())
{
throw new BusinessException($"请先删除该公司的部门信息");
}
var corporationUsers = await GetService<IUserAppService>().GetOrgUser(orgInfo.Id,true);
await UnitOfWorkAsync(async (conn, trans) => {
await _organizationRepository.DeleteAsync(p => p.Id == orgInfo.Id,conn,trans);
await _corporationRepository.DeleteAsync(p => p.OrgId == orgInfo.Id, conn, trans);
foreach (var corporationUser in corporationUsers)
{
if (!await GetService<IUserAppService>().ResetUserOrgInfo(corporationUser.Id))
{
throw new BusinessException("重置该公司部门员工部门信息失败,请稍后重试");
}
}
}, Connection);
}
public async Task <IEnumerable <ITree <GetOrganizationTreeOutput> > > GetTree()
{
var organizations = await _organizationRepository.GetAllAsync();
var organizationOutputs = organizations.MapTo <IEnumerable <GetOrganizationTreeOutput> >();
return(organizationOutputs.BuildTree());
}
public async Task <IEnumerable <GetPositionOutput> > GetDeptPosition(long deptId)
{
var dept = await _departmentRepository.SingleOrDefaultAsync(p => p.OrgId == deptId);
if (dept == null)
{
throw new BusinessException($"不存在OrgId为{deptId}的部门信息");
}
var positions = await _positionRepository.GetAllAsync(p => p.DeptId == dept.Id);
return(positions.MapTo <IEnumerable <GetPositionOutput> >());
}
public async Task <IEnumerable <GetPositionOutput> > GetPositionsByDeptId(long deptId)
{
var positions = await _positionRepository.GetAllAsync(p => p.DeptId == deptId);
var positionOutputs = positions.MapTo <IEnumerable <GetPositionOutput> >();
foreach (var positionOutput in positionOutputs)
{
positionOutput.PositionLevelName = (await GetService <IWordbookAppService>().GetWordbookItem(positionOutput.PositionLevelId)).Value;
positionOutput.FunctionName = (await GetService <IWordbookAppService>().GetWordbookItem(positionOutput.FunctionId)).Value;
}
return(positionOutputs);
}
public async Task <ICollection <GetUserGroupOutput> > GetAll()
{
var topUserGroups = await _userGroupRepository.GetAllAsync(p => p.ParentId == 0);
var topUserGroupOutputs = topUserGroups.MapTo <ICollection <GetUserGroupOutput> >();
var allUserGroups = await _userGroupRepository.GetAllAsync();
foreach (var userGroupOutput in topUserGroupOutputs)
{
userGroupOutput.Children = await GetUserGroupChildren(userGroupOutput.Id, allUserGroups);
}
return(topUserGroupOutputs);
}
private async Task RemoveUserGroupCheckPemissionCache(long userGroupId)
{
var sql = @"SELECT oar.ServiceId FROM OperationActionRelation as oar
INNER JOIN Operation as o on oar.OperationId=o.Id AND o.IsDeleted=@IsDeleted
INNER JOIN UserGroupPermission as ugp on o.PermissionId=ugp.PermissionId
WHERE ugp.UserGroupId=@UserGroupId AND TenantId=@TenantId";
var sqlParams = new Dictionary <string, object>()
{
{ "IsDeleted", HeroConstants.UnDeletedFlag }, { "UserGroupId", userGroupId }, { "TenantId", _session.TenantId }
};
await using (Connection)
{
var userGroupServiceIds = await Connection.QueryAsync <string>(sql, sqlParams);
foreach (var serviceId in userGroupServiceIds)
{
var cacheKey = string.Format(HeroConstants.CacheKey.PermissionCheck, serviceId, "*");
await _cacheProvider.RemoveAsync(cacheKey);
}
}
var userGroupRoleIds =
(await _userGroupRoleRepository.GetAllAsync(p => p.UserGroupId == userGroupId)).Select(p => p.RoleId);
foreach (var roleId in userGroupRoleIds)
{
await _roleDomainService.RemoveRoleCheckPemissionCache(roleId);
}
}
public async Task <bool> CheckWordbookItem(CheckWordbookInput input)
{
var wordbook = await _wordbookRepository.SingleOrDefaultAsync(p => p.Code == input.WordbookCode);
if (wordbook == null)
{
throw new BusinessException($"系统中不存在Code为{input.WordbookCode}的字典项");
}
var wordbookItems = await _wordbookItemRepository.GetAllAsync(p => p.WordbookId == wordbook.Id);
if (wordbookItems.Any(p => p.Key == input.WordbookItemKey))
{
return(true);
}
return(false);
}
public async Task <IPagedResult <PermissionData> > Search(QueryPermissionData query)
{
RpcContext.GetContext().SetAttachment(ClaimTypes.DataPermissionOrgIds, new long[] { 2, 5 });
//var result = await _permissionDataRepository.GetPageAsync(p =>
// p.UserName.Contains(query.UserName) && p.Address.Contains(query.Address),query.PageIndex,query.PageCount);
//return result.Item1.GetPagedResult(result.Item2);
var sql = "SELECT * FROM PermissionData Where 1=1 ";
var sqlParams = new Dictionary <string, object>();
if (!query.UserName.IsNullOrEmpty())
{
sql += " AND UserName like @UserName";
sqlParams.Add("UserName", $"%{query.UserName}%");
}
if (!query.Address.IsNullOrEmpty())
{
sql += " AND Address like @Address";
sqlParams.Add("Address", $"%{query.Address}%");
}
var result = await Connection.QueryDataPermissionPageAsync <PermissionData>(sql, sqlParams, query.PageIndex, query.PageCount
);
var result2 = await Connection.QueryDataPermissionAsync <PermissionData>(sql, sqlParams);
var s = await _permissionDataRepository.GetAllAsync();
return(result.Item1.GetPagedResult((int)result.Item2));;
}
public async Task <bool> CheckPermission(long operationId, string serviceId)
{
var operation = await _operationRepository.SingleOrDefaultAsync(p => p.Id == operationId);
if (operation == null)
{
throw new BusinessException($"系统中不存在{operationId}的操作");
}
if (operation.Mold == OperationMold.Query || operation.Mold == OperationMold.Query)
{
return(true);
}
if (AppConfig.ServerOptions.Environment == RuntimeEnvironment.Test)
{
if (AuthDomainConstants.PermissionServiceIdWhiteList.Contains(serviceId))
{
return(true);
}
throw new AuthException("项目演示环境，不允许操作！", StatusCode.UnAuthorized);
}
var operationActionRelations =
await _operationActionRepository.GetAllAsync(p => p.OperationId == operationId);
return(operationActionRelations.Any(p => p.ServiceId == serviceId));
}
/// <summary>
/// 缓存
/// </summary>
/// <returns></returns>
public async Task <IEnumerable <AbpUser> > GetCacheAll()
{
//IEnumerable<AbpUser> ret = _userRepository.GetAll();
//return ret;
var entityCache = await _cacheManager.GetCache("MemberUserCache")
.Get("MemberUser", () => _userRepository.GetAllAsync());// 缓存之后这句就不执行了，_userRepository.GetAllAsync() 断点调试
var entityCache1 = _cacheManager.GetCache("MemberUserCache")
.Get("User_1", () => _userRepository.FirstOrDefault(1));// .GetAllAsync());
// 清除缓存
// _cacheManager.GetCache("MemberUserCache").Clear(); // 打开监视器可以看到已经去除掉了
// await _cacheManager.GetCache("MemberUserCache").ClearAsync(); // 打开监视器可以看到已经去除掉了
// ITypedCache泛型版本
var entityCache2 = _cacheManager.GetCache("MemberUserCache") // ControllerCache
.AsTyped <string, IEnumerable <AbpUser> >()
.Get("AllUsers", () => _userRepository.GetAll());
// 注意对应 IEnumerable<AbpUser> , 不是 List<AbpUser>
// _cacheManager.GetCache("MemberUserCache").Remove("AllUsers"); // 打开监视器可以看到已经去除掉了
// await _cacheManager.GetCache("MemberUserCache").RemoveAsync("AllUsers"); // 打开监视器可以看到已经去除掉了
return(entityCache);
}
private async Task <IEnumerable <GetPermissionTreeOutput> > BuildPermissionChildren(GetPermissionTreeOutput permissionTreeOutput, IEnumerable <Menu> menus)
{
var permissionChildren = new List <GetPermissionTreeOutput>();
var menuChildren = menus.Where(p => p.ParentId == permissionTreeOutput.Id);
var menuPermissionChildrenOutput = menuChildren.MapTo <IEnumerable <GetPermissionTreeOutput> >();
permissionChildren.AddRange(menuPermissionChildrenOutput);
if (menuPermissionChildrenOutput.Any())
{
foreach (var menuChildOutput in menuPermissionChildrenOutput)
{
menuChildOutput.FullName = permissionTreeOutput.FullName + HeroConstants.CodeRuleRestrain.CodeSeparator + menuChildOutput.Name;
menuChildOutput.Children = await BuildPermissionChildren(menuChildOutput, menus);
}
}
var operationChildren = await _operationRepository.GetAllAsync(p => p.MenuId == permissionTreeOutput.Id);
var operationChildrenOutput = operationChildren.MapTo <IEnumerable <GetPermissionTreeOutput> >();
foreach (var operationChildOutput in operationChildrenOutput)
{
operationChildOutput.FullName = permissionTreeOutput.FullName + HeroConstants.CodeRuleRestrain.CodeSeparator + operationChildOutput.Name;
}
permissionChildren.AddRange(operationChildrenOutput);
return(permissionChildren);
}
public async Task <IPagedResult <GetUserOutput> > Query(QueryUserInput query)
{
var userList = await _userRepository.GetAllAsync(p => p.UserName.Contains(query.UserName) && p.ChineseName.Contains(query.ChineseName) &&
p.Email.Contains(query.Email) && p.Phone.Contains(query.Phone));
return(userList.MapTo <IEnumerable <GetUserOutput> >().PageBy(query));
}
private async Task <Tuple <long[], long[]> > GetAllUserRoleIdsAndUserGroupIds(long userId,
Status?status = Status.Valid)
{
var allUserRoleIds = new List <long>();
var allUserGroupIds = new List <long>();
var userRoles = await GetUserRoles(userId, status);
allUserRoleIds.AddRange(userRoles.Select(p => p.Id));
var userGroupRelations = await _userUserGroupRelationRepository.GetAllAsync(p => p.UserId == userId);
foreach (var userGroupRelation in userGroupRelations)
{
var userGroup =
await _userGroupRepository.SingleOrDefaultAsync(p => p.Id == userGroupRelation.UserGroupId);
if (userGroup == null)
{
continue;
}
if (status.HasValue && userGroup.Status != status)
{
continue;
}
allUserGroupIds.Add(userGroup.Id);
var userGroupRoles = await _userGroupDomainService.GetUserGroupRoleOutputs(userGroup.Id, status);
allUserRoleIds.AddRange(userGroupRoles.Select(p => p.Id));
}
return(new Tuple <long[], long[]>(allUserRoleIds.ToArray(), allUserGroupIds.ToArray()));
}
public async Task <IEnumerable <GetPermissionTreeOutput> > GetTree()
{
var menus = await _menuRepository.GetAllAsync();
var permissionTree = await BuildPermissionTree(menus);
return(permissionTree);
}
public async Task <IEnumerable <ITree <GetUserGroupTreeOutput> > > GetTree()
{
var userGroups = await _userGroupRepository.GetAllAsync();
var userGroupTreeOutputs = userGroups.MapTo <IEnumerable <GetUserGroupTreeOutput> >();
return(userGroupTreeOutputs.BuildTree());
}
public async Task <IEnumerable <GetUserBasicOutput> > GetOrgUser(long orgId, bool includeSubOrg)
{
IEnumerable <UserInfo> orgUsers = new List <UserInfo>();
if (includeSubOrg)
{
var subOrdIds = await GetService <IOrganizationAppService>().GetSubOrgIds(orgId);
Expression <Func <UserInfo, bool> > expression = null;
foreach (var subOrdId in subOrdIds)
{
if (expression == null)
{
expression = p => p.OrgId == subOrdId;
}
else
{
expression = expression.Or(p => p.OrgId == subOrdId);
}
}
orgUsers = await _userRepository.GetAllAsync(expression);
}
else
{
orgUsers = await _userRepository.GetAllAsync(p => p.OrgId == orgId);
}
var orgUserOutputs = orgUsers.MapTo <IEnumerable <GetUserBasicOutput> >();
foreach (var userOutput in orgUserOutputs)
{
if (userOutput.OrgId.HasValue)
{
userOutput.DeptName = (await GetService <IDepartmentAppService>().GetByOrgId(userOutput.OrgId.Value))
.Name;
}
if (userOutput.PositionId.HasValue)
{
userOutput.PositionName =
(await GetService <IPositionAppService>().Get(userOutput.PositionId.Value)).Name;
}
}
return(orgUserOutputs);
}
public async Task <IPagedResult <GetUserNormOutput> > Query(QueryUserInput query)
{
Expression <Func <UserInfo, bool> > expression = p => p.UserName.Contains(query.SearchKey) ||
p.ChineseName.Contains(query.SearchKey) ||
p.Email.Contains(query.SearchKey) ||
p.Phone.Contains(query.SearchKey);
if (query.Status.HasValue)
{
expression = expression.And(p => p.Status == query.Status.Value);
}
var queryResult = await _userRepository.GetAllAsync(expression);
if (query.OrgId.HasValue && query.OrgId != 0)
{
var subOrgIds = await GetService <IOrganizationAppService>().GetSubOrgIds(query.OrgId.Value);
queryResult = queryResult.Where(p => subOrgIds.Any(q => q == p.OrgId));
}
var queryResultOutput = queryResult.MapTo <IEnumerable <GetUserNormOutput> >().GetPagedResult(queryResult.Count());
foreach (var userOutput in queryResultOutput.Items)
{
if (userOutput.OrgId.HasValue)
{
userOutput.DeptName = (await GetService <IDepartmentAppService>().GetByOrgId(userOutput.OrgId.Value)).Name;
}
if (userOutput.PositionId.HasValue)
{
userOutput.PositionName = (await GetService <IPositionAppService>().Get(userOutput.PositionId.Value)).Name;
}
userOutput.Roles = (await _userDomainService.GetUserRoles(userOutput.Id)).MapTo <IEnumerable <GetDisplayRoleOutput> >();
if (userOutput.LastModifierUserId.HasValue)
{
var modifyUserInfo = (await _userRepository.SingleOrDefaultAsync(p => p.Id == userOutput.LastModifierUserId.Value));
userOutput.LastModificationUserName = modifyUserInfo.ChineseName;
}
}
return(queryResultOutput);
}
public async Task <LoginRespose> CheckLogin(VmAdminLogin vm)
{
LoginRespose result = new LoginRespose()
{
Success = false
};
try
{
var list = await _manager.GetAllAsync(c => c.user_name == vm.txtUserName);
if (null == list)
{
result.Message = "账号不存在！";
return(result);
}
var managers = list.ToList();
if (managers.Count == 0)
{
result.Message = "账号不存在！";
return(result);
}
if (managers.Count > 1)
{
result.Message = "存在多个相同账号！";
return(result);
}
var model = managers.FirstOrDefault();
if (!model.password.Equals(vm.txtPassword.ToMd5()))
{
result.Message = "登录密码不正确！";
return(result);
}
if (model.is_lock == 1)
{
result.Message = "该账号已被锁定！";
return(result);
}
var claimsIdentity = new ClaimsIdentity("ApplicationCookie");
claimsIdentity.AddClaim(new Claim(ClaimTypes.Name, model.user_name));
var security = Guid.NewGuid().ToString();
claimsIdentity.AddClaim(new Claim(ClaimTypes.GroupSid, "1"));
claimsIdentity.AddClaim(new Claim(ClaimTypes.Role, ""));
claimsIdentity.AddClaim(new Claim("http://schemas.microsoft.com/accesscontrolservice/2010/07/claims/identityprovider", "ASP.NET Identity"));
claimsIdentity.AddClaim(new Claim(ClaimTypes.System, "-1"));
claimsIdentity.AddClaim(new Claim("AspNet.Identity.SecurityStamp", security));
claimsIdentity.AddClaim(new Claim(ClaimTypes.NameIdentifier, model.Id.ToString()));
result.Success = true;
result.Identity = claimsIdentity;
return(result);
}
catch (Exception)
{
}
return(result);
}
public async Task <IEnumerable <RolePermission> > GetRolePermissions(long roleId)
{
var role = await _roleRepository.SingleOrDefaultAsync(p => p.Id == roleId);
if (role == null)
{
throw new BusinessException($"不存在Id为{roleId}的角色信息");
}
return(await _rolePermissionRepository.GetAllAsync(p => p.RoleId == roleId));
}
public async Task <GetRoleOutput> Get(long id)
{
var role = await _roleRepository.SingleOrDefaultAsync(p => p.Id == id);
if (role == null)
{
throw new BusinessException($"不存在Id为{id}的角色信息");
}
var roleOutput = role.MapTo <GetRoleOutput>();
await roleOutput.SetAuditInfo();
roleOutput.PermissionIds = (await _rolePermissionRepository.GetAllAsync(p => p.RoleId == role.Id))
.Select(p => p.PermissionId).ToArray();
roleOutput.DataPermissionOrgIds = (await _roleDataPermissionOrgRelationRepository.GetAllAsync(p => p.RoleId == role.Id))
.Select(p => p.OrgId).ToArray();
roleOutput.Organizations = await GetRoleOrgInfo(role.Id);
return(roleOutput);
}
public async Task <IPagedResult <GetUserNormOutput> > Query(QueryUserInput query)
{
IPagedResult <GetUserNormOutput> queryResultOutput = null;
if (!query.OrgId.HasValue || query.OrgId == 0)
{
var queryPageResult = await _userRepository.GetPageAsync(p => p.UserName.Contains(query.SearchKey) ||
p.ChineseName.Contains(query.SearchKey) ||
p.Email.Contains(query.SearchKey) ||
p.Phone.Contains(query.SearchKey), query.PageIndex, query.PageCount);
queryResultOutput = queryPageResult.Item1.WhereIf(query.Status.HasValue, p => p.Status == query.Status.Value).MapTo <IEnumerable <GetUserNormOutput> >().GetPagedResult(queryPageResult.Item2);
}
else
{
var subOrgIds = await GetService <IOrganizationAppService>().GetSubOrgIds(query.OrgId.Value);
// :todo 优化
var queryResult = await _userRepository.GetAllAsync(p => p.UserName.Contains(query.SearchKey) ||
p.ChineseName.Contains(query.SearchKey) ||
p.Email.Contains(query.SearchKey) ||
p.Phone.Contains(query.SearchKey));
queryResult = queryResult.Where(p => subOrgIds.Any(q => q == p.OrgId)).WhereIf(query.Status.HasValue, p => p.Status == query.Status.Value);
queryResultOutput = queryResult.MapTo <IEnumerable <GetUserNormOutput> >().PageBy(query);
}
foreach (var userOutput in queryResultOutput.Items)
{
if (userOutput.OrgId.HasValue)
{
userOutput.DeptName = (await GetService <IDepartmentAppService>().GetByOrgId(userOutput.OrgId.Value)).Name;
}
if (userOutput.PositionId.HasValue)
{
userOutput.PositionName = (await GetService <IPositionAppService>().Get(userOutput.PositionId.Value)).Name;
}
userOutput.Roles = (await _userDomainService.GetUserRoles(userOutput.Id)).MapTo <IEnumerable <GetDisplayRoleOutput> >();
}
return(queryResultOutput);
}
public async Task InitActions(ICollection <InitActionActionInput> actions)
{
await UnitOfWorkAsync(async (conn, trans) => {
foreach (var action in actions)
{
var actionEntity = await _actionRepository.SingleOrDefaultAsync(p => p.ServiceId == action.ServiceId);
if (actionEntity == null)
{
actionEntity = action.MapTo <Action>();
var actionId = await _actionRepository.InsertAndGetIdAsync(actionEntity, conn, trans);
var operationActionRelations = await _operationActionRelationRepository.GetAllAsync(p => p.ServiceId == action.ServiceId);
if (operationActionRelations.Any())
{
foreach (var operationActionRelation in operationActionRelations)
{
operationActionRelation.ActionId = actionId;
await _operationActionRelationRepository.UpdateAsync(operationActionRelation, conn, trans);
}
}
}
else
{
actionEntity = action.MapTo(actionEntity);
await _actionRepository.UpdateAsync(actionEntity, conn, trans);
var operationActionRelations = await _operationActionRelationRepository.GetAllAsync(p => p.ServiceId == action.ServiceId);
if (operationActionRelations.Any())
{
foreach (var operationActionRelation in operationActionRelations)
{
if (operationActionRelation.ActionId != actionEntity.Id)
{
operationActionRelation.ActionId = actionEntity.Id;
await _operationActionRelationRepository.UpdateAsync(operationActionRelation, conn, trans);
}
}
}
}
}
}, Connection);
}
public async Task <GetRoleOutput> Get(long id)
{
var role = await _roleRepository.SingleOrDefaultAsync(p => p.Id == id);
if (role == null)
{
throw new BusinessException($"不存在Id为{id}的角色信息");
}
var roleOutput = role.MapTo <GetRoleOutput>();
if (roleOutput.LastModifierUserId.HasValue)
{
var modifyUserInfo = await _userInfoRepository.SingleOrDefaultAsync(p => p.Id == roleOutput.LastModifierUserId.Value);
if (modifyUserInfo != null)
{
roleOutput.LastModificationUserName = modifyUserInfo.ChineseName;
}
}
roleOutput.PermissionIds = (await _rolePermissionRepository.GetAllAsync(p => p.RoleId == role.Id)).Select(p => p.PermissionId).ToArray();
return(roleOutput);
}
public async Task CreatePosition(CreatePositionInput input)
{
await CheckPosition(input);
var position = input.MapTo <Position>();
var departPositionMax = (await _positionRepository.GetAllAsync(p => p.DeptId == input.DeptId)).FirstOrDefault();
var department = await _departmentRepository.GetAsync(input.DeptId);
var orgInfo = await _organizationRepository.GetAsync(department.OrgId);
var positionCode = string.Empty;
if (departPositionMax == null)
{
positionCode = "1".PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
}
else
{
positionCode = (Convert.ToInt32(departPositionMax.Code.TrimStart('0')) + 1).ToString().PadLeft(HeroConstants.CodeRuleRestrain.CodeCoverBit, HeroConstants.CodeRuleRestrain.CodeCoverSymbol);
}
position.Code = orgInfo.Code + positionCode;
await _positionRepository.InsertAsync(position);
}
public async virtual Task <PagedResultDto <TEntityDto> > GetAll(TGetAllInput input)
{
Expression <Func <TEntity, bool> > expression = null;
Tuple <Expression <Func <TEntity, object> >[], bool> sorting = null;
int pageNumber = 0;
int itemsPerPage = 0;
int totalCount = 0;
IEnumerable <TEntity> list = null;
expression = ApplyFiltering(input);
sorting = ApplySorting(input);
var pageInput = input as IPagedResultRequest;
if (pageInput != null)
{
pageNumber = pageInput.PageIndex - 1;
if (pageNumber < 0)
{
pageNumber = 0;
}
itemsPerPage = pageInput.PageSize;
list = await Repository.GetAllPagedAsync(expression, pageNumber, itemsPerPage, sorting.Item2, sorting.Item1);
}
else
{
list = await Repository.GetAllAsync(expression, sorting.Item2, sorting.Item1);
}
totalCount = await Repository.CountAsync(expression);
return(new PagedResultDto <TEntityDto>(pageNumber, itemsPerPage, totalCount, MapToEntityDtoList(list.ToList())));
}
private async Task <long[]> GetAllUserRoleIds(long userId)
{
var userRoles = await _userRoleRepository.GetAllAsync(p => p.UserId == userId);
var userRoleIds = userRoles.Select(p => p.RoleId).ToList();
var userGroups = await _userUserGroupRelationRoleRepository.GetAllAsync(p => p.UserId == userId);
foreach (var userGroup in userGroups)
{
var userGroupRoles = await _userGroupDomainService.GetUserGroupRoles(userGroup.UserGroupId);
userRoleIds.AddRange(userGroupRoles.Select(p => p.Id));
}
return(userRoleIds.ToArray());
}
public async Task <bool> CheckPermission(long userId, string serviceId)
{
var userGroups = await _userUserGroupRelationRepository.GetAllAsync(p => p.UserId == userId);
foreach (var userGroup in userGroups)
{
var userGroupRoles = await GetUserGroupRoles(userGroup.UserGroupId);
foreach (var userGroupRole in userGroupRoles)
{
if (await _roleDomainService.CheckPermission(userGroupRole.Id, serviceId))
{
return(true);
}
}
}
return(false);
}
private async Task <GetDisplayOrganizationOutput[]> GetRoleOrgInfo(long roleId)
{
var organziationAppServiceProxy = GetService <IOrganizationAppService>();
var orgIds =
(await _roleOrganizationRepository.GetAllAsync(p => p.RoleId == roleId)).Select(p => p.OrgId).ToArray();
var roleOrgs = new List <GetDisplayOrganizationOutput>();
foreach (var orgId in orgIds)
{
var orginInfo = await organziationAppServiceProxy.GetOrg(orgId);
roleOrgs.Add(new GetDisplayOrganizationOutput()
{
OrgId = orgId, Name = orginInfo.Name
});
}
return(roleOrgs.ToArray());
}
