24Hour.Service/24Hour/Controllers/Common/LawyerArchivesController.cs

using AutoMapper;
using AutoMapper.Internal;
using com.sun.xml.@internal.bind.v2.model.core;
using Dto;
using Elight.Entity;
using Elight.Entity.APPDto.Lawyer;
using Elight.Entity.AppMode.Lawyer;
using Elight.Logic;
using Elight.Logic.Model.Lawyer;
using Elight.Logic.SystemModel;
using Elight.Utility;
using Elight.Utility.Code;
using Elight.Utility.Extensions;
using Elight.Utility.logs;
using java.io;
using java.lang;
using java.time;
using javax.xml.crypto;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Newtonsoft.Json;
using NPOI.OpenXmlFormats.Spreadsheet;
using NPOI.SS.Formula.Functions;
using SqlSugar;
using SqlSugar.Extensions;
using System.Data;
using System.IO.Compression;
using System.Linq;
using System.Net.WebSockets;
using System.Text;
using static _24Hour.TwentySystemProxyClient;
using static com.sun.tools.@internal.xjc.reader.xmlschema.bindinfo.BIConversion;
using static NPOI.HSSF.Util.HSSFColor;
using Exception = System.Exception;
using User = Elight.Utility.User;

namespace _24Hour.Controllers.Common
{
    /// <summary>
    /// 律师服务
    /// </summary>
    [Authorize]
    [ApiController]
    [Route("api/Lawyer")]
    public class LawyerArchivesController : Controller
    {
        #region Identity
        private readonly SqlSugarClient _db;//数据库
        private readonly WriteSysLog _logs;//操作日志
        App_Sys_UserModel _userdata = new App_Sys_UserModel();//当前用户
        private readonly ILogger<LawyerArchivesController> logger;//日志
        Result result = new Result();
        private readonly TwentySystemProxyClient twentyClient;
        private readonly IConfiguration configuration;
        private readonly IMapper mapper;
        public LawyerArchivesController(ILogger<LawyerArchivesController> _logger, SqlSugarClient db, WriteSysLog logs, User user, IMapper _mapper, TwentySystemProxyClient _twentyClient, IConfiguration _configuration)
        {
            this.logger = _logger;
            _db = db;
            _logs = logs;
            this.mapper = _mapper;
            this.twentyClient = _twentyClient;
            this.configuration = _configuration;
            _userdata = user.Userdata();

        }
        #endregion
        #region 律师阅卷
        /// <summary>
        /// 获取当前登录人员的单位下所有的律师信息
        /// </summary>
        /// <returns></returns>
        [HttpGet("GetAllLawyerByUnitCode")]
        public async Task<Result<IEnumerable<App_Sys_UserModel>>> GetAllLawyerByUnitCode()
        {
            var res = new Result<IEnumerable<App_Sys_UserModel>>();

            var data = await _db.Queryable<App_Sys_UserModel>()
                .Where(x => x.unitCode == _userdata.unitCode && x.IsDeleted == 0 && x.isdeactivate == 0)
                .Where(x => x.identity == "律师")
                .ToListAsync();
            res.IsSucceed = true;
            res.result = data;
            return res;
        }
        /// <summary>
        /// 修改内网律师信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("EditLawyer")]
        public async Task<Result> EditLawyer(App_Sys_AddLawyerInput input)
        {
            try
            {
                var data = await _db.Queryable<App_Sys_UserModel>().FirstAsync(x => x.Id == input.Id);
                if (data != null)
                {
                    data = mapper.Map(input, data);
                    _db.BeginTran();
                    var num = await _db.Updateable(data).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                    _db.CommitTran();

                    if (num > 0)
                    {
                        result.IsSucceed = true;
                        result.result = "修改成功";

                    }
                }
                else
                {
                    result.IsSucceed = false;
                    result.result = "用户不存在";
                }
            }
            catch (Exception ex)
            {
                result.IsSucceed = false;
                logger.LogError(ex, "");
            }
            return result;
        }
        /// <summary>
        /// 导入律师库信息，先调用/api/Common/Upload_Files1将文件上传至库，然后用url调用ImportLawyerData
        /// </summary>
        /// <param name="path">excel文件相对路径</param>
        /// <returns></returns>
        [HttpGet]
        [Route("ImportLawyerData")]
        public async Task<Result> ImportLawyerData(string path)
        {
            Result res = new Result();
            int updated = 0, added = 0;
            var ext = Path.GetExtension(path).ToLower();

            if (ext == ".xlsx" || ext == ".xls")
            {
                if (System.IO.File.Exists(path))
                {
                    var reader = new ExcelReader(path);
                    var dt = reader.ExcelToDataTable();
                    if (dt != null)
                    {
                        var lawyers = new List<App_Sys_UserModel>();
                        foreach (DataRow dr in dt.Rows)
                        {
                            var cardid = dr.Field<string>("证件编号");
                            if (string.IsNullOrEmpty(cardid))
                            {
                                continue;
                            }
                            lawyers.Add(new()
                            {
                                Id = Guid.NewGuid().ToString(),
                                name = dr.Field<string>("姓名"),
                                sex = dr?.Field<string>("性别")?.Contains('男') == true ? 0 : 1,
                                phone = dr.Field<string>("手机号码"),
                                departmentName = dr.Field<string>("执业机构"),
                                identitycardId = dr.Field<string>("执业证号"),
                                cardId = dr.Field<string>("证件编号"),
                                unitCode = _userdata.unitCode,

                                createtime = DateTime.Now,
                                createuserId = _userdata.createuserId,
                                createusername = _userdata.name,
                                identity = "律师",
                                usertype = 1,
                                audit = 0,

                                isdeactivate = 0,
                                IsDeleted = 0,
                            });
                        }
                        var cardids = lawyers.Select(e => e.cardId).ToList();
                        var lawyersInDb = await _db.Queryable<App_Sys_UserModel>().In(x => x.cardId, cardids).ToListAsync();
                        if (lawyersInDb.Any())
                        {
                            var updatelist = new List<App_Sys_UserModel>();
                            foreach (var item in lawyersInDb)
                            {
                                var lawyerinfo = lawyers.FirstOrDefault(x => x.cardId == item.cardId);
                                if (lawyerinfo == null)
                                {
                                    continue;
                                }
                                if (item.name != lawyerinfo.name ||
                                    item.sex != lawyerinfo.sex ||
                                    item.phone != lawyerinfo.phone ||
                                    item.departmentName != lawyerinfo.departmentName ||
                                    item.cardId != lawyerinfo.cardId)
                                {
                                    item.name = lawyerinfo.name;
                                    item.sex = lawyerinfo.sex;
                                    item.phone = lawyerinfo.phone;
                                    item.departmentName = lawyerinfo.departmentName;
                                    item.cardId = lawyerinfo.cardId;
                                    updatelist.Add(item);
                                }
                            }
                            if (updatelist.Any())
                                updated = await _db.Updateable(updatelist)
                                    .IgnoreColumns(ignoreAllNullColumns: true)
                                    .ExecuteCommandAsync();
                        }
                        var addlawyers = lawyers.Where(x => lawyersInDb.Any(e => e.cardId == x.cardId) == false).ToList();

                        if (addlawyers.Any())
                            added = await _db.Insertable(addlawyers).ExecuteCommandAsync();

                        res.IsSucceed = true;
                        res.result = new
                        {
                            updated,
                            added
                        };
                    }
                    else
                    {
                        res.IsSucceed = false;
                        res.Message = "数据格式不正确";
                    }
                }
                else
                {
                    res.IsSucceed = false;
                    res.Message = "文件上传失败";
                }
            }
            else
            {
                res.IsSucceed = false;
                res.Message = "文件格式不支持";
            }
            if (System.IO.File.Exists(path))
                System.IO.File.Delete(path);
            return res;
        }
        /// <summary>
        /// 同步外网律师人员信息(未完成) (根据律师身份证号更新或新增用户信息)
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddLawyerInfo")]
        public async Task<Result> AddLawyer(App_Sys_AddLawyerInput input)
        {
            try
            {
                var data = await _db.Queryable<App_Sys_UserModel>().FirstAsync(x => x.cardId == input.cardId && x.IsDeleted == 0 && x.isdeactivate == 0);
                if (data != null)
                {
                    #region 为了避免律师先在一体机刷卡自动创建账号后无法添加律师身份的问题
                    if (data.identity != "律师")
                    {
                        data.identity = "律师";
                    }
                    try
                    {
                        _db.BeginTran();
                        var num = await _db.Updateable(data)
                            .WhereColumns(x => x.Id)
                            .IgnoreColumns(ignoreAllNullColumns: true)
                            .ExecuteCommandAsync();
                        _db.CommitTran();
                    }
                    catch (Exception ex)
                    {
                        logger.LogError(ex, "AddLawyer");
                    }
                    #endregion

                    result.IsSucceed = false;
                    result.Message = "用户已存在";
                    return result;
                }
                else
                {
                    var user = mapper.Map<App_Sys_UserModel>(input);
                    //user.name = input.name;
                    //user.phone = input.phone;
                    //user.cardId=input.cardId;
                    user.Id = Guid.NewGuid().ToString();
                    user.unitCode = _userdata.unitCode;
                    if (user.cardId.Length == 18)
                    {
                        user.sex = int.Parse(user.cardId.Substring(16, 1)) % 2;
                    }
                    user.sex = _userdata.sex;
                    user.usertype = 1;
                    user.isdeactivate = 0;
                    user.becurrent = 0;
                    user.IsDeleted = 0;
                    user.audit = 0;
                    user.createuserId = _userdata.Id;
                    user.createusername = _userdata.name;
                    user.createtime = DateTime.Now;
                    user.identity = "律师";

                    //insert
                    _db.BeginTran();
                    var num = await _db.Insertable(user).ExecuteCommandAsync();
                    _db.CommitTran();
                    if (num > 0)
                    {
                        result.IsSucceed = true;
                        result.Message = "添加成功";
                    }
                    else
                    {
                        result.IsSucceed = false;
                        result.Message = "添加失败";
                    }
                }
            }
            catch
            {
                result.IsSucceed = false;
            }
            return result;
        }
        /// <summary>
        /// 查询律师阅卷信息
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("QueryLawyerArchives")]
        public async Task<Result> QueryLawyerArchives([FromQuery] LawyerArchivesInput input)
        {
            RefAsync<int> totalNumber = 0;//总数据
            var starttime = input.StartTime ?? DateTime.Now.AddDays(-100);
            var endtime = input.EndTime ?? DateTime.Now;
            //查询律师服务
            var list = await _db.Queryable<LawyerArchives>()
                .WhereIF(string.IsNullOrEmpty(input.lawyerName) == false, x => x.lawyerName.Contains(input.lawyerName))
                .WhereIF(string.IsNullOrEmpty(input.party) == false, x => x.party.Contains(input.party))
                .WhereIF(string.IsNullOrEmpty(input.partyCardId) == false, x => x.partycardId == input.partyCardId)
                .WhereIF(string.IsNullOrEmpty(input.caseName) == false, x => x.casename.Contains(input.caseName))
                .WhereIF(string.IsNullOrEmpty(input.bmsah) == false, x => x.bmsah.Contains(input.bmsah))
                .Where(x => x.createTime.Value.Date >= starttime.Date && x.createTime.Value.Date <= endtime.Date)
                .Where(x => x.unitcode == input.unitCode)
                .WhereIF(input.Isdelete != null, x => x.IsDeleted == input.Isdelete)
                .OrderByDescending(x => x.createTime)
                .ToPageListAsync(input.PageIndex, input.PageSize, totalNumber);
            input.RowsCount = totalNumber;
            var data = new QueryResult<LawyerArchives>(input, list.OrderByDescending(q => q.createTime).ToList());
            result.IsSucceed = true;
            result.result = data;
            return result;
        }
        /// <summary>
        /// 新增阅卷信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddLawyerArchives")]
        public async Task<Result> AddLawyerArchives(LawyerArchivesDto dto)
        {
            try
            {
                var lawsvc =await _db.Queryable<App_LawyerServicesModel>().Where(x => x.Id == dto.lawyerserviceId).FirstAsync();
                if (lawsvc==null)
                {
                    return Result.Error("预约信息不存在");
                }
                if (lawsvc.IsAssigned==true)
                {
                    return Result.Error("当前预约信息已被分配");
                }

                var entity = mapper.Map<LawyerArchives>(dto);
                entity.Id = Guid.NewGuid().ToString();
                entity.createrId = _userdata.Id;
                entity.createTime = DateTime.Now;
                entity.status = 0;
                entity.copyStatus = 0;
                entity.IsDeleted = 0;

                lawsvc.IsAssigned = true;
                _db.BeginTran();
                _db.Updateable(lawsvc).UpdateColumns(x => x.IsAssigned).ExecuteCommand();
                var num = await _db.Insertable(entity).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.Message = "添加成功";
                    result.result = mapper.Map<LawyerArchivesDto>(entity);
                }
            }
            catch
            {
                result.IsSucceed = false;
            }
            return result;
        }
        /// <summary>
        /// 删除律师阅卷信息
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteLawyerArchives")]
        public async Task<Result> DeleteLawyerArchives(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var Deletelist = await _db.Queryable<LawyerArchives>().In(q => q.Id, Currency.id).ToListAsync();
                Deletelist.ForEach(q =>
                {
                    q.IsDeleted = 1;
                });
                var num = await _db.Updateable(Deletelist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
                LogService.WriteLog(ex, "删除律师阅卷预约");
            }
            _logs.WriteSysLogadd("律师阅卷服务", "删除律师阅卷预约", result, _db);
            return result;
        }
        /// <summary>
        /// 修改律师阅卷信息
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPut]
        [Route("UpdateLawyerArchives")]
        public async Task<Result> UpdateLawyerArchives(LawyerArchivesDto Lawyerdata)
        {
            try
            {
                var entity = mapper.Map<LawyerArchives>(Lawyerdata);
                _db.BeginTran();
                var num = await _db.Updateable(entity)
                    .WhereColumns(x => x.Id)
                    .IgnoreColumns(ignoreAllNullColumns: true)
                    .ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "修改成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
                LogService.WriteLog(ex, "删除律师阅卷预约");

            }
            _logs.WriteSysLogadd("律师阅卷服务", "删除律师阅卷预约", result, _db);
            return result;
        }
        /// <summary>
        /// 从2.0系统查询案件信息
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        /// <remarks>接口，还没有确定好这个接口返回的数据的具体格式</remarks>
        [HttpGet]
        [Route("QueryCaseFromtwenty")]
        public async Task<Result<QueryResult<CaseInfo>>> QueryCaseFromtwenty(string? bmsah, string? dwbm, string? casename, DateTime? starttime, DateTime? endtime, int page, int size)
        {
            return await twentyClient.GetCaseList(casename, bmsah, dwbm, starttime, endtime, page, size);
        }
        /// <summary>
        /// 从2.0系统查询卷宗信息
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        /// <remarks>数据的返回格式已确定，内容时真实数据经过修改的</remarks>
        [HttpGet]
        [Route("QueryFileFromtwenty")]
        public async Task<Result> QueryFileFromtwenty(string bmsah, string dwbm)
        {
            var reponse = await twentyClient.GetArchivesInfo(bmsah, dwbm);
            if (reponse.IsSucceed == true)
            {
                var a = reponse.result;
                if (a?.jzml?.Any() == true)
                {
                    var datd = new
                    {
                        id = a.Id,
                        lable = a.jzmc,
                        children = a.jzml.Where(x => x.fmlbh == null).OrderBy(x => x.mlsxh).Select(x => new
                        {
                            id = x.Id,
                            lable = x.mlxsmc,
                            children = a.jzml.Where(q => q.fmlbh == x.mlbh).OrderBy(q => q.mlsxh).Select(q => new
                            {
                                id = q.Id,
                                lable = q.mlxsmc,
                                children = q.jzwj.OrderBy(e => e.wjsxh).Select(e => new
                                {
                                    id = e.wjxh,
                                    lable = e.wjxsmc,
                                    filepath = e.jpgwjlj
                                })
                            })
                        })
                    };

                    result.IsSucceed = true;
                    result.result = datd;
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = "未找到对应的卷宗信息";

                }
            }
            else
            {
                result.IsSucceed = false;
                result.Message = reponse.Message;
            }
            return result;
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="bmsah">部门受案号</param>
        /// <param name="unitcode">单位编码</param>
        /// <param name="PartyIdCard">当事人身份证</param>
        /// <remarks>
        /// 查询当事人信息，如果返回的集合为0，提示 当事人信息不存在，请注意核实当事人信息
        /// request:安北检刑诉受[2023]410503000002号,410503,410502199606164872
        /// response:
        /// {
        ///  "result": {
        ///    "endRow": 1,
        ///    "firstPage": 1,
        ///    "hasNextPage": false,
        ///    "isFirstPage": true,
        ///    "isLastPage": true,
        ///    "lastPage": 1,
        ///    "list": [
        ///      {
        ///        "bmsah": "安北检刑诉受[2023]410503000002号",
        ///        "gjdm": "9911180200001",
        ///        "gjmc": "中国",
        ///        "mzdm": "9912180100001",
        ///        "mzmc": "汉族",
        ///        "xbdm": "9909180000001",
        ///        "xbmc": "男性",
        ///        "xm": "李四",
        ///        "zjhm": "410502199606164872",
        ///        "zjlxdm": "9910180300001",
        ///        "zjlxmc": "居民身份证",
        ///        "zrrbm": "4105030323000001",
        ///        "zrrlxdm": "0009000900001",
        ///        "zrrlxmc": "嫌疑人"
        ///      }
        ///    ],
        ///    "navigateFirstPage": 1,
        ///    "navigateLastPage": 1,
        ///    "navigatePages": 8,
        ///    "navigatepageNums": [
        ///      1
        ///    ],
        ///    "nextPage": 0,
        ///    "pageNum": 1,
        ///    "pageSize": 20,
        ///    "pages": 1,
        ///    "prePage": 0,
        ///    "size": 1,
        ///    "startRow": 1,
        ///    "total": 1
        ///  },
        ///  "IsSucceed": true,
        ///  "Message": "操作成功"
        ///}
        /// </remarks>
        /// <returns></returns>
        [HttpGet]
        [Route("QueryDsrList")]
        public async Task<Result<AjgldsrxxDto>> QueryDsrList(string bmsah, string unitcode, string PartyIdCard)
        {
            return await twentyClient.QueryDsrList(bmsah, unitcode, PartyIdCard);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="identityCardId">律师职业资格证书id</param>
        /// <remarks>
        /// 查询律师信息，如果返回的集合为0，提示 律师信息不存在，请注意核实律师信息
        /// 
        /// request：123445788876677
        /// repones:
        ///{
        ///  "result": {
        ///    "content": [
        ///      {
        ///        "cjsj": "2021-01-12T16:12:34.004+0800",
        ///        "djdwbm": "410403",
        ///        "djdwmc": "卫东区院",
        ///        "jmsfzh": "123345666777778",
        ///        "lxdh": null,
        ///        "lxdz": null,
        ///        "sfsc": "N",
        ///        "sjbsbh": "8cdbeb3ce3da483780b4e1acf60677e0",
        ///        "sjly": "3",
        ///        "sqrbh": "42b84c481b734f52b37d5b99157057f4",
        ///        "sqrlxdm": "1403187300001",
        ///        "sqrlxmc": "辩护人",
        ///        "sqrsfdm": "1404187300003",
        ///        "sqrsfmc": "律师",
        ///        "sqrxm": "张能能",
        ///        "szlssws": "河南千会律师事务所",
        ///        "tyshxydm": null,
        ///        "zbls": null,
        ///        "zhxgsj": "2021-01-21T15:10:51.982+0800",
        ///        "zjhm": "123445788876677",
        ///        "zjlxdm": "9910180300010",
        ///        "zjlxmc": "律师执业证",
        ///        "zyzh": null
        ///      }
        ///    ],
        ///    "empty": false,
        ///    "first": true,
        ///    "last": true,
        ///    "number": 0,
        ///    "numberOfElements": 1,
        ///    "pageable": {
        ///      "offset": 0,
        ///      "pageNumber": 0,
        ///      "pageSize": 20,
        ///      "paged": true,
        ///      "unpaged": false,
        ///      "sort": {
        ///        "empty": false,
        ///        "sorted": true,
        ///        "unsorted": false
        ///      }
        ///    },
        ///    "size": 20,
        ///    "sort": {
        ///    "empty": false,
        ///      "sorted": true,
        ///      "unsorted": false
        ///    },
        ///    "totalPages": 1,
        ///    "totalElements": 1
        ///  },
        ///  "IsSucceed": true,
        ///  "Message": "操作成功"
        ///}
        /// </remarks>
        /// <returns></returns>
        [HttpGet]
        [Route("QueryLsList")]
        public async Task<Result<FindSqrxxDto>> QueryLsList(string identityCardId)
        {
            return await twentyClient.QueryLsList(identityCardId);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="input"></param>
        /// <remarks>
        /// request
        ///{
        ///  "Bmsah": "安北检刑诉受[2023]410503000002号",
        ///  "UnitCode": "410503",
        ///  "UnitName": "北关区检",
        ///  "PartyIdCard": "410502199606164872",
        ///  "PartyConsignor": "李四",
        ///  "ProposerZJHM": "11111111111111111111111",
        ///  "ProposerType": "",
        ///  "ProposerTel": "123321",
        ///  "ProposerSCC": "12545",
        ///  "Wtr": "委托人",
        ///  "Wtrydsrgxdm": "1424000000100",
        ///  "Wtrydsrgxmc": "本人",
        ///  "Zbls": "",
        ///  "Lxdh": "",
        ///  "Lxdz": ""
        ///}
        /// 
        /// reponse
        /// {
        ///  "result": {
        ///    "ajcbdwbm": "410503",
        ///    "ajcbdwmc": "北关区检",
        ///    "ajmc": "李四涉嫌故意伤害案",
        ///    "bhdlbh": "2939f29f83dc4abaa6a1936014ebd46e",
        ///    "bmsah": "安北检刑诉受[2023]410503000002号",
        ///    "czr": "曲超艺",
        ///    "czrybm": "4105030058",
        ///    "dwbm": "410503",
        ///    "flyznr": "",
        ///    "sfagdj": "Y",
        ///    "sfflyz": "N",
        ///    "sqrbh": "53b591f325e34edcaf8ef097bb418a1e",
        ///    "wfwgqkdm": "",
        ///    "wfwgqkmc": "",
        ///    "wfwgqknr": "",
        ///    "wtr": "啦啦啦",
        ///    "wtrydsrgxdm": "1424000000200",
        ///    "wtrydsrgxmc": "近亲属",
        ///    "zbls": "string",
        ///    "zrrbm": "4105030323000001",
        ///    "bhdlYxSqrInsertInputDto": {
        ///      "djdwbm": "410423",
        ///      "djdwmc": "鲁山县院",
        ///      "jmsfzh": "123123193909161111",
        ///      "lxdh": "string",
        ///      "lxdz": "string",
        ///      "sfgxlsk": false,
        ///      "sqrlxdm": "1403187300001",
        ///      "sqrlxmc": "辩护人",
        ///      "sqrsfdm": "1404187300003",
        ///      "sqrsfmc": "律师",
        ///      "sqrxm": "王五",
        ///      "szlssws": "大润发律所",
        ///      "tyshxydm": null,
        ///      "zjhm": "112313113434314134134",
        ///      "zjlxdm": "9910180300010",
        ///      "zjlxmc": "律师执业证"
        ///    }
        ///  },
        ///  "IsSucceed": true,
        ///  "Message": null
        ///}
        ///</remarks>
        /// <returns></returns>
        [HttpPost]
        [Route("Register")]
        public async Task<Result<SaveBhdlDjxxDto>> Register(RegisterDto input)
        {
            return await twentyClient.Register(input);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="input"></param>
        /// <remarks>
        /// request:{
        ///  "bhdlbh": "2939f29f83dc4abaa6a1936014ebd46e",
        ///  "bmsah": "安北检刑诉受[2023]410503000002号",
        ///  "clqkbm": "",
        ///  "clqkmc": "",
        ///  "czr": "曲超艺",
        ///  "czrybm": "4105030058",
        ///  "dwbm": "410503",
        ///  "jwgksxid": "",
        ///  "sqrlxdm": "1403187300001",
        ///  "sqrmc": "王五",
        ///  "sqrq": "2023-11-30",
        ///  "sqrsfdm": "1404187300003",
        ///  "sxlxdm": "1405187400001",
        ///  "sxlxmc": "申请阅卷",
        ///  "zrrmc": "李四"
        ///}
        /// reponse:
        /// {
        ///  "result": {
        ///    "ApplyMarKingDto": {
        ///      "bhdlbh": "e027a707f262435d9fc29b080101beed",
        ///      "bmsah": "安北检刑诉受[2023]410503000002号",
        ///      "clqkbm": "",
        ///      "clqkmc": "",
        ///      "czr": "曲超艺",
        ///      "czrybm": "4105030058",
        ///      "dwbm": "410503",
        ///      "jwgksxid": "",
        ///      "sqrlxdm": "1403187300001",
        ///      "sqrmc": "辩护人",
        ///      "sqrq": "2023-11-30",
        ///      "sqrsfdm": "1404187300003",
        ///      "sxlxdm": "1405187400001",
        ///      "sxlxmc": "申请阅卷",
        ///      "zrrmc": "李四"
        ///    },
        ///    "sxbh": "5d89f1bd6df142aeb6d4d7582116811a"
        ///  },
        ///  "IsSucceed": true,
        ///  "Message": null
        ///}
        ///</remarks>
        /// <returns></returns>
        [HttpPost]
        [Route("ApplyMarKing")]
        public async Task<Result<ApplyMarKingBackDto>> ApplyMarKing(ApplyMarKingDto input)
        {
            return await twentyClient.ApplyMarKing(input);
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="input"></param>
        /// <remarks>
        /// request
        /// {
        ///  "bhdlbh": "2939f29f83dc4abaa6a1936014ebd46e",
        ///  "bmsah": "安北检刑诉受[2023]410503000002号",
        ///  "dwbm": "410503",
        ///  "fydysl": "",
        ///  "fzfsdm": "",
        ///  "fzfsmc": "",
        ///  "jzztxsdm": "",
        ///  "jzztxsmc": "",
        ///  "sxbh": "5d89f1bd6df142aeb6d4d7582116811a",
        ///  "yjfsdm": "",
        ///  "yjfsmc": "",
        ///  "yjjzsj": "2023-11-30",
        ///  "yjkssj": "2023-12-30"
        ///}
        ///
        ///reponse true 流程结束
        ///</remarks>
        /// <returns></returns>
        [HttpPost]
        [Route("Arrange")]
        public async Task<Result> Arrange(ArrangeDto input)
        {
            return await twentyClient.Arrange(input);
        }
        /// <summary>
        /// 上传数据只2.0系统
        /// </summary>
        /// <param name="lawyerarchivesId"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UploadDataToTwentyfourSys")]
        public async Task<Result> UploadDataToTwentyfourSys(string lawyerarchivesId)
        {
            try
            {
                var lawyerArchives = await _db.Queryable<LawyerArchives>().Where(x => x.Id == lawyerarchivesId).FirstAsync();
                var lawyersvc = await _db.Queryable<App_LawyerServicesModel>().Where(x => x.Id == lawyerArchives.Id).FirstAsync();
                var lawyer = await _db.Queryable<App_Sys_UserModel>().Where(x => x.Id == lawyerArchives.lawyerId).FirstAsync();
                var departmenginfo = await _db.Queryable<App_Sys_UnitModel>().Where(x => x.unitCode == _userdata.unitCode).FirstAsync();
                logger.LogInformation($"get lawyerarchivesinfo:{lawyerArchives.ConvertToJsonStr()}");
                logger.LogInformation($"get lawyersvcinfo:{lawyersvc.ConvertToJsonStr()}");
                logger.LogInformation($"get lawyerinfo:{lawyer.ConvertToJsonStr()}");
                logger.LogInformation($"get departmenginfo:{departmenginfo.ConvertToJsonStr()}");
                var UnitCode = _userdata.unitCode;
                var UnitName = departmenginfo.unitjc;
                var querylawyer = await QueryLsList(lawyer.identitycardId);
                #region 数据检查
                if (querylawyer.IsSucceed == true)
                {
                    if (querylawyer.result.content.Count <= 0)
                    {
                        result.IsSucceed = false;
                        result.Message = "案管系统不存在该律师信息，请注意核实律师信息";
                        return result;
                    }
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = "数据上传案管系统失败,查询律师信息失败";
                    return result;
                }

                var querydsr = await QueryDsrList(lawyerArchives.bmsah, UnitCode, lawyersvc.partyIDcard);
                if (querydsr.IsSucceed == true)
                {
                    if (querydsr.result.list.Count <= 0)
                    {
                        result.IsSucceed = false;
                        result.Message = "案管系统不存在该律师信息，请注意核实律师信息";
                        return result;
                    }
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = "数据上传案管系统失败,查询当事人信息失败";
                    return result;
                }
                if (lawyerArchives == null)
                {
                    result.IsSucceed = false;
                    result.Message = "分配数据不存在";
                    return result;
                }
                if (lawyersvc == null)
                {
                    result.IsSucceed = false;
                    result.Message = "预约数据不存在";
                    return result;
                }
                if (lawyer == null)
                {
                    result.IsSucceed = false;
                    result.Message = "律师数据不存在";
                    return result;
                }
                #endregion
                var registerinforequest = await Register(new RegisterDto()
                {
                    Bmsah = lawyerArchives.bmsah,
                    UnitCode = UnitCode,
                    UnitName = UnitName,
                    PartyIdCard = lawyersvc.partyIDcard,
                    PartyConsignor = lawyersvc.party,
                    ProposerZJHM = lawyer.identitycardId,
                    ProposerType = "",
                    ProposerTel = lawyer.phone,
                    ProposerSCC = lawyer.departmentUnifiedSocialCreditCode,
                    Wtr = lawyersvc.mandator,
                    Wtrydsrgxdm = lawyersvc.relationship switch
                    {
                        "监护人" => "1424000000300",
                        "近亲属" => "1424000000200",
                        _ => "1424000000100"
                    },
                    Wtrydsrgxmc = lawyersvc.relationship switch
                    {
                        "监护人" => "监护人",
                        "近亲属" => "近亲属",
                        _ => "本人"
                    },
                    Zbls = "",
                    Lxdh = "",
                    Lxdz = ""

                });
                if (registerinforequest.IsSucceed == true)
                {
                    var registerinfo = registerinforequest.result;
                    var applymarkingrequest = await ApplyMarKing(new()
                    {
                        bhdlbh = registerinfo.bhdlbh,
                        bmsah = registerinfo.bmsah,
                        clqkbm = "",
                        clqkmc = "",
                        czr = registerinfo.czr,
                        czrybm = registerinfo.czrybm,
                        dwbm = registerinfo.dwbm,
                        jwgksxid = "",
                        sqrlxdm = registerinfo.bhdlYxSqrInsertInputDto.sqrlxdm,
                        sqrmc = registerinfo.bhdlYxSqrInsertInputDto.sqrxm,
                        sqrq = DateTime.Now.ToString("yyyy-MM-dd"),
                        sqrsfdm = registerinfo.bhdlYxSqrInsertInputDto.sqrsfdm,
                        sxlxdm = "1405187400001",
                        sxlxmc = "申请阅卷",
                        zrrmc = lawyersvc.party
                    });

                    if (applymarkingrequest.IsSucceed == true)
                    {
                        var applymarkinginfo = applymarkingrequest.result;
                        var Arrangerequest = await Arrange(new ArrangeDto()
                        {
                            bhdlbh = registerinfo.bhdlbh,
                            bmsah = registerinfo.bmsah,
                            dwbm = registerinfo.dwbm,
                            fydysl = "",
                            fzfsdm = "",
                            fzfsmc = "",
                            jzztxsdm = "",
                            jzztxsmc = "",
                            sxbh = applymarkinginfo.sxbh,
                            yjfsdm = "",
                            yjfsmc = "",
                            yjjzsj = lawyerArchives.permissibleStartTime?.ToString("yyyy-MM-dd"),
                            yjkssj = lawyerArchives.permissibleEndTime?.ToString("yyyy-MM-dd"),
                        });
                        if (Arrangerequest.IsSucceed == true)
                        {
                            result.IsSucceed = true;
                            result.Message = "数据上传案管系统成功";
                            return result;
                        }
                        else
                        {
                            result.IsSucceed = false;
                            result.Message = "数据上传案管系统失败，申请阅卷添加失败";
                            return result;
                        }
                    }
                    else
                    {
                        result.IsSucceed = false;
                        result.Message = "数据上传案管系统失败，申请添加失败";
                        return result;
                    }
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = "数据上传案管系统失败，登记添加失败";
                    return result;
                }
            }
            catch (Exception ex)
            {
                logger.LogInformation(ex.Message);
                result.IsSucceed = false;
                result.Message = "数据上传案管系统失败";
                return result;
            }
        }
        /// <summary>
        /// PC端根据卷宗id获取卷宗信息
        /// </summary>
        /// <param name="jzid"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("QueryArchiveByIdPC")]
        public async Task<Result> QueryArchiveByIdPC(string jzid)
        {
            var list = await _db.Queryable<JZJBXX>()
                   .Includes(x => x.jzml.OrderBy(x => x.mlsxh).ToList())
                   .Includes(x => x.jzml, x => x.jzwj.OrderBy(x => x.wjsxh).ToList())
                   .FirstAsync(x => x.Id == jzid);
            if (list != null)
            {
                var a = mapper.Map<JZJBXXDto>(list);
                var datd = new
                {
                    id = a.Id,
                    lable = a.jzmc,
                    children = a.jzml.Where(x => x.fmlbh == null).OrderBy(x => x.mlsxh).Select(x => new
                    {
                        id = x.mlbh,
                        lable = x.mlxsmc,
                        children = a.jzml.Where(q => q.fmlbh == x.mlbh).OrderBy(q => q.mlsxh).Select(q => new
                        {
                            id = q.mlbh,
                            lable = q.mlxsmc,
                            children = q.jzwj.OrderBy(e => e.wjsxh).Select(e => new
                            {
                                id = e.wjxh,
                                lable = e.wjxsmc,
                                filepath = e.jpgwjlj
                            })
                        })
                    })
                };

                result.IsSucceed = true;
                result.result = datd;
            }
            else
            {
                result.IsSucceed = false;
                result.Message = "卷宗不存在";
            }
            return result;
        }
        /// <summary>
        /// 上传已选中的第三级页码的id
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <remarks>
        /// {
        ///     "IsSucceed": false,
        ///     "Message": null,
        ///     "result": "9f272d7f-2b66-4314-95a3-ca4e0de2b1ec"
        /// }
        ///返回的id 用于在调用 AddLawyerArchives 传入jzlbxxId
        /// </remarks>
        [HttpPost("AddArchivesInfoByChildId")]
        public async Task<Result> AddArchivesInfoByChildId(AddArchivesInfoInput input)
        {
            try
            {
                var reponse = await twentyClient.GetArchivesInfo(input.Bmsah, _userdata.unitCode);
                if (reponse.IsSucceed == true)
                {
                    var dto = reponse.result;
                    //先将没有被选中的第三级文件排除
                    foreach (var item in dto.jzml)
                    {
                        item.jzwj = item.jzwj.Where(x => input.Ids.Contains(x.wjxh)).ToList();
                    }
                    //再排除没有文件的目录信息
                    //这样筛选后获取的数据就可以保证不会出现空子节点的父节点
                    //dto.jzml = dto.jzml.Where(x => x.jzwj.Any() || x.fmlbh == null).ToList();
                    //var fml = dto.jzml.Where(x => x.fmlbh == null);

                    var hasfileslist = dto.jzml.Where(x => x.jzwj.Any()).ToList();
                    var fmllist = dto.jzml.Where(x => string.IsNullOrEmpty(x.fmlbh) && hasfileslist.Any(q => q != null && q.fmlbh == x.mlbh));

                    dto.jzml = hasfileslist.Concat(fmllist).Distinct().ToList();
                    var insert = await AddArchivesInfo(dto);
                    result.result = insert.result.Id;
                    result.IsSucceed = true;
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = reponse.Message;
                }

            }
            catch (Exception ex)
            {
                result.IsSucceed = false;
                result.Message = ex.Message;
                logger.LogError(ex, "AddArchivesInfoByChildId");
            }
            return result;
        }
        /// <summary>
        /// 一体机 根据卷宗id获取详细的卷宗信息
        /// </summary>
        /// <param name="jzid"></param>
        /// <returns></returns>
        [HttpGet("QueryArchiveById")]
        public async Task<Result> QueryArchiveById(string jzid)
        {
            try
            {
                var list = await _db.Queryable<JZJBXX>()
                    .Includes(x => x.jzml.OrderBy(x => x.mlsxh).ToList())
                    .Includes(x => x.jzml, x => x.jzwj.OrderBy(x => x.wjsxh).ToList())
                    .FirstAsync(x => x.Id == jzid);

                var data = mapper.Map<JZJBXXDto>(list);

                result.result = data;
                result.IsSucceed = true;
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "QueryArchiveById");
            }
            return result;
        }
        /// <summary>
        /// 一体机查询当前用户已有的 被同意的 预约阅卷信息
        /// </summary>
        /// <returns></returns>
        [HttpGet("QueryReservedInfo")]
        public async Task<Result> QueryReservedInfo()
        {
            try
            {
                logger.LogInformation("12312312312");
                var list = await _db.Queryable<LawyerArchives>()
                  .Where(x => x.lawyerId == _userdata.Id)
                  .Where(x => x.status == 0 || x.status == 1)
                  .Where(x => x.permissibleStartTime <= DateTime.Now && x.permissibleEndTime >= DateTime.Now)
                  .Where(x => x.IsDeleted == 0)
                  .ToListAsync();

                var data = mapper.Map<IEnumerable<LawyerArchivesDto>>(list);
                result.result = data;
                result.IsSucceed = true;
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "QueryReservedInfo");
            }
            return result;
        }
        /// <summary>
        /// 统计律师名下的预约信息
        /// </summary>
        /// <param name="lawyerId"></param>
        /// <returns></returns>
        [HttpGet("QueryLawyerReservedInfo")]
        public async Task<Result> QueryLawyerReservedInfo(string? lawyerId)
        {
            try
            {
                var list = await _db.Queryable<LawyerArchives>()
                  .Where(x => x.lawyerId == lawyerId)
                  .Where(x => x.status == 0 || x.status == 1)
                  .Where(x => x.IsDeleted == 0)
                  .ToListAsync();

                var data = mapper.Map<IEnumerable<LawyerArchivesDto>>(list);
                result.result = data;
                result.IsSucceed = true;
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "QueryReservedInfo");
            }
            return result;
        }
        #endregion
        #region HiddenApi
        /// <summary>
        /// 添加卷宗信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HiddenApi]
        [HttpPost]
        [Route("AddArchivesInfo")]
        public async Task<Result<JZJBXXDto>> AddArchivesInfo(JZJBXXDto dto)
        {
            Result<JZJBXXDto> res = new Result<JZJBXXDto>();
            try
            {
                var data = mapper.Map<JZJBXX>(dto);
                var mls = dto.jzml.ToList();
                var vloum = mapper.Map<List<JZML>>(mls);
                var wjs = dto.jzml.SelectMany(x => x.jzwj).ToList();
                var files = mapper.Map<List<JZWJItem>>(wjs);

                _db.BeginTran();
                var num = await _db.Insertable(data).ExecuteCommandAsync();
                var add = await _db.Insertable(vloum).ExecuteCommandAsync();
                var addwj = await _db.Insertable(files).ExecuteCommandAsync();
                _db.CommitTran();
                res.result = dto;
                return res;
            }
            catch (Exception ex)
            {
                logger.LogError(ex, "AddArchivesInfo");
                result.IsSucceed = false;
                return res;
            }
        }
        /// <summary>
        /// 统计 总数 已读的 未读的 刻录
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("Countinfo")]
        public async Task<Result> Countinfo()
        {
            try
            {
                var registerCount = await _db.Queryable<LawyerArchives>().Where(x => x.unitcode == _userdata.unitCode).CountAsync(x => x.IsDeleted == 0);
                var readcount = await _db.Queryable<LawyerArchives>().Where(x => x.unitcode == _userdata.unitCode).CountAsync(x => x.IsDeleted == 0 && x.status != 0);
                var unreadcount = await _db.Queryable<LawyerArchives>().Where(x => x.unitcode == _userdata.unitCode).CountAsync(x => x.IsDeleted == 0 && x.status == 0);
                var burnedcount = await _db.Queryable<LawyerArchives>().Where(x => x.unitcode == _userdata.unitCode).CountAsync(x => x.IsDeleted == 0 && (x.copyStatus == 2 || x.copyStatus == 3));

                result.result = new
                {
                    registerCount = registerCount,
                    readcount = readcount,
                    unreadcount = unreadcount,
                    burnedcount = burnedcount,
                };
                result.IsSucceed = true;
            }
            catch
            {
                result.result = new
                {
                    registerCount = 0,
                    readcount = 0,
                    unreadcount = 0,
                    burnedcount = 0,
                };
                result.IsSucceed = false;
            }
            return result;
        }
        /// <summary>
        /// 统计近7天阅卷登记情况
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("CountRegistSevendays")]
        public async Task<Result> CountRegistSevendays()
        {
            try
            {
                int dayscount = 7;
                var days = Enumerable.Range(0, dayscount).Select(x => DateTime.Now.AddDays(-x).Date).ToList();
                var registerCount = await _db.Queryable<LawyerArchives>()
                    .Where(x => x.createTime.Value.Date >= days[dayscount - 1] && x.createTime.Value.Date <= days[0])
                    .Where(x => x.unitcode == _userdata.unitCode)
                    .Where(x => x.IsDeleted == 0)
                    .ToListAsync();
                var data = registerCount
                    .GroupBy(x => x.createTime.Value.Date)
                    .ToDictionary(x => x.Key, x => x.Count());
                foreach (var item in days)
                {
                    if (data.ContainsKey(item) == false)
                    {
                        data.Add(item, 0);
                    }
                }
                var res = data.OrderBy(x => x.Key).Select(x => new
                {
                    date = x.Key.ToShortDateString(),
                    count = x.Value
                }).ToList();
                result.result = res;
                result.IsSucceed = true;
            }
            catch
            {
                result.IsSucceed = false;
            };
            return result;
        }
        /// <summary>
        /// 统计阅卷信息
        /// </summary>
        /// <param name="stime">开始时间</param>
        /// <param name="etime">结束时间</param>
        /// <param name="groupby">分类类型 有效值：year，month,day</param>
        /// <returns></returns>
        [HttpGet]
        [Route("CountReadStatusByTime")]
        public async Task<Result> CountReadStatusByTime(DateTime? stime, DateTime? etime, string groupby)
        {
            #region 入参校验
            DateTime starttime = stime == null ? DateHelper.GetStartDateOfDay(DateTime.Now.AddDays(-30)) : stime.Value;
            DateTime endtime = etime == null ? DateHelper.GetEndDateOfDay(DateTime.Now) : etime.Value;
            if (string.IsNullOrEmpty(groupby) || (groupby.ToLower() != "year" && groupby.ToLower() != "month" && groupby.ToLower() != "day"))
            {
                groupby = "day";
            }
            #endregion
            try
            {
                #region 根据入参获取查询区间
                var dates = new List<DateTime>();
                DateTime start, end;
                switch (groupby)
                {
                    case "year":
                        dates = DateHelper.GetArrayByYear(starttime, endtime);
                        start = DateHelper.GetStartDateOfYear(starttime);
                        end = DateHelper.GetEndDateOfYear(endtime);
                        break;
                    case "month":
                        dates = DateHelper.GetArrayByMonth(starttime, endtime);
                        start = DateHelper.GetStartDateOfMonth(starttime);
                        end = DateHelper.GetEndDateOfMonth(endtime);
                        break;
                    default:
                        dates = DateHelper.GetArrayByDay(starttime, endtime);
                        start = DateHelper.GetStartDateOfDay(starttime);
                        end = DateHelper.GetEndDateOfDay(endtime);
                        break;
                }
                #endregion
                #region 查询已经阅卷的统计信息

                var readedlist = await Task.Run(async () =>
                {
                    var registerCount = await _db.Queryable<LawyerArchives>()
                    .Where(x => x.status != 0)
                    .Where(x => x.actualStartTime != null && x.actualStartTime >= start)
                    .Where(x => x.actualStartTime != null && x.actualStartTime <= end)
                    .Where(x => x.unitcode == _userdata.unitCode)
                    .Where(x => x.IsDeleted == 0)
                    .ToListAsync();
                    var groupedlist = groupby switch
                    {
                        "year" => registerCount.GroupBy(x => DateHelper.GetStartDateOfYear(x.actualStartTime.Value))
                                               .ToDictionary(x => x.Key, x => x.Count()),
                        "month" => registerCount.GroupBy(x => DateHelper.GetStartDateOfMonth(x.actualStartTime.Value))
                                               .ToDictionary(x => x.Key, x => x.Count()),
                        _ => registerCount.GroupBy(x => x.actualStartTime.Value.Date)
                                               .ToDictionary(x => x.Key, x => x.Count())
                    };
                    foreach (var item in dates)
                    {
                        if (groupedlist.ContainsKey(item) == false)
                        {
                            groupedlist.Add(item, 0);
                        }
                    }
                    var res = groupedlist.OrderBy(x => x.Key).Select(x => new
                    {
                        name = groupby switch
                        {
                            "year" => x.Key.ToString("yyyy"),
                            "month" => x.Key.ToString("yyyy-MM"),
                            _ => x.Key.ToString("yyyy-MM-dd")
                        },
                        value = x.Value
                    }).ToList();
                    return res;
                });
                #endregion
                #region 根据查阅状态进行分组
                var groupbystatus = await Task.Run(async () =>
                        {
                            var registerCount = await _db.Queryable<LawyerArchives>()
                               .Where(x => x.createTime != null && x.createTime >= start)
                               .Where(x => x.createTime != null && x.createTime <= end)
                               .Where(x => x.unitcode == _userdata.unitCode)
                               .Where(x => x.IsDeleted == 0)
                               .Where(x => x.status != null)
                               .ToListAsync();

                            var a = registerCount.GroupBy(x => x.status)
                                                 .ToDictionary(x => x.Key, x => x.Count());

                            var res = a.Select(x => new
                            {
                                name = x.Key switch
                                {
                                    0 => "待查阅",
                                    1 => "查阅中",
                                    2 => "已查阅",
                                    _ => "待查阅"
                                },
                                value = x.Value
                            }).ToList();
                            return res;
                        });
                #endregion
                #region 根据案件类型进行分组

                var groupbycasetype = await Task.Run(async () =>
                {
                    var registerCount = await _db.Queryable<LawyerArchives>()
                   .Where(x => x.createTime != null && x.createTime >= start)
                   .Where(x => x.createTime != null && x.createTime <= end)
                   .Where(x => x.unitcode == _userdata.unitCode)
                   .Where(x => x.IsDeleted == 0)
                   .Where(x => x.status != null)
                   .LeftJoin<JZJBXX>((x, e) => x.jzlbxxId == e.Id)
                   .GroupBy((x, e) => new { e.ajlbmc })
                   .Select((x, e) => new
                   {
                       name = e.ajlbmc,
                       value = SqlFunc.AggregateCount(e.ajlbmc)
                   })
                   .Take(10)
                   .ToListAsync();

                    if (registerCount.Count >= 10)
                    {
                        var excount = registerCount.Sum(x => x.value);
                        var allCount = await _db.Queryable<LawyerArchives>()
                                       .Where(x => x.createTime != null && x.createTime >= start)
                                       .Where(x => x.createTime != null && x.createTime <= end)
                                       .Where(x => x.unitcode == _userdata.unitCode)
                                       .Where(x => x.IsDeleted == 0)
                                       .Where(x => x.status != null)
                                       .CountAsync();
                        if (allCount > excount)
                        {
                            var list = new[]
                            {
                                new
                                {
                                    name = "其他",
                                    value = allCount-excount,
                                }
                            };
                            registerCount.AddRange(list);
                        }
                    }
                    return registerCount;
                });
                #endregion

                result.IsSucceed = true;
                result.result = new
                {
                    GroupByReadStatus = readedlist,
                    GroupByStatus = groupbystatus,
                    GroupByType = groupbycasetype
                };
            }
            catch
            {
                result.IsSucceed = false;
            };
            return result;
        }
        /// <summary>
        /// 按律师分类
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("CountByLawyer")]
        public async Task<Result> CountByLawyer()
        {
            try
            {
                // var allcount = await _db.Queryable<LawyerArchives>().CountAsync();
                var registerCount = await _db.Queryable<LawyerArchives>()
                    .LeftJoin<App_Sys_UserModel>((it, user) => it.lawyerId == user.Id)
                       .GroupBy((it, user) => new { it.lawyerId }).Select((it, user) => new
                       {
                           name = user.name,
                           cardId = user.cardId,
                           departmentName = user.departmentName,
                           value = (double)SqlFunc.AggregateCount(it.lawyerId)
                           //  count = (double)SqlFunc.AggregateCount(it.lawyerId) / (double)allcount
                       }).Take(10).ToListAsync();
                result.result = registerCount;
                result.IsSucceed = true;
            }
            catch (Exception ex)
            {
                result.IsSucceed = true;
                result.Message = "查询异常";
                logger.LogError(ex, "CountByLawyer");
            }
            return result;
        }
        /// <summary>
        /// 按卷宗案件类型分类
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("CountByCaseType")]
        public async Task<Result> CountByCaseType()
        {
            try
            {
                // var allcount = await _db.Queryable<JZJBXX>().CountAsync();
                var registerCount = await _db.Queryable<JZJBXX>()
                       .GroupBy(it => new { it.ajlbmc }).Select(it => new
                       {
                           name = it.ajlbmc,
                           value = SqlFunc.AggregateCount(it.ajlbmc)
                           //count = (double)SqlFunc.AggregateCount(it.ajlbmc) / (double)allcount
                       }).ToListAsync();
                result.result = registerCount;
                result.IsSucceed = true;
            }
            catch
            {

            }
            return result;
        }
        /// <summary>
        /// 同步外网预约信息（不需要调用此接口） 
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [HiddenApi]
        [Route("AddLawyerServiceInfo")]
        public async Task<Result> AddLawyerServiceInfo(App_LawyerServicesModel info)
        {
            var data = await _db.Queryable<App_LawyerServicesModel>().FirstAsync(x => x.Id == info.Id);
            if (data != null)
            {
                result.IsSucceed = true;
                result.Message = "改数据已同步";
                return result;
            }
            else
            {
                _db.BeginTran();
                var num = await _db.Insertable(info).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.Message = "添加成功";
                    result.result = mapper.Map<LawyerArchivesDto>(info);
                    return result;
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = "添加失败";
                    return result;
                }
            }
        }
        /// <summary>
        /// 加密字符串信息
        /// </summary>
        /// <param name="idcard"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("EncodeData")]
        public Task<Result<string>> EncodeData()
        {
            var str = $"{_userdata.cardId},{_userdata.name}";
            Result<string> result = new();
            result.result = Convert.ToBase64String(Encoding.UTF8.GetBytes(str));
            result.IsSucceed = true;

            return Task.FromResult(result);
        }
        /// <summary>
        /// 导入律师信息
        /// </summary>
        /// <param name="path"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("ImportLawyerArchivesInfo")]
        public async Task<Result> ImportLawyerArchivesInfo(string path)
        {
            try
            {
                if (System.IO.File.Exists(path) == false)
                {
                    result.Message = "文件丢失";
                    result.IsSucceed = false;
                    return result;
                }
                var dir = Path.Combine(Environment.CurrentDirectory, "wwwroot", "CaseFile", "imports");
                var userdir = Path.Combine(dir, "users");
                var lawyersvcs = Path.Combine(dir, "lawyersvcs");

                var extratname = Path.GetFileNameWithoutExtension(path);
                var extratdirpath = Path.Combine(dir, extratname);
                ZipFile.ExtractToDirectory(path, extratdirpath, true);
                var zipusers = Path.Combine(extratdirpath, "users");
                var ziplawyersvcs = Path.Combine(extratdirpath, "lawyerservices");
                var zipjson = Path.Combine(extratdirpath, "data");
                if (System.IO.File.Exists(zipjson) == false)
                {
                    result.Message = "文件丢失";
                    result.IsSucceed = false;
                    return result;
                }
                var json = System.IO.File.ReadAllText(zipjson);

                var jsonstr = Encoding.UTF8.GetString(Convert.FromBase64String(json));

                var importdata = jsonstr.ConvertToAnonymousType(new
                {
                    lawyerservices = default(List<App_LawyerServicesModel>),
                    users = default(List<App_Sys_UserModel>)
                });
                foreach (var userim in importdata.users.Where(x => x != null))
                {
                    var user = await _db.Queryable<App_Sys_UserModel>()
                        .Where(x => x.cardId == userim.cardId)
                        .Where(x => x.IsDeleted == 0)
                        .Where(x => x.isdeactivate == 0)
                        .Where(x => x.identity == "律师")
                        .FirstAsync();
                    var identityphotopath = Path.Combine(zipusers, userim.cardId, "identityphotos");
                    var files = new DirectoryInfo(identityphotopath)
                        .GetFiles()
                        .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                        .Replace(@"\", @"/"))
                        .ToList()
                        .ConvertToJsonStr();

                    var departmentPhotos = Path.Combine(zipusers, userim.cardId, "departmentPhotos");
                    var departments = new DirectoryInfo(departmentPhotos)
                        .GetFiles()
                        .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                        .Replace(@"\", @"/"))
                        .ToList()
                        .ConvertToJsonStr();

                    var cardidphotos = Path.Combine(zipusers, userim.cardId, "cardids");
                    var cardids = new DirectoryInfo(cardidphotos)
                        .GetFiles()
                        .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                        .Replace(@"\", @"/"))
                        .ToList()
                        .ConvertToJsonStr();

                    if (user == null)
                    {
                        userim.cardIdphoto = cardids;
                        userim.identityphoto = files;
                        userim.departmentPhoto = departments;
                        userim.unitCode = _userdata.unitCode;
                        _db.BeginTran();
                        var num = await _db.Insertable(userim).ExecuteCommandAsync();
                        _db.CommitTran();
                    }
                    else
                    {
                        user.cardIdphoto = cardids;
                        user.identityphoto = files;
                        user.departmentPhoto = departments;
                        user.unitCode = _userdata.unitCode;
                        _db.BeginTran();
                        var num = await _db.Updateable(user)
                            .UpdateColumns(x => new
                            {
                                x.cardIdphoto,
                                x.identityphoto,
                                x.departmentPhoto,
                                x.unitCode,
                            })
                            .IgnoreColumns(ignoreAllNullColumns: true)
                            .ExecuteCommandAsync();
                        _db.CommitTran();
                    }
                }
                foreach (var lawyersvc in importdata.lawyerservices.Where(x => x != null))
                {
                    var svc = await _db.Queryable<App_LawyerServicesModel>()
                        .Where(x => x.Id == lawyersvc.Id).FirstAsync();

                    var annexphoto = Path.Combine(ziplawyersvcs, lawyersvc.Id, "annexs");
                    var annexs = new DirectoryInfo(annexphoto)
                        .GetFiles()
                        .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                        .Replace(@"\", @"/"))
                        .ToList()
                        .ConvertToJsonStr();


                    var legalAidPhoto = Path.Combine(ziplawyersvcs, lawyersvc.Id, "legalAidPhoto");
                    var legalAidPhotos = new DirectoryInfo(legalAidPhoto)
                        .GetFiles()
                        .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                        .Replace(@"\", @"/"))
                        .ToList()
                        .ConvertToJsonStr();

                    var relationshipProofPhoto = Path.Combine(ziplawyersvcs, lawyersvc.Id, "relationshipProofPhoto");
                    var relationshipProofPhotos = new DirectoryInfo(relationshipProofPhoto)
                        .GetFiles()
                        .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                        .Replace(@"\", @"/"))
                        .ToList()
                        .ConvertToJsonStr();

                    var otherPhoto = Path.Combine(ziplawyersvcs, lawyersvc.Id, "otherPhoto");
                    var otherPhotos = new DirectoryInfo(otherPhoto)
                        .GetFiles()
                        .Select(x => "/CaseFile/imports/" + Path.GetRelativePath(dir, x.FullName)
                        .Replace(@"\", @"/"))
                        .ToList()
                        .ConvertToJsonStr();

                    if (svc == null)
                    {
                        var lawyer = await _db.Queryable<App_Sys_UserModel>()
                        .Where(x => x.cardId == lawyersvc.createuserId)
                        .Where(x => x.IsDeleted == 0)
                        .Where(x => x.isdeactivate == 0)
                        .Where(x => x.identity == "律师")
                        .FirstAsync();

                        lawyersvc.createuserId = lawyer.Id;
                        lawyersvc.annex = annexs;
                        lawyersvc.legalAidPhoto = legalAidPhotos;
                        lawyersvc.relationshipProofPhoto = relationshipProofPhotos;
                        lawyersvc.otherPhoto = otherPhotos;

                        _db.BeginTran();
                        var num = await _db.Insertable(lawyersvc).ExecuteCommandAsync();
                        _db.CommitTran();
                    }
                    else
                    {
                        var lawyer = await _db.Queryable<App_Sys_UserModel>()
                       .Where(x => x.cardId == lawyersvc.createuserId)
                       .Where(x => x.IsDeleted == 0)
                       .Where(x => x.isdeactivate == 0)
                       .Where(x => x.identity == "律师")
                       .FirstAsync();

                        svc.createuserId = lawyer.Id;
                        svc.annex = annexs;
                        svc.legalAidPhoto = legalAidPhotos;
                        svc.relationshipProofPhoto = relationshipProofPhotos;
                        svc.otherPhoto = otherPhotos;
                        _db.BeginTran();
                        var num = await _db.Updateable(svc)
                            .UpdateColumns(x => new
                            {
                                x.annex,
                                x.createuserId,
                                x.relationshipProofPhoto,
                                x.otherPhoto,
                                x.legalAidPhoto
                            })
                            .IgnoreColumns(ignoreAllNullColumns: true)
                            .ExecuteCommandAsync();
                        _db.CommitTran();
                    }
                }
            }
            catch (Exception ex)
            {
                result.Message = ex.Message;
                result.IsSucceed = false;
                return result;
            }
            result.IsSucceed = true;
            return result;
        }
        /// <summary>
        /// 导出律师信息
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("ExportLawyerArchivesInfo")]
        public async Task<Result> ExportLawyerArchivesInfo(List<string> ids)
        {
            try
            {
                var lawyerarchives = await _db.Queryable<App_LawyerServicesModel>()
                    .In(info => info.Id, ids)
                    .ToListAsync();
                var userids = lawyerarchives
                    .Select(x => x.createuserId)
                    .Distinct()
                    .ToList();
                var users = await _db.Queryable<App_Sys_UserModel>()
                    .In(x => x.Id, userids)
                    .ToListAsync();
                //把创建人Id变为创建人的身份证
                lawyerarchives.All(x =>
                {
                    x.createuserId = users.FirstOrDefault(q => q.Id == x.createuserId).cardId;
                    return true;
                });
                var packegdirname = DateTime.Now.Ticks.ToString();
                var dir = Path.Combine(Environment.CurrentDirectory, "wwwroot", "temp");
                var packegdir = Path.Combine(dir, packegdirname);
                var packegzipname = Path.ChangeExtension(packegdir, ".zip");
                if (Directory.Exists(packegdir) == false) Directory.CreateDirectory(packegdir);
                var jsonfilepath = Path.Combine(packegdir, "data");
                var jsonstr = new
                {
                    lawyerservices = lawyerarchives,
                    users = users
                }.ConvertToJsonStr().ConvertToBase64();
                System.IO.File.WriteAllText(jsonfilepath, jsonstr);
                //存储预约申请的相关附件
                foreach (var item in lawyerarchives)
                {
                    var lawyerdir = Path.Combine(packegdir, "lawyerservices", item.Id);
                    if (Directory.Exists(lawyerdir) == false) Directory.CreateDirectory(lawyerdir);

                    var files = item.annex.ConvertToModel<List<string>>() ?? new List<string>();
                    var annecdir = Path.Combine(lawyerdir, "annexs");
                    if (Directory.Exists(annecdir) == false) Directory.CreateDirectory(annecdir);
                    foreach (var file in files.Where(x => x != null))
                    {
                        var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot") + file.Replace("/", @"\");
                        if (System.IO.File.Exists(filepath))
                        {
                            var targetfile = Path.Combine(annecdir, Path.GetFileName(filepath));
                            System.IO.File.Copy(filepath, targetfile);
                        }
                    }

                    var legalphotots = item.legalAidPhoto.ConvertToModel<List<string>>() ?? new List<string>();
                    var legalAidPhotoDir = Path.Combine(lawyerdir, "legalAidPhoto");
                    if (Directory.Exists(legalAidPhotoDir) == false) Directory.CreateDirectory(legalAidPhotoDir);

                    foreach (var legalphotot in legalphotots.Where(x => x != null))
                    {
                        logger.LogInformation(legalphotot);
                        var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot") + legalphotot.Replace("/", @"\");
                        if (System.IO.File.Exists(filepath))
                        {
                            var targetfile = Path.Combine(legalAidPhotoDir, Path.GetFileName(filepath));
                            System.IO.File.Copy(filepath, targetfile);
                        }
                    }


                    var relationshipProofPhotos = item.relationshipProofPhoto.ConvertToModel<List<string>>() ?? new List<string>();
                    var relationshipProofPhotoDir = Path.Combine(lawyerdir, "relationshipProofPhoto");
                    if (Directory.Exists(relationshipProofPhotoDir) == false) Directory.CreateDirectory(relationshipProofPhotoDir);
                    foreach (var relationshipProofPhoto in relationshipProofPhotos.Where(x => x != null))
                    {
                        var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot") + relationshipProofPhoto.Replace("/", @"\");
                        if (System.IO.File.Exists(filepath))
                        {
                            var targetfile = Path.Combine(legalAidPhotoDir, Path.GetFileName(filepath));
                            System.IO.File.Copy(filepath, targetfile);
                        }
                    }
                    var otherPhotos = item.otherPhoto.ConvertToModel<List<string>>() ?? new List<string>();
                    var otherPhotoDir = Path.Combine(lawyerdir, "otherPhoto");
                    if (Directory.Exists(otherPhotoDir) == false) Directory.CreateDirectory(otherPhotoDir);
                    foreach (var otherPhoto in otherPhotos.Where(x => x != null))
                    {
                        var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot") + otherPhoto.Replace("/", @"\");
                        if (System.IO.File.Exists(filepath))
                        {
                            var targetfile = Path.Combine(legalAidPhotoDir, Path.GetFileName(filepath));
                            System.IO.File.Copy(filepath, targetfile);
                        }
                    }

                }
                //存储用户的相关附件
                foreach (var item in users)
                {
                    //["/CaseFile/card/2023-11-21/20231121200659497.jpg"]
                    var userdir = Path.Combine(packegdir, "users", item.cardId);

                    //保存身份证图片
                    var cardids = item.cardIdphoto.ConvertToModel<List<string>>();
                    var cardidDir = Path.Combine(userdir, "cardids");
                    if (Directory.Exists(cardidDir) == false) Directory.CreateDirectory(cardidDir);
                    foreach (var file in cardids)
                    {
                        var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot") + file.Replace("/", @"\");
                        if (System.IO.File.Exists(filepath))
                        {
                            System.IO.File.Copy(filepath, Path.Combine(cardidDir, Path.GetFileName(filepath)));
                        }
                    }
                    //保存工作证图片  律师职业证书
                    var identityphotos = item.identityphoto.ConvertToModel<List<string>>();
                    var identityphotosDir = Path.Combine(userdir, "identityphotos");
                    if (Directory.Exists(identityphotosDir) == false) Directory.CreateDirectory(identityphotosDir);
                    foreach (var file in identityphotos)
                    {
                        var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot") + file.Replace("/", @"\");
                        if (System.IO.File.Exists(filepath))
                        {
                            System.IO.File.Copy(filepath, Path.Combine(identityphotosDir, Path.GetFileName(filepath)));
                        }
                    }

                    var departmentPhotos = item.departmentPhoto.ConvertToModel<List<string>>();
                    var departmentPhotosDir = Path.Combine(userdir, "departmentPhotos");
                    if (Directory.Exists(departmentPhotosDir) == false) Directory.CreateDirectory(departmentPhotosDir);
                    foreach (var file in departmentPhotos)
                    {
                        var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot") + file.Replace("/", @"\");
                        if (System.IO.File.Exists(filepath))
                        {
                            System.IO.File.Copy(filepath, Path.Combine(departmentPhotosDir, Path.GetFileName(filepath)));
                        }
                    }
                }
                logger.LogInformation("step4");
                ZipFile.CreateFromDirectory(packegdir, packegzipname);
                Directory.Delete(packegdir, true);

                result.result = $"/temp/{packegdirname}.zip";
                result.IsSucceed = true;
                logger.LogInformation("step5");
                return result;
            }
            catch (Exception ex)
            {
                result.IsSucceed = false;
                result.Message = ex.Message;
                return result;
            }
        }
        [HttpPost]
        [Route("UploadSignImage")]
        /// <summary>
        /// 上传签字照片
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public async Task<Result> UploadSignImage(object data)
        {
            var input = data.ConvertToAnonymousType(new
            {
                id = default(string),
                image = default(string)
            });
            if (string.IsNullOrEmpty(input.image) == false)
            {
                var _path = Path.Combine("CaseFile", "card", DateTime.Now.ToString("yyyy-MM-dd"));
                var dic = Path.Combine(Environment.CurrentDirectory, "wwwroot", _path);
                var filename = DateTime.Now.Ticks.ToString() + ".png";
                var filefullpath = Path.Combine(dic, filename);
                if (Directory.Exists(dic) == false)
                {
                    Directory.CreateDirectory(dic);
                }
                await System.IO.File.WriteAllBytesAsync(filefullpath, Convert.FromBase64String(input.image));

                var item = await _db.Queryable<LawyerArchives>().Where(x => x.Id == input.id).FirstAsync();
                if (item != null)
                {
                    var __path = Path.Combine(_path, filename);
                    var repath = "/" + __path.Replace(@"\", @"/");
                    item.secertphoto = repath;
                    await _db.Updateable(item).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                    result.IsSucceed = true;
                }
                else
                {
                    result.IsSucceed = false;
                    result.Message = "数据不存在";
                }
            }
            else
            {
                result.IsSucceed = false;
                result.Message = "图片接收失败";
            }

            return result;
        }
        public class DecodeQRDataModel
        {
            public string QRData { get; set; }
        }
        ///// <summary>
        ///// 加密二维码信息
        ///// </summary>
        ///// <returns></returns>
        //[HttpGet]
        //[HiddenApi]
        //[Route("EncodeData")]
        //public async Task<Result> EncodeData(string id)
        //{
        //    var groupedlist = await _db.Queryable<App_LawyerServicesModel>().LeftJoin<App_Sys_UserModel>((lawyer, user) => lawyer.createuserId == user.Id)
        //    .Where(lawyer => lawyer.Id == id)
        //    .Select((lawyer, user) => new
        //    {
        //        info = lawyer,
        //        user
        //    }).FirstAsync();
        //    if (groupedlist != null)
        //    {
        //        var dto = new
        //        {
        //            info = mapper.Map<QRLawyerServiceDto>(groupedlist.info),
        //            user = mapper.Map<QRUserDto>(groupedlist.user)
        //        };
        //        var encodingdata = Convert.ToBase64String(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(dto)));
        //        result.IsSucceed = true;
        //        result.result = encodingdata;
        //    }
        //    return result;
        //}

        ///// <summary>
        ///// 解码二维码信息
        ///// </summary>
        ///// <returns></returns>
        //[HttpPost]
        //[HiddenApi]
        //[Route("DecodeQRData")]
        //public Task<Result> DecodeQRData(DecodeData groupedlist)
        //{
        //    try
        //    {
        //        var basestr = Convert.FromBase64String(groupedlist.EncodingString);
        //        var str = Encoding.UTF8.GetString(basestr);

        //        var model = str.ConvertToAnonymousType(new
        //        {
        //            info = default(QRLawyerServiceDto),
        //            user = default(QRUserDto)
        //        });
        //        result.IsSucceed = true;
        //        result.result = model;
        //    }
        //    catch (System.Exception ex)
        //    {
        //        result.IsSucceed = false;
        //    }
        //    return Task.FromResult(result);
        //}
        #endregion
    }
}