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

using AutoMapper;
using com.sun.xml.@internal.bind.v2.model.core;
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.lang;
using javax.xml.crypto;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.Filters;
using Newtonsoft.Json;
using SqlSugar;
using System.Net.WebSockets;
using System.Text;
using static _24Hour.TwentySystemProxyClient;
using static com.sun.tools.@internal.xjc.reader.xmlschema.bindinfo.BIConversion;
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 IMapper mapper;
        public LawyerArchivesController(ILogger<LawyerArchivesController> _logger, SqlSugarClient db, WriteSysLog logs, User user, IMapper _mapper, TwentySystemProxyClient _twentyClient)
        {
            this.logger = _logger;
            _db = db;
            _logs = logs;
            this.mapper = _mapper;
            this.twentyClient = _twentyClient;
            _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)
                .Where(x => x.identity == "律师")
                .ToListAsync();
            res.IsSucceed = true;
            res.result = data;
            return res;
        }

        /// <summary>
        /// 删除律师
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("RemoveLawyer")]
        public async Task<Result> RemoveLawyer(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var Deletelist = await _db.Queryable<App_Sys_UserModel>().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;
                logger.LogError(ex, "");

            }
            _logs.WriteSysLogadd("律师阅卷服务", "删除律师信息", result, _db);
            return result;
        }

        /// <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.cardId = input.cardId;
                    data.phone = input.phone;
                    data.name = input.name;
                    data.departmentName = input.departmentName;
                    data.identitycardId = input.identitycardId;
                    //update
                    _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>
        /// 同步外网律师人员信息(未完成) (根据律师身份证号更新或新增用户信息)
        /// </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);
                if (data != null)
                {
                    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.permissibleStartTime > starttime && x.permissibleStartTime < endtime)
                .Where(x => x.unitcode == input.unitCode)
                .WhereIF(input.Isdelete != null, x => x.IsDeleted == input.Isdelete)
                .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 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;
                _db.BeginTran();
                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;
                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 = reponse.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;
        }
        #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>
        /// <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);
        }
        public class DecodeQRDataModel
        {
            public string QRData { get; set; }
        }
        ///// <summary>
        ///// 加密二维码信息
        ///// </summary>
        ///// <returns></returns>
        //[HttpGet]
        //[HiddenApi]
        //[Route("EncodeData")]
        //public async Task<Result> EncodeData(string id)
        //{
        //    var data = 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 (data != null)
        //    {
        //        var dto = new
        //        {
        //            info = mapper.Map<QRLawyerServiceDto>(data.info),
        //            user = mapper.Map<QRUserDto>(data.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 data)
        //{
        //    try
        //    {
        //        var basestr = Convert.FromBase64String(data.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
    }
}