LegalServiceV1/SourceCode/V2/ContractService/ContractService.Application/LegalContract/Contract/LegalContractApplicationService.cs

using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Threading.Tasks;
using System.Web.Mvc;
using Abp.Application.Services.Dto;
using Abp.Auditing;
using Abp.Authorization;
using Abp.Domain.Repositories;
using Abp.Runtime.Caching;
using IwbZero.Auditing;
using IwbZero.AppServiceBase;
using ContractService.Authorization;
using ContractService.Configuration;
using ContractService.LegalCase.Dto;
using ContractService.LegalContract.Contract.Dto;
using IwbZero.ToolCommon.StringModel;

namespace ContractService.LegalContract.Contract
{
    [AbpAuthorize, AuditLog("合同信息")]
    public class LegalContractAppService : IwbAsyncCrudAppService<LegalContractInfo, LegalContractDto, string, IwbPagedRequestDto, LegalContractCreateDto, LegalContractUpdateDto >, ILegalContractAppService
    {
        public LegalContractAppService(
			ICacheManager cacheManager,
			IRepository<LegalContractInfo, string> repository, LegalManager legalManager, IRepository<LegalContractContentInfo, long> contentRepository) : base(repository, "Id")
        {
            LegalManager = legalManager;
            ContentRepository = contentRepository;
            CacheManager = cacheManager;
        }

        protected override bool KeyIsAuto { get; set; } = false;
        public LegalManager LegalManager { get; }

        protected IRepository<LegalContractContentInfo,long> ContentRepository { get; }

        #region GetSelect

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

        #endregion

        #region CURD

        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgCreate)]
        public override async Task Create(LegalContractCreateDto input)
        {
            var entity = MapToEntity(input);
            await LegalManager.CreateContract(entity,input.AttachFiles);
        }

        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgUpdate)]
        public override async Task Update(LegalContractUpdateDto input)
        {
            var entity = await GetEntityById(input.Id);
            if (entity == null)
            {
                CheckErrors(NotExistMessage);
            }
            MapToEntity(input, entity);
            await LegalManager.UpdateContract(entity, input.AttachFiles);
        }

        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgDelete)]
        public override Task Delete(EntityDto<string> input)
        {
            return LegalManager.DeleteContract(input.Id);
        }

        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgQuery)]
        public override async Task<PagedResultDto<LegalContractDto>> GetAll(IwbPagedRequestDto input)
        {
            var query = LegalManager.QueryContract();
            if (input.SearchList?.Count > 0)
            {
                if (AbpSession.AccountType == AccountTypeDefinition.System)
                {
                    if (input.SearchList.Any(a => a.KeyField.ToLower() == "haslawfirm"))
                    {
                        var search = input.SearchList.FirstOrDefault(a => a.KeyField.ToLower() == "haslawfirm");
                        var name = search?.KeyWords ?? "";
                        if (search != null) input.SearchList.Remove(search);
                        query = LegalManager.QueryContractByHasLawFirm(query, name);
                    }
                }
                if (input.SearchList.Any(a => a.KeyField.ToLower() == "casename"))
                {
                    var search = input.SearchList.FirstOrDefault(a => a.KeyField.ToLower() == "casename");
                    var name = search?.KeyWords ?? "";
                    if (search != null) input.SearchList.Remove(search);
                    query = query.Where(a => a.CaseInfo.Name.Contains(name));
                }
                if (AbpSession.AccountType == AccountTypeDefinition.System || AbpSession.AccountType == AccountTypeDefinition.Lawyer)
                {
                    if (input.SearchList.Any(a => a.KeyField.ToLower() == "companyname"))
                    {
                        var search = input.SearchList.FirstOrDefault(a => a.KeyField.ToLower() == "companyname");
                        var name = search?.KeyWords ?? "";
                        if (search != null) input.SearchList.Remove(search);
                        query = query.Where(a => a.CaseInfo.CompanyInfo.Name.Contains(name) || a.CaseInfo.CompanyInfo.DisplayName.Contains(name));
                    }
                }
            }

          
            query = ApplyFilter(query, input);
            var totalCount = await AsyncQueryableExecuter.CountAsync(query);
            query = ApplySorting(query, input);
            query = ApplyPaging(query, input);
            var entities = await AsyncQueryableExecuter.ToListAsync(query);
            var dtoList = new PagedResultDto<LegalContractDto>(totalCount, entities.Select(MapToEntityDto).ToList());
            return dtoList;
        }

        protected override LegalContractDto MapToEntityDto(LegalContractInfo entity)
        {
            var dto = base.MapToEntityDto(entity);
            dto.CaseName = entity.CaseInfo?.Name;
            dto.CaseName = dto.CaseName.Empty() ? LegalManager.GetCacheName(dto.CaseNo) : dto.CaseName;
            dto.CaseState = entity.CaseInfo?.CaseState ?? 0;
            dto.CaseCode = entity.CaseInfo?.Code;
            dto.CompanyName = entity.CaseInfo?.CompanyInfo?.Name;
            dto.CompanyName = dto.CompanyName.Empty() ? LegalManager.GetCompanyNameByCase(dto.CaseNo) : dto.CompanyName;
            dto.LawFirmName = LegalManager.GetLawFirmNameByContract(entity.Id);
            dto.IsMaster = LegalManager.IsLawyerContractMaster(entity.Id);
            return dto;
        }

        protected override IQueryable<LegalContractInfo> SelfSorting(IQueryable<LegalContractInfo> query, IwbPagedRequestDto input)
        {
            return query.OrderByDescending(r => r.Id);
        }

        protected override IQueryable<LegalContractInfo> KeyWordFilter(IQueryable<LegalContractInfo> query, string keyword)
        {
            return query.Where(a => a.Code.Contains(keyword)|| a.Name.Contains(keyword));
        }


		#region GetEntity/Dto

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

        /// <summary>
        ///  查询实体Dto
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [DisableAuditing]
        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgQuery)]
        public override async Task<LegalContractDto> GetDtoById(string id)
        {
            var entity = await GetEntityById(id);
            var content=await ContentRepository.GetAll().Where(a => a.No == id).OrderByDescending(a=>a.Id).FirstOrDefaultAsync();
            var dto = MapToEntityDto(entity);
            dto.ContentInfo = content?.ContentInfo??"";
            return dto;
        }

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

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

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

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

        #endregion

        #region Hide

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



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

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

        #endregion

        #endregion

        /// <summary>
        /// 变更负责人
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgChangeState), AuditLog("变更状态")]
        public async Task ChangeState(ChangeStaterDto input)
        {
            await LegalManager.ChangeState(input.Id, input.State, input.Reason, ServiceType.Contract);
        }


        public async Task<List<LegalContractDto>> GetAllContract(List<MultiSearchRequest> input)
        {
            var query = LegalManager.QueryContract();
            if (input.Count > 0)
            {
                if (input.Any(a => a.KeyField.ToLower() == "keyword"))
                {
                    var search = input.FirstOrDefault(a => a.KeyField.ToLower() == "keyword");
                    if (search != null)
                    {
                        var keyword = search.KeyWords ?? "";
                        input.Remove(search);
                        //query = query.Where(a =>
                        //    a.Code.Contains(keyword) || a.Name.Contains(keyword) || a.CaseInfo.Name.Contains(keyword) ||
                        //    a.CaseInfo.Code.Contains(keyword));
                        query = KeyWordFilter(query, keyword);
                    }
                }
                if (input.Any(a => a.KeyField.ToLower() == "case"))
                {
                    var search = input.FirstOrDefault(a => a.KeyField.ToLower() == "case");
                    if (search != null)
                    {
                        var keyword = search.KeyWords ?? "";
                        input.Remove(search);
                        query = query.Where(a => a.CaseInfo.Name.Contains(keyword) || a.CaseInfo.Code.Contains(keyword));
                    }
                }
                if (input.Any(a => a.KeyField.ToLower() == "contract_state"))
                {
                    var search = input.FirstOrDefault(a => a.KeyField.ToLower() == "contract_state");
                    if (search != null)
                    {
                        input.Remove(search);
                        query = query.Where(a =>
                            (a.CaseInfo.CaseState == LegalContractStateDefinition.Running ||
                             a.CaseInfo.CaseState == LegalContractStateDefinition.Running) &&
                            (a.ContractState == LegalContractStateDefinition.Running ||
                             a.ContractState == LegalContractStateDefinition.Hang));
                    }
                }
                
            }
                
            query = SearchListFilter(query, input);
            query = query.OrderByDescending(a => a.CreationTime);
            var entities = await AsyncQueryableExecuter.ToListAsync(query);
            var dtoList = entities.Select(MapToEntityDto).ToList();
            return dtoList;
        }

        /// <summary>
        /// 关联职员
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgSetStaff), AuditLog("关联职员")]
        public async Task SetStaff(SetStaffLawyerDto input)
        {
            if (input.Master.NotEmpty())
            {
                await LegalManager.SetContractMasterStaff(input.Id, input.Master);
            }

            await LegalManager.SetContractStaffs(input.Id, input.List);
        }

        /// <summary>
        /// 分配律师
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgSetLawyer), AuditLog("分配律师")]
        public async Task SetLawyer(SetStaffLawyerDto input)
        {
            if (input.Master.NotEmpty())
            {
                await LegalManager.SetContractMasterLawyer(input.Id, input.Master);
            }
            await LegalManager.SetContractLawyers(input.Id, input.List);
        }

        /// <summary>
        /// 分配律所
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgSetLawFirm), AuditLog("分配律所")]
        public async Task SetLawFirm(SetStaffLawyerDto input)
        {
            await LegalManager.SetContractLawFirm(input.Id, input.LawFirmNo);
        }

        /// <summary>
        /// 检查合同是否被分配律所
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        public async Task<bool> CheckContractHasLawFirm(string no)
        {
            return await LegalManager.CheckContractHasLawFirm(no);
        }

        /// <summary>
        /// 查询合同的员工
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<StaffLawyerDto>> GetContractStaffs(string no)
        {
            var staffs = await LegalManager.QueryContractAllStaffs(no).Select(a => new StaffLawyerDto()
            {
                Name = a.Name,
                No = a.Id,
                UserName = a.UserName,
                OrgName = a.OrganizationName,
                IsMaster = a.IsMaster
            }).ToListAsync();

            return staffs;
        }
        /// <summary>
        /// 查询合同的律师
        /// </summary>
        /// <param name="no"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<List<StaffLawyerDto>> GetContractLawyers(string no)
        {
            var isLawFirmMaster = LegalManager.IsLawFirmMaster(AbpSession.AccountNo);
            var staffs = await LegalManager.QueryContractAllLawyers(no).Where(a => isLawFirmMaster || !a.IsMaster).Select(a => new StaffLawyerDto()
            {
                Name = a.Name,
                No = a.Id,
                UserName = a.UserName,
                IsMaster = a.IsMaster
            }).ToListAsync();
            
            return staffs;
        }

        /// <summary>
        /// 合同备注
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgNote,PermissionNames.PagesCaseContractMgContractMgLawNote), AuditLog("合同备注")]
        public async Task CreateNote(ContractNoteDto input)
        {
            var entity = ObjectMapper.Map<LegalContractNoteInfo>(input);
            entity.KeyPointNo = entity.KeyPointNo.Empty() ? null : entity.KeyPointNo;
            await LegalManager.ContractNote(entity);
        }

        /// <summary>
        /// 查询合同备注
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<PagedResultDto<ContractNoteDto>> QueryNote(LazyQueryDto input)
        {
            var query = LegalManager.QueryContractNoteInfos(input.No, true);
            if (AbpSession.AccountType == AccountTypeDefinition.Lawyer)
            {
                query = LegalManager.QueryLawyerContractNoteInfos(input.No, true);
            }else if (AbpSession.AccountType == AccountTypeDefinition.Client) 
            {
                query = LegalManager.QueryStaffContractNoteInfos(input.No, true);
            }
            if (input.Keyword.NotEmpty())
            {
                var wordArr = input.Keyword.Split('|');
                if (wordArr[0].NotEmpty())
                {
                    var kpNo = wordArr[0];
                    query = query.Where(a => a.KeyPointNo == kpNo);
                }
                if (wordArr.Length>1&& wordArr[1].NotEmpty())
                {
                    var typeArr = wordArr[1].Split(',');
                    List<int> arr = new List<int>();
                    foreach (var s in typeArr)
                    {
                        if (int.TryParse(s, out var type))
                        {
                            arr.Add(type);
                        }
                    }
                    if (arr.Any())
                    {
                        query = query.Where(a => arr.Contains(a.NoteType));
                    }
                }
            }
            var totalCount = await query.CountAsync();
            query = query.OrderByDescending(a => a.Id).Skip(input.Skip).Take(input.Take);
            var list = await query.ToListAsync();
            return new PagedResultDto<ContractNoteDto>(totalCount, list.Select(MapNoteDto).ToList());
        }

        private ContractNoteDto MapNoteDto(LegalContractNoteInfo entity)
        {
            var dto = ObjectMapper.Map<ContractNoteDto>(entity);
            if (entity.CreatorUser != null)
            {
                dto.UserImage = entity.CreatorUser.ImagePath;
                dto.UserRealName = LegalManager.QueryStaffByUserName(entity.CreatorUser.UserName)?.Name ??
                                   LegalManager.QueryLawyerByUserName(entity.CreatorUser.UserName)?.Name ??
                                   entity.CreatorUser.Name;
            }

            dto.KeyPointName = entity.KeyPointInfo?.Name??"";
            return dto;
        }

        /// <summary>
        /// 补充合同
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AbpAuthorize(PermissionNames.PagesCaseContractMgContractMgSupplement), AuditLog("补充合同")]
        public async Task CreateSupplement(SupplementDto input)
        {
            var entity = ObjectMapper.Map<LegalContractSupplementInfo>(input);
            await LegalManager.ContractSupplement(entity,input.AttachFiles);
        }

        /// <summary>
        /// 查询补充合同
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [DisableAuditing]
        public async Task<PagedResultDto<SupplementDto>> QuerySupplement(LazyQueryDto input)
        {
            var query = LegalManager.QueryContractSupplementInfos(input.No, true);
            if (input.Keyword.NotEmpty())
            {
                query = query.Where(a => a.KeyPointNo == input.Keyword);
            }
            else
            {
                query = query.Where(a => string.IsNullOrEmpty(a.KeyPointNo));
            }
            var totalCount = await query.CountAsync();
            query = query.OrderByDescending(a => a.Id).Skip(input.Skip).Take(input.Take);
            var list = await query.ToListAsync();
            return new PagedResultDto<SupplementDto>(totalCount, list.Select(MapSupplementDto).ToList());
        }


        private SupplementDto MapSupplementDto(LegalContractSupplementInfo entity)
        {
            var dto = ObjectMapper.Map<SupplementDto>(entity);
            var content =  ContentRepository.GetAll().Where(a => a.No == entity.Id).OrderByDescending(a => a.Id).FirstOrDefault();
            dto.ContentInfo = content?.ContentInfo ?? "";
            return dto;
        }
    }
}