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 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 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 (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 idcard,string name,string casename)
        {
            return Task.FromResult(result);
        }

        /// <summary>
        /// 添加卷宗信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddArchivesInfo")]
        public Task<Result<JZJBXXDto>> AddArchivesInfo(JZJBXXDto dto)
        {
            Result<JZJBXXDto> res = new Result<JZJBXXDto>();
            return Task.FromResult(res);
        }

        #endregion
    }
}