LegalServiceV1/SourceCode/V2/ContractService/ContractService.Application/Basic/Organization/OrganizationApplicationService.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Mvc;
using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;
using ContractService.Authorization;
using ContractService.BaseInfo;
using ContractService.BaseSystem.Roles.Dto;
using ContractService.BaseSystem.Users.Dto;
using ContractService.Basic.Organization.Dto;
using ContractService.Client;
using ContractService.Configuration;
using ContractService.LegalContract;
using IwbZero.AppServiceBase;
using IwbZero.Auditing;
using IwbZero.Authorization.Base.Users;
using IwbZero.ToolCommon.StringModel;

namespace ContractService.Basic.Organization
{
    [AbpAuthorize, AuditLog("组织结构")]
    public class OrganizationAppService : IwbAsyncCrudAppService<OrganizationInfo, OrganizationDto, string, IwbPagedRequestDto, OrganizationCreateDto, OrganizationUpdateDto >, IOrganizationAppService
    {
        public OrganizationAppService(
			ICacheManager cacheManager,
			IRepository<OrganizationInfo, string> repository, LegalManager legalManager, IRepository<SysFunction> funRepository) : base(repository, "Id")
        {
            LegalManager = legalManager;
            FunRepository = funRepository;
            CacheManager = cacheManager;
        }

        protected override bool KeyIsAuto { get; set; } = false;
        public LegalManager LegalManager { get; }
        private IRepository<SysFunction> FunRepository { get; }
       

        #region GetSelect

        [DisableAuditing]
        public override async Task<List<SelectListItem>> GetSelectList()
        {
            var list = await Repository.GetAllListAsync();
            var sList = new List<SelectListItem> {new SelectListItem {Text = @"请选择...", Value = "", Selected = true}};
            foreach (var l in list)
            {
                sList.Add(new SelectListItem { Value = l.Id, Text = l.Name });
            }
            return sList;
        }
        [DisableAuditing]
        public override async Task<string> GetSelectStr()
        {
            var list = await Repository.GetAllListAsync();
            string str = "<option value=\"\" selected>请选择...</option>";
            foreach (var l in list)
            {
                str += $"<option value=\"{l.Id}\">{l.Name}</option>";
            }
            return str;
        }

        #endregion

        #region CURD

        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgCreate, PermissionNames.PagesLegalLawFirmMgLawOrgMgCreate)]
        public override async Task Create(OrganizationCreateDto input)
        {
            var entity = MapToEntity(input);
            entity.CompanyNo = entity.CompanyNo.Empty() ? null : entity.CompanyNo;
            entity.LawFirmNo = entity.LawFirmNo.Empty() ? null : entity.LawFirmNo;
            await LegalManager.CreateOrg(entity);
        }

        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgUpdate, PermissionNames.PagesLegalLawFirmMgLawOrgMgUpdate)]
        public override async Task Update(OrganizationUpdateDto input)
        {
            var entity = await GetEntityById(input.Id);
            if (entity == null)
            {
                CheckErrors(NotExistMessage);
            }
            MapToEntity(input, entity);
            await LegalManager.UpdateOrg(entity);
        }

        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgDelete, PermissionNames.PagesLegalLawFirmMgLawOrgMgDelete)]
        public override Task Delete(EntityDto<string> input)
        {
            return LegalManager.DeleteOrg(input.Id);
        }

        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgQuery,PermissionNames.PagesLegalLawFirmMgLawOrgMgQuery)]
        public override async Task<PagedResultDto<OrganizationDto>> GetAll(IwbPagedRequestDto input)
        {
            var query = CreateFilteredQuery(input);
            var totalCount = await AsyncQueryableExecuter.CountAsync(query);
            query = ApplySorting(query, input);
            query = ApplyPaging(query, input);
            var entities = await AsyncQueryableExecuter.ToListAsync(query);
            var dtoList = new PagedResultDto<OrganizationDto>(totalCount, entities.Select(MapToEntityDto).ToList());
            return dtoList;
        }

        protected override IQueryable<OrganizationInfo> SelfSorting(IQueryable<OrganizationInfo> query, IwbPagedRequestDto input)
        {
            return query.OrderBy(r => r.Sort).ThenByDescending(a=>a.Id);
        }

        protected override IQueryable<OrganizationInfo> KeyWordFilter(IQueryable<OrganizationInfo> query, string keyword)
        {
            return query.Where(a => a.Id.Contains(keyword));
        }

		#region GetEntity/Dto

        /// <summary>
        ///  查询实体Dto
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgQuery, PermissionNames.PagesLegalLawFirmMgLawOrgMgQuery)]
        public override async Task<OrganizationDto> GetDto(EntityDto<string> input)
        {
            var entity = await GetEntity(input);
            return MapToEntityDto(entity);
        }

        /// <summary>
        ///  查询实体Dto
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgQuery, PermissionNames.PagesLegalLawFirmMgLawOrgMgQuery)]
        public override async Task<OrganizationDto> GetDtoById(string id)
        {
            var entity = await GetEntityById(id);
            return MapToEntityDto(entity);
        }

        /// <summary>
        /// 查询实体Dto（需指明自定义字段）
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgQuery, PermissionNames.PagesLegalLawFirmMgLawOrgMgQuery)]
        public override async Task<OrganizationDto> GetDtoByNo(string no)
        {
            var entity = await GetEntityByNo(no);
            return MapToEntityDto(entity);
        }

        /// <summary>
        /// 查询实体
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgQuery, PermissionNames.PagesLegalLawFirmMgLawOrgMgQuery)]
        public override async Task<OrganizationInfo> GetEntity(EntityDto<string> input)
        {
            var entity = await GetEntityById(input.Id);
            return entity;
        }

        /// <summary>
        /// 查询实体
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgQuery, PermissionNames.PagesLegalLawFirmMgLawOrgMgQuery)]
        public override async Task<OrganizationInfo> GetEntityById(string id)
        {
            return await Repository.FirstOrDefaultAsync(a=>a.Id==id);
        }

        /// <summary>
        /// 查询实体（需指明自定义字段）
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgQuery, PermissionNames.PagesLegalLawFirmMgLawOrgMgQuery)]
        public override async Task<OrganizationInfo> GetEntityByNo(string no)
        {
            //CheckGetPermission();
            if (string.IsNullOrEmpty(KeyFiledName))
            {
                ThrowError("NoKeyFieldName");
            }
            return await base.GetEntityByNo(no);
        }

        #endregion

        #region Hide

        ///// <summary>
        ///// 根据给定的<see cref="IwbPagedRequestDto"/>创建 <see cref="IQueryable{ClientOrganizationInfo}"/>过滤查询.
        ///// </summary>
        ///// <param name="input">The input.</param>
        //protected override IQueryable<ClientOrganizationInfo> CreateFilteredQuery(IwbPagedRequestDto input)
        //{
        //    var query = Repository.GetAll();
        //    var pagedInput = input as IIwbPagedRequest;
        //    if (pagedInput == null)
        //    {
        //        return query;
        //    }
        //    if (!string.IsNullOrEmpty(pagedInput.KeyWords))
        //    {
        //        object keyWords = pagedInput.KeyWords;
        //        LambdaObject obj = new LambdaObject()
        //        {
        //            FieldType = (LambdaFieldType)pagedInput.FieldType,
        //            FieldName = pagedInput.KeyField,
        //            FieldValue = keyWords,
        //            ExpType = (LambdaExpType)pagedInput.ExpType
        //        };
        //        var exp = obj.GetExp<ClientOrganizationInfo>();
        //        query = exp != null ? query.Where(exp) : query;
        //    }
        //    if (pagedInput.SearchList != null && pagedInput.SearchList.Count > 0)
        //    {
        //        List<LambdaObject> objList = new List<LambdaObject>();
        //       foreach (var o in pagedInput.SearchList)
        //        {
        //            if (string.IsNullOrEmpty(o.KeyWords))
        //                continue;
        //           object keyWords = o.KeyWords;
        //            objList.Add(new LambdaObject
        //            {
        //                FieldType = (LambdaFieldType)o.FieldType,
        //                FieldName = o.KeyField,
        //                FieldValue = keyWords,
        //                ExpType = (LambdaExpType)o.ExpType
        //            });
        //        }
        //        var exp = objList.GetExp<ClientOrganizationInfo>();
        //        query = exp != null ? query.Where(exp) : query;
        //    }
        //    return query;
        //}



        //protected override IQueryable<ClientOrganizationInfo> ApplySorting(IQueryable<ClientOrganizationInfo> query, IwbPagedRequestDto input)
        //{
        //    return query.OrderBy(a => a.No);
        //}

        //protected override IQueryable<ClientOrganizationInfo> ApplyPaging(IQueryable<ClientOrganizationInfo> query, IwbPagedRequestDto input)
        //{
        //    if (input is IPagedResultRequest pagedInput)
        //    {
        //        return query.Skip(pagedInput.SkipCount).Take(pagedInput.MaxResultCount);
        //    }
        //    return query;
        //}

        #endregion

        #endregion



        #region Auth

        /// <summary>
        /// 组织权限配置
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgOrgAuth, PermissionNames.PagesLegalLawFirmMgLawOrgMgOrgAuth)]
        [AuditLog("组织权限配置")]
        public async Task Auth(OrgAuthDto input)
        {
            var org = await GetEntityById(input.Id);
            if (org.ParentNo==null)
            {
                CheckErrors("此组织的权限不能变更");
            }
            var grantedPermissions = new List<Permission>();
            if (input.PermissionNames != null && input.PermissionNames.Any())
            {
                grantedPermissions = PermissionManager
                    .GetAllPermissions()
                    .Where(p => input.PermissionNames.Contains(p.Name))
                    .ToList();
            }
            await UserManager.SetGrantedOrgPermissionsAsync(org, grantedPermissions);
        }

        /// <summary>
        /// 获取组织权限
        /// </summary>
        /// <param name="orgId"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesClientMgOrgMgOrgAuth, PermissionNames.PagesLegalLawFirmMgLawOrgMgOrgAuth)]
        public async Task<PermissionAuthDto> GetPermissions(string orgId)
        {
            var permissions = (await GetAllPermissions()).Items;
            List<PermissionDto> currentPerms = new List<PermissionDto>();
            if (AbpSession.UserName == UserBase.AdminUserName)
            {
                currentPerms.AddRange(permissions);
            }
            else
            {
                foreach (var perm in permissions)
                {
                    if (AbpSession.UserId != null &&
                        await UserManager.IsGrantedAsync((long) AbpSession.UserId, perm.Name)) 
                        currentPerms.Add(perm);
                }
            }
            var permission = permissions.FirstOrDefault(a => a.Name == PermissionNames.Pages);
            var model = new PermissionAuthDto();
            if (permission != null)
            {
                var fun = await CacheManager.GetCache(IwbCacheNames.FunctionCache)
                    .GetAsync(permission.Name, () => FunRepository.FirstOrDefaultAsync(a => a.PermissionName == permission.Name));
                model.Name = permission.Name;
                model.IsAuth = await UserManager.IsOrgGrantedAsync(orgId, permission.Name);
                model.PermDisplayName = fun.FunctionName;
                model.Sort = fun.Sort;
                model.Icon = fun.Icon;
                model.IsOpen = fun.Depth < 2;
                model.Children = await GetPermissionTree(permission.Name, currentPerms, orgId);
            }
            return model;
        }

        /// <summary>
        /// 获取用户权限树
        /// </summary>
        /// <param name="parentName"></param>
        /// <param name="permissions"></param>
        /// <param name="orgId"></param>
        /// <returns></returns>
        private async Task<List<PermissionAuthDto>> GetPermissionTree(string parentName, List<PermissionDto> permissions, string orgId)
        {
            var parentPerms = permissions.Where(a => a.Parent?.Name == parentName).OrderBy(a => a.Sort).ToList();
            var list = new List<PermissionAuthDto>();
            if (parentPerms.Any())
            {
                foreach (var p in parentPerms)
                {
                    var fun = await CacheManager.GetCache(IwbCacheNames.FunctionCache)
                        .GetAsync(p.Name, () => FunRepository.FirstOrDefaultAsync(a => a.PermissionName == p.Name));
                    var model = new PermissionAuthDto
                    {
                        Name = p.Name,
                        IsAuth = await UserManager.IsOrgGrantedAsync(orgId, p.Name),
                        PermDisplayName = fun.FunctionName,
                        Sort = fun.Sort,
                        Icon = fun.Icon,
                        IsOpen = fun.Depth < 2,
                        Children = await GetPermissionTree(p.Name, permissions, orgId)
                    };
                    list.Add(model);
                }
            }
            return list;
        }


        [DisableAuditing]
        private Task<ListResultDto<PermissionDto>> GetAllPermissions()
        {
            var permissions = PermissionManager.GetAllPermissions();

            return Task.FromResult(new ListResultDto<PermissionDto>(
                ObjectMapper.Map<List<PermissionDto>>(permissions)
            ));
        }



        #endregion


    }
}