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<LoginController> _logger;//日志
        Result result = new Result();

        private readonly IMapper mapper;
        public LawyerArchivesController(ILogger<LoginController> logger, SqlSugarClient db, WriteSysLog logs, User user, IMapper _mapper)
        {
            this._logger = logger;
            _db = db;
            _logs = logs;
            _userdata = user.Userdata();
            this.mapper = _mapper;
        }
        #endregion



        #region 律师阅卷
        /// <summary>
        /// 加密二维码信息
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [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]
        [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);
        }
        /// <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();
                    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="info"></param>
        /// <returns></returns>
        [HttpPost]
        [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="input"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("QueryLawyerArchives")]
        public async Task<Result> QueryLawyerArchives(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.lawyerservicesId != null, (archives, services) => archives.lawyerservicesId == input.lawyerservicesId)
                .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>
        [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>
        [HttpPost]
        [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>
        [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>
        [HttpGet]
        [Route("QueryFileFromtwenty")]
        public Task<Result> QueryFileFromtwenty(string bmsah)
        {
            if (bmsah == "安北检刑诉受[2023]433333333333号")
            {
                var a = GetInfo();
                var data = 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 Task.FromResult(result);
        }
        private JZJBXXDto GetInfo()
        {
            var path = Path.Combine(Environment.CurrentDirectory, "datajson.txt");
            var json = System.IO.File.ReadAllText(path);
            var convert = json.ConvertToModel<JZJBXXDto>();
            convert.Id = Guid.NewGuid().ToString();
            foreach (var ml in convert.jzml)
            {
                ml.Id = Guid.NewGuid().ToString();
                foreach (var item in ml.jzwj)
                {
                    item.Id = Guid.NewGuid().ToString();
                }
            }
            return convert;
        }
        /// <summary>
        /// 上传已选中的第三级页码的id
        /// </summary>
        /// <param name="bmsah"></param>
        /// <param name="ids"></param>
        /// <returns></returns>
        [HttpPost("AddArchivesInfoByChildId")]
        public Task<Result> AddArchivesInfoByChildId(AddArchivesInfoInput input)
        {
            return Task.FromResult(result);
        }
        /// <summary>
        /// 添加卷宗信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [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;
            }
        }

        #endregion
    }
}