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.Utility;
using Elight.Utility.Code;
using Elight.Utility.Extensions;
using Elight.Utility.logs;
using java.lang;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Newtonsoft.Json;
using SqlSugar;
using System.Net.WebSockets;
using System.Text;
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 CaseServiceTwentyClient twentyClient;

        private readonly IMapper mapper;
        public LawyerArchivesController(ILogger<LawyerArchivesController> _logger, SqlSugarClient db, WriteSysLog logs, User user, IMapper _mapper, CaseServiceTwentyClient _twentyClient)
        {
            this.logger = _logger;
            _db = db;
            _logs = logs;
            this.mapper = _mapper;
            this.twentyClient = _twentyClient;
            _userdata = user.Userdata();
        }
        #endregion
        #region 律师阅卷
        /// <summary>
        /// 同步外网律师人员信息(未完成) (根据律师身份证号更新或新增用户信息)
        /// </summary>
        /// <param name="user"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddUserInfo")]
        public async Task<Result> AddUserInfo(App_Sys_UserModel user)
        {
            try
            {
                var data = await _db.Queryable<App_Sys_UserModel>().FirstAsync(x => x.cardId == user.cardId);
                if (data != null)
                {
                    //update
                    _db.BeginTran();
                    var num = await _db.Updateable(user).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                    _db.CommitTran();
                    if (num > 0)
                    {
                        result.IsSucceed = true;
                        result.result = "修改成功";
                    }
                }
                else
                {
                    //insert
                    _db.BeginTran();
                    user.Id = Guid.NewGuid().ToString();
                    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 list = await _db.Queryable<LawyerArchives>().LeftJoin<App_LawyerServicesModel>((archives, services) => archives.lawyerservicesId == services.Id)
                .WhereIF(input.bmsah != null, (archives, services) => archives.bmsah == input.bmsah)
                .WhereIF(input.lawyerId != null, (archives, services) => archives.lawyerId == input.lawyerId)
                .WhereIF(input.Id != null, (archives, services) => archives.Id == input.Id)
                .WhereIF(input.unitCode != null, (archives, services) => services.unitCode == input.unitCode)
                .WhereIF(input.receptionuserId != null, (archives, services) => services.receptionuser == input.receptionuserId)
                .WhereIF(input.state != null, (archives, services) => services.state == input.state)
                .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;
        }
        public class DecodeData
        {
            public string EncodingString { get; set; }
        }
        /// <summary>
        /// 新增阅卷信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddLawyerArchives")]
        public async Task<Result> AddLawyerArchives(LawyerArchivesDto dto)
        {
            try
            {
                var data = await _db.Queryable<LawyerArchives>().FirstAsync(x => x.lawyerservicesId == dto.lawyerservicesId);
                if (data != null)
                {
                    result.IsSucceed = false;
                    result.Message = "该预约信息已经处理，无法再次新建阅卷预约";
                    return result;
                }
                var entity = mapper.Map<LawyerArchives>(dto);

                entity.Id = Guid.NewGuid().ToString();
                entity.createrId = _userdata.Id;
                entity.createTime = DateTime.Now;

                _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>
        [HttpDelete]
        [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
            {
                _db.BeginTran();
                var num = await _db.Updateable(Lawyerdata).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 Task<Result> QueryCaseFromtwenty(string? bmsah, string? name, string? casename)
        {
            result.IsSucceed = true;
            result.result = new[]
            {
                new
                {
                    bmsah="安北检刑诉受[2023]433333333333号",
                    casename="张三杀人案",
                }
            };
            return Task.FromResult(result);
        }
        /// <summary>
        /// 从2.0系统查询卷宗信息（假数据）
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        /// <remarks>数据的返回格式已确定，内容时真实数据经过修改的</remarks>
        [HttpGet]
        [Route("QueryFileFromtwenty")]
        public async Task<Result> QueryFileFromtwenty(string bmsah)
        {
            if (bmsah == "安北检刑诉受[2023]433333333333号")
            {
                var a = await twentyClient.GetArchivesInfo(bmsah);
                var data = new[]
                {
                    new {
                        id = a.jzbh,
                        lable = a.jzmc,
                        children = a?.jzml?.Select(x => new
                        {
                            id = x.mlbh,
                            lable = x.mlxsmc,
                            children = x.jzwj.Select(q => new
                            {
                                id = q.wjxh,
                                lable = q.wjxsmc,
                                filepath = q.jpgwjlj
                            })
                        })
                    }
                };
                result.IsSucceed = true;
                result.result = data;
            }
            else
            {
                result.IsSucceed = false;
            }
            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 dto = await twentyClient.GetArchivesInfo(input.Bmsah);
                //先将没有被选中的第三级文件排除
                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()).ToList();

                var insert = await AddArchivesInfo(dto);
                result.result = insert.result.Id;
            }
            catch (Exception ex)
            {
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            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, q => q.jzwj)
                    .FirstAsync(x => x.Id == jzid);

                var data = mapper.Map<JZJBXXDto>(list);
                result.result = data;
                result.IsSucceed = true;
            }
            catch (Exception ex)
            {

            }
            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)
                  .Where(x => x.permissibleStartTime <= DateTime.Now && x.permissibleEndTime >= DateTime.Now)
                  .ToListAsync();

                var data = mapper.Map<IEnumerable<LawyerArchivesDto>>(list);
                result.result = data;
                result.IsSucceed = true;
            }
            catch (Exception ex)
            {

            }
            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)
            {
                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>
        /// <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
    }
}