BeiJinSettleAccount/code/src/Modules/BaseService/BaseService.Application/BranchManagement/BranchAppService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Threading.Tasks;
using BaseService.BaseData.BranchManagement.Dto;
using BaseService.Permissions;
using BaseService.RelationData.Dto;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Caching;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Identity;
using Win.Sfs.Shared.CacheBase;

namespace BaseService.BaseData.BranchManagement
{
    [Route("api/base/branch")]
    [Authorize(BaseServicePermissions.Branch.Default)]
    public class BranchAppService : ApplicationService, IBranchAppService
    {
        private readonly IRepository<Branch, Guid> _repository;
        private readonly IRepository<UserBranch> _repositoryBranchRole;
        public IIdentityRoleRepository RoleRepository { get; }

        private readonly IDistributedCache<Branch> _cache;
        public BranchAppService(IRepository<Branch, Guid> repository,
            IRepository<UserBranch> repositoryBranchRole,
            IDistributedCache<Branch> cache,
            IIdentityRoleRepository roleRepository)
        {
            _repository = repository;
            _repositoryBranchRole = repositoryBranchRole;
            RoleRepository = roleRepository;
            _cache = cache;
        }
        [HttpPost]
        [Authorize(BaseServicePermissions.Branch.Create)]
        public virtual async Task<BranchDto> CreateAsync(CreateOrUpdateBranchDto input)
        {
            var exist = await _repository.FirstOrDefaultAsync(_ => _.Name == input.Name).ConfigureAwait(false);
            if (exist != null)
            {
                throw new BusinessException("名称：" + input.Name + "机构已存在");
            }

            var branch = new Branch(GuidGenerator.Create(),
                                                CurrentTenant.Id,
                                                input.CategoryId,
                                                input.Pid,
                                                input.Name,
                                                "",
                                                input.Sort,
                                                true,
                                                input.Enabled
                                                );
            var parent = await _repository.FirstOrDefaultAsync(_ => _.Id == input.Pid).ConfigureAwait(false);
            ChangeOrganizationModel(branch, parent);
            await _repository.InsertAsync(branch).ConfigureAwait(false);

            //create cache
            await _cache.SetAsync(branch.Id.ToString(), branch, CacheStrategyConst.FIVE_MINUTES).ConfigureAwait(false);

            return ObjectMapper.Map<Branch, BranchDto>(branch);
        }

        [HttpPost]
        [Route("delete")]
        [Authorize(BaseServicePermissions.Branch.Delete)]
        public virtual async Task DeleteAsync(List<Guid> ids)
        {
            foreach (var id in ids)
            {
                var branch = await _repository.GetAsync(id).ConfigureAwait(false);
                await _repository.DeleteAsync(_ => _.CascadeId.Contains(branch.CascadeId)).ConfigureAwait(false);
                await _cache.DeleteAsync(id.ToString()).ConfigureAwait(false);
                await _repository.DeleteAsync(_ => _.Id == id).ConfigureAwait(false);
            }
        }
        [HttpGet]
        [Route("{id}")]
        [AllowAnonymous]
        public virtual async Task<BranchDto> GetAsync(Guid id)
        {
            var result = await GetFromCacheAsync(id).ConfigureAwait(false);
            return ObjectMapper.Map<Branch, BranchDto>(result);
        }

        protected virtual async Task<Branch> GetFromCacheAsync(Guid id)
        {
            var result = await _cache.GetOrAddAsync(
                id.ToString(),
                async () => await GetFromRepository(id).ConfigureAwait(false),
                CacheStrategyConst.FIVE_MINUTES).ConfigureAwait(false);

            return result;
        }

        private async Task<Branch> GetFromRepository(Guid id)
        {
            return await _repository.GetAsync(id).ConfigureAwait(false);
        }

        [HttpGet]
        [Route("paged")]
        public virtual async Task<PagedResultDto<BranchDto>> GetPagedListAsync(GetBranchInputDto input)
        {
            var query = _repository
           .WhereIf(!string.IsNullOrWhiteSpace(input.Filter), _ => _.Name.Contains(input.Filter))
           .WhereIf(input.CategoryId.HasValue, _ => _.CategoryId == input.CategoryId);
            if (input.Id.HasValue)
            {
                var org = await _repository.GetAsync(input.Id.Value).ConfigureAwait(false);
                query = query.Where(_ => _.CascadeId.Contains(org.CascadeId));
            }

            var items = await query.OrderBy(input.Sorting ?? "Sort")
                     .Skip(input.SkipCount)
                     .Take(input.MaxResultCount)
                     .ToListAsync().ConfigureAwait(false);
            var totalCount = await query.CountAsync().ConfigureAwait(false);

            var dtos = ObjectMapper.Map<List<Branch>, List<BranchDto>>(items);
            return new PagedResultDto<BranchDto>(totalCount, dtos);
            //var query = _repository
            //    .WhereIf(!string.IsNullOrWhiteSpace(input.Filter), _ => _.Name.Contains(input.Filter))
            //    .WhereIf(input.CategoryId.HasValue, _ => _.CategoryId == input.CategoryId);

            //var items = await query.OrderBy(input.Sorting ?? "Sort")
            //         .Skip(input.SkipCount)
            //         .Take(input.MaxResultCount)
            //         .ToListAsync();
            //var totalCount = await query.CountAsync();

            //var dtos = ObjectMapper.Map<List<Branch>, List<BranchDto>>(items);
            //return new PagedResultDto<BranchDto>(totalCount, dtos);
        }
        [HttpGet]
        [Route("all")]
        public virtual async Task<ListResultDto<BranchDto>> GetAllAsync(Guid? id, string filter)
        {
            var items = new List<Branch>();
            if (!string.IsNullOrWhiteSpace(filter))
            {
                items = await _repository.Where(_ => _.Name.Contains(filter)).ToListAsync().ConfigureAwait(false);
            }
            else
            {
                var query = id.HasValue ? _repository.Where(_ => _.Pid == id) :
                                         _repository.Where(_ => _.Pid == null);
                items = await query.ToListAsync().ConfigureAwait(false);
            }

            var dtos = ObjectMapper.Map<List<Branch>, List<BranchDto>>(items);
            return new ListResultDto<BranchDto>(dtos);
        }
        [HttpGet]
        [Route("children")]
        public virtual async Task<ListResultDto<BranchDto>> GetChildrenAsync()
        {
            var items = await _repository.GetListAsync().ConfigureAwait(false);

            var dtos = ObjectMapper.Map<List<Branch>, List<BranchDto>>(items);
            return new ListResultDto<BranchDto>(dtos);
        }
        [HttpPut]
        [Route("{id}")]
        [Authorize(BaseServicePermissions.Branch.Update)]
        public virtual async Task<BranchDto> UpdateAsync(Guid id, CreateOrUpdateBranchDto input)
        {
            if (input.Pid == id)
            {
                throw new BusinessException("机构上级不能为当前机构！");
            }

            var branch = await _repository.FirstOrDefaultAsync(_ => _.Id == id).ConfigureAwait(false);
            if (branch.Pid != input.Pid)
            {
                var parent = await _repository.FirstOrDefaultAsync(_ => _.Id == input.Pid).ConfigureAwait(false);
                var orgs = await _repository.Where(_ => _.CascadeId.Contains(branch.CascadeId) && _.Id != branch.Id)
                                      .OrderBy(_ => _.CascadeId).ToListAsync().ConfigureAwait(false);
                branch.Pid = input.Pid;
                ChangeOrganizationModel(branch, parent);
                foreach (var org in orgs)
                {
                    if (org.Pid == branch.Id)
                    {
                        ChangeOrganizationModel(org, branch, false);
                    }
                    else
                    {
                        var orgParent = orgs.FirstOrDefault(_ => _.Id == org.Pid);
                        ChangeOrganizationModel(org, orgParent, false);
                    }
                }
            }
            branch.Name = input.Name;
            branch.Sort = input.Sort;
            branch.Enabled = input.Enabled;

            await _cache.SetAsync(id.ToString(), branch, CacheStrategyConst.FIVE_MINUTES).ConfigureAwait(false);

            return ObjectMapper.Map<Branch, BranchDto>(branch);
        }

        private void ChangeOrganizationModel(Branch org, Branch parent, bool checkLevel = true)
        {
            var cascadeId = org.CascadeId == null ? 1 : int.Parse(org.CascadeId.TrimEnd('.').Split('.').Last());
            if (checkLevel)
            {
                if (parent != null && parent.Leaf)
                {
                    parent.Leaf = false;
                }

                var lastLevel = _repository.Where(_ => _.Pid == org.Pid && _.Id != org.Id)
                      .OrderByDescending(_ => _.CascadeId)
                      .FirstOrDefault();
                cascadeId = lastLevel == null ? 1 : int.Parse(lastLevel.CascadeId.TrimEnd('.').Split('.').Last()) + 1;
            }

            if (org.Pid.HasValue)
            {
                if (parent == null)
                {
                    throw new BusinessException("上级机构查询错误！");
                }

                org.CascadeId = parent.CascadeId + cascadeId + ".";
                org.FullName = parent.FullName + "/" + org.Name;
            }
            else
            {
                org.CascadeId = ".0." + cascadeId + ".";
                org.FullName = org.Name;
            }

        }

        /// <summary>
        /// 根据分支ID，查找中间表branch-role
        /// </summary>
        /// <param name="branchId"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("{branchId}/roles")]
        public virtual async Task<ListResultDto<BranchRoleDto>> GetRolesAsync(Guid branchId)
        {
            var dtos = new List<BranchRoleDto>();
            var getRoleIds = await GetRolesByBranchIdAsync(branchId).ConfigureAwait(false);
            var roles = await RoleRepository.GetListAsync().ConfigureAwait(false);
            if (getRoleIds != null)
            {
                foreach (var role in getRoleIds)
                {
                    dtos.Add(new BranchRoleDto() { RoleId = role.RoleId, RoleName = roles.FirstOrDefault(p => p.Id == role.RoleId)?.Name });
                }
            }
            return new ListResultDto<BranchRoleDto>(dtos);
        }

        protected virtual async Task<List<UserBranchRole>> GetRolesByBranchIdAsync(Guid branchId)
        {
            var userBranch = await _repositoryBranchRole.GetAsync(_ => _.BranchId == branchId).ConfigureAwait(false);
            var roles = userBranch.Roles.ToList();
            return roles;
        }

        /// <summary>
        /// 用于角色管理：分支和角色互动
        /// </summary>
        /// <param name="branchId"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("paged-roles/{branchId}")]
        public virtual async Task<PagedResultDto<IdentityRoleDto>> GetPagedRolesAsync(Guid branchId, PagedAndSortedResultRequestDto input)
        {
            var listRoles = new List<IdentityRole>();
            var getRoleIds = GetUserRolesAsync(branchId);
            if (getRoleIds == null)
            {
                throw new BusinessException("未找到分支和角色的关联信息！");
            }
            else
            {
                var list = await RoleRepository.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount).ConfigureAwait(false);
                foreach (var roleid in getRoleIds)
                {
                    var filterRole = list.FirstOrDefault(_ => _.Id == roleid.RoleId);
                    listRoles.Add(filterRole);
                }
            }
            var totalCount = listRoles.Count;

            return new PagedResultDto<IdentityRoleDto>(
                totalCount,
                ObjectMapper.Map<List<IdentityRole>, List<IdentityRoleDto>>(listRoles)
                );
        }

        protected virtual List<UserBranchRole> GetUserRolesAsync(Guid branchId)
        {
            var dtos = new List<UserBranchRole>();
            var isInRole = _repositoryBranchRole.Where(_ => _.BranchId == branchId);
            if (isInRole != null)
            {
                foreach (var userRoles in isInRole)
                {
                    foreach (var role in userRoles.Roles)
                    {
                        dtos.Add(new UserBranchRole() { RoleId = role.RoleId });
                    }
                }
            }
            return dtos;
        }

    }

}