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

using com.sun.xml.@internal.bind.v2.model.core;
using Elight.Entity;
using Elight.Entity.APPDto.Lawyer;
using Elight.Logic;
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 sun.security.x509;
using System.Net.WebSockets;
using System.Text;
using static com.sun.tools.@internal.xjc.reader.xmlschema.bindinfo.BIConversion;
using static java.security.cert.CertPathValidatorException;
using User = Elight.Utility.User;

namespace _24Hour.Controllers.Common
{
    /// <summary>
    /// 律师服务
    /// </summary>
    [Authorize]
    [ApiController]
    [Route("api/Lawyer")]
    public class LawyerservicesController : Controller
    {

        private static Dictionary<string, WebSocket> CONNECT_POOL = new Dictionary<string, WebSocket>();//用户连接池
        #region Identity
        private readonly SqlSugarClient _db;//数据库
        private readonly WriteSysLog _logs;//操作日志
        App_Sys_UserModel _userdata = new App_Sys_UserModel();//当前用户
        private readonly ILogger<LoginController> _logger;//日志
        private readonly WechatMessagerClient _wechatMessagerClient;
        private readonly List<App_Sys_UnitModel> _Unitdata;//当前用户
        Result result = new Result();
        public LawyerservicesController(ILogger<LoginController> logger, SqlSugarClient db, WriteSysLog logs, User user, WechatMessagerClient wechatMessagerClient)
        {
            _logger = logger;
            _db = db;
            _logs = logs;
            _userdata = user.Userdata();
            _Unitdata = _db.Queryable<App_Sys_UnitModel>().Where(q => q.IsDelete == 0).ToList();
            _wechatMessagerClient = wechatMessagerClient;
        }

        #endregion

        #region 律师服务增删改查
        /// <summary>
        /// app--根据当前登录人查询律师预约分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryLawyereuser")]
        public async Task<Result> QueryLawyereuser(App_LawyerServicesInput Lawyeredata)
        {
            RefAsync<int> totalNumber = 0;//总数据
            //查询律师服务预约记录
            var list = await _db.Queryable<App_LawyerServicesModel>()
                .WhereIF(Lawyeredata.name != null, q => q.name.Contains(Lawyeredata.name))
                .WhereIF(Lawyeredata.objectstr != null, q => q.objectstr.Contains(Lawyeredata.objectstr))
                .WhereIF(Lawyeredata.state != null, q => q.state == Lawyeredata.state)
                .WhereIF(Lawyeredata.unitId.NotNull(), q => q.unitCode.Contains(Lawyeredata.unitId))
                .WhereIF(Lawyeredata.StartTime != null && Lawyeredata.EndTime != null, q => q.receptiontime >= Lawyeredata.StartTime && q.receptiontime < Lawyeredata.EndTime.Value.AddDays(1))
                .Where(q => q.IsDeleted == 0 && q.createuserId == _userdata.Id).ToPageListAsync(Lawyeredata.PageIndex, Lawyeredata.PageSize, totalNumber);
            Lawyeredata.RowsCount = totalNumber;
            var data = new QueryResult<App_LawyerServicesModel>(Lawyeredata, list.OrderByDescending(q => q.creationtime).ToList());
            result.IsSucceed = true;
            result.result = data;
            return result;
        }

        /// <summary>
        /// 律师服务分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryLawyer")]
        public async Task<Result> QueryLawyer(App_LawyerServicesInput Lawyerdata)
        {
            RefAsync<int> totalNumber = 0;//总数据


            //查询律师服务
            var list = await _db.Queryable<App_LawyerServicesModel>()
                .Where(q => q.IsDeleted == 0)
                .WhereIF(Lawyerdata?.name != null, q => q.name.Contains(Lawyerdata.name))
                .WhereIF(Lawyerdata?.objectstr != null, q => q.objectstr.Contains(Lawyerdata.objectstr))
                .WhereIF(Lawyerdata?.unitId != null, q => q.unitCode.Contains(Lawyerdata.unitId))
                .WhereIF(Lawyerdata?.state != null, q => q.state == Lawyerdata.state)
                .WhereIF(Lawyerdata?.IsAssigned != null, q => q.IsAssigned == Lawyerdata.IsAssigned)
                .WhereIF(Lawyerdata?.StartTime != null && Lawyerdata.EndTime != null, q => q.receptiontime >= Lawyerdata.StartTime && q.receptiontime < Lawyerdata.EndTime.Value.AddDays(1))

                .WhereIF(string.IsNullOrEmpty(Lawyerdata.Id) == false, q => q.Id == Lawyerdata.Id)

                .WhereIF(_userdata.phone != "admin", q => q.unitCode == _userdata.unitCode)
                .OrderByDescending(q => q.creationtime)
                .ToPageListAsync(Lawyerdata.PageIndex, Lawyerdata.PageSize, totalNumber);

            Lawyerdata.RowsCount = totalNumber;
            var data = new QueryResult<App_LawyerServicesModel>(Lawyerdata, list.OrderByDescending(q => q.creationtime).ToList());
            result.IsSucceed = true;
            result.result = data;
            return result;
        }
        /// <summary>
        /// 添加律师服务
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddLawyer")]
        public async Task<Result> AddDevice(App_LawyerServicesModel Lawyerdata)
        {
            try
            {
                _db.BeginTran();
                Lawyerdata.Id = Guid.NewGuid().ToString();
                Lawyerdata.createuserId = _userdata.Id.ToString();
                Lawyerdata.createusername = _userdata.name;
                var num = await _db.Insertable(Lawyerdata).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    var jcguserdata = await _db.Queryable<App_Sys_UserModel>()
                                    .Where(q => q.usertype == 0 && q.messages ==true && q.unitCode == Lawyerdata.unitCode).ToListAsync();
                    if (jcguserdata.Count>0)
                    {
                        foreach (var item in jcguserdata)
                        {
                            if (!string.IsNullOrEmpty(item.wechatId))
                            {
                                //给检察官发送审核消息
                                _wechatMessagerClient.gzhwxts(item.wechatId, Lawyerdata?.name, Lawyerdata?.phone, Lawyerdata?.objectstr + "-" + Lawyerdata?.matter, Lawyerdata?.reason);
                            }
                        }
                    }
                    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("AddLawyerInNet")]
        public async Task<Result> AddLawyerInNet(App_LawyerServicesModel Lawyerdata)
        {
            try
            {
                _db.BeginTran();
                Lawyerdata.Id = Guid.NewGuid().ToString();
                Lawyerdata.state = 1;
                Lawyerdata.unitCode = _userdata.unitCode;
                Lawyerdata.IsAssigned = false;
                Lawyerdata.creationtime = DateTime.Now;
                var num = await _db.Insertable(Lawyerdata).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("UpdateLawyer")]
        public async Task<Result> UpdateLawyer(App_LawyerServicesModel 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>
        /// 删除律师服务预约
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteLawyer")]
        public async Task<Result> DeleteLawyer(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var Deletelist = await _db.Queryable<App_LawyerServicesModel>().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("GetCancellationLawyer")]
        public async Task<Result> GetCancellationLawyer(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var Deletelist = await _db.Queryable<App_LawyerServicesModel>().In(q => q.Id, Currency.id).ToListAsync();
                Deletelist.ForEach(q =>
                {
                    q.state = 4;
                });
                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;
        }
        #endregion





        #region 律师预约修改办理人及状态修改

        /// <summary>
        /// 修改律师服务预约办理人
        /// </summary>
        /// <param name="Id">律师服务预约Id</param>
        /// <param name="transactors">推送办理人Id</param>
        /// <returns></returns>
        [HttpGet]
        [Route("UpdateLawyeruser")]
        public async Task<Result> UpdateLawyeruser(string? Id, string? transactors)
        {
            try
            {
                var Lawyerbol = await _db.Queryable<App_LawyerServicesModel>().Where(q => q.Id == Id).ToListAsync();
                if (Lawyerbol.Count() > 0)
                {
                    if (Lawyerbol.FirstOrDefault().state == 4)
                    {
                        result.IsSucceed = false;
                        result.result = "预约已被取消";
                    }
                    else
                    {
                        Lawyerbol.FirstOrDefault().receptionuser = transactors;
                        _db.BeginTran();
                        var num = await _db.Updateable(Lawyerbol.FirstOrDefault()).UpdateColumns(it => new { it.receptionuser }).ExecuteCommandAsync();
                        _db.CommitTran();
                        if (num > 0)
                        {
                            result.IsSucceed = true;
                            result.result = "修改成功";
                        }
                    }
                }
                else
                {
                    result.IsSucceed = false;
                    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="Id">律师服务预约Id</param>
        /// <param name="state">状态</param>
        /// <param name="reason">拒绝原因</param>
        /// <returns></returns>
        [HttpGet]
        [Route("UpdateLawyerstate")]
        public async Task<Result> UpdateLawyerstate(string? Id, int state, string? reason, DateTime starttime, DateTime endtime)
        {
            try
            {
                var Lawyerbol = await _db.Queryable<App_LawyerServicesModel>().Where(q => q.Id == Id).ToListAsync();
                if (Lawyerbol.Any())
                {
                    var Lawyerboldata = Lawyerbol.FirstOrDefault();
                    if (Lawyerboldata.state != 0)
                    {
                        if (Lawyerboldata.state==4)
                            result.result = "预约已被取消！";
                        else
                            result.result = "数据已被其他人接收处理！";
                        result.IsSucceed = false;
                        return result;
                    }
                    Lawyerboldata.receptiontime = starttime;
                    Lawyerboldata.receptionEndtime = endtime;

                    Lawyerboldata.state = state;
                    if (reason.NotNull())
                        Lawyerboldata.reason = reason;
                    Lawyerboldata.acceptancetime = DateTime.Now;
                    _db.BeginTran();
                    var num = await _db.Updateable(Lawyerboldata).UpdateColumns(it => new
                    {
                        it.state,
                        it.reason,
                        it.acceptancetime,
                        it.receptiontime,
                        it
                    .receptionEndtime
                    }).ExecuteCommandAsync();
                    _db.CommitTran();
                    if (num > 0)
                    {
                        var userdata = await _db.Queryable<App_Sys_UserModel>()
                            .Where(q => q.Id == Lawyerboldata.createuserId).ToArrayAsync();
                        //获取单位信息
                        var unitname = _Unitdata.FirstOrDefault(q => q.unitCode == Lawyerboldata.unitCode)?.unitname;
                        if (state == 1)
                        {
                            //判单预约人是否有微信openId
                            if (!string.IsNullOrEmpty(userdata.FirstOrDefault()?.wechatId))
                                //发送晨成功订阅号消息
                                _wechatMessagerClient.wxts(userdata.FirstOrDefault()?.wechatId, Lawyerboldata?.operatorName, unitname, Lawyerboldata?.receptiontime, Lawyerboldata?.objectstr + "-" + Lawyerboldata?.matter, Lawyerboldata?.reason);
                        }
                        else
                        {
                            //判单预约人是否有微信openId
                            if (!string.IsNullOrEmpty(userdata.FirstOrDefault()?.wechatId))
                                //发送拒绝订阅号消息
                                _wechatMessagerClient.sbwxts(userdata.FirstOrDefault()?.wechatId, Lawyerboldata?.operatorName, unitname, Lawyerboldata?.receptiontime, Lawyerboldata?.matter, Lawyerboldata?.reason);
                        }
                        result.IsSucceed = true;
                        result.result = "同意";
                    }
                }
                else
                {
                    result.IsSucceed = false;
                    result.result = "未找到预约信息";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
                LogService.WriteLog(ex, "修改律师服务预约状态");
            }
            _logs.WriteSysLogadd("律师服务", "修改律师服务预约状态", result, _db);
            return result;
        }
        #endregion
    }
}