LegalServiceV1/SourceCode/V2/ContractService/ContractService.Core/LegalContract/LegalManager.cs

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;
using System.Web.WebPages;
using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.Domain.Services;
using Abp.Runtime.Caching;
using Abp.UI;
using ContractService.Authorization;
using ContractService.Authorization.Users;
using ContractService.Client;
using ContractService.CommonManager.AppGuids;
using ContractService.CommonManager.AttachFiles;
using ContractService.CommonManager.States;
using ContractService.Configuration;
using ContractService.LawFirm;
using ContractService.Lawyer;
using ContractService.LegalCase;
using IwbZero.Authorization.Base.Users;
using IwbZero.IdentityFramework;
using IwbZero.Runtime.Session;
using IwbZero.ToolCommon.StringModel;
using Microsoft.AspNet.Identity;

namespace ContractService.LegalContract
{
    public class LegalManager : DomainService
    {
        public LegalManager(IRepository<LegalCaseInfo, string> lsRepository, IRepository<LegalContractInfo, string> lcRepository, IRepository<LegalContractNoteInfo, long> lCnRepository, IRepository<LegalContractSupplementInfo, string> lCsRepository, IRepository<LegalContractKeyPointInfo, string> lCkpRepository, IRepository<LawyerInfo, string> lawyerRepository, IRepository<LawyerRelatedInfo> lawyerRelatedRepository, IRepository<LegalCaseNoteInfo, long> lSnRepository, ICacheManager cacheManager,  IRepository<LawFirmInfo, string> lfRepository, IRepository<LegalContractContentInfo, long> lCcRepository,  IRepository<User, long> userRepository, IRepository<StaffRelatedInfo> staffRelatedRepository, IRepository<ClientStaffInfo, string> staffRepository, IRepository<ClientCompanyInfo, string> ccRepository, IRepository<OrganizationInfo, string> coRepository, IRepository<ClientStaffInfo, string> csRepository, UserManager userManager)
        {
            AbpSession = NullIwbSession.Instance;
            PermissionChecker = NullPermissionChecker.Instance;
            StatesManager = NullStatesManager.Instance;
            AppGuidManager = NullAppGuidManager.Instance;
            AttachManager = NullAttachFileManager.Instance;
            LsRepository = lsRepository;
            LcRepository = lcRepository;
            LCnRepository = lCnRepository;
            LCsRepository = lCsRepository;
            LCkpRepository = lCkpRepository;
            LawyerRepository = lawyerRepository;
            LawyerRelatedRepository = lawyerRelatedRepository;
            LSnRepository = lSnRepository;
            CacheManager = cacheManager;
            LfRepository = lfRepository;
            LCcRepository = lCcRepository;
            UserRepository = userRepository;
            StaffRelatedRepository = staffRelatedRepository;
            StaffRepository = staffRepository;
            CcRepository = ccRepository;
            CoRepository = coRepository;
            CsRepository = csRepository;
            UserManager = userManager;
        }

        private const int STEP = 1000;
        public  IIwbSession AbpSession { get; set; }
        public IPermissionChecker PermissionChecker { get; set; }
        public IStatesManager StatesManager { get; set; }
        public IAttachFileManager AttachManager { get; set; }
        public IAppGuidManager AppGuidManager { get; set; }
        public ICacheManager CacheManager { get; }
        public IRepository<LawFirmInfo, string> LfRepository { get; }
        public IRepository<LegalCaseInfo, string> LsRepository { get; }
        public IRepository<LegalContractInfo,string> LcRepository { get; }
        public IRepository<LegalCaseNoteInfo,long> LSnRepository { get; }
        public IRepository<LegalContractNoteInfo,long> LCnRepository { get; }
        public IRepository<LegalContractSupplementInfo,string> LCsRepository { get; }
        public IRepository<LegalContractContentInfo,long> LCcRepository { get; }
        public IRepository<LegalContractKeyPointInfo,string> LCkpRepository { get; }
        public IRepository<LawyerInfo,string> LawyerRepository { get; }
        public IRepository<LawyerRelatedInfo> LawyerRelatedRepository { get; }
        public IRepository<ClientStaffInfo,string> StaffRepository { get; }
        public IRepository<StaffRelatedInfo> StaffRelatedRepository { get; }
        public IRepository<ClientCompanyInfo,string> CcRepository { get; }
        public IRepository<OrganizationInfo,string> CoRepository { get; }
        public IRepository<ClientStaffInfo,string> CsRepository { get; }
        public IRepository<User, long> UserRepository { get; }
        public UserManager UserManager { get; }


        #region CURD 

        #region Company

        public async Task CreateCompany(ClientCompanyInfo entity, ClientStaffInfo staff)
        {
            CheckSysAccount();
            entity.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.Company);
            var id = await CcRepository.InsertAndGetIdAsync(entity);
           var orgId= await CreateOrg(new OrganizationInfo()
            {
                ParentNo = null,
                CompanyNo = id,
                LawFirmNo = null,
                Name = entity.Name,
                Description = $"{entity.Name}的组织结构根节点。"
            }, false);
            if (staff!=null)
            {
                staff.OrganizationNo = orgId;
                staff.CompanyNo = id;
                staff = await CreateStaff(staff, id, false);
                var staffDefaultMasterRole = ConfigurationManager.AppSettings["MasterRole.Default.Company"];
                await UserManager.CreateUser(new User()
                {
                    Name = staff.Name,
                    EmailAddress = staff.Email,
                    UserType = UsersAndRolesTypeDefinition.Advanced,
                    AccountType = AccountTypeDefinition.Client,
                    AccountNo = staff.Id,
                    IsActive = true,
                }, staffDefaultMasterRole);
                await SetCompanyMasterStaff(id, staff.Id);
            }
        }
        public async Task UpdateCompany(ClientCompanyInfo entity)
        {
            await CcRepository.UpdateAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();
            await SetCacheName(entity.Id, entity.Name);
        }
        public async Task DeleteCompany(string no)
        {
            CheckSysAccount();
            if ((await StaffRelatedRepository.CountAsync(a => a.CompanyNo == no && a.RelatedType == StaffRelatedDefinition.LegalCase)) > 0)
            {
                CheckError("公司还有关联项目，请先删除关联项目！");
            }
            var entity = await CcRepository.FirstOrDefaultAsync(a => a.Id == no);
            await CcRepository.DeleteAsync(entity);
            var list = await CsRepository.GetAllListAsync(a => a.CompanyNo == no);
            foreach (var staff in list)
            {
                await UnBindStaffAccount(staff,false);
                await CsRepository.DeleteAsync(staff);
            }
            var list2= await StaffRelatedRepository.GetAllListAsync(a => a.CompanyNo == no);
            foreach (var info in list2)
            {
                info.RelatedType = info.RelatedType + STEP;
                await StaffRelatedRepository.UpdateAsync(info);
            }
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        #endregion

        #region Org

        public async Task<string> CreateOrg(OrganizationInfo entity,bool isCheck =true)
        {
            if (isCheck)
            {
                CheckAccount(AccountTypeDefinition.Lawyer, AccountTypeDefinition.Client);
            }
            OrganizationInfo parent = entity.ParentNo.IsEmpty()
                ? null
                : await CoRepository.FirstOrDefaultAsync(a => a.Id == entity.ParentNo);
            entity.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.Organization);
            entity.Path = parent == null ? entity.Id : $"{parent.Path},{entity.Id}";
           var id= await CoRepository.InsertAndGetIdAsync(entity);
           return id;
        }
        public async Task UpdateOrg(OrganizationInfo entity)
        {
            CheckAccount(AccountTypeDefinition.Lawyer, AccountTypeDefinition.Client);
            await CoRepository.UpdateAsync(entity);
            await SetCacheName(entity.Id, entity.Name);
        }
        public async Task DeleteOrg(string no)
        {
            CheckAccount(AccountTypeDefinition.Lawyer, AccountTypeDefinition.Client);
            var entity = await CoRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckError("未查询到组织结构！");
            }
            
            if ((await CoRepository.CountAsync(a => a.ParentNo == entity.Id)) > 0)
            {
                CheckError("请先删除子节点！");
            }
            await CoRepository.DeleteAsync(entity);
        }

        #endregion

        #region Staff

        public async Task<ClientStaffInfo> CreateStaff(ClientStaffInfo entity, string companyNo = null, bool isCheck = true)
        {
            if (isCheck)
            {
                CheckClientAccount();
            }
            entity.CompanyNo = companyNo.Empty() ? entity.CompanyNo : companyNo ?? "";
            if ((await StaffRepository.FirstOrDefaultAsync(a => a.Code == entity.Code && a.CompanyNo == entity.CompanyNo)) != null) 
            {
                CheckError($"员工编号[{entity.Code}]已存在，请检查后再试！");
            }
            entity.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.Staff);
            var id = await StaffRepository.InsertAndGetIdAsync(entity);
            if (entity.CompanyNo == null)
            {
                CheckError("未查询到企业，请检查后再试！");
            }
            if (entity.CompanyNo.NotEmpty())
            {
                await SetStaffCompany(id, entity.CompanyNo);
            }
            
            await CurrentUnitOfWork.SaveChangesAsync();
            return entity;
        }
        public async Task UpdateStaff(ClientStaffInfo entity)
        {
            CheckClientAccount();
            if (!IsCompanyMaster(AbpSession.AccountNo) && AbpSession.AccountNo != entity.Id)
            {
                CheckError("账号权限不够，不能修改企业负责人信息！");
            }
            var old = await StaffRepository.FirstOrDefaultAsync(a => a.Code == entity.Code && a.CompanyNo==entity.CompanyNo);
            if (old != null && old.Id != entity.Id)
            {
                CheckError($"员工编号[{entity.Code}]已存在，请检查后再试！");
            }

            if (old != null && old.UserName.NotEmpty())
            {
                var user = await UserRepository.FirstOrDefaultAsync(a =>
                    a.UserName == old.UserName && a.IsActive && a.AccountType == AccountTypeDefinition.Client && a.AccountNo == old.Id);
                if (user != null)
                {
                    user.Name = entity.Name;
                    user.PhoneNumber = entity.PhoneNumber;
                    if (user.EmailAddress != entity.Email)
                    {
                        CheckError(await UserManager.CheckDuplicateUsernameOrEmailAddressAsync(user.Id, "", entity.Email));
                        user.EmailAddress = entity.Email;
                        user.SetNormalizedNames();
                        user.IsEmailConfirmed = false;
                    }
                }
            }
            if (entity.UserName.NotEmpty())
            {
                await CacheManager.GetCache(IwbCacheNames.QueryStaffInfo).SetAsync(entity.UserName, entity);
            }
            await StaffRepository.UpdateAsync(entity);

            await CurrentUnitOfWork.SaveChangesAsync();
            await SetCacheName(entity.Id, entity.Name);
        }
        public async Task DeleteStaff(string no)
        {
            CheckClientAccount();
            var entity = await StaffRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckError("未查询到员工！");
                return;
            }
            if ((await StaffRelatedRepository.CountAsync(a => a.StaffNo == no && a.RelatedType!=StaffRelatedDefinition.Company)) > 0)
            {
                CheckError("员工还有关联项目或合同，不能删除");
            }
            if (entity.UserName.NotEmpty())
            {
                CheckError("请先解绑员工账号后再删除！");
            }
            await StaffRepository.DeleteAsync(entity);
            await StaffRelatedRepository.DeleteAsync(a => a.StaffNo == no);
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        #endregion

        #region LawFirm

        public async Task CreateLawFirm(LawFirmInfo entity, LawyerInfo lawyer)
        {
            CheckSysAccount();
            entity.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.LawFirm);
            var id = await LfRepository.InsertAndGetIdAsync(entity);
            var orgId = await CreateOrg(new OrganizationInfo()
            {
                ParentNo = null,
                CompanyNo = null,
                LawFirmNo = id,
                Name = entity.Name,
                Description = $"{entity.Name}的组织结构根节点。"
            }, false);
            if (lawyer!=null)
            {
                lawyer.OrganizationNo = orgId;
                lawyer.LawFirmNo = id;
                lawyer = await CreateLawyer(lawyer, id,false);
                var lawyerMasterRole = ConfigurationManager.AppSettings["MasterRole.Default.LawFirm"];
                await UserManager.CreateUser(new User()
                {
                    Name = lawyer.Name,
                    EmailAddress = lawyer.Email,
                    UserType = UsersAndRolesTypeDefinition.Advanced,
                    AccountType = AccountTypeDefinition.Lawyer,
                    AccountNo = lawyer.Id,
                    IsActive = true,
                }, lawyerMasterRole);
                await SetLawFirmMasterLawyer(id, lawyer.Id);
            }
        }
        public async Task UpdateLawFirm(LawFirmInfo entity)
        {
            await LfRepository.UpdateAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();
            await SetCacheName(entity.Id, entity.Name);
        }
        public async Task DeleteLawFirm(string no)
        {
            CheckSysAccount();

            if ((await LawyerRelatedRepository.CountAsync(a => a.LawFirmNo == no && a.RelatedType == LawyerRelatedDefinition.LegalContract && a.MasterType != LawyerMasterDefinition.LawFirmContract)) > 0)
            {
                CheckError("律所还有关联合同，请先解除关联合同！");
            }
            var entity = await LfRepository.FirstOrDefaultAsync(a => a.Id == no);
            await LfRepository.DeleteAsync(entity);
            var list = await LawyerRepository.GetAllListAsync(a => a.LawFirmNo == no);
            foreach (var lawyer in list)
            {
                await UnBindLawyerAccount(lawyer,false);
                await LawyerRepository.DeleteAsync(lawyer);
            }
            var list2 = await LawyerRelatedRepository.GetAllListAsync(a => a.LawFirmNo == no);
            foreach (var info in list2)
            {
                info.RelatedType = info.RelatedType + STEP;
                await LawyerRelatedRepository.UpdateAsync(info);
            }
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        #endregion

        #region Lawyer

        public async Task<LawyerInfo> CreateLawyer(LawyerInfo entity, string lawFirmNo=null,bool isCheck=true)
        {
            if (isCheck)
            {
                CheckLawyerAccount();
            }
            entity.LawFirmNo = lawFirmNo.Empty() ? entity.LawFirmNo : lawFirmNo;
            if ((await LawyerRepository.FirstOrDefaultAsync(a => a.Code == entity.Code&& a.LawFirmNo==entity.LawFirmNo)) != null)
            {
                CheckError($"律师编号[{entity.Code}]已存在，请检查后再试！");
            }
            entity.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.Lawyer);
            var id = await LawyerRepository.InsertAndGetIdAsync(entity);
            if (entity.LawFirmNo == null)
            {
                CheckError("未查询到律所，请检查后再试！");
            }
            if (entity.LawFirmNo.NotEmpty())
            {
                await SetLawyerLawFirm(id, entity.LawFirmNo);
            }
            await CurrentUnitOfWork.SaveChangesAsync();

            return entity;
        }
        public async Task UpdateLawyer(LawyerInfo entity)
        {
            CheckLawyerAccount();
            if (!IsLawFirmMaster(AbpSession.AccountNo) && AbpSession.AccountNo != entity.Id)
            {
                CheckError($"账号权限不够，不能修改律师负责人信息！");
            }
            var old = await LawyerRepository.FirstOrDefaultAsync(a => a.Code == entity.Code);
            if (old != null && old.Id != entity.Id)
            {
                CheckError($"律师编号[{entity.Code}]已存在，请检查后再试！");
            }
            if (old != null && old.UserName.NotEmpty())
            {
                var user = await UserRepository.FirstOrDefaultAsync(a =>
                    a.UserName == old.UserName && a.IsActive && a.AccountType == AccountTypeDefinition.Lawyer && a.AccountNo==old.Id);
                if (user != null)
                {
                    user.Name = entity.Name;
                    user.PhoneNumber = entity.PhoneNumber;
                    if (user.EmailAddress != entity.Email)
                    {
                        CheckError(await UserManager.CheckDuplicateUsernameOrEmailAddressAsync(user.Id, "", entity.Email));
                        user.EmailAddress = entity.Email;
                        user.SetNormalizedNames();
                        user.IsEmailConfirmed = false;
                    }
                }
            }
            if (entity.UserName.NotEmpty())
            {
                await CacheManager.GetCache(IwbCacheNames.QueryLawyerInfo).SetAsync(entity.UserName, entity);
            }

            await LawyerRepository.UpdateAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();
            await SetCacheName(entity.Id, entity.Name);
        }
        public async Task DeleteLawyer(string no)
        {
            CheckLawyerAccount();
            var entity = await LawyerRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckError("未查询到律师！");
                return;
            }
            if ((await LawyerRelatedRepository.CountAsync(a => a.LawyerNo == no && a.RelatedType != LawyerRelatedDefinition.LawFirm)) > 0)
            {
                CheckError("律师还有关联项目或合同，不能删除");
            }
            if (entity.UserName.NotEmpty())
            {
                CheckError("请先解绑律师账号后再删除！");
            }
            await LawyerRepository.DeleteAsync(entity);
            await LawyerRelatedRepository.DeleteAsync(a => a.LawyerNo == no);
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        #endregion

        #region Case

        public async Task CreateCase(LegalCaseInfo entity, string masterStaffNo = null)
         {
            CheckClientAccount();
            if (entity.CompanyNo.IsEmpty() || (await CcRepository.FirstOrDefaultAsync(a => a.Id == entity.CompanyNo)) == null)
            {
                CheckError("未查询到企业，请检查后再试！");
            }
            masterStaffNo = masterStaffNo ?? AbpSession.AccountNo;
            if (masterStaffNo.IsEmpty())
            {
                CheckError("当前账号未绑定职员，请检查后再试！");
            }

            if ((await LsRepository.FirstOrDefaultAsync(a => a.Code == entity.Code)) != null)
            {
                CheckError($"项目编码[{entity.Code}]已存在，请检查后再试！");
            }
            entity.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.LegalCase);
            entity.CaseState = LegalCaseStateDefinition.New;
            var id = await LsRepository.InsertAndGetIdAsync(entity);
            await SetCaseMasterStaff(id, masterStaffNo, entity.CompanyNo);
            await CurrentUnitOfWork.SaveChangesAsync();
        }
        public async Task UpdateCase(LegalCaseInfo entity)
        {
            CheckLawyerAccount();
            if (entity.CaseState != LegalCaseStateDefinition.New)
            {
                CheckError("项目不能被修改！");
            }
            var old = await LsRepository.FirstOrDefaultAsync(a => a.Code == entity.Code);
            if (old != null && old.Id != entity.Id)
            {
                CheckError($"项目编码[{entity.Code}]已存在，请检查后再试！");
            }
            await LsRepository.UpdateAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();
            await SetCacheName(entity.Id, entity.Name);
        }
        public async Task DeleteCase(string no)
        {
            CheckLawyerAccount();
            var entity = await LsRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckError("未查询到项目！");
            }
            if (entity?.CaseState != LegalCaseStateDefinition.New)
            {
                CheckError("项目不能被删除！");
            }
            if ((await LcRepository.CountAsync(a => a.CaseNo == no)) > 0)
            {
                CheckError("项目中还有关联合同，请先删除合同！");
            }

            await LsRepository.DeleteAsync(entity);
            await LawyerRelatedRepository.DeleteAsync(a => a.CaseNo == no);
            await CurrentUnitOfWork.SaveChangesAsync();
        }
        public async Task CreateCaseNote(LegalCaseNoteInfo entity)
        {
            await LSnRepository.InsertAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        #endregion

        #region Contract
        public async Task CreateContract(LegalContractInfo entity, List<AttachFileCreateDto> attachFiles = null, string masterStaffNo = null)
        {
            CheckClientAccount();
            if (entity.CaseNo.IsEmpty() || (await LsRepository.FirstOrDefaultAsync(a => a.Id == entity.CaseNo)) == null)
            {
                CheckError("未查询到项目，请检查后再试！");
            }
            masterStaffNo = masterStaffNo ?? AbpSession.AccountNo;
            if (masterStaffNo.IsEmpty())
            {
                CheckError("当前账号未绑定职员，请检查后再试！");
            }

            if ((await LcRepository.FirstOrDefaultAsync(a => a.Code == entity.Code)) != null)
            {
                CheckError($"合同编码[{entity.Code}]已存在，请检查后再试！");
            }
            entity.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.LegalContract);
            entity.ContractState = LegalContractStateDefinition.New;
            var id = await LcRepository.InsertAndGetIdAsync(entity);
            await SetContractMasterStaff(id, masterStaffNo, entity.CaseNo);
            if (entity.ContentInfo.NotEmpty())
            {
                await LCcRepository.InsertAsync(new LegalContractContentInfo()
                {
                    No = entity.Id,
                    ContentInfo = entity.ContentInfo
                });
            }
            await CurrentUnitOfWork.SaveChangesAsync();
            if (attachFiles?.Count > 0)
            {
                foreach (var attachFile in attachFiles)
                {
                    attachFile.TableName = "Contract";
                    attachFile.ColumnName = "Contract";
                    attachFile.SourceKey = entity.Id;
                    attachFile.AllowExt = "pdf,doc,xls,xlsx,docx,jpg,png";
                    await AttachManager.FileUpload(attachFile);
                }
            }
        }
        public async Task UpdateContract(LegalContractInfo entity, List<AttachFileCreateDto> attachFiles = null)
        {
            CheckClientAccount();
            if (entity.ContractState != LegalContractStateDefinition.New)
            {
                CheckError("合同不能被修改！");
            }
            var old = await LcRepository.FirstOrDefaultAsync(a => a.Code == entity.Code);
            if (old != null && old.Id != entity.Id)
            {
                CheckError($"合同编码[{entity.Code}]已存在，请检查后再试！");
            }
            await LcRepository.UpdateAsync(entity);
            if (entity.ContentInfo.NotEmpty())
            {
                await LCcRepository.InsertAsync(new LegalContractContentInfo()
                {
                    No = entity.Id,
                    ContentInfo = entity.ContentInfo
                });
            }
            await CurrentUnitOfWork.SaveChangesAsync();
            if (attachFiles?.Count > 0)
            {
                foreach (var attachFile in attachFiles)
                {
                    attachFile.TableName = "Contract";
                    attachFile.ColumnName = "Contract";
                    attachFile.SourceKey = entity.Id;
                    attachFile.AllowExt = "pdf,doc,xls,xlsx,docx,jpg,png";
                    await AttachManager.FileUpload(attachFile);
                }
            }
            await SetCacheName(entity.Id, entity.Name);
        }
        public async Task DeleteContract(string no)
        {
            CheckClientAccount();
            var entity = await LcRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckError("未查询到合同！");
            }
            if (entity?.ContractState != LegalContractStateDefinition.New)
            {
                CheckError("合同不能被删除！");
            }
            //if((await LCkpRepository.CountAsync(a => a.ContractNo == no)) > 0)
            //{
            //    CheckError("合同中还有关联关键点，请先删除关键点！");
            //}

            await LcRepository.DeleteAsync(entity);
            await LawyerRelatedRepository.DeleteAsync(a => a.ContractNo == no);
            //await LCsRepository.DeleteAsync(a => a.ContractNo == no);
            //await LCcRepository.DeleteAsync(a => a.No == no);
            await CurrentUnitOfWork.SaveChangesAsync();
        }
        public async Task ContractNote(LegalContractNoteInfo entity)
        {
            await LCnRepository.InsertAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 合同补充内容
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="attachFiles"></param>
        /// <returns></returns>
        public async Task ContractSupplement(LegalContractSupplementInfo entity, List<AttachFileCreateDto> attachFiles = null)
        {
            entity.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.LegalContractSupplement);
            await LCsRepository.InsertAsync(entity);
            if (entity.ContentInfo.NotEmpty())
            {
                await LCcRepository.InsertAsync(new LegalContractContentInfo()
                {
                    No = entity.Id,
                    ContentInfo = entity.ContentInfo
                });
            }
            await CurrentUnitOfWork.SaveChangesAsync();
            if (attachFiles?.Count > 0)
            {
                foreach (var attachFile in attachFiles)
                {
                    attachFile.TableName = entity.KeyPointNo.IsEmpty()?"Contract": "KeyPoint";
                    attachFile.ColumnName = "Supplement";
                    attachFile.SourceKey = entity.Id;
                    attachFile.AllowExt = "pdf,doc,xls,xlsx,docx,jpg,png";
                    await AttachManager.FileUpload(attachFile);
                }
            }
        }

        #endregion

        #region KeyPoint

        public async Task<LegalContractKeyPointInfo> CreateKeyPoint(LegalContractKeyPointInfo entity)
        {
            CheckAccount(AccountTypeDefinition.Lawyer,AccountTypeDefinition.Client);
            LegalContractKeyPointInfo parent = entity.ParentNo.IsEmpty()
                ? null
                : await LCkpRepository.FirstOrDefaultAsync(a => a.Id == entity.ParentNo);
            entity.ParentNo = entity.ParentNo.Empty() ? null : entity.ParentNo;
            entity.Id = await AppGuidManager.GetNextRecordIdAsync(DataLibType.LegalContractKeyPoint);
            entity.KeyPointPath = parent == null ? entity.Id : $"{parent.KeyPointPath},{entity.Id}";
            entity.KeyPointState = LegalKeyPointStateDefinition.New;
            entity.AlarmDay = entity.AlarmDate == null ? entity.AlarmDay : 0;
            entity.ExpireDay = entity.ExpireDate == null ? entity.ExpireDay : 0;
            await LCkpRepository.InsertAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();
            return entity;
        }
        public async Task UpdateKeyPoint(LegalContractKeyPointInfo entity)
        {
            CheckAccount(AccountTypeDefinition.Lawyer,AccountTypeDefinition.Client);
            entity.ParentNo = entity.ParentNo.Empty() ? null : entity.ParentNo;
            if (entity.KeyPointState != LegalKeyPointStateDefinition.New)
            {
                await ContractNote(new LegalContractNoteInfo()
                {
                    KeyPointNo = entity.Id,
                    ContractNo = entity.ContractNo,
                    NoteType = NoteTypeDefinition.ContentChange,
                    NoteContent = $"<strong class=\"pr-2\">变更关键点</strong><br/><strong  class=\"pr-2\">详情</strong> [<i class=\"pl-1 pr-1\">{entity.Description}</i>]<br/><strong class=\"pr-2\">提醒日期</strong> [<i class=\"pl-1 pr-1\">{(entity.AlarmDate != null ? entity.AlarmDate?.ToString("yyyy-MM-dd") : $"{entity.AlarmDay}天")}</i>] <span> </span> <strong class=\"pl-4 pr-2\">过期日期</strong> [<i class=\"pl-1 pr-1\">{(entity.ExpireDate != null ? entity.ExpireDate?.ToString("yyyy-MM-dd") : $"{entity.ExpireDay}天")}</i>]"
                });
                //CheckError("关键点不能被修改！");
            }
            await LCkpRepository.UpdateAsync(entity);
            await SetCacheName(entity.Id, entity.Name);
        }
        public async Task DeleteKeyPoint(string no)
        {
            CheckAccount(AccountTypeDefinition.Lawyer,AccountTypeDefinition.Client);
            var entity = await LCkpRepository.FirstOrDefaultAsync(a => a.Id == no);
            if (entity == null)
            {
                CheckError("未查询到关键点！");
            }
            if (entity?.KeyPointState != LegalKeyPointStateDefinition.New)
            {
                CheckError("关键点不能被删除！");
            }
            if ((await LCkpRepository.CountAsync(a => a.ParentNo == entity.Id)) > 0)
            {
                CheckError("请先删除子关键点！");
            }
            await LCkpRepository.DeleteAsync(entity);
        }
        public async Task KeyPointNote(LegalContractNoteInfo entity)
        {
            await LCnRepository.InsertAsync(entity);
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        public async Task SetKeyPointOrg(string staffNo,string kpNo)
        {
            var reKp = await StaffRelatedRepository.FirstOrDefaultAsync(a =>
                a.KeyPointNo == kpNo && a.RelatedType == StaffRelatedDefinition.KeyPoint);
            if (reKp == null)
            {
                var kp = await LCkpRepository.GetAllIncluding(a=>a.ContractInfo,a=>a.ContractInfo.CaseInfo).FirstOrDefaultAsync(a => a.Id == kpNo);
                if (kp == null)
                {
                    CheckError("未查询到关键点！");
                    return;
                }
                await StaffRelatedRepository.InsertAsync(new StaffRelatedInfo()
                {
                    CompanyNo = kp.ContractInfo?.CaseInfo?.CompanyNo??"",
                    CaseNo = kp.ContractInfo?.CaseNo,
                    ContractNo = kp.ContractNo,
                    KeyPointNo = kpNo,
                    StaffNo = staffNo,
                    RelatedType = StaffRelatedDefinition.KeyPoint,
                    MasterType = StaffMasterDefinition.CommonStaff
                });
            }
            else
            {
                reKp.StaffNo = staffNo;
                await StaffRelatedRepository.UpdateAsync(reKp);
            }

            await CacheManager.GetCache(IwbCacheNames.QueryKeyPointStaffInfo).RemoveAsync(kpNo);
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        public ClientStaffInfoClone GetKeyPointOrgStaff(string no)
        {
            return  CacheManager.GetCache(IwbCacheNames.QueryKeyPointStaffInfo).Get(no,  () =>
            {
                var query = StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo, a => a.StaffInfo.CompanyInfo).Where(
                    a =>
                        a.KeyPointNo == no && a.RelatedType == StaffRelatedDefinition.KeyPoint);
                var staff =  QueryCloneStaff(query).FirstOrDefault();
                return staff;
            });
        }

        #endregion

        #endregion

        #region 状态

        /// <summary>
        /// 状态变更
        /// </summary>
        /// <param name="id"></param>
        /// <param name="state"></param>
        /// <param name="reason"></param>
        /// <param name="type"></param>
        /// <returns></returns>
        public async Task ChangeState(string id, int state, string reason, ServiceType type)
        {
            var date = DateTime.Now;
            switch (type)
            {
                case ServiceType.Case:
                    {
                        var entity = await LsRepository.FirstOrDefaultAsync(a => a.Id == id);
                        if (entity == null)
                        {
                            throw new UserFriendlyException("未查询到项目，请检测后再试。");
                        }
                        string oldName = LegalCaseStateDefinition.GetName(entity.CaseState, StatesManager),
                        newName = LegalCaseStateDefinition.GetName(state, StatesManager);
                        if (entity.CaseState == state)
                        {
                            throw new UserFriendlyException($"需变更的与原状态[{oldName}]相同，不能操作！");
                        }
                        if (state == LegalCaseStateDefinition.New)
                        {
                            throw new UserFriendlyException("不能变更为新建状态！");
                        }
                        if (entity.CaseState == LegalCaseStateDefinition.End && !(await PermissionChecker.IsGrantedAsync(PermissionNames.PagesCaseContractMgCaseMgRestart)))
                        {
                            throw new UserFriendlyException("项目已结束，不能操作！");
                        }
                      
                        await LSnRepository.InsertAsync(new LegalCaseNoteInfo()
                        {
                            CaseNo = id,
                            NoteType = NoteTypeDefinition.StateChange,
                            NoteContent = $"状态由{oldName}变更为{newName}{(reason.Empty() ? "" : $",原因：<i class=\"text-iwb\">{reason}</i>")}"
                        });

                        if (entity.CaseState == LegalCaseStateDefinition.New && state== LegalCaseStateDefinition.Running)
                        {
                            entity.StartDateTime = date;
                        }else if (state == LegalCaseStateDefinition.End)
                        {
                            entity.EndDateTime = date;
                        }

                        entity.CaseState = state;
                        entity.StateLastChangeTime = date;
                        entity.StateLastChangeCause = reason;
                        await LsRepository.UpdateAsync(entity);
                        break;
                    }
                case ServiceType.Contract:
                    {
                        var entity = await LcRepository.GetAllIncluding(a=>a.CaseInfo).FirstOrDefaultAsync(a => a.Id == id);
                        if (entity == null)
                        {
                            throw new UserFriendlyException("未查询到合同，请检测后再试。");
                        }
                        if (entity.CaseInfo.CaseState != LegalCaseStateDefinition.Running)
                        {
                            throw new UserFriendlyException("合同所在项目未启动，不能操作，请检测后再试。");
                        }
                        string oldName = LegalContractStateDefinition.GetName(entity.ContractState, StatesManager),
                        newName = LegalContractStateDefinition.GetName(state, StatesManager);
                        if (entity.ContractState == state)
                        {
                            throw new UserFriendlyException($"需变更的与原状态[{oldName}]相同，不能操作！");
                        }
                        if (state == LegalContractStateDefinition.New)
                        {
                            throw new UserFriendlyException("不能变更为新建状态！");
                        }
                        if (entity.ContractState == LegalContractStateDefinition.End && !(await PermissionChecker.IsGrantedAsync(PermissionNames.PagesCaseContractMgContractMgRestart)))
                        {
                            throw new UserFriendlyException("合同已结束，不能操作！");
                        }
                        await LCnRepository.InsertAsync(new LegalContractNoteInfo()
                        {
                            ContractNo = id,
                            NoteType = NoteTypeDefinition.StateChange,
                            NoteContent = $"状态由{oldName}变更为{newName}{(reason.Empty() ? "" : $",原因：<i class=\"text-iwb\">{reason}</i>")}"
                        });
                        if (entity.ContractState == LegalContractStateDefinition.New && state == LegalContractStateDefinition.Running)
                        {
                            entity.StartDateTime = date;
                        }
                        else if (state == LegalContractStateDefinition.End)
                        {
                            entity.EndDateTime = date;
                        }
                        entity.ContractState = state;
                        entity.StateLastChangeTime = date;
                        entity.StateLastChangeCause = reason;
                        await LcRepository.UpdateAsync(entity);
                        break;
                    }
                case ServiceType.KeyPoint:
                    {
                        var entity = await LCkpRepository.GetAllIncluding(a=>a.ContractInfo).FirstOrDefaultAsync(a => a.Id == id);
                        if (entity == null)
                        {
                            throw new UserFriendlyException("未查询到关键点，请检测后再试。");
                        }
                        if (entity.ContractInfo.ContractState != LegalContractStateDefinition.Running)
                        {
                            throw new UserFriendlyException("关键点所在合同未启动，不能操作，请检测后再试。");
                        }
                        await ChangeKpState(entity, state, reason);
                        break;
                    }
            }
        }
       
        /// <summary>
        /// 关键点状态
        /// </summary>
        /// <param name="entity"></param>
        /// <param name="state"></param>
        /// <param name="reason"></param>
        /// <returns></returns>
        private async Task ChangeKpState(LegalContractKeyPointInfo entity, int state, string reason)
        {
            string oldName = LegalKeyPointStateDefinition.GetName(entity.KeyPointState, StatesManager),
                       newName = LegalKeyPointStateDefinition.GetName(state, StatesManager);
            if (entity.KeyPointState == state)
            {
                throw new UserFriendlyException($"需变更的与原状态[{oldName}]相同，不能操作！");
            }
            if (entity.KeyPointState == LegalKeyPointStateDefinition.Executed)
            {
                throw new UserFriendlyException("关键点已执行，不能操作！");
            }
            if (entity.KeyPointState == LegalKeyPointStateDefinition.End && state != LegalKeyPointStateDefinition.Run)
            {
                throw new UserFriendlyException("关键点已结束，不能操作！");
            }
            if (state == LegalKeyPointStateDefinition.New)
            {
                throw new UserFriendlyException("不能变更为新建状态！");
            }

            if (state == LegalKeyPointStateDefinition.Executed &&
                entity.KeyPointState != LegalKeyPointStateDefinition.Run)
            {
                throw new UserFriendlyException($"只有[{LegalKeyPointStateDefinition.GetName(LegalKeyPointStateDefinition.Run, StatesManager)}]的关键点可以变更为[{newName}],请检查后再试！");
            }

            if (entity.KeyPointState == LegalKeyPointStateDefinition.New)
            {
                await ContractNote(new LegalContractNoteInfo()
                {
                    KeyPointNo = entity.Id,
                    ContractNo = entity.ContractNo,
                    NoteType = NoteTypeDefinition.StateChange,
                    NoteContent = $"<strong class=\"pr-2\">启动关键点</strong><br/><strong  class=\"pr-2\">详情</strong> [<i class=\"pl-1 pr-1\">{entity.Description}</i>]<br/><strong class=\"pr-2\">提醒日期</strong> [<i class=\"pl-1 pr-1\">{(entity.AlarmDate != null ? entity.AlarmDate?.ToString("yyyy-MM-dd") : $"{entity.AlarmDay}天")}</i>] <span> </span> <strong class=\"pl-4 pr-2\">过期日期</strong> [<i class=\"pl-1 pr-1\">{(entity.ExpireDate != null ? entity.ExpireDate?.ToString("yyyy-MM-dd") : $"{entity.ExpireDay}天")}</i>]"
                });
            }
            else
            {
                await ContractNote(new LegalContractNoteInfo()
                {
                    ContractNo = entity.ContractNo,
                    KeyPointNo = entity.Id,
                    NoteType = NoteTypeDefinition.StateChange,
                    NoteContent = $"状态由{oldName}变更为{newName}{(reason.Empty() ? "" : $",原因：<i class=\"text-iwb\">{reason}</i>")}"
                });
            }

            //if (entity.KeyPointState == LegalKeyPointStateDefinition.New && state == LegalKeyPointStateDefinition.Runned)
            //{
            //    entity.StartDateTime = date;
            //}
            //else if (state == LegalKeyPointStateDefinition.End)
            //{
            //    entity.EndDateTime = date;
            //}
            entity.KeyPointState = state;
            if (state == LegalKeyPointStateDefinition.Executed)
            {
                await StartChildKp(entity);
            }
            await LCkpRepository.UpdateAsync(entity);
        }

        /// <summary>
        /// 启动子关键点
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        private async Task StartChildKp(LegalContractKeyPointInfo entity)
        {
            var child = await LCkpRepository.FirstOrDefaultAsync(a => a.ParentNo == entity.Id);
            if (child != null)
            {
                if (child.ExpireDate == null)
                {
                    child.ExpireDate = DateTime.Today.AddDays(child.ExpireDay+child.AlarmDay);
                }
                if (child.AlarmDate == null)
                {
                    child.AlarmDate = DateTime.Today.AddDays(child.AlarmDay);
                }
                await LCkpRepository.UpdateAsync(child);
                await ChangeKpState(child, LegalKeyPointStateDefinition.Run, "");
            }
        }
        #endregion

        #region 律师 Lawyers

        /// <summary>
        /// 获取未绑定的律师账号
        /// </summary>
        /// <returns></returns>
        public async Task<List<User>> GetLawyerAccount()
        {
            var list = await UserRepository.GetAll()
                .Where(a => a.IsActive && a.AccountType == AccountTypeDefinition.Lawyer &&
                            string.IsNullOrEmpty(a.AccountNo)).OrderByDescending(a => a.UserName).Select(a => new User
                            {
                                UserName = a.UserName,
                                Name = a.Name
                            }).ToListAsync();
            return list;
        }

        /// <summary>
        /// 绑定律师账号
        /// </summary>
        /// <param name="lawyerNo"></param>
        /// <param name="userName"></param>
        /// <returns></returns>
        public async Task BindLawyerAccount(string lawyerNo, string userName)
        {
            var user = await UserRepository.FirstOrDefaultAsync(a =>
                a.UserName == userName && a.IsActive && a.AccountType == AccountTypeDefinition.Lawyer &&
                string.IsNullOrEmpty(a.AccountNo));
            if (user == null)
            {
                CheckError("账号不存或已被锁定，请检查后再试！");
                return;
            }

            var lawyer = await LawyerRepository.FirstOrDefaultAsync(a => a.Id == lawyerNo);
            if (lawyer == null)
            {
                CheckError("未查询到律师，请检查后再试！");
                return;
            }

            CheckError(await UserManager.CheckDuplicateUsernameOrEmailAddressAsync(user.Id, "", lawyer.Email));

            lawyer.UserName = userName;
            await LawyerRepository.UpdateAsync(lawyer);
            user.AccountNo = lawyerNo;
            user.Name = lawyer.Name;
            user.PhoneNumber = lawyer.PhoneNumber;
            user.EmailAddress = lawyer.Email;
            user.SetNormalizedNames();
            user.IsEmailConfirmed = false;
            await UserRepository.UpdateAsync(user);
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 解绑律师账号
        /// </summary>
        /// <param name="lawyerNo"></param>
        /// <returns></returns>
        public async Task UnBindLawyerAccount(string lawyerNo)
        {
            var lawyer = await LawyerRepository.FirstOrDefaultAsync(a => a.Id == lawyerNo);
            if (lawyer == null)
            {
                CheckError("未查询到律师，请检查后再试！");
                return;
            }
            if (lawyer.UserName.IsEmpty())
            {
                CheckError("律师未绑定账号，请检查后再试！");
            }

            await UnBindLawyerAccount(lawyer);
        }

        /// <summary>
        /// 解绑律师账号
        /// </summary>
        /// <returns></returns>
        public async Task UnBindLawyerAccount(LawyerInfo lawyer, bool checkUser = true)
        {
            var user = await UserRepository.FirstOrDefaultAsync(a =>
                a.UserName == lawyer.UserName && a.IsActive && a.AccountType == AccountTypeDefinition.Lawyer &&
                !string.IsNullOrEmpty(a.AccountNo));
            lawyer.UserName = "";
            await LawyerRepository.UpdateAsync(lawyer);
            if (user == null)
            {
                if (checkUser)
                {
                    CheckError("律师绑定的账号不存或已被锁定，请检查后再试！");
                }
                return;
            }

            user.AccountNo = "";
            user.Name = user.UserName;
            user.PhoneNumber = "";
            user.EmailAddress = "";
            user.SetNormalizedNames();
            user.IsEmailConfirmed = false;
            user.IsActive = false;
            await UserRepository.UpdateAsync(user);
            await CurrentUnitOfWork.SaveChangesAsync();
        }
        
        /// <summary>
        /// 设置律所的负责人
        /// </summary>
        /// <param name="lawFirmNo"></param>
        /// <param name="lawyerNo"></param>
        /// <param name="oldDelete"></param>
        /// <returns></returns>
        public async Task SetLawFirmMasterLawyer(string lawFirmNo, string lawyerNo, bool oldDelete = false)
        {
            CheckSysAccount();
            var old = await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == LawyerRelatedDefinition.LawFirm && a.LawFirmNo == lawFirmNo &&
                a.MasterType == LawyerMasterDefinition.LawFirmMaster);
            if (old != null)
            {
                if (old.LawyerNo == lawyerNo)
                {
                    CheckError("当前律师已是负责人！");
                    return;
                }
                if (oldDelete)
                {
                    await LawyerRelatedRepository.DeleteAsync(old);
                }
                else
                {
                    old.MasterType = LawyerMasterDefinition.CommonLawyer;
                    await LawyerRelatedRepository.UpdateAsync(old);
                }
            }
            var newEntity = await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == LawyerRelatedDefinition.LawFirm && a.LawFirmNo == lawFirmNo &&
                a.LawyerNo == lawyerNo);
            if (newEntity == null)
            {
                await LawyerRelatedRepository.InsertAsync(new LawyerRelatedInfo()
                {
                    LawyerNo = lawyerNo,
                    LawFirmNo = lawFirmNo,
                    RelatedType = LawyerRelatedDefinition.LawFirm,
                    MasterType = LawyerMasterDefinition.LawFirmMaster
                });
            }
            else
            {
                newEntity.MasterType = LawyerMasterDefinition.LawFirmMaster;
                await LawyerRelatedRepository.UpdateAsync(newEntity);
            }
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 设置律师的律所
        /// </summary>
        /// <param name="lawyerNo"></param>
        /// <param name="lawFirmNo"></param>
        /// <returns></returns>
        public async Task SetLawyerLawFirm(string lawyerNo, string lawFirmNo)
        {
            CheckAccount(AccountTypeDefinition.System, AccountTypeDefinition.Lawyer);
            var entity = await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == LawyerRelatedDefinition.LawFirm &&
                a.LawyerNo == lawyerNo &&
                a.MasterType == LawyerMasterDefinition.CommonLawyer);
            if (entity == null)
            {
                await LawyerRelatedRepository.InsertAsync(new LawyerRelatedInfo()
                {
                    LawyerNo = lawyerNo,
                    LawFirmNo = lawFirmNo,
                    RelatedType = LawyerRelatedDefinition.LawFirm,
                    MasterType = LawyerMasterDefinition.CommonLawyer
                });
            }
            else
            {
                entity.LawFirmNo = lawFirmNo;
                await LawyerRelatedRepository.UpdateAsync(entity);
            }
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        ///// <summary>
        ///// 设置项目的负责人
        ///// </summary>
        ///// <param name="caseNo"></param>
        ///// <param name="lawyerNo"></param>
        ///// <param name="oldDelete"></param>
        ///// <returns></returns>
        //public async Task SetCaseMasterLawyer(string caseNo, string lawyerNo, bool oldDelete = false)
        //{
        //    if (lawyerNo.IsEmpty())
        //    {
        //        CheckError("请设置一名负责人！");
        //    }
        //    CheckLawyerAccount();
        //    var legalCase = await LsRepository.FirstOrDefaultAsync(a => a.Id == caseNo);
        //    if (legalCase == null)
        //    {
        //        CheckError("未查询到项目，请检查后再试！");
        //        return;
        //    }
        //    var isLawFirmMaster = IsLawFirmMaster(AbpSession.AccountNo, out var lawFirmNo);
        //    if (!isLawFirmMaster)
        //    {
        //        CheckError("没有权限操作！");
        //    }

        //    await SetCaseMasterLawyer(caseNo, lawyerNo, lawFirmNo, oldDelete);
        //}

        ///// <summary>
        ///// 设置项目的负责人
        ///// </summary>
        ///// <param name="caseNo"></param>
        ///// <param name="lawyerNo"></param>
        ///// <param name="lawFirmNo"></param>
        ///// <param name="oldDelete"></param>
        ///// <returns></returns>
        //private async Task SetCaseMasterLawyer(string caseNo, string lawyerNo,string lawFirmNo, bool oldDelete = false)
        //{
        //    var old = await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
        //        a.RelatedType == LawyerRelatedDefinition.LegalCase && a.CaseNo == caseNo &&
        //        a.MasterType == LawyerMasterDefinition.MasterLawyer);
        //    if (old != null)
        //    {
        //        if (old.LawyerNo == lawyerNo)
        //        {
        //            CheckError("当前律师已是负责人！");
        //            return;
        //        }
        //        if (oldDelete)
        //        {
        //            await LawyerRelatedRepository.DeleteAsync(old);
        //        }
        //        else
        //        {
        //            old.MasterType = LawyerMasterDefinition.CommonLawyer;
        //            await LawyerRelatedRepository.UpdateAsync(old);
        //        }
        //    }
        //    var newEntity = await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
        //        a.RelatedType == LawyerRelatedDefinition.LegalCase && a.CaseNo == caseNo &&
        //        a.LawyerNo == lawyerNo);
        //    if (newEntity == null)
        //    {
        //        lawFirmNo = lawFirmNo.NotEmpty() ? lawFirmNo : await QueryLawFirmNoByCase(caseNo);
        //        await LawyerRelatedRepository.InsertAsync(new LawyerRelatedInfo()
        //        {
        //            LawyerNo = lawyerNo,
        //            LawFirmNo = lawFirmNo,
        //            CaseNo = caseNo,
        //            RelatedType = LawyerRelatedDefinition.LegalCase,
        //            MasterType = LawyerMasterDefinition.MasterLawyer
        //        });
        //    }
        //    else
        //    {
        //        newEntity.MasterType = LawyerMasterDefinition.MasterLawyer;
        //        await LawyerRelatedRepository.UpdateAsync(newEntity);
        //    }
        //    await CurrentUnitOfWork.SaveChangesAsync();
        //}

        ///// <summary>
        ///// 设置项目的职员
        ///// </summary>
        ///// <param name="caseNo"></param>
        ///// <param name="lawyerNos"></param>
        ///// <returns></returns>
        //public async Task SetCaseLawyers(string caseNo, string lawyerNos)
        //{
        //    await SetCaseLawyers(caseNo, lawyerNos.Split(',').ToList());
        //}

        ///// <summary>
        ///// 设置项目的职员
        ///// </summary>
        ///// <param name="caseNo"></param>
        ///// <param name="lawyerNos"></param>
        ///// <returns></returns>
        //public async Task SetCaseLawyers(string caseNo, List<string> lawyerNos)
        //{
        //    CheckLawyerAccount();
        //    var legalCase = await LsRepository.FirstOrDefaultAsync(a => a.Id == caseNo);
        //    if (legalCase == null)
        //    {
        //        CheckError("未查询到项目，请检查后再试！");
        //        return;
        //    }
        //    var isMaster = IsLawFirmCaseMaster(AbpSession.AccountNo, caseNo);
        //    string lawFirmNo = null;
        //    if (!isMaster)
        //    {
        //        var isLawFirmMaster = IsLawFirmMaster(AbpSession.AccountNo, out lawFirmNo);
        //        if (!isLawFirmMaster)
        //        {
        //            CheckError("没有权限操作！");
        //        }
        //    }
        //    //lawFirmNo = lawFirmNo.IsEmpty() ? lawFirmNo : await QueryLawFirmNoByCase(caseNo);
        //    var oldNos = await LawyerRelatedRepository.GetAll()
        //        .Where(a => a.RelatedType == LawyerRelatedDefinition.LegalCase && a.CaseNo == caseNo && a.MasterType == LawyerMasterDefinition.CommonLawyer)
        //        .Select(a => a.LawyerNo).ToListAsync();
        //    lawyerNos = lawyerNos.Distinct().ToList();
        //    foreach (var no in lawyerNos)
        //    {
        //        if (oldNos.Contains(no))
        //        {
        //            oldNos.Remove(no);
        //        }
        //        else
        //        {
        //            await LawyerRelatedRepository.InsertAsync(new LawyerRelatedInfo()
        //            {
        //                LawyerNo = no,
        //                LawFirmNo = lawFirmNo,
        //                CaseNo = caseNo,
        //                RelatedType = LawyerRelatedDefinition.LegalCase,
        //                MasterType = LawyerMasterDefinition.CommonLawyer
        //            });
        //        }
        //    }

        //    if (oldNos.Any())
        //    {
        //        await LawyerRelatedRepository.DeleteAsync(a =>
        //            a.RelatedType == LawyerRelatedDefinition.LegalCase && a.CaseNo == caseNo &&
        //            a.MasterType == LawyerMasterDefinition.CommonLawyer && oldNos.Contains(a.LawyerNo));
        //    }
        //    await CurrentUnitOfWork.SaveChangesAsync();

        //}

        /// <summary>
        /// 设置合同的负责人
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="lawyerNo"></param>
        /// <param name="oldDelete"></param>
        /// <returns></returns>
        public async Task SetContractMasterLawyer(string contractNo, string lawyerNo, bool oldDelete = true)
        {
            //CheckSysAccount();
            CheckLawyerAccount();
            if (lawyerNo.IsEmpty())
            {
                CheckError("请设置一名负责人！");
            }
            var contract = await LcRepository.FirstOrDefaultAsync(a => a.Id == contractNo);
            if (contract == null)
            {
                CheckError("未查询到合同，请检查后再试！");
                return;
            }
            var isMaster = IsLawFirmMaster(AbpSession.AccountNo);
            if (!isMaster)
            {
                CheckError("您不是律所负责人，没有权限操作！");
            }
            await SetContractMasterLawyer(contractNo, lawyerNo, contract.CaseNo, oldDelete);
        }

        /// <summary>
        /// 设置合同的负责人
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="lawyerNo"></param>
        /// <param name="caseNo"></param>
        /// <param name="oldDelete"></param>
        /// <returns></returns>
        private async Task SetContractMasterLawyer(string contractNo, string lawyerNo, string caseNo, bool oldDelete = true)
        {
            var old = await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == LawyerRelatedDefinition.LegalContract && a.ContractNo == contractNo &&
                a.MasterType == LawyerMasterDefinition.MasterLawyer);
            if (old != null)
            {
                if (old.LawyerNo == lawyerNo)
                {
                    //CheckError("当前律师已是负责人！");
                    return;
                }
                if (oldDelete)
                {
                    await LawyerRelatedRepository.DeleteAsync(old);
                }
                else
                {
                    old.MasterType = LawyerMasterDefinition.CommonLawyer;
                    await LawyerRelatedRepository.UpdateAsync(old);
                }
            }
            
            var newEntity = await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == LawyerRelatedDefinition.LegalContract && a.ContractNo == contractNo &&
                a.LawyerNo == lawyerNo);
            var cLawFirmNo= (await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == LawyerRelatedDefinition.LegalContract && a.ContractNo == contractNo &&
                a.MasterType == LawyerMasterDefinition.LawFirmContract))?.LawFirmNo;
            if (newEntity == null)
            {
                caseNo = caseNo.Empty() ? await QueryCaseNoByContract(contractNo) : caseNo;
                var lawFirmNo = await QueryLawFirmNoByLawyerAsync(lawyerNo);
                if (lawFirmNo != cLawFirmNo)
                {
                    CheckError("请分配当前律所的律师！");
                }
                await LawyerRelatedRepository.InsertAsync(new LawyerRelatedInfo()
                {
                    LawyerNo = lawyerNo,
                    LawFirmNo = lawFirmNo,
                    CaseNo = caseNo,
                    ContractNo = contractNo,
                    RelatedType = LawyerRelatedDefinition.LegalContract,
                    MasterType = LawyerMasterDefinition.MasterLawyer
                });
            }
            else
            {
                newEntity.MasterType = LawyerMasterDefinition.MasterLawyer;
                await LawyerRelatedRepository.UpdateAsync(newEntity);
            }
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 设置合同的职员
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="lawyerNos"></param>
        /// <returns></returns>
        public async Task SetContractLawyers(string contractNo, string lawyerNos)
        {
            await SetContractLawyers(contractNo, lawyerNos.Split(',').ToList());
        }

        /// <summary>
        /// 设置合同的职员
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="lawyerNos"></param>
        /// <returns></returns>
        public async Task SetContractLawyers(string contractNo, List<string> lawyerNos)
        {
            //CheckSysAccount();
            CheckLawyerAccount();
            var contract = await LcRepository.FirstOrDefaultAsync(a => a.Id == contractNo);
            if (contract == null)
            {
                CheckError("未查询到合同，请检查后再试！");
                return;
            }

            var isContractMaster = IsLawyerContractMaster(AbpSession.AccountNo, contractNo);
            if (!isContractMaster)
            {
                var isLawFirmMaster = IsLawFirmMaster(AbpSession.AccountNo);
                if (!isLawFirmMaster)
                {
                    CheckError("没有权限操作！");
                }
            }

            var oldNos = await LawyerRelatedRepository.GetAll()
                .Where(a => a.RelatedType == LawyerRelatedDefinition.LegalContract && a.ContractNo == contractNo && a.MasterType == LawyerMasterDefinition.CommonLawyer)
                .Select(a => a.LawyerNo).ToListAsync();
            lawyerNos = lawyerNos.Distinct().ToList();
            var cLawFirmNo = (await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == LawyerRelatedDefinition.LegalContract && a.ContractNo == contractNo))?.LawFirmNo;
            foreach (var no in lawyerNos)
            {
                if (oldNos.Contains(no))
                {
                    oldNos.Remove(no);
                }
                else
                {
                    var lawFirmNo = await QueryLawFirmNoByLawyerAsync(no);
                    if (lawFirmNo != cLawFirmNo)
                    {
                        CheckError("请分配当前律所的律师！");
                    }
                    await LawyerRelatedRepository.InsertAsync(new LawyerRelatedInfo()
                    {
                        LawyerNo = no,
                        LawFirmNo = lawFirmNo,
                        CaseNo = contract.CaseNo,
                        ContractNo = contractNo,
                        RelatedType = LawyerRelatedDefinition.LegalContract,
                        MasterType = LawyerMasterDefinition.CommonLawyer
                    });
                }
            }

            if (oldNos.Any())
            {
                await LawyerRelatedRepository.DeleteAsync(a =>
                    a.RelatedType == LawyerRelatedDefinition.LegalContract && a.ContractNo == contractNo &&
                    a.MasterType == LawyerMasterDefinition.CommonLawyer && oldNos.Contains(a.LawyerNo));
            }

            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 分配合同律所
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="lawFirmNo"></param>
        /// <returns></returns>
        public async Task SetContractLawFirm(string contractNo,string lawFirmNo)
        {
            CheckSysAccount();
            var contract = await LcRepository.FirstOrDefaultAsync(a => a.Id == contractNo);
            if (contract == null)
            {
                CheckError("未查询到合同，请检查后再试！");
                return;
            }

            if (await CheckContractHasLawFirm(contractNo))
            {
                CheckError("合同已被分配，请检查后再试！");
                return;
            }

            var lawyerNo = (await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
                a.LawFirmNo == lawFirmNo && a.RelatedType == LawyerRelatedDefinition.LawFirm &&
                a.MasterType == LawyerMasterDefinition.LawFirmMaster))?.LawyerNo;
            if (lawyerNo.Empty())
            {
                CheckError("律所暂未指定负责人，请检查后再试！");
                return;
            }
            await LawyerRelatedRepository.InsertAsync(new LawyerRelatedInfo()
            {
                ContractNo = contractNo,
                LawFirmNo = lawFirmNo,
                CaseNo = contract.CaseNo,
                LawyerNo = lawyerNo,
                RelatedType = LawyerRelatedDefinition.LegalContract,
                MasterType = LawyerMasterDefinition.LawFirmContract
            });
        }

        /// <summary>
        /// 检查合同是否被分配律所
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public async Task<bool> CheckContractHasLawFirm(string contractNo)
        {
            var old = await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == LawyerRelatedDefinition.LegalContract && a.ContractNo == contractNo &&
                a.MasterType == LawyerMasterDefinition.LawFirmContract);
            return old != null;
        }

        #endregion

        #region 员工 Staff

        /// <summary>
        /// 获取未绑定的客户账号
        /// </summary>
        /// <returns></returns>
        public async Task<List<User>> GetStaffAccount()
        {
            var list = await UserRepository.GetAll()
                .Where(a => a.IsActive && a.AccountType == AccountTypeDefinition.Client &&
                            string.IsNullOrEmpty(a.AccountNo)).OrderByDescending(a => a.UserName).Select(a => new User
                            {
                                UserName = a.UserName,
                                Name = a.Name
                            }).ToListAsync();
            return list;
        }

        /// <summary>
        /// 绑定员工账号
        /// </summary>
        /// <param name="staffNo"></param>
        /// <param name="userName"></param>
        /// <returns></returns>
        public async Task BindStaffAccount(string staffNo, string userName)
        {

            var user = await UserRepository.FirstOrDefaultAsync(a =>
                a.UserName == userName && a.IsActive && a.AccountType == AccountTypeDefinition.Client &&
                string.IsNullOrEmpty(a.AccountNo));
            if (user == null)
            {
                CheckError("账号不存或已被锁定，请检查后再试！");
                return;
            }

            var staff = await StaffRepository.FirstOrDefaultAsync(a => a.Id == staffNo);
            if (staff == null)
            {
                CheckError("未查询到员工，请检查后再试！");
                return;
            }
            CheckError(await UserManager.CheckDuplicateUsernameOrEmailAddressAsync(user.Id, "", staff.Email));

            staff.UserName = userName;
            await StaffRepository.UpdateAsync(staff);
            user.AccountNo = staffNo;
            user.Name = staff.Name;
            user.PhoneNumber = staff.PhoneNumber;
            user.EmailAddress = staff.Email;
            user.SetNormalizedNames();
            user.IsEmailConfirmed = false;
            await UserRepository.UpdateAsync(user);
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 解绑员工账号
        /// </summary>
        /// <param name="staffNo"></param>
        /// <returns></returns>
        public async Task UnBindStaffAccount(string staffNo)
        {
            var staff = await StaffRepository.FirstOrDefaultAsync(a => a.Id == staffNo);
            if (staff == null)
            {
                CheckError("未查询到员工，请检查后再试！");
                return;
            }
            if (staff.UserName.IsEmpty())
            {
                CheckError("员工未绑定账号，请检查后再试！");
            }

            await UnBindStaffAccount(staff);
        }

        /// <summary>
        /// 解绑员工账号
        /// </summary>
        /// <param name="staff"></param>
        /// <param name="checkUser"></param>
        /// <returns></returns>
        private async Task UnBindStaffAccount(ClientStaffInfo staff, bool checkUser = true)
        {
            var user = await UserRepository.FirstOrDefaultAsync(a =>
                a.UserName == staff.UserName && a.IsActive && a.AccountType == AccountTypeDefinition.Client &&
                !string.IsNullOrEmpty(a.AccountNo));
            staff.UserName = "";
            await StaffRepository.UpdateAsync(staff);
            if (user == null)
            {
                if (checkUser)
                {
                    CheckError("员工绑定的账号不存或已被锁定，请检查后再试！");
                }
                return;
            }
            user.AccountNo = "";
            user.Name = user.UserName;
            user.PhoneNumber = "";
            user.EmailAddress = "";
            user.SetNormalizedNames();
            user.IsEmailConfirmed = false;
            user.IsActive = false;
            await UserRepository.UpdateAsync(user);
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 设置公司的负责人
        /// </summary>
        /// <param name="companyNo"></param>
        /// <param name="staffNo"></param>
        /// <param name="oldDelete"></param>
        /// <returns></returns>
        public async Task SetCompanyMasterStaff(string companyNo, string staffNo, bool oldDelete = false)
        {
            var old = await StaffRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == StaffRelatedDefinition.Company && a.CompanyNo == companyNo &&
                a.MasterType == StaffMasterDefinition.CompanyMaster);
            if (old != null)
            {
                if (old.StaffNo == staffNo)
                {
                    CheckError("当前员工已是负责人！");
                    return;
                }
                if (oldDelete)
                {
                    await StaffRelatedRepository.DeleteAsync(old);
                }
                else
                {
                    old.MasterType = StaffMasterDefinition.CommonStaff;
                    await StaffRelatedRepository.UpdateAsync(old);
                }
            }
            var newEntity = await StaffRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == StaffRelatedDefinition.Company && a.CompanyNo == companyNo &&
                a.StaffNo == staffNo);
            if (newEntity == null)
            {
                await StaffRelatedRepository.InsertAsync(new StaffRelatedInfo()
                {
                    StaffNo = staffNo,
                    CompanyNo = companyNo,
                    RelatedType = StaffRelatedDefinition.Company,
                    MasterType = StaffMasterDefinition.CompanyMaster
                });
            }
            else
            {
                newEntity.MasterType = StaffMasterDefinition.CompanyMaster;
                await StaffRelatedRepository.UpdateAsync(newEntity);
            }
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 设置员工的公司
        /// </summary>
        /// <param name="staffNo"></param>
        /// <param name="companyNo"></param>
        /// <returns></returns>
        public async Task SetStaffCompany(string staffNo, string companyNo)
        {
            var entity = await StaffRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == StaffRelatedDefinition.Company  &&
                a.StaffNo == staffNo &&
                a.MasterType == StaffMasterDefinition.CommonStaff);
            if (entity == null)
            {
                await StaffRelatedRepository.InsertAsync(new StaffRelatedInfo()
                {
                    StaffNo = staffNo,
                    CompanyNo = companyNo,
                    RelatedType = StaffRelatedDefinition.Company,
                    MasterType = StaffMasterDefinition.CommonStaff
                });
            }
            else
            {
                entity.CompanyNo = companyNo;
                await StaffRelatedRepository.UpdateAsync(entity);
            }
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 设置项目的负责人
        /// </summary>
        /// <param name="caseNo"></param>
        /// <param name="staffNo"></param>
        /// <param name="oldDelete"></param>
        /// <returns></returns>
        public async Task SetCaseMasterStaff(string caseNo, string staffNo, bool oldDelete = false)
        {
            if (staffNo.IsEmpty())
            {
                CheckError("请设置一名负责人！");
            }
            CheckClientAccount();
            var legalCase = await LsRepository.FirstOrDefaultAsync(a => a.Id == caseNo);
            if (legalCase == null)
            {
                CheckError("未查询到项目，请检查后再试！");
                return;
            }
            var isCompanyMaster = IsCompanyMaster(AbpSession.AccountNo, out var companyNo);
            if (!isCompanyMaster)
            {
                CheckError("没有权限变更项目负责人，请联系企业负责人！");
            }

            await SetCaseMasterStaff(caseNo, staffNo, companyNo, oldDelete);
        }

        /// <summary>
        /// 设置项目的负责人
        /// </summary>
        /// <param name="caseNo"></param>
        /// <param name="staffNo"></param>
        /// <param name="companyNo"></param>
        /// <param name="oldDelete"></param>
        /// <returns></returns>
        private async Task SetCaseMasterStaff(string caseNo, string staffNo,string companyNo, bool oldDelete = false)
        {
            var old = await StaffRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == StaffRelatedDefinition.LegalCase && a.CaseNo == caseNo &&
                a.MasterType == StaffMasterDefinition.MasterStaff);
            if (old != null)
            {
                if (old.StaffNo == staffNo)
                {
                    //CheckError("当前员工已是负责人！");
                    return;
                }
                if (oldDelete)
                {
                    await StaffRelatedRepository.DeleteAsync(old);
                }
                else
                {
                    old.MasterType = StaffMasterDefinition.CommonStaff;
                    await StaffRelatedRepository.UpdateAsync(old);
                }
            }
            var newEntity = await StaffRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == StaffRelatedDefinition.LegalCase && a.CaseNo == caseNo &&
                a.StaffNo == staffNo);
            if (newEntity == null)
            {
                companyNo = companyNo.Empty() ? await QueryCompanyNoByCase(caseNo) : companyNo;
                await StaffRelatedRepository.InsertAsync(new StaffRelatedInfo()
                {
                    StaffNo = staffNo,
                    CompanyNo = companyNo,
                    CaseNo = caseNo,
                    RelatedType = StaffRelatedDefinition.LegalCase,
                    MasterType = StaffMasterDefinition.MasterStaff
                });
            }
            else
            {
                newEntity.MasterType = StaffMasterDefinition.MasterStaff;
                await StaffRelatedRepository.UpdateAsync(newEntity);
            }
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 设置项目的职员
        /// </summary>
        /// <param name="caseNo"></param>
        /// <param name="staffNos"></param>
        /// <returns></returns>
        public async Task SetCaseStaffs(string caseNo, string staffNos)
        {
            await SetCaseStaffs(caseNo, staffNos.Split(',').ToList());
        }

        /// <summary>
        /// 设置项目的职员
        /// </summary>
        /// <param name="caseNo"></param>
        /// <param name="staffNos"></param>
        /// <returns></returns>
        public async Task SetCaseStaffs(string caseNo, List<string> staffNos)
        {
            CheckClientAccount();
            var legalCase = await LsRepository.FirstOrDefaultAsync(a => a.Id == caseNo);
            if (legalCase == null)
            {
                CheckError("未查询到项目，请检查后再试！");
                return;
            }
            var isMaster = IsClientCaseMaster(AbpSession.AccountNo, caseNo);
            string companyNo = null;
            if (!isMaster)
            {
                var isCompanyMaster = IsCompanyMaster(AbpSession.AccountNo, out companyNo);
                if (!isCompanyMaster)
                {
                    CheckError("没有权限操作！");
                }
            }
            companyNo = companyNo.Empty() ?  await QueryCompanyNoByCase(caseNo): companyNo ;
            var oldNos = await StaffRelatedRepository.GetAll()
                .Where(a => a.RelatedType == StaffRelatedDefinition.LegalCase && a.CaseNo == caseNo && a.MasterType == StaffMasterDefinition.CommonStaff)
                .Select(a => a.StaffNo).ToListAsync();
            staffNos = staffNos.Distinct().ToList();
            foreach (var no in staffNos)
            {
                if (oldNos.Contains(no))
                {
                    oldNos.Remove(no);
                }
                else
                {
                    await StaffRelatedRepository.InsertAsync(new StaffRelatedInfo()
                    {
                        StaffNo = no,
                        CompanyNo = companyNo,
                        CaseNo = caseNo,
                        RelatedType = StaffRelatedDefinition.LegalCase,
                        MasterType = StaffMasterDefinition.CommonStaff
                    });
                }
            }

            if (oldNos.Any())
            {
                await StaffRelatedRepository.DeleteAsync(a =>
                    a.RelatedType == StaffRelatedDefinition.LegalCase && a.CaseNo == caseNo &&
                    a.MasterType == StaffMasterDefinition.CommonStaff && oldNos.Contains(a.StaffNo));
            }
            await CurrentUnitOfWork.SaveChangesAsync();

        }

        /// <summary>
        /// 设置合同的负责人
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="staffNo"></param>
        /// <param name="oldDelete"></param>
        /// <returns></returns>
        public async Task SetContractMasterStaff(string contractNo, string staffNo, bool oldDelete = false)
        {
            if (staffNo.IsEmpty())
            {
                CheckError("请设置一名负责人！");
            }
            var contract = await LcRepository.FirstOrDefaultAsync(a => a.Id == contractNo);
            if (contract == null)
            {
                CheckError("未查询到合同，请检查后再试！");
                return;
            }
            
            var isMaster = IsClientCaseMaster(AbpSession.AccountNo, contract.CaseNo);
            string companyNo = null;
            if (!isMaster)
            {
                var isCompanyMaster = IsCompanyMaster(AbpSession.AccountNo, out companyNo);
                if (!isCompanyMaster)
                {
                    CheckError("没有权限操作！");
                }
            }

            await SetContractMasterStaff(contractNo, staffNo, contract.CaseNo, companyNo, oldDelete);
        }

        /// <summary>
        /// 设置合同的负责人
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="staffNo"></param>
        /// <param name="caseNo"></param>
        /// <param name="companyNo"></param>
        /// <param name="oldDelete"></param>
        /// <returns></returns>
        private async Task SetContractMasterStaff(string contractNo, string staffNo, string caseNo, string companyNo=null, bool oldDelete = false)
        {
            var old = await StaffRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == StaffRelatedDefinition.LegalContract && a.ContractNo == contractNo &&
                a.MasterType == StaffMasterDefinition.MasterStaff);
            if (old != null)
            {
                if (old.StaffNo == staffNo)
                {
                    //CheckError("当前员工已是负责人！");
                    return;
                }
                if (oldDelete)
                {
                    await StaffRelatedRepository.DeleteAsync(old);
                }
                else
                {
                    old.MasterType = StaffMasterDefinition.CommonStaff;
                    await StaffRelatedRepository.UpdateAsync(old);
                }
            }
           
            var newEntity = await StaffRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == StaffRelatedDefinition.LegalContract && a.ContractNo == contractNo &&
                a.StaffNo == staffNo);
            if (newEntity == null)
            {
                caseNo = caseNo.Empty() ?  await QueryCaseNoByContract(contractNo): caseNo ;
                companyNo = companyNo.Empty() ? await QueryCompanyNoByContract(contractNo) : companyNo;
                await StaffRelatedRepository.InsertAsync(new StaffRelatedInfo()
                {
                    StaffNo = staffNo,
                    CompanyNo = companyNo,
                    CaseNo = caseNo,
                    ContractNo = contractNo,
                    RelatedType = StaffRelatedDefinition.LegalContract,
                    MasterType = StaffMasterDefinition.MasterStaff
                });
            }
            else
            {
                newEntity.MasterType = StaffMasterDefinition.MasterStaff;
                await StaffRelatedRepository.UpdateAsync(newEntity);
            }
            await CurrentUnitOfWork.SaveChangesAsync();
        }

        /// <summary>
        /// 设置合同的职员
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="staffNos"></param>
        /// <returns></returns>
        public async Task SetContractStaffs(string contractNo, string staffNos)
        {
            await SetContractStaffs(contractNo, staffNos.Split(',').ToList());
        }

        /// <summary>
        /// 设置合同的职员
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="staffNos"></param>
        /// <returns></returns>
        public async Task SetContractStaffs(string contractNo, List<string> staffNos)
        {
            CheckClientAccount();
            var contract = await LcRepository.FirstOrDefaultAsync(a => a.Id == contractNo);
            if (contract == null)
            {
                CheckError("未查询到合同，请检查后再试！");
                return;
            }

            string companyNo = null;
            var isContractMaster = await IsClientContractMaster(contractNo);
            if (!isContractMaster)
            {
                CheckError("没有权限操作！");
                //var isCaseMaster = IsClientCaseMaster(AbpSession.AccountNo, contract.CaseNo);
                //if (!isCaseMaster)
                //{
                //    var isCompanyMaster = IsCompanyMaster(AbpSession.AccountNo, out companyNo);
                //    if (!isCompanyMaster)
                //    {
                        
                //    }
                //}
            }

            var oldNos = await StaffRelatedRepository.GetAll()
                .Where(a => a.RelatedType == StaffRelatedDefinition.LegalContract && a.ContractNo == contractNo && a.MasterType == StaffMasterDefinition.CommonStaff)
                .Select(a => a.StaffNo).ToListAsync();
            //companyNo = companyNo.Empty() ? await QueryCompanyNoByContract(contractNo) : companyNo;
            companyNo = await QueryCompanyNoByContract(contractNo);
            staffNos = staffNos.Distinct().ToList();
            foreach (var no in staffNos)
            {
                if (oldNos.Contains(no))
                {
                    oldNos.Remove(no);
                }
                else
                {
                    await StaffRelatedRepository.InsertAsync(new StaffRelatedInfo()
                    {
                        StaffNo = no,
                        CompanyNo = companyNo,
                        CaseNo = contract.CaseNo,
                        ContractNo = contractNo,
                        RelatedType = StaffRelatedDefinition.LegalContract,
                        MasterType = StaffMasterDefinition.CommonStaff
                    });
                }
            }

            if (oldNos.Any())
            {
                await StaffRelatedRepository.DeleteAsync(a =>
                    a.RelatedType == StaffRelatedDefinition.LegalContract && a.ContractNo == contractNo &&
                    a.MasterType == StaffMasterDefinition.CommonStaff && oldNos.Contains(a.StaffNo));
            }

            await CurrentUnitOfWork.SaveChangesAsync();
        }

        #endregion

        #region 查询 

        #region IQueryable

        /// <summary>
        /// 查询项目
        /// </summary>
        /// <returns></returns>
        public IQueryable<LegalCaseInfo> QueryCase()
        {
            IQueryable<LegalCaseInfo> query = AbpSession.AccountType == AccountTypeDefinition.Lawyer
                ? QueryLawyerCase()
                : AbpSession.AccountType == AccountTypeDefinition.Client
                    ? QueryStaffCase()
                    : LsRepository.GetAll();//系统账号可以看到全部
            return query;
        }
       
        /// <summary>
        /// 查询合同
        /// </summary>
        /// <returns></returns>
        public IQueryable<LegalContractInfo> QueryContract()
        {
            IQueryable<LegalContractInfo> query = AbpSession.AccountType == AccountTypeDefinition.Lawyer
                ? QueryLawyerContract()
                : AbpSession.AccountType == AccountTypeDefinition.Client
                    ? QueryStaffContract()
                    : LcRepository.GetAllIncluding(a=>a.CaseInfo,a=>a.CaseInfo.CompanyInfo);//系统账号可以看到全部
            return query;
        }


        #region Lawyer
        public IQueryable<LawyerInfoClone> QueryAllLawyer()
        {
            var query = LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo, a => a.LawyerInfo.LawFirmInfo,
                     a => a.LawyerInfo.OrganizationInfo)
             .Where(a => a.RelatedType == LawyerRelatedDefinition.LawFirm);
            return QueryCloneLawyer(query, true, LawyerMasterDefinition.LawFirmMaster);

            //return LawyerRepository.GetAllIncluding(a => a.LawFirmInfo, a => a.OrganizationInfo).Select(a =>
            //    new LawyerInfoClone()
            //    {
            //        Id = a.Id,
            //        Code = a.Code,
            //        Name = a.Name,
            //        IdCard = a.IdCard,
            //        PhoneNumber = a.PhoneNumber,
            //        Birthday = a.Birthday,
            //        UserName = a.UserName,
            //        LawFirmNo = a.LawFirmNo,
            //        Email = a.Email,
            //        OrganizationNo = a.OrganizationNo,
            //        LawFirmName = a.LawFirmInfo.Name,
            //        OrganizationName = a.OrganizationInfo.Name,
            //        CreationTime = a.CreationTime
            //    });
        }


        /// <summary>
        /// 查询律所的所有律师
        /// </summary>
        /// <param name="no"></param>
        /// <param name="withEx"></param>
        /// <returns></returns>
        public IQueryable<LawyerInfoClone> QueryLawFirmAllLawyers(string no, bool withEx = true)
        {
            var query = (withEx
                    ? LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo, a => a.LawyerInfo.LawFirmInfo,
                        a => a.LawyerInfo.OrganizationInfo)
                    : LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo))
                .Where(a => a.LawFirmNo == no && a.RelatedType == LawyerRelatedDefinition.LawFirm);

            return QueryCloneLawyer(query, withEx, LawyerMasterDefinition.LawFirmMaster);
        }


        /// <summary>
        /// 查询律所的负责人
        /// </summary>
        /// <param name="lawFirmNo"></param>
        /// <returns></returns>
        public IQueryable<LawyerInfoClone> QueryMasterLawyerByLawFirm(string lawFirmNo)
        {
            var query = LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo)
                .Where(a => a.LawFirmNo == lawFirmNo && a.RelatedType == LawyerRelatedDefinition.LawFirm &&
                            a.MasterType == LawyerMasterDefinition.LawFirmMaster);
            return QueryCloneLawyer(query, false);
        }

        /// <summary>
        /// 查询律所的律师
        /// </summary>
        /// <param name="lawFirmNo"></param>
        /// <returns></returns>
        public IQueryable<LawyerInfoClone> QueryLawyerByLawFirm(string lawFirmNo)
        {
            var query = LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo)
                .Where(a => a.LawFirmNo == lawFirmNo && a.RelatedType == LawyerRelatedDefinition.LawFirm &&
                            a.MasterType == LawyerMasterDefinition.CommonLawyer && a.MasterType != LawyerMasterDefinition.LawFirmContract);
            return QueryCloneLawyer(query, false);
        }


        /// <summary>
        /// 查询项目的全部律师
        /// </summary>
        /// <param name="caseNo"></param>
        /// <returns></returns>
        public IQueryable<LawyerInfoClone> QueryCaseAllLawyers(string caseNo)
        {
            var query = LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo)
                .Where(a => a.CaseNo == caseNo && a.RelatedType == LawyerRelatedDefinition.LegalContract && a.MasterType != LawyerMasterDefinition.LawFirmContract);
            return QueryCloneLawyer(query, false);
        }

        ///// <summary>
        ///// 查询项目的负责人
        ///// </summary>
        ///// <param name="caseNo"></param>
        ///// <returns></returns>
        //public IQueryable<LawyerInfoClone> QueryMasterLawyerByCase(string caseNo)
        //{
        //    return LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo)
        //        .Where(a => a.CaseNo == caseNo && a.RelatedType == LawyerRelatedDefinition.LegalCase &&
        //                    a.MasterType == LawyerMasterDefinition.MasterLawyer)
        //        .Select(a => a.LawyerInfo).Distinct();

        //}

        /// <summary>
        /// 查询项目律师
        /// </summary>
        /// <param name="caseNo"></param>
        /// <returns></returns>
        public IQueryable<LawyerInfoClone> QueryLawyerByCase(string caseNo)
        {
            var query = LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo)
                .Where(a => a.CaseNo == caseNo && a.RelatedType == LawyerRelatedDefinition.LegalContract &&
                            a.MasterType == LawyerMasterDefinition.CommonLawyer );
            return QueryCloneLawyer(query, false);
        }


        /// <summary>
        /// 查询合同的全部律师
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public IQueryable<LawyerInfoClone> QueryContractAllLawyers(string contractNo)
        {
            var query = LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo)
                .Where(a => a.ContractNo == contractNo && a.RelatedType == LawyerRelatedDefinition.LegalContract && a.MasterType != LawyerMasterDefinition.LawFirmContract);
            return QueryCloneLawyer(query, false);
        }

        /// <summary>
        /// 查询合同的负责人
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public IQueryable<LawyerInfoClone> QueryMasterLawyerByContract(string contractNo)
        {
            var query = LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo)
                .Where(a => a.ContractNo == contractNo && a.RelatedType == LawyerRelatedDefinition.LegalContract &&
                            a.MasterType == LawyerMasterDefinition.MasterLawyer);
            return QueryCloneLawyer(query, false);
        }

        /// <summary>
        /// 查询合同律师
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public IQueryable<LawyerInfoClone> QueryLawyerByContract(string contractNo)
        {
            var query = LawyerRelatedRepository.GetAllIncluding(a => a.LawyerInfo)
                .Where(a => a.ContractNo == contractNo && a.RelatedType == LawyerRelatedDefinition.LegalContract &&
                            a.MasterType == LawyerMasterDefinition.CommonLawyer);
            return QueryCloneLawyer(query, false);
        }
        private IQueryable<LawyerInfoClone> QueryCloneLawyer(IQueryable<LawyerRelatedInfo> query, bool withEx = true, int masterType = LawyerMasterDefinition.MasterLawyer)
        {
            if (withEx)
            {
                return query.Select(a => new LawyerInfoClone()
                {
                    Id = a.LawyerInfo.Id,
                    Code = a.LawyerInfo.Code,
                    Name = a.LawyerInfo.Name,
                    IdCard = a.LawyerInfo.IdCard,
                    PhoneNumber = a.LawyerInfo.PhoneNumber,
                    PhoneNumber2 = a.LawyerInfo.PhoneNumber2,
                    Birthday = a.LawyerInfo.Birthday,
                    UserName = a.LawyerInfo.UserName,
                    Email = a.LawyerInfo.Email,
                    LawFirmNo = a.LawFirmNo,
                    OrganizationNo = a.LawyerInfo.OrganizationNo,
                    LawFirmName = a.LawyerInfo.LawFirmInfo.Name,
                    OrganizationName = a.LawyerInfo.OrganizationInfo.Name,
                    IsMaster = a.MasterType == masterType,
                    CreationTime = a.LawyerInfo.CreationTime
                }).Distinct();
            }

            return query.Select(a => new LawyerInfoClone()
            {
                Id = a.LawyerInfo.Id,
                Code = a.LawyerInfo.Code,
                Name = a.LawyerInfo.Name,
                IdCard = a.LawyerInfo.IdCard,
                PhoneNumber = a.LawyerInfo.PhoneNumber,
                Birthday = a.LawyerInfo.Birthday,
                UserName = a.LawyerInfo.UserName,
                Email = a.LawyerInfo.Email,
                LawFirmNo = a.LawFirmNo,
                OrganizationNo = a.LawyerInfo.OrganizationNo,
                IsMaster = a.MasterType == masterType,
                CreationTime = a.LawyerInfo.CreationTime
            }).Distinct();
        }

        #endregion

        #region LawFirm

        /// <summary>
        /// 查询律所的项目
        /// </summary>
        /// <param name="lawFirmNo"></param>
        /// <returns></returns>
        public IQueryable<LegalCaseInfo> QueryCaseByLawFirm(string lawFirmNo)
        {
            //lawyerNo= lawyerNo??AbpSession.
            return LawyerRelatedRepository.GetAllIncluding(a => a.CaseInfo).Where(a => a.LawFirmNo == lawFirmNo && a.RelatedType == LawyerRelatedDefinition.LegalContract)
                .Select(a => a.CaseInfo).Distinct();

        }

        /// <summary>
        /// 查询律所的合同
        /// </summary>
        /// <param name="lawFirmNo"></param>
        /// <returns></returns>
        public IQueryable<LegalContractInfo> QueryContractByLawFirm(string lawFirmNo)
        {
            return LawyerRelatedRepository.GetAllIncluding(a => a.ContractInfo).Where(a => a.LawFirmNo == lawFirmNo && a.RelatedType == LawyerRelatedDefinition.LegalContract)
                .Select(a => a.ContractInfo).Distinct();

        }

        /// <summary>
        /// 查询律师的项目
        /// </summary>
        /// <param name="lawyerNo"></param>
        /// <returns></returns>
        public IQueryable<LegalCaseInfo> QueryLawyerCase(string lawyerNo = null)
        {
            if (lawyerNo == null)
            {
                CheckLawyerAccount();
                lawyerNo = AbpSession.AccountNo;
            }

            var isLawFirmMaster = IsLawFirmMaster(lawyerNo);
            var lawFirmNo =  QueryLawFirmNoByLawyer(lawyerNo);
            return LawyerRelatedRepository.GetAllIncluding(a => a.CaseInfo,a=>a.CaseInfo.CompanyInfo).Where(a =>
                    (a.LawyerNo == lawyerNo || isLawFirmMaster && a.LawFirmNo == lawFirmNo) && a.RelatedType == LawyerRelatedDefinition.LegalContract)
                .Select(a => a.CaseInfo).Distinct();
        }

        /// <summary>
        /// 查询律师的合同
        /// </summary>
        /// <param name="lawyerNo"></param>
        /// <returns></returns>
        public IQueryable<LegalContractInfo> QueryLawyerContract(string lawyerNo = null)
        {
            if (lawyerNo == null)
            {
                CheckLawyerAccount();
                lawyerNo = AbpSession.AccountNo;
            }
            var isLawFirmMaster = IsLawFirmMaster(lawyerNo);
            var lawFirmNo =  QueryLawFirmNoByLawyer(lawyerNo);
            return LawyerRelatedRepository.GetAllIncluding(a => a.ContractInfo,a=>a.ContractInfo.CaseInfo,a=>a.ContractInfo.CaseInfo.CompanyInfo).Where(a =>
                   (a.LawyerNo == lawyerNo || isLawFirmMaster && a.LawFirmNo == lawFirmNo) && a.RelatedType == LawyerRelatedDefinition.LegalContract)
                .Select(a => a.ContractInfo).Distinct();
        }

        /// <summary>
        /// 查询律所项目的合同
        /// </summary>
        /// <param name="caseNo"></param>
        /// <returns></returns>
        public IQueryable<LegalContractInfo> QueryLawFirmContractByCase(string caseNo)
        {
            CheckLawyerAccount();
            return LawyerRelatedRepository.GetAllIncluding(a => a.ContractInfo).Where(a =>
                   (a.CaseNo == caseNo) && a.RelatedType == LawyerRelatedDefinition.LegalContract)
                .Select(a => a.ContractInfo).Distinct();
        }


        public IQueryable<LegalContractInfo> QueryContractByHasLawFirm(IQueryable<LegalContractInfo> query,
            string hasLawFirm)
        {
            if (hasLawFirm=="1")
            {
                query = from l in query
                    join r in LawyerRelatedRepository.GetAll().Where(a =>
                            a.RelatedType == LawyerRelatedDefinition.LegalContract &&
                            a.MasterType == LawyerMasterDefinition.LawFirmContract) on l.Id equals r.ContractNo
                        into lr
                    from i in lr.DefaultIfEmpty()
                    where i.ContractNo != null
                    select l;
            }
            else if (hasLawFirm == "0")
            {
                query = from l in query
                    join r in LawyerRelatedRepository.GetAll().Where(a =>
                            a.RelatedType == LawyerRelatedDefinition.LegalContract &&
                            a.MasterType == LawyerMasterDefinition.LawFirmContract) on l.Id equals r.ContractNo
                        into lr
                    from i in lr.DefaultIfEmpty()
                    where i.ContractNo == null
                    select l;


            }

            return query;
        }

        #endregion

        #region Staff

        public IQueryable<ClientStaffInfoClone> QueryAllStaff()
        {
            var query = StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo, a => a.StaffInfo.CompanyInfo,
                        a => a.StaffInfo.OrganizationInfo).Where(a=>a.RelatedType == StaffRelatedDefinition.Company);
            return QueryCloneStaff(query, true, StaffMasterDefinition.CompanyMaster);
            //return StaffRepository.GetAllIncluding(a => a.CompanyInfo, a => a.OrganizationInfo).Select(a =>
            //    new ClientStaffInfoClone()
            //    {
            //        Id = a.Id,
            //        Code = a.Code,
            //        Name = a.Name,
            //        IdCard = a.IdCard,
            //        PhoneNumber = a.PhoneNumber,
            //        Birthday = a.Birthday,
            //        UserName = a.UserName,
            //        CompanyNo = a.CompanyNo,
            //        Email = a.Email,
            //        OrganizationNo = a.OrganizationNo,
            //        CompanyName = a.CompanyInfo.Name,
            //        OrganizationName = a.OrganizationInfo.Name,
            //        CreationTime = a.CreationTime
            //    });
        }


        /// <summary>
        /// 查询企业的所有员工
        /// </summary>
        /// <param name="no"></param>
        /// <param name="withEx"></param>
        /// <returns></returns>
        public IQueryable<ClientStaffInfoClone> QueryCompanyAllStaffs(string no,bool withEx=true)
        {
            var query = (withEx
                    ? StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo, a => a.StaffInfo.CompanyInfo,
                        a => a.StaffInfo.OrganizationInfo)
                    : StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo))
                .Where(a => a.CompanyNo == no && a.RelatedType == StaffRelatedDefinition.Company);

            return QueryCloneStaff(query, withEx, StaffMasterDefinition.CompanyMaster);
        }


        /// <summary>
        /// 查询律所的负责人
        /// </summary>
        /// <param name="companyNo"></param>
        /// <returns></returns>
        public IQueryable<ClientStaffInfoClone> QueryMasterStaffByCompany(string companyNo)
        {
            var query = StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo)
                .Where(a => a.CompanyNo == companyNo && a.RelatedType == StaffRelatedDefinition.Company &&
                            a.MasterType == StaffMasterDefinition.CompanyMaster);
            return QueryCloneStaff(query, false, StaffMasterDefinition.CompanyMaster);
        }

        /// <summary>
        /// 查询企业的员工
        /// </summary>
        /// <param name="companyNo"></param>
        /// <returns></returns>
        public IQueryable<ClientStaffInfoClone> QueryCommonStaffByCompany(string companyNo)
        {
            var query = StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo)
                .Where(a => a.CompanyNo == companyNo && a.RelatedType == StaffRelatedDefinition.Company &&
                            a.MasterType == StaffMasterDefinition.CommonStaff);
            return QueryCloneStaff(query, true, StaffMasterDefinition.CompanyMaster);
        }

        public IQueryable<ClientStaffInfoClone> QueryCaseStaffs(string caseNo)
        {
            var isMaster = IsCompanyMaster(AbpSession.AccountNo);
            return isMaster ? QueryCaseAllStaffs(caseNo) : QueryCommonStaffByCase(caseNo);
        }


        /// <summary>
        /// 查询项目的全部员工
        /// </summary>
        /// <param name="caseNo"></param>
        /// <returns></returns>
        public IQueryable<ClientStaffInfoClone> QueryCaseAllStaffs(string caseNo)
        {
            var query = StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo)
                .Where(a => a.CaseNo == caseNo && a.RelatedType == StaffRelatedDefinition.LegalCase);
            return QueryCloneStaff(query);
        }

        /// <summary>
        /// 查询项目的负责人
        /// </summary>
        /// <param name="caseNo"></param>
        /// <returns></returns>
        public IQueryable<ClientStaffInfoClone> QueryMasterStaffByCase(string caseNo)
        {
            var query = StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo)
                .Where(a => a.CaseNo == caseNo && a.RelatedType == StaffRelatedDefinition.LegalCase &&
                            a.MasterType == StaffMasterDefinition.MasterStaff);
            return QueryCloneStaff(query);
        }

        /// <summary>
        /// 查询项目员工（普通）
        /// </summary>
        /// <param name="caseNo"></param>
        /// <returns></returns>
        public IQueryable<ClientStaffInfoClone> QueryCommonStaffByCase(string caseNo)
        {
            var query = StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo)
                .Where(a => a.CaseNo == caseNo && a.RelatedType == StaffRelatedDefinition.LegalCase &&
                            a.MasterType == StaffMasterDefinition.CommonStaff);
            return QueryCloneStaff(query);
        }

        /// <summary>
        /// 查询合同的员工
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public IQueryable<ClientStaffInfoClone> QueryContractStaffs(string contractNo)
        {
            var isMaster = IsCompanyMaster(AbpSession.AccountNo);
            return isMaster ? QueryContractAllStaffs(contractNo) : QueryCommonStaffByContract(contractNo);
        }


        /// <summary>
        /// 查询合同的全部员工
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public IQueryable<ClientStaffInfoClone> QueryContractAllStaffs(string contractNo)
        {
            var query = StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo)
                .Where(a => a.ContractNo == contractNo && a.RelatedType == StaffRelatedDefinition.LegalContract);
            return QueryCloneStaff(query);
        }

        /// <summary>
        /// 查询合同的负责人
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public IQueryable<ClientStaffInfoClone> QueryMasterStaffByContract(string contractNo)
        {
            var query = StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo)
                .Where(a => a.ContractNo == contractNo && a.RelatedType == StaffRelatedDefinition.LegalContract &&
                            a.MasterType == StaffMasterDefinition.MasterStaff);
            return QueryCloneStaff(query);
        }

        /// <summary>
        /// 查询合同律师
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public IQueryable<ClientStaffInfoClone> QueryCommonStaffByContract(string contractNo)
        {
            var query = StaffRelatedRepository.GetAllIncluding(a => a.StaffInfo)
                .Where(a => a.ContractNo == contractNo && a.RelatedType == StaffRelatedDefinition.LegalContract &&
                            a.MasterType == StaffMasterDefinition.CommonStaff);
            return QueryCloneStaff(query);
        }

        #endregion

        #region Company

        /// <summary>
        /// 查询公司的项目
        /// </summary>
        /// <param name="companyNo"></param>
        /// <returns></returns>
        public IQueryable<LegalCaseInfo> QueryCaseByCompany(string companyNo)
        {
            return StaffRelatedRepository.GetAllIncluding(a => a.CaseInfo).Where(a => a.CompanyNo == companyNo && a.RelatedType == StaffRelatedDefinition.LegalCase)
                .Select(a => a.CaseInfo).Distinct();
        }

        /// <summary>
        /// 查询公司的合同
        /// </summary>
        /// <param name="companyNo"></param>
        /// <returns></returns>
        public IQueryable<LegalContractInfo> QueryContractByCompany(string companyNo)
        {
            return StaffRelatedRepository.GetAllIncluding(a => a.ContractInfo).Where(a => a.CompanyNo == companyNo && a.RelatedType == StaffRelatedDefinition.LegalCase)
                .Select(a => a.ContractInfo).Distinct();
        }

        /// <summary>
        /// 查询员工的项目
        /// </summary>
        /// <param name="staffNo"></param>
        /// <returns></returns>
        public IQueryable<LegalCaseInfo> QueryStaffCase(string staffNo=null)
        {
            if (staffNo == null)
            {
                CheckClientAccount();
                staffNo = AbpSession.AccountNo;
            }
            var isMaster = IsCompanyMaster(staffNo, out var companyNo);
            return StaffRelatedRepository.GetAllIncluding(a => a.CaseInfo,a=>a.CaseInfo.CompanyInfo).Where(a =>
                    (a.StaffNo == staffNo || isMaster && a.CompanyNo == companyNo) && a.RelatedType == StaffRelatedDefinition.LegalCase)
                .Select(a => a.CaseInfo).Distinct();
        }

        /// <summary>
        /// 查询员工的合同
        /// </summary>
        /// <param name="staffNo"></param>
        /// <returns></returns>
        public IQueryable<LegalContractInfo> QueryStaffContract(string staffNo=null)
        {
            if (staffNo == null)
            {
                CheckClientAccount();
                staffNo = AbpSession.AccountNo;
            }
            var isMaster = IsCompanyMaster(staffNo, out var companyNo);
            return StaffRelatedRepository
                .GetAllIncluding(a => a.ContractInfo, a => a.ContractInfo.CaseInfo, a => a.ContractInfo.CaseInfo.CompanyInfo).Where(a =>
                    (a.StaffNo == staffNo || isMaster && a.CompanyNo == companyNo) &&
                    a.RelatedType == StaffRelatedDefinition.LegalContract).Select(a => a.ContractInfo).Distinct();

            //.Select(a => new LegalContractInfoClone()
            //{
            //    Id = a.ContractInfo.Id,
            //    Code = a.ContractInfo.Code,
            //    Name = a.ContractInfo.Name,
            //    Tags = a.ContractInfo.Tags,
            //    ContractState = a.ContractInfo.ContractState,
            //    StartDateTime = a.ContractInfo.StartDateTime,
            //    EndDateTime = a.ContractInfo.EndDateTime,
            //    StateLastChangeTime = a.ContractInfo.StateLastChangeTime,
            //    StateLastChangeCause = a.ContractInfo.StateLastChangeCause,
            //    CaseNo = a.ContractInfo.CaseNo,
            //    CaseInfo = a.CaseInfo,
            //    CaseName = a.CaseInfo.Name,
            //    CompanyName = a.CaseInfo.CompanyInfo.Name,
            //    CompanyInfo = a.CaseInfo.CompanyInfo
            //}).Distinct();
        }

        /// <summary>
        /// 查询公司项目的合同
        /// </summary>
        /// <param name="caseNo"></param>
        /// <returns></returns>
        public IQueryable<LegalContractInfo> QueryCompanyContractByCase(string caseNo)
        {
            CheckLawyerAccount();
            return StaffRelatedRepository.GetAllIncluding(a => a.ContractInfo).Where(a =>
                    (a.CaseNo == caseNo) && a.RelatedType == StaffRelatedDefinition.LegalContract)
                .Select(a => a.ContractInfo).Distinct();
        }


        #endregion


        /// <summary>
        /// 查询合同关键点
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public IQueryable<LegalContractKeyPointInfo> QueryKeyPointByContract(string contractNo = null)
        {
            //lawyerNo= lawyerNo??AbpSession.
            //var cNos= LawyerRelatedRepository.GetAll().Where(a => a.LawyerNo == lawyerNo)
            //    .Select(a => a.ContractNo);
            return LCkpRepository.GetAll().Where(a => a.ContractNo == contractNo);
        }
        /// <summary>
        /// 查询关键点
        /// </summary>
        /// <returns></returns>
        public IQueryable<LegalContractKeyPointInfo> QueryRunKeyPointByUser()
        {
            var kpQuery = LCkpRepository.GetAll();
            IQueryable<LegalContractInfo> contractQuery;
            if (AbpSession.AccountType == AccountTypeDefinition.Client)
            {
               var staffNo = AbpSession.AccountNo;
                var isMaster = IsCompanyMaster(staffNo, out var companyNo);
                contractQuery = StaffRelatedRepository
                    .GetAllIncluding(a => a.ContractInfo, a => a.ContractInfo.CaseInfo).Where(a =>
                        (a.StaffNo == staffNo || isMaster && a.CompanyNo == companyNo) &&
                        a.RelatedType == StaffRelatedDefinition.LegalContract &&
                        a.ContractInfo.ContractState == LegalContractStateDefinition.Running &&
                        a.ContractInfo.CaseInfo.CaseState == LegalCaseStateDefinition.Running)
                    .Select(a => a.ContractInfo).Distinct();
            }
            else if (AbpSession.AccountType == AccountTypeDefinition.Lawyer)
            {
                var lawyerNo = AbpSession.AccountNo;
                var isMaster = IsLawFirmMaster(lawyerNo);
                var lawFirmNo = QueryLawFirmNoByLawyer(lawyerNo);
                contractQuery = LawyerRelatedRepository
                    .GetAllIncluding(a => a.ContractInfo, a => a.ContractInfo.CaseInfo).Where(a =>
                        (a.LawyerNo == lawyerNo || isMaster && a.LawFirmNo == lawFirmNo) &&
                        a.RelatedType == LawyerRelatedDefinition.LegalContract &&
                        a.ContractInfo.ContractState == LegalContractStateDefinition.Running &&
                        a.ContractInfo.CaseInfo.CaseState == LegalCaseStateDefinition.Running)
                    .Select(a => a.ContractInfo).Distinct();
            }
            else
            {
                contractQuery = null;
            }

            if (contractQuery != null)
            {
                kpQuery = from kp in kpQuery
                    join cq in contractQuery on kp.ContractNo equals cq.Id
                    where kp.KeyPointState == LegalKeyPointStateDefinition.Run
                    select kp;
            }
            else
            {
                kpQuery = kpQuery.Where(a => false);
            }

            return kpQuery;
        }


        /// <summary>
        /// 查询项目备注
        /// </summary>
        /// <param name="caseNo"></param>
        /// <param name="withCase"></param>
        /// <returns></returns>
        public IQueryable<LegalCaseNoteInfo> QueryCaseNoteInfos(string caseNo,bool withCase=false)
        {
            return (withCase
                ? LSnRepository.GetAllIncluding(a => a.CaseInfo, a => a.CreatorUser)
                : LSnRepository.GetAllIncluding(a => a.CreatorUser)).Where(a =>
                a.CaseNo == caseNo).Distinct();
        }
        /// <summary>
        /// 查询项目备注
        /// </summary>
        /// <param name="caseNo"></param>
        /// <param name="withCase"></param>
        /// <returns></returns>
        public IQueryable<LegalCaseNoteInfo> QueryLawyerCaseNoteInfos(string caseNo, bool withCase = false)
        {
            return (withCase
                ? LSnRepository.GetAllIncluding(a => a.CaseInfo, a => a.CreatorUser)
                : LSnRepository.GetAllIncluding(a => a.CreatorUser)).Where(a =>
                a.CaseNo == caseNo && a.NoteType != NoteTypeDefinition.Note).Distinct();
        }
        /// <summary>
        /// 查询项目备注
        /// </summary>
        /// <param name="caseNo"></param>
        /// <param name="withCase"></param>
        /// <returns></returns>
        public IQueryable<LegalCaseNoteInfo> QueryStaffCaseNoteInfos(string caseNo,bool withCase=false)
        {
            return (withCase
                ? LSnRepository.GetAllIncluding(a => a.CaseInfo, a => a.CreatorUser)
                : LSnRepository.GetAllIncluding(a => a.CreatorUser)).Where(a =>
                a.CaseNo == caseNo && a.NoteType != NoteTypeDefinition.LawyerNote).Distinct();
        }
      

        /// <summary>
        /// 查询合同备注
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="withContract"></param>
        /// <returns></returns>
        public IQueryable<LegalContractNoteInfo> QueryContractNoteInfos(string contractNo,bool withContract=false)
        {
            return (withContract
                ? LCnRepository.GetAllIncluding(a => a.ContractInfo, a => a.CreatorUser,a=>a.KeyPointInfo)
                : LCnRepository.GetAllIncluding(a => a.CreatorUser)).Where(a =>
                a.ContractNo == contractNo).Distinct();
        }
        /// <summary>
        /// 查询员工合同备注
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="withContract"></param>
        /// <returns></returns>
        public IQueryable<LegalContractNoteInfo> QueryStaffContractNoteInfos(string contractNo,bool withContract=false)
        {
            return (withContract
                ? LCnRepository.GetAllIncluding(a => a.ContractInfo, a => a.CreatorUser,a=>a.KeyPointInfo)
                : LCnRepository.GetAllIncluding(a => a.CreatorUser)).Where(a =>
                a.ContractNo == contractNo && a.NoteType != NoteTypeDefinition.LawyerNote).Distinct();
        }
        /// <summary>
        /// 查询律师合同备注
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="withContract"></param>
        /// <returns></returns>
        public IQueryable<LegalContractNoteInfo> QueryLawyerContractNoteInfos(string contractNo,bool withContract=false)
        {
            return (withContract
                ? LCnRepository.GetAllIncluding(a => a.ContractInfo, a => a.CreatorUser,a=>a.KeyPointInfo)
                : LCnRepository.GetAllIncluding(a => a.CreatorUser)).Where(a =>
                a.ContractNo == contractNo && a.NoteType != NoteTypeDefinition.Note).Distinct();
        }

        /// <summary>
        /// 查询补充合同
        /// </summary>
        /// <param name="contractNo"></param>
        /// <param name="withContract"></param>
        /// <returns></returns>
        public IQueryable<LegalContractSupplementInfo> QueryContractSupplementInfos(string contractNo,bool withContract=false)
        {
            return (withContract
                ? LCsRepository.GetAllIncluding(a => a.ContractInfo, a => a.CreatorUser)
                : LCsRepository.GetAllIncluding(a => a.CreatorUser)).Where(a =>
                a.ContractNo == contractNo).Distinct();
        }

        private IQueryable<ClientStaffInfoClone> QueryCloneStaff(IQueryable<StaffRelatedInfo> query, bool withEx = true,int masterType =  StaffMasterDefinition.MasterStaff)
        {
            if (withEx)
            {
                return query.Select(a => new ClientStaffInfoClone()
                {
                    Id = a.StaffInfo.Id,
                    Code = a.StaffInfo.Code,
                    Name = a.StaffInfo.Name,
                    IdCard = a.StaffInfo.IdCard,
                    PhoneNumber = a.StaffInfo.PhoneNumber,
                    Birthday = a.StaffInfo.Birthday,
                    UserName = a.StaffInfo.UserName,
                    Email = a.StaffInfo.Email,
                    CompanyNo = a.CompanyNo,
                    OrganizationNo = a.StaffInfo.OrganizationNo,
                    CompanyName = a.StaffInfo.CompanyInfo.Name,
                    OrganizationName = a.StaffInfo.OrganizationInfo.Name,
                    IsMaster = a.MasterType == masterType,
                    CreationTime = a.StaffInfo.CreationTime
                }).Distinct();
            }

            return query.Select(a => new ClientStaffInfoClone()
            {
                Id = a.StaffInfo.Id,
                Code = a.StaffInfo.Code,
                Name = a.StaffInfo.Name,
                IdCard = a.StaffInfo.IdCard,
                PhoneNumber = a.StaffInfo.PhoneNumber,
                Birthday = a.StaffInfo.Birthday,
                UserName = a.StaffInfo.UserName,
                Email = a.StaffInfo.Email,
                CompanyNo = a.CompanyNo,
                OrganizationNo = a.StaffInfo.OrganizationNo,
                IsMaster = a.MasterType == masterType,
                CreationTime = a.StaffInfo.CreationTime
            }).Distinct();
        }

        #endregion


        /// <summary>
        /// 查询律师
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public async Task<LawyerInfo> QueryLawyerByUserNameAsync(string userName)
        {
            var lawyer = await CacheManager.GetCache(IwbCacheNames.QueryLawyerInfo)
                .GetAsync($"{userName}", () => LawyerRepository.FirstOrDefaultAsync(a => a.UserName == userName));
            return lawyer;
        }

        /// <summary>
        /// 查询律师
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public LawyerInfo QueryLawyerByUserName(string userName)
        {
            return CacheManager.GetCache(IwbCacheNames.QueryLawyerInfo)
                .Get($"{userName}", () => LawyerRepository.FirstOrDefault(a => a.UserName == userName));
        }

        /// <summary>
        /// 查询员工
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public  Task<ClientStaffInfo> QueryStaffByUserNameAsync(string userName)
        {
            return  CacheManager.GetCache(IwbCacheNames.QueryStaffInfo)
                .GetAsync($"{userName}", () => StaffRepository.FirstOrDefaultAsync(a => a.UserName == userName));
        }

        /// <summary>
        /// 查询员工
        /// </summary>
        /// <param name="userName"></param>
        /// <returns></returns>
        public ClientStaffInfo QueryStaffByUserName(string userName)
        {
            return CacheManager.GetCache(IwbCacheNames.QueryStaffInfo)
                .Get($"{userName}", () => StaffRepository.FirstOrDefault(a => a.UserName == userName));
        }

        ///// <summary>
        ///// 查询项目所在律所
        ///// </summary>
        ///// <param name="no"></param>
        ///// <returns></returns>
        //private async Task<string> QueryLawFirmNoByCase(string no)
        //{
        //    return await CacheManager.GetCache(IwbCacheNames.QueryLawFirmNo).GetAsync(no, async () =>
        //    {
        //        var legalCase = await LsRepository.FirstOrDefaultAsync(a => a.Id == no);
        //        return legalCase?.CompanyNo;
        //    });
        //}

        ///// <summary>
        ///// 查询合同所在律所
        ///// </summary>
        ///// <param name="no"></param>
        ///// <returns></returns>
        //private async Task<string> QueryLawFirmNoByContract(string no)
        //{
        //    return await CacheManager.GetCache(IwbCacheNames.QueryLawFirmNo).GetAsync(no, async () =>
        //    {
        //        var contract = await LcRepository.GetAllIncluding(a => a.CaseInfo).FirstOrDefaultAsync(a => a.Id == no);
        //        return contract?.CaseInfo?.CompanyNo;
        //    });
        //}

        /// <summary>
        /// 查询项目所在公司
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        private async Task<string> QueryCompanyNoByCase(string no)
        {
            return await CacheManager.GetCache(IwbCacheNames.QueryCompanyNo).GetAsync(no, async () =>
            {
                var service = await LsRepository.FirstOrDefaultAsync(a => a.Id == no);
                return service?.CompanyNo;
            });
        }

        /// <summary>
        /// 查询合同所在公司
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        private async Task<string> QueryCompanyNoByContract(string no)
        {
            return await CacheManager.GetCache(IwbCacheNames.QueryCompanyNo).GetAsync(no, async () =>
            {
                var contract = await LcRepository.GetAllIncluding(a => a.CaseInfo).FirstOrDefaultAsync(a => a.Id == no);
                return contract?.CaseInfo?.CompanyNo;
            });
        }

        /// <summary>
        /// 查询合同所在项目
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<string> QueryCaseNoByContract(string no)
        {
            return await CacheManager.GetCache(IwbCacheNames.QueryCaseNo).GetAsync(no, async () =>
            {
                var contract = await LcRepository.FirstOrDefaultAsync(a => a.Id == no);
                return contract?.CaseNo;
            });
        }

        /// <summary>
        /// 查询律师所在律所
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<string> QueryLawFirmNoByLawyerAsync(string no)
        {
            return await CacheManager.GetCache(IwbCacheNames.QueryLawFirmNo).GetAsync($"lawyer-{no}", async () => (await LawyerRelatedRepository.FirstOrDefaultAsync(a =>
                a.RelatedType == LawyerRelatedDefinition.LawFirm && a.LawyerNo == no))?.LawFirmNo);
        }


        /// <summary>
        /// 查询律师所在律所
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public string QueryLawFirmNoByLawyer(string no)
        {
            return CacheManager.GetCache(IwbCacheNames.QueryLawFirmNo).Get($"lawyer-{no}", () =>
                LawyerRelatedRepository.FirstOrDefault(a =>
                    a.RelatedType == LawyerRelatedDefinition.LawFirm && a.LawyerNo == no)?.LawFirmNo);
        }

        /// <summary>
        /// 查询员工所在公司
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<string> QueryCompanyNoByStaffAsync(string no)
        {
            return await CacheManager.GetCache(IwbCacheNames.QueryCompanyNo).GetAsync($"staff-{no}",async () =>
               (await StaffRelatedRepository.FirstOrDefaultAsync(a =>
                    a.RelatedType == StaffRelatedDefinition.Company && a.StaffNo == no))?.ContractNo);
        }

        /// <summary>
        /// 查询员工所在公司
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public string QueryCompanyNoByStaff(string no)
        {
            return CacheManager.GetCache(IwbCacheNames.QueryCompanyNo).Get($"staff-{no}", () =>
                StaffRelatedRepository.FirstOrDefault(a =>
                    a.RelatedType == StaffRelatedDefinition.Company && a.StaffNo == no)?.ContractNo);
        }




        #endregion

        #region 账号检验 是否是负责人  Check IsMaster

        /// <summary>
        /// 是否是律所负责人
        /// </summary>
        /// <param name="lawyerNo"></param>
        /// <returns></returns>
        public bool IsLawFirmMaster(string lawyerNo)
        {
            return LawyerRelatedRepository.FirstOrDefault(a =>
                a.LawyerNo == lawyerNo && a.RelatedType == LawyerRelatedDefinition.LawFirm &&
                a.MasterType == LawyerMasterDefinition.LawFirmMaster)!=null;
        }

        /// <summary>
        /// 是否是合同负责律师
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public bool IsLawyerContractMaster(string contractNo)
        {
            return IsLawFirmMaster(AbpSession.AccountNo) || IsLawyerContractMaster(AbpSession.AccountNo, contractNo);
        }

        ///// <summary>
        ///// 是否是项目负责人
        ///// </summary>
        ///// <param name="lawyerNo"></param>
        ///// <param name="caseNo"></param>
        ///// <returns></returns>
        //private bool IsLawFirmCaseMaster(string lawyerNo,  string caseNo)
        //{
        //    CheckLawyerAccount();
        //    return LawyerRelatedRepository.FirstOrDefault(a =>
        //               a.LawyerNo == lawyerNo && a.CaseNo == caseNo &&
        //               a.RelatedType == LawyerRelatedDefinition.LegalCase &&
        //               a.MasterType == LawyerMasterDefinition.MasterLawyer) != null;
        //}


        /// <summary>
        /// 是否是合同负责律师
        /// </summary>
        /// <param name="lawyerNo"></param>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        private bool IsLawyerContractMaster(string lawyerNo,  string contractNo)
        {
            return LawyerRelatedRepository.FirstOrDefault(a =>
                       a.LawyerNo == lawyerNo && a.ContractNo == contractNo &&
                       a.RelatedType == LawyerRelatedDefinition.LegalContract &&
                       a.MasterType == LawyerMasterDefinition.MasterLawyer) != null;
        }

        /// <summary>
        /// 是否是企业负责人
        /// </summary>
        /// <param name="staffNo"></param>
        /// <param name="no"></param>
        /// <returns></returns>
        public bool IsCompanyMaster(string staffNo,out string no)
        {
            no = StaffRelatedRepository.FirstOrDefault(a =>
                a.StaffNo == staffNo && a.RelatedType == StaffRelatedDefinition.Company &&
                a.MasterType == StaffMasterDefinition.CompanyMaster)?.CompanyNo;
            return !string.IsNullOrEmpty(no);
        }
        /// <summary>
        /// 是否是企业负责人
        /// </summary>
        /// <param name="staffNo"></param>
        /// <returns></returns>
        public bool IsCompanyMaster(string staffNo)
        {
            string no = StaffRelatedRepository.FirstOrDefault(a =>
                a.StaffNo == staffNo && a.RelatedType == StaffRelatedDefinition.Company &&
                a.MasterType == StaffMasterDefinition.CompanyMaster)?.CompanyNo;
            return !string.IsNullOrEmpty(no);
        }


        /// <summary>
        /// 是否是公司负责人
        /// </summary>
        /// <returns></returns>
        public  Task<bool> IsCompanyMaster()
        {
            var result = AbpSession.AccountType == AccountTypeDefinition.Client &&
                         (IsCompanyMaster(AbpSession.AccountNo) );
            return Task.FromResult(result);
        }
        /// <summary>
        /// 是否是项目负责人
        /// </summary>
        /// <param name="caseNo"></param>
        /// <returns></returns>
        public  Task<bool> IsClientCaseMaster(string caseNo)
        {
            var result = AbpSession.AccountType == AccountTypeDefinition.Client &&
                         (IsCompanyMaster(AbpSession.AccountNo) ||
                          IsClientCaseMaster(AbpSession.AccountNo, caseNo));
            return Task.FromResult(result);
        }

        /// <summary>
        /// 是否是项目负责人
        /// </summary>
        /// <param name="staffNo"></param>
        /// <param name="caseNo"></param>
        /// <returns></returns>
        private bool IsClientCaseMaster(string staffNo, string caseNo)
        {
            return StaffRelatedRepository.FirstOrDefault(a =>
                       a.StaffNo == staffNo && a.CaseNo == caseNo &&
                       a.RelatedType == StaffRelatedDefinition.LegalCase &&
                       a.MasterType == StaffMasterDefinition.MasterStaff) != null;
        }

        /// <summary>
        /// 是否是合同负责人
        /// </summary>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        public async Task<bool> IsClientContractMaster(string contractNo)
        {
            return AbpSession.AccountType == AccountTypeDefinition.Client &&
                   (IsCompanyMaster(AbpSession.AccountNo) || IsClientContractMaster(AbpSession.AccountNo, contractNo) ||
                    IsClientCaseMaster(AbpSession.AccountNo,await QueryCaseNoByContract(contractNo)));
        }

        /// <summary>
        /// 是否是合同负责人
        /// </summary>
        /// <param name="staffNo"></param>
        /// <param name="contractNo"></param>
        /// <returns></returns>
        private bool IsClientContractMaster(string staffNo, string contractNo)
        {
            return StaffRelatedRepository.FirstOrDefault(a =>
                       a.StaffNo == staffNo && a.ContractNo == contractNo &&
                       a.RelatedType == StaffRelatedDefinition.LegalContract &&
                       a.MasterType == StaffMasterDefinition.MasterStaff) != null;
        }

        /// <summary>
        /// 检查是否是系统用户
        /// </summary>
        private void CheckSysAccount()
        {
            CheckAccount(AccountTypeDefinition.System);
        }
        /// <summary>
        /// 检查是否是律师用户
        /// </summary>
        private void CheckLawyerAccount()
        {
            CheckAccount(AccountTypeDefinition.Lawyer);
        }

        /// <summary>
        /// 检查是否是客户用户
        /// </summary>
        private void CheckClientAccount()
        {
            CheckAccount(AccountTypeDefinition.Client);
        }

        /// <summary>
        /// 检查是否是系统用户
        /// </summary>
        public bool CheckAccount(params int[] accountTypes)
        {
            if (AbpSession.UserName == UserBase.AdminUserName)
            {
                return true;
            }
            if (AbpSession.AccountType != null && accountTypes.ToList().Contains((int)AbpSession.AccountType)   )
            {
                return true;
            }
            CheckError("非法账号，不能操作");
            return false;
        }
        #endregion

        private void CheckError(string msg)
        {
            throw new UserFriendlyException(msg);
        }
        protected virtual void CheckError(IdentityResult identityResult)
        {
            identityResult.CheckErrors(LocalizationManager);
        }
        public async Task<string> GetCacheNameAsync(string no)
        {
            return await CacheManager.GetCache(IwbCacheNames.EntityCacheName).GetAsync(no,
                async () =>
                {
                    var type = AppGuidManager.GetRecordIdType(no);
                    switch (type)
                    {
                        case DataLibType.LegalCase:
                            return (await LsRepository.FirstOrDefaultAsync(a => a.Id == no))?.Name;
                        case DataLibType.LegalContract:
                            return (await LcRepository.FirstOrDefaultAsync(a => a.Id == no))?.Name;
                        case DataLibType.LegalContractKeyPoint:
                            return (await LCkpRepository.FirstOrDefaultAsync(a => a.Id == no))?.Name;
                        case DataLibType.Company:
                            return (await CcRepository.FirstOrDefaultAsync(a => a.Id == no))?.Name;
                        case DataLibType.LawFirm:
                            return (await LfRepository.FirstOrDefaultAsync(a => a.Id == no))?.Name;
                        default:
                            return "";
                    }
                });
        }
        public string GetCacheName(string no)
        {
            return CacheManager.GetCache(IwbCacheNames.EntityCacheName).Get(no,
                () =>
                {
                    var type = AppGuidManager.GetRecordIdType(no);
                    switch (type)
                    {
                        case DataLibType.LegalCase:
                            return (LsRepository.FirstOrDefault(a => a.Id == no))?.Name;
                        case DataLibType.LegalContract:
                            return (LcRepository.FirstOrDefault(a => a.Id == no))?.Name;
                        case DataLibType.LegalContractKeyPoint:
                            return (LCkpRepository.FirstOrDefault(a => a.Id == no))?.Name;
                        case DataLibType.Company:
                            return (CcRepository.FirstOrDefault(a => a.Id == no))?.Name;
                        case DataLibType.LawFirm:
                            return (LfRepository.FirstOrDefault(a => a.Id == no))?.Name;
                        default:
                            return "";
                    }
                });
        }

        public string GetCompanyNameByCase(string no)
        {
            return CacheManager.GetCache(IwbCacheNames.EntityCacheName).Get($"CaseCompany-{no}",
                () =>
                {
                    var legalCase = LsRepository.FirstOrDefault(a => a.Id == no);
                    return legalCase == null ? null : GetCacheName(legalCase.CompanyNo);
                });
        }
        public string GetLawFirmNameByContract(string no)
        {
            return CacheManager.GetCache(IwbCacheNames.EntityCacheName).Get($"ContractLawFirm-{no}",
                () =>
                {
                    var lawFirm = LawyerRelatedRepository.FirstOrDefault(a =>
                        a.ContractNo == no && a.RelatedType == LawyerRelatedDefinition.LegalContract &&
                        a.MasterType == LawyerMasterDefinition.LawFirmContract);
                    return lawFirm == null ? null : GetCacheName(lawFirm.LawFirmNo);
                });
        }
        private async Task SetCacheName(string no,string name)
        {
             await CacheManager.GetCache(IwbCacheNames.EntityCacheName).SetAsync(no,name);
        }

    }

    public enum ServiceType
    {
        Case,
        Contract,
        ContractNote,
        ContractSupplement,
        KeyPoint,
    }
}