24Hour.Service/24Hour/Controllers/system/SystemControllerController.cs

using AutoMapper;
using com.sun.corba.se.spi.orbutil.fsm;
using com.sun.org.apache.bcel.@internal.generic;
using com.sun.xml.@internal.ws.api.model;
using Elight.Entity;
using Elight.Entity.SystemModel;
using Elight.Logic;
using Elight.Logic.SystemModel;
using Elight.Utility;
using Elight.Utility.Code;
using Elight.Utility.Encrypt;
using Elight.Utility.Extensions;
using Elight.Utility.logs;
using javax.xml.crypto;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using SqlSugar;

namespace _24Hour.Controllers.system
{
    /// <summary>
    /// 系统设置
    /// </summary>
    [Authorize]
    [ApiController]
    [Route("api/system")]
    public class SystemControllerController : Controller
    {
        #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 IMapper _mapper;
        Result result = new Result();
        public SystemControllerController(IMapper mapper, ILogger<LoginController> logger, SqlSugarClient db, WriteSysLog logs, User user, WechatMessagerClient _wechatMessagerClient)
        {
            _logger = logger;
            _db = db;
            _logs = logs;
            _userdata = user.Userdata();
            this.wechatMessagerClient = _wechatMessagerClient;
            _mapper = mapper;
        }
        #endregion
        #region 用户管理
        /// <summary>
        /// 根据部门Id查询用户
        /// </summary>
        /// <param name="department"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("Querydepartment")]
        public async Task<Result> Querydepartment(string department)
        {
            var Unitlist = await _db.Queryable<App_Sys_UserModel>().Where(q => q.phone != "admin" && q.IsDeleted == 0 && q.isdeactivate == 0 && q.department == department).ToListAsync();
            result.IsSucceed = true;
            result.result = Unitlist.OrderByDescending(q => q.createtime).ToList();
            return result;
        }
        /// <summary>
        /// 系统用户list查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("QueryUserlist")]
        public async Task<Result> QueryUserlist()
        {
            var Unitlist = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.isdeactivate == 0 && q.usertype == 0 && q.unitCode == _userdata.unitCode && q.phone != "admin" && q.usertype == 0).ToListAsync();
            result.IsSucceed = true;
            result.result = Unitlist.OrderByDescending(q => q.createtime).ToList();
            return result;
        }
        /// <summary>
        /// 系统用户分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryUser0")]
        public async Task<Result> QueryUser0(App_Sys_UserInput UserModel)
        {
            RefAsync<int> totalNumber = 0;//总数据
            var userlist = new List<dynamic>();
            //获取单位信息
            var Unitlist = await _db.Queryable<App_Sys_UnitModel>().Where(q => q.IsDelete == 0).ToListAsync();
            //获取部门信息
            var Departlist = await _db.Queryable<App_Sys_DepartModel>().Where(q => q.IsDelete == 0).ToListAsync();
            //获取角色信息
            var RoleModel = _db.Queryable<App_Sys_RoleUserModel>()
                .LeftJoin<App_Sys_RoleModel>((o, i) => o.roleId == i.Id && o.IsDelete == 0 && i.IsDeleted == 0)
                .Select((o, i) => new App_Sys_RoleDto { Id = o.roleId, name = i.name, userId = o.roleuserId })
                .ToList();
            var list = await _db.Queryable<App_Sys_UserModel>()
                .WhereIF(!UserModel.name.IsNull(), q => q.name.Contains(UserModel.name))
                .WhereIF(!UserModel.phone.IsNull(), q => q.phone.Contains(UserModel.phone))
                .WhereIF(!UserModel.duties.IsNull(), q => q.duties.Contains(UserModel.duties))
                .WhereIF(!UserModel.cardId.IsNull(), q => q.cardId.Contains(UserModel.cardId))

                .Where(q => q.IsDeleted == 0 && q.phone != "admin" && q.usertype == 0)
                .ToPageListAsync(UserModel.PageIndex, UserModel.PageSize, totalNumber);
            UserModel.RowsCount = totalNumber;
            list.ForEach(q =>
            {
                var Unitdata = Unitlist.Where(x => x.unitCode == q.unitCode)?.FirstOrDefault();
                var Departdata = Departlist.Where(x => x.Id == q.department)?.FirstOrDefault();
                userlist.Add(new
                {
                    q.Id,
                    q.unitCode,
                    q.department,
                    q.name,
                    q.sex,
                    q.duties,
                    q.phone,
                    q.cardId,
                    q.wechatId,
                    q.isdeactivate,
                    q.becurrent,
                    q.photo,
                    q.identity,
                    q.createtime,
                    q.messages,
                    unitname = Unitdata?.unitname,
                    departname = Departdata?.departname,
                    roleId = RoleModel.FirstOrDefault(x => x.userId == q.Id)?.Id,
                    roleName = RoleModel.FirstOrDefault(x => x.userId == q.Id)?.name,
                });
            });
            var data = new { Paging = UserModel, Data = userlist };
            result.IsSucceed = true;
            result.result = data;
            return result;
        }

        /// <summary>
        /// app用户分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryUser1")]
        public async Task<Result> QueryUser1(App_Sys_UserInput UserModel)
        {
            RefAsync<int> totalNumber = 0;//总数据
            var list = await _db.Queryable<App_Sys_UserModel>()
                .WhereIF(!UserModel.name.IsNull(), q => q.name.Contains(UserModel.name))
                .WhereIF(!UserModel.identity.IsNull(), q => q.identity.Contains(UserModel.identity))
                .WhereIF(!UserModel.phone.IsNull(), q => q.phone.Contains(UserModel.phone))
                .WhereIF(!UserModel.duties.IsNull(), q => q.duties.Contains(UserModel.duties))
                .WhereIF(!UserModel.cardId.IsNull(), q => q.cardId.Contains(UserModel.cardId))
                .WhereIF(!UserModel.unitCode.IsNull(), q => q.unitCode == UserModel.unitCode)
                .WhereIF(!UserModel.department.IsNull(), q => q.departmentName.Contains(UserModel.department))
                .WhereIF(UserModel.audit != null, q => q.audit == UserModel.audit)
                .WhereIF(UserModel.isdeactivate >= 0, q => q.isdeactivate == UserModel.isdeactivate)
                .WhereIF(!UserModel.Id.IsNull(),q=>q.Id==UserModel.Id)
                .Where(q => q.IsDeleted == 0 && q.usertype == 1)
                .ToPageListAsync(UserModel.PageIndex, UserModel.PageSize, totalNumber);
            UserModel.RowsCount = totalNumber;
            var data = new QueryResult<App_Sys_UserModel>(UserModel, list);
            result.IsSucceed = true;
            result.result = data;
            return result;
        }
        /// <summary>
        /// 系统添加用户
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddUser0")]
        public async Task<Result> AddUser0(App_Sys_UserDto UserModel)
        {
            try
            {
                var UserDate = _mapper.Map<App_Sys_UserDto, App_Sys_UserModel>(UserModel);
                var data = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.phone == UserDate.phone || q.cardId == UserDate.cardId).FirstAsync();
                if (data != null)
                {
                    result.IsSucceed = false;
                    result.Message = "电话号码或身份证号已存在！";
                    return result;
                }
                _db.BeginTran();
                UserDate.Id = Guid.NewGuid().ToString();
                UserDate.createuserId = _userdata.Id.ToString();
                UserDate.createusername = _userdata.name;
                UserDate.usertype = 0;
                UserDate.photo = "/CaseFile/resource/headicon.aks";
                //默认密码
                UserDate.Password = string.IsNullOrEmpty(UserDate.Password) ? Elight.Utility.Encrypt.Md5.Encrypt32($"mr123456").ToLower() : Elight.Utility.Encrypt.Md5.Encrypt32(UserDate.Password).ToLower();
                var roledata = new App_Sys_RoleUserModel();
                if (!string.IsNullOrEmpty(UserModel.roleId))
                {
                    //添加角色用户信息
                    roledata = new App_Sys_RoleUserModel()
                    {
                        Id = Guid.NewGuid().ToString(),
                        roleId = UserModel.roleId,
                        roleuserId = UserDate.Id,
                        userId = _userdata.Id.ToString(),
                        username = _userdata.name,
                    };
                }
                var num = await _db.Insertable(UserDate).ExecuteCommandAsync();
                if (roledata.Id != null)
                    await _db.Insertable(roledata).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "添加成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("用户管理", "添加系统用户信息", result, _db);
            return result;
        }

        /// <summary>
        /// 修改密码
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdatePass")]
        public async Task<Result> UpdateUser(UpdatePassModel UserModel)
        {
            try
            {
                var model = await _db.Queryable<App_Sys_UserModel>().Where(x => x.Id == UserModel.Id).FirstAsync();
                if (model == null)
                {
                    result.IsSucceed = false;
                    result.result = "数据不存在";
                }
                var Passmd5 = Md5.Encrypt32(UserModel.OldPassword).ToLower();
                var newpass = Md5.Encrypt32(UserModel.Password).ToLower();
                if (Passmd5 != model.Password)
                {
                    result.IsSucceed = false;
                    result.Message = "账号或密码错误！";
                    return result;
                }

                model.Password = newpass;

                _db.BeginTran();
                var num = await _db.Updateable(model).UpdateColumns(it => new { it.Password }).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "修改成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("用户管理", "修改人员信息", result, _db);
            return result;
        }
        /// <summary>
        /// 修改用户
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdateUser")]
        public async Task<Result> UpdateUser(App_Sys_UserDto UserModel)
        {
            try
            {
                var model = await _db.Queryable<App_Sys_UserModel>().Where(x => x.Id == UserModel.Id).FirstAsync();
                if (model != null)
                {
                    model.unitCode = UserModel.unitCode;
                    model.department = UserModel.department;
                    model.name = UserModel.name;
                    model.sex = UserModel.sex;
                    model.duties = UserModel.duties;
                    model.phone = UserModel.phone;
                    model.cardId = UserModel.cardId;
                    model.messages = UserModel.messages;
                }

                _db.BeginTran();
                var num = await _db.Updateable(model).UpdateColumns(it => new { it.unitCode, it.department, it.name, it.sex, it.duties, it.phone, it.cardId, it.messages }).ExecuteCommandAsync();
                //判断角色不等于空进
                if (!string.IsNullOrEmpty(UserModel.roleId))
                {
                    if (_db.Queryable<App_Sys_RoleUserModel>().Any(x => x.IsDelete == 0 && x.roleuserId == UserModel.Id))
                    {
                        //查询角色用户是否存在
                        var rolemodel = await _db.Queryable<App_Sys_RoleUserModel>().Where(x => x.IsDelete == 0 && x.roleuserId == UserModel.Id).FirstAsync();
                        rolemodel.roleId = UserModel.roleId;
                        await _db.Updateable(rolemodel).UpdateColumns(it => new { it.roleId }).ExecuteCommandAsync();
                    }
                    else
                    {
                        var rolemodel = new App_Sys_RoleUserModel()
                        {
                            Id = Guid.NewGuid().ToString(),
                            roleId = UserModel.roleId,
                            roleuserId = UserModel.Id,
                            userId = _userdata.Id.ToString(),
                            username = _userdata.name,
                        };
                        if (rolemodel != null)
                            await _db.Insertable(rolemodel).ExecuteCommandAsync();
                    }
                }
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "修改成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("用户管理", "修改人员信息", result, _db);
            return result;
        }

        [HttpGet]
        [Route("UserUnbindWechat")]
        public async Task<Result> UserUnbindWechat()
        {
            try
            {
                var model = await _db.Queryable<App_Sys_UserModel>()
                    .FirstAsync(x => x.Id == _userdata.Id && x.IsDeleted == 0);
                if (model != null)
                {
                    model.wechatId = string.Empty;
                }
                _db.BeginTran();
                var num = await _db.Updateable(model).UpdateColumns(it => new { it.wechatId }).ExecuteCommandAsync();
                //var num = await _db.Updateable(UserModel).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;
            }
            _logs.WriteSysLogadd("用户管理", "修改人员信息", result, _db);
            return result;
        }

        /// <summary>
        /// 用户绑定微信小程序openid
        /// </summary>
        /// <param name="openid"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("UserBindWechat")]
        public async Task<Result> UserBindWechat(string code)
        {
            try
            {
                var getopenid = await wechatMessagerClient.GetOpenId(code);
                if (getopenid.IsSucceed == false)
                {
                    return getopenid;
                }
                string openid = getopenid.result;

                if (await _db.Queryable<App_Sys_UserModel>().AnyAsync(x => x.wechatId == openid && x.IsDeleted == 0))
                {
                    result.IsSucceed = false;
                    result.Message = "当前微信已与其他账号绑定";
                    return result;
                }


                var model = await _db.Queryable<App_Sys_UserModel>().Where(x => x.Id == _userdata.Id && x.IsDeleted == 0).FirstAsync();
                if (model != null)
                {
                    model.wechatId = getopenid.result;
                }
                _db.BeginTran();
                var num = await _db.Updateable(model).UpdateColumns(it => new { it.wechatId }).ExecuteCommandAsync();
                //var num = await _db.Updateable(UserModel).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = getopenid.result;
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("用户管理", "修改人员信息", result, _db);
            return result;
        }

        /// <summary>
        /// 用户绑定微信公众号openid
        /// </summary>
        /// <param name="openid"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("UserBindGzhWechat")]
        public async Task<Result> UserBindGzhWechat(string code)
        {
            try
            {
                var getopenid = await wechatMessagerClient.GetGzhOpenId(code);
                if (getopenid.IsSucceed == false)
                {
                    return getopenid;
                }
                string openid = getopenid.result;

                if (await _db.Queryable<App_Sys_UserModel>().AnyAsync(x => x.wechatId == openid && x.IsDeleted == 0))
                {
                    result.IsSucceed = false;
                    result.Message = "当前微信已与其他账号绑定";
                    return result;
                }


                var model = await _db.Queryable<App_Sys_UserModel>().Where(x => x.Id == _userdata.Id && x.IsDeleted == 0).FirstAsync();
                if (model != null)
                {
                    model.wechatId = getopenid.result;
                }
                _db.BeginTran();
                var num = await _db.Updateable(model).UpdateColumns(it => new { it.wechatId }).ExecuteCommandAsync();
                //var num = await _db.Updateable(UserModel).IgnoreColumns(ignoreAllNullColumns: true).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = getopenid.result;
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("用户管理", "修改人员信息", result, _db);
            return result;
        }

        /// <summary>
        /// 删除用户
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteUser")]
        public async Task<Result> DeleteUser(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_UserModel>().In(q => q.Id, Currency.id).ToListAsync();
                userlist.ForEach(q =>
                {
                    q.IsDeleted = 1;
                });
                var num = await _db.Updateable(userlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("用户管理", "删除人员信息", result, _db);
            return result;
        }

        /// <summary>
        /// 启用用户
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("EnableUser")]
        public async Task<Result> EnableUser(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_UserModel>().In(q => q.Id, Currency.id).ToListAsync();
                userlist.ForEach(q =>
                {
                    q.isdeactivate = 0;
                });
                var num = await _db.Updateable(userlist).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("DisableUser")]
        public async Task<Result> DisableUser(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_UserModel>().In(q => q.Id, Currency.id).ToListAsync();
                userlist.ForEach(q =>
                {
                    q.isdeactivate = 1;
                });
                var num = await _db.Updateable(userlist).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("resettingUser")]
        public async Task<Result> resettingUser(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_UserModel>().In(q => q.Id, Currency.id).ToListAsync();
                userlist.ForEach(q =>
                {
                    //默认密码
                    q.Password = Elight.Utility.Encrypt.Md5.Encrypt32($"mr123456").ToLower();
                });
                var num = await _db.Updateable(userlist).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>
        [HttpGet]
        [Route("Changepass")]
        public async Task<Result> Changepass()
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.Id == _userdata.Id).ToListAsync();
                userlist.ForEach(q =>
                {
                    //默认密码
                    q.Password = Elight.Utility.Encrypt.Md5.Encrypt32($"{q.Password}").ToLower();
                });
                var num = await _db.Updateable(userlist).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>
        [HttpGet]
        [Route("Sculpture")]
        public async Task<Result> Sculpture(string photo)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.Id == _userdata.Id).ToListAsync();
                userlist.ForEach(q =>
                {
                    //头像地址
                    q.photo = photo;
                });
                var num = await _db.Updateable(userlist).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>
        /// 修改部门证件 departmentPhoto
        /// </summary> 
        /// <param name="info"></param>
        /// <returns></returns>
        //[HttpGet]
        //[Route("EditDepartmentPhoto")]
        //public async Task<Result> EditDepartmentPhoto(string photo)
        //{
        //    try
        //    {
        //        _db.BeginTran();
        //        var userlist = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.Id == _userdata.Id).ToListAsync();
        //        userlist.ForEach(q =>
        //        {
        //            //头像地址
        //            q.departmentPhoto = photo;
        //        });
        //        var num = await _db.Updateable(userlist).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>
        /// 根据律师id修改律师事务所证明图片
        /// </summary>
        /// <param name="photo"></param>
        /// <param name="lawyerid"></param>
        /// <returns></returns>
        //[HttpPost]
        //[Route("EditLawyerDepartmentPhoto")]
        //public async Task<Result> EditLawyerDepartmentPhoto(EditLawyerInput input)
        //{
        //    try
        //    {
        //        _db.BeginTran();
        //        var userlist = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.Id ==input.lawyerid).ToListAsync();
        //        userlist.ForEach(q =>
        //        {
        //            //头像地址
        //            q.departmentPhoto = input.photo.ConvertToJsonStr();
        //        });
        //        var num = await _db.Updateable(userlist).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;
        //}
        public class EditLawyerInput
        {
            public string[] photo { get; set; }
            public string lawyerid { get; set; }
        }

        /// <summary>
        /// 根据律师id修改律师职业证图片
        /// </summary>
        /// <param name="photo"></param>
        /// <param name="lawyerid"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("EditLawyerIdentityphot")]
        public async Task<Result> EditLawyerIdentityphoto(EditLawyerInput input)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.Id ==input.lawyerid).ToListAsync();

                var deleteOldData = (string? jsonpath) =>
                {
                    if (string.IsNullOrEmpty(jsonpath))
                    {
                        return;
                    }
                    var photos = jsonpath.ConvertToModel<List<string>>() ?? new List<string>();
                    foreach (var photo in photos.Where(x => x != null))
                    {
                        var urlpath = photo.Split('/');
                        var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot", Path.Combine(urlpath));
                        if (System.IO.File.Exists(filepath))
                        {
                            System.IO.File.Delete(filepath);
                        }
                    }
                };
                userlist.ForEach(q =>
                {
                    deleteOldData(q.identityphoto);

                    //头像地址
                    q.identityphoto =input.photo.ConvertToJsonStr();
                });
                var num = await _db.Updateable(userlist).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>
        /// 修改身份证件 Identityphoto
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("EditIdentityphoto")]
        public async Task<Result> EditIdentityphoto(string photo)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.Id == _userdata.Id).ToListAsync();

                var deleteOldData = (string? jsonpath) =>
                {
                    if (string.IsNullOrEmpty(jsonpath))
                    {
                        return;
                    }
                    var photos = jsonpath.ConvertToModel<List<string>>() ?? new List<string>();
                    foreach (var photo in photos.Where(x => x != null))
                    {
                        var urlpath = photo.Split('/');
                        var filepath = Path.Combine(Environment.CurrentDirectory, "wwwroot", Path.Combine(urlpath));
                        if (System.IO.File.Exists(filepath))
                        {
                            System.IO.File.Delete(filepath);
                        }
                    }
                };

                userlist.ForEach(q =>
                {
                    //头像地址
                    q.identityphoto = photo;
                });
                var num = await _db.Updateable(userlist).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>
        /// 修改身份证 cardIdphoto
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("EditCardIdphoto")]
        public async Task<Result> EditCardIdphoto(string photo)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.Id == _userdata.Id).ToListAsync();
                userlist.ForEach(q =>
                {
                    //头像地址
                    q.cardIdphoto = photo;
                });
                var num = await _db.Updateable(userlist).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>
        /// app--认证接口
        /// </summary>
        /// <param name="Id">用户Id</param>
        /// <param name="status">审核状态：0：通过，1：不通过</param>
        /// <param name="describe">审核描述</param>
        /// <returns>律师信息审核认证</returns>
        [HttpGet]
        [Route("Examine")]
        public async Task<Result> Examine(string Id, int status, string describe)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.Id == Id).ToListAsync();
                if (userlist.Count > 0)
                {
                    var data = userlist.FirstOrDefault();
                    if (data!=null&&data.audit != 2)
                    {
                        result.IsSucceed = false;
                        result.result = "已审核处理！";
                        result.Message = "已审核处理！";
                        return result;
                    }
                }
                userlist.ForEach(q =>
                {
                    q.audit = status;
                    q.describe = describe;
                });
                var num = await _db.Updateable(userlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {                    //认证结果消息通知
                    if (userlist.Count > 0)
                    {
                        var str = status == 0 ? "认证通过" : "认证不通过";
                        if (!string.IsNullOrEmpty(userlist.FirstOrDefault().wechatId))
                        {
                            await wechatMessagerClient.gzhwxtsshtxjg(userlist.FirstOrDefault().wechatId, str, "", userlist.FirstOrDefault()?.createtime, DateTime.Now);
                        }
                    }
                    result.IsSucceed = true;
                    result.result = status == 0 ? "认证通过" : "认证不通过";
                }
            }
            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="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryRole")]
        public async Task<Result> QueryRole(App_Sys_RoleInput roledata)
        {
            RefAsync<int> totalNumber = 0;//总数据
            var list = await _db.Queryable<App_Sys_RoleModel>()
                .WhereIF(roledata.name.NotNull(), q => q.name.Contains(roledata.name))
                .WhereIF(roledata.unitCode.NotNull(), q => q.unitCode.Contains(roledata.unitCode))
                .WhereIF(_userdata.phone != "admin", x => x.userId == _userdata.Id)
                .Where(q => q.IsDeleted == 0).ToPageListAsync(roledata.PageIndex, roledata.PageSize, totalNumber);
            roledata.RowsCount = totalNumber;
            var data = new QueryResult<App_Sys_RoleModel>(roledata, list);
            result.IsSucceed = true;
            result.result = data;
            return result;
        }

        /// <summary>
        /// 添加角色
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddRole")]
        public async Task<Result> AddRole(App_Sys_RoleModel Roledata)
        {
            try
            {
                _db.BeginTran();
                Roledata.Id = Guid.NewGuid().ToString();
                Roledata.userId = _userdata.Id.ToString();
                Roledata.username = _userdata.name;
                var num = await _db.Insertable(Roledata).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "添加成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("角色管理", "添加角色信息", result, _db);
            return result;
        }

        /// <summary>
        /// 修改角色
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdateRole")]
        public async Task<Result> UpdateRole(App_Sys_RoleModel Roledata)
        {
            try
            {
                _db.BeginTran();
                var num = await _db.Updateable(Roledata).UpdateColumns(it => new { it.name }).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "修改成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("角色管理", "修改角色信息", result, _db);
            return result;
        }

        /// <summary>
        /// 删除角色
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteRole")]
        public async Task<Result> DeleteRole(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_RoleModel>().In(q => q.Id, Currency.id).ToListAsync();
                userlist.ForEach(q =>
                {
                    q.IsDeleted = 1;
                });
                var num = await _db.Updateable(userlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("角色管理", "删除角色信息", result, _db);
            return result;
        }
        #endregion

        #region 角色菜单管理
        /// <summary>
        /// 获取角色下的所有菜单Id
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryRoleMenu")]
        public async Task<Result> QueryRoleMenu(App_Sys_RoleMenuInput roledata)
        {
            var totalCount = 0;
            var list = await _db.Queryable<App_Sys_RoleMenuModel>()
                .WhereIF(!roledata.roleId.IsNull(), q => q.roleId == roledata.roleId)
                .Where(q => q.IsDelete == 0).Select(x => x.menuId).ToListAsync();
            //roledata.PageCount = totalCount;
            //var data = new QueryResult<App_Sys_RoleModel>(roledata, list);
            var ids = "";
            list.ForEach(x => ids += $"{x},");
            result.IsSucceed = true;
            result.result = ids.Trim(',').Split(",");
            return result;
        }

        /// <summary>
        /// 添加角色菜单
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddRoleMenu")]
        public async Task<Result> AddRoleMenu(App_Sys_RoleMenuAdd RoleMenudata)
        {
            try
            {
                if (string.IsNullOrEmpty(RoleMenudata.RoleMenuIds))
                {
                    result.IsSucceed = false;
                    result.result = "没有选中项";
                    return result;
                }
                //查询角色下的菜单
                var list = await _db.Queryable<App_Sys_RoleMenuModel>().Where(q => q.roleId == RoleMenudata.Id).ToListAsync();
                _db.BeginTran();
                //删除角色下的菜单
                await _db.Deleteable(list).ExecuteCommandAsync();
                var RoleMenulist = RoleMenudata.RoleMenuIds.Split(",").ToList();
                var menulist = new List<App_Sys_RoleMenuModel>();
                if (RoleMenulist.Count > 0)
                {
                    //添加角色菜单
                    for (int i = 0; i < RoleMenulist.Count; i++)
                    {
                        var App_Sys_RoleMenuModel = new App_Sys_RoleMenuModel()
                        {
                            Id = Guid.NewGuid().ToString(),
                            roleId = RoleMenudata.Id,
                            userId = _userdata.Id.ToString(),
                            username = _userdata.name,
                            menuId = RoleMenulist[i],
                        };
                        menulist.Add(App_Sys_RoleMenuModel);
                    }
                }
                var num = await _db.Insertable(menulist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "添加成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("角色管理", "添加角色菜单信息", result, _db);
            return result;
        }

        /// <summary>
        /// 删除角色菜单
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteRoleMenu")]
        public async Task<Result> DeleteRoleMenu(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_RoleMenuModel>().Where(q => q.roleId == Currency.tyId).In(q => q.menuId, Currency.id).ToListAsync();
                userlist.ForEach(q =>
                {
                    q.IsDelete = 1;
                });
                var num = await _db.Updateable(userlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("角色管理", "删除角色菜单信息", result, _db);
            return result;
        }
        #endregion

        #region 角色用户管理
        /// <summary>
        /// 获取角色下的所有用户
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryRoleUser")]
        public async Task<Result> QueryRoleUser(App_Sys_RoleUserInput roledata)
        {
            var totalCount = 0;
            //获取角色下得所有用户id
            var list = await _db.Queryable<App_Sys_RoleUserModel>()
                .WhereIF(roledata.roleId.IsNull(), q => q.roleId == roledata.roleId)
                .Where(q => q.IsDelete == 0).Select(x => x.roleuserId).ToListAsync();
            //roledata.PageCount = totalCount;
            //var data = new QueryResult<App_Sys_RoleMenuModel>(roledata, list);
            result.IsSucceed = true;
            result.result = list;
            return result;
        }

        /// <summary>
        /// 添加角色用户
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddRoleUser")]
        public async Task<Result> AddRoleUser(App_Sys_RoleUserAdd RoleUser)
        {
            try
            {
                //查询角色下的菜单
                var list = await _db.Queryable<App_Sys_RoleUserModel>().Where(q => q.roleId == RoleUser.roleId).ToListAsync();
                _db.BeginTran();
                //删除角色下的菜单
                await _db.Deleteable(list).ExecuteCommandAsync();
                RoleUser.roleuserlist.ForEach(RoleUserdata =>
                {
                    RoleUserdata.Id = Guid.NewGuid().ToString();
                    RoleUserdata.roleuserId = RoleUser.roleId;
                    RoleUserdata.userId = _userdata.Id.ToString();
                    RoleUserdata.username = _userdata.name;
                });
                var num = await _db.Insertable(RoleUser.roleuserlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "添加成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("角色管理", "添加角色用户信息", result, _db);
            return result;
        }

        /// <summary>
        /// 删除角色用户
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteRoleUser")]
        public async Task<Result> DeleteRoleUser(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var userlist = await _db.Queryable<App_Sys_RoleUserModel>().Where(q => q.roleId == Currency.tyId).In(q => q.roleuserId, Currency.id).ToListAsync();
                userlist.ForEach(q =>
                {
                    q.IsDelete = 1;
                });
                var num = await _db.Updateable(userlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("角色管理", "删除角色用户信息", result, _db);
            return result;
        }
        #endregion

        #region 单位管理
        /// <summary>
        /// 单位list集合
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryUnitlist")]
        public async Task<Result> QueryUnitlist(App_Sys_UnitInput Unitdata)
        {
            var list = await _db.Queryable<App_Sys_UnitModel>()
                .WhereIF(!Unitdata.unitCode.IsNull(), q => q.unitCode.Contains(Unitdata.unitCode))
                .WhereIF(!Unitdata.unitname.IsNull(), q => q.unitname.Contains(Unitdata.unitname))
                .WhereIF(!Unitdata.unitjc.IsNull(), q => q.unitjc.Contains(Unitdata.unitjc))
                .Where(q => q.IsDelete == 0).ToListAsync();
            result.IsSucceed = true;
            result.result = list;
            return result;
        }
        /// <summary>
        /// 单位树型查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryUnitTree")]
        public async Task<Result> QueryUnitTree(App_Sys_UnitInput Unitdata)
        {
            var treelist = await _db.Queryable<App_Sys_UnitTree>()
                .WhereIF(!Unitdata.unitCode.IsNull(), q => q.unitCode.Contains(Unitdata.unitCode))
                .WhereIF(!Unitdata.unitname.IsNull(), q => q.unitname.Contains(Unitdata.unitname))
                .WhereIF(!Unitdata.unitjc.IsNull(), q => q.unitjc.Contains(Unitdata.unitjc))
                .WhereIF(Unitdata.StartTime != null && Unitdata.EndTime != null, q => q.createtime >= Unitdata.StartTime && q.createtime < Unitdata.EndTime.Value.AddDays(1))
                .Where(q => q.IsDelete == 0).ToTreeAsync(it => it.children, it => it.pid, null);
            result.IsSucceed = true;
            result.result = treelist;
            return result;
        }

        /// <summary>
        /// 添加单位
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddUnit")]
        public async Task<Result> AddUnit(App_Sys_UnitModel Unitdata)
        {
            try
            {
                //添加单位前判断单位编码是否重复
                var data = await _db.Queryable<App_Sys_UnitModel>().Where(q => q.unitCode == Unitdata.unitCode).FirstAsync();
                if (data != null)
                {

                    result.IsSucceed = false;
                    result.Message = "单位编码已存在！";
                    return result;
                }
                _db.BeginTran();
                Unitdata.Id = Guid.NewGuid().ToString();
                Unitdata.createuserId = _userdata.Id.ToString();
                Unitdata.createusername = _userdata.name;
                var num = await _db.Insertable(Unitdata).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "添加成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("单位管理", "添加单位信息", result, _db);
            return result;
        }

        /// <summary>
        /// 修改单位
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdateUnit")]
        public async Task<Result> UpdateUnit(App_Sys_UnitModel Unitdata)
        {
            try
            {
                //判断单位编码是否已存在
                var data = await _db.Queryable<App_Sys_UnitModel>().Where(q => q.unitCode == Unitdata.unitCode).FirstAsync();
                if (data != null && data.Id != Unitdata.Id)
                {

                    result.IsSucceed = false;
                    result.Message = "单位编码已存在！";
                    return result;
                }
                _db.BeginTran();
                var num = await _db.Updateable(Unitdata).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;
            }
            _logs.WriteSysLogadd("单位管理", "修改单位信息", result, _db);
            return result;
        }

        /// <summary>
        /// 删除单位
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteUnit")]
        public async Task<Result> DeleteUnit(CurrencyDelete Currency)
        {
            try
            {
                //查询单位是否存在子级
                var Unitpidlist = await _db.Queryable<App_Sys_UnitModel>().In(q => q.pid, Currency.id).ToListAsync();
                if (Unitpidlist.Count() > 0)
                {
                    result.IsSucceed = false;
                    result.result = "删除单位存在子级数据！";
                    return result;
                }
                _db.BeginTran();
                var Unitlist = await _db.Queryable<App_Sys_UnitModel>().In(q => q.Id, Currency.id).ToListAsync();
                Unitlist.ForEach(q =>
                {
                    q.IsDelete = 1;
                });
                var num = await _db.Updateable(Unitlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("单位管理", "删除单位信息", result, _db);
            return result;
        }
        #endregion

        #region 部门管理

        /// <summary>
        /// 通过单位ID查询部门
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("QueryDepart")]
        [AllowAnonymous]
        public async Task<Result> QueryDepart(string unitId)
        {
            var totalCount = 0;
            var list = await _db.Queryable<App_Sys_DepartModel>()
                .WhereIF(!unitId.IsNull(), q => q.unitCode.Contains(unitId))
                .Where(q => q.IsDelete == 0).ToListAsync();
            result.IsSucceed = true;
            result.result = list;
            return result;
        }
        /// <summary>
        /// 部门分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryDepart")]
        public async Task<Result> QueryDepart(App_Sys_DepartInput Departdata)
        {
            RefAsync<int> totalNumber = 0;//总数据
            var list = await _db.Queryable<App_Sys_DepartModel>()
                .WhereIF(!Departdata.departCode.IsNull(), q => q.departCode.Contains(Departdata.departCode))
                .WhereIF(!Departdata.departjc.IsNull(), q => q.departjc.Contains(Departdata.departjc))
                .WhereIF(!Departdata.departname.IsNull(), q => q.departname.Contains(Departdata.departname))
                .WhereIF(!Departdata.unitId.IsNull(), q => q.unitCode.Contains(Departdata.unitId))
                .WhereIF(Departdata.StartTime != null && Departdata.EndTime != null, q => q.createtime >= Departdata.StartTime && q.createtime < Departdata.EndTime.Value.AddDays(1))
                .Where(q => q.IsDelete == 0).ToPageListAsync(Departdata.PageIndex, Departdata.PageSize, totalNumber);
            Departdata.RowsCount = totalNumber;
            var data = new QueryResult<App_Sys_DepartModel>(Departdata, list);
            result.IsSucceed = true;
            result.result = data;
            return result;
        }

        /// <summary>
        /// 添加部门
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddDepart")]
        public async Task<Result> AddDepart(App_Sys_DepartModel Departdata)
        {
            try
            {
                //添加单位前判断单位编码是否重复
                var data = await _db.Queryable<App_Sys_DepartModel>().Where(q => q.departCode == Departdata.departCode && q.IsDelete == 0).FirstAsync();
                if (data != null)
                {

                    result.IsSucceed = false;
                    result.Message = "部门编码已存在！";
                    return result;
                }
                _db.BeginTran();
                Departdata.Id = Guid.NewGuid().ToString();
                Departdata.createuserId = _userdata.Id.ToString();
                Departdata.createusername = _userdata.name;
                var num = await _db.Insertable(Departdata).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "添加成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("部门管理", "添加部门信息", result, _db);
            return result;
        }

        /// <summary>
        /// 修改部门
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("UpdateDepart")]
        public async Task<Result> UpdateDepart(App_Sys_DepartModel Departdata)
        {
            try
            {
                //判断单位编码是否已存在
                var data = await _db.Queryable<App_Sys_DepartModel>().Where(q => q.Id == Departdata.Id && q.IsDelete == 0).FirstAsync();
                if (data != null)
                {
                    var IsCodeExites = await _db.Queryable<App_Sys_DepartModel>().Where(q => q.departCode == Departdata.departCode && q.IsDelete == 0 && q.Id != Departdata.Id).AnyAsync();
                    if (IsCodeExites)
                    {
                        result.IsSucceed = false;
                        result.Message = "部门编码已存在！";
                        return result;
                    }
                }
                _db.BeginTran();
                var num = await _db.Updateable(Departdata).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;
            }
            _logs.WriteSysLogadd("部门管理", "修改部门信息", result, _db);
            return result;
        }

        /// <summary>
        /// 删除部门
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("DeleteDepart")]
        public async Task<Result> DeleteDepart(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var Departlist = await _db.Queryable<App_Sys_DepartModel>().In(q => q.Id, Currency.id).ToListAsync();
                Departlist.ForEach(q =>
                {
                    q.IsDelete = 1;
                });
                var num = await _db.Updateable(Departlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    result.IsSucceed = true;
                    result.result = "删除成功";
                }
            }
            catch (System.Exception ex)
            {
                _db.RollbackTran();
                result.IsSucceed = false;
                result.Message = ex.Message;
            }
            _logs.WriteSysLogadd("部门管理", "删除部门信息", result, _db);
            return result;
        }
        #endregion

        #region 菜单管理

        /// <summary>
        /// 获取父级菜单
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetQueryMenulist")]
        public async Task<Result> GetQueryMenulist()
        {
            var list = await _db.Queryable<App_Sys_MenuModel>().Where(q => q.IsDelete == 0 || q.pid == null || q.pid == "").Select(q => new { q.Id, q.name }).ToListAsync();
            result.IsSucceed = true;
            result.result = list;
            return result;
        }

        /// <summary>
        /// 菜单树型查询
        /// </summary>
        /// <param name="Menudata"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryMenuTree")]
        public async Task<Result> QueryMenuTree(App_Sys_MenuInput Menudata)
        {
            var roleids = new List<string?>();
            if (_userdata.phone != "admin")
            {
                var userroleinfo = await _db.Queryable<App_Sys_RoleUserModel>().FirstAsync(x => x.roleuserId == _userdata.Id);
                roleids = await _db.Queryable<App_Sys_RoleMenuModel>()
                    .WhereIF(!userroleinfo.roleId.IsNull(), q => q.roleId == userroleinfo.roleId)
                    .Where(q => q.IsDelete == 0).Select(x => x.menuId).ToListAsync();
            }
            var treelist = await _db.Queryable<App_Sys_MenuTree>()
                .WhereIF(!Menudata.name.IsNull(), q => q.name.Contains(Menudata.name))
                .WhereIF(!Menudata.title.IsNull(), q => q.title.Contains(Menudata.title))
                .Where(q => q.IsDelete == 0)
                .OrderBy(q => q.sortnum, OrderByType.Asc)
                .ToTreeAsync(it => it.children, it => it.pid, null);
            if (_userdata.phone != "admin")
            {
                foreach (var item in treelist)
                {
                    if (roleids.Contains(item.Id))
                    {
                        if (item.children != null)
                        {
                            item.children = item.children.Where(x => roleids.Contains(x.Id)).ToList();
                        }
                    }
                    else
                    {
                        if (item.children == null)
                        {
                            item.IsDelete = -1;
                        }
                        else
                        {
                            if (item.children.Any(x => roleids.Contains(x.Id)))
                            {
                                item.children = item.children.Where(x => roleids.Contains(x.Id)).ToList();
                            }
                            else
                            {
                                item.IsDelete = -1;
                            }
                        }
                    }
                }
                treelist = treelist.Where(x => x.IsDelete != -1).ToList();

                result.IsSucceed = true;
                result.result = treelist;
                return result;
            }
            else
            {
                result.IsSucceed = true;
                result.result = treelist;
                return result;
            }

        }
        /// <summary>
        /// 菜单分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryMenupage")]
        public async Task<Result> QueryMenupage(App_Sys_MenuInput Menudata)
        {
            try
            {
                RefAsync<int> totalNumber = 0;//总数据
                var list = await _db.Queryable<App_Sys_MenuModel>()
                    .WhereIF(!Menudata.name.IsNull(), q => q.name.Contains(Menudata.name))
                    .WhereIF(!Menudata.pid.IsNull(), q => q.pid.Contains(Menudata.pid))
                    .Where(q => q.IsDelete == 0).ToPageListAsync(Menudata.PageIndex, Menudata.PageSize, totalNumber);
                Menudata.RowsCount = totalNumber;
                var data = new QueryResult<App_Sys_MenuModel>(Menudata, list.OrderByDescending(q => q.createtime).ToList());

                result.IsSucceed = true;
                result.result = data;
            }
            catch (Exception ex)
            {
                result.IsSucceed = false;
                result.result = ex.Message;
                LogService.WriteLog(ex, "菜单分页查询");
            }
            return result;
        }
        /// <summary>
        /// 添加菜单
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddMenu")]
        public async Task<Result> AddMenu(App_Sys_MenuModel Menudata)
        {
            try
            {
                _db.BeginTran();
                Menudata.Id = Guid.NewGuid().ToString();
                Menudata.createuserId = _userdata.Id;
                Menudata.createusername = _userdata.name;
                var num = await _db.Insertable(Menudata).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("UpdateMenu")]
        public async Task<Result> UpdateMenu(App_Sys_MenuModel Menudata)
        {
            try
            {
                _db.BeginTran();
                var num = await _db.Updateable(Menudata).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("DeleteMenu")]
        public async Task<Result> DeleteMenu(CurrencyDelete Currency)
        {
            try
            {
                _db.BeginTran();
                var Menulist = await _db.Queryable<App_Sys_MenuModel>().In(q => q.Id, Currency.id).ToListAsync();
                Menulist.ForEach(q =>
                {
                    q.IsDelete = 1;
                });
                var num = await _db.Updateable(Menulist).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="info"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("GetroleMenu")]
        public async Task<Result> GetroleMenu()
        {
            var list = new List<dynamic>();
            //获取父级菜单
            var pidlist = await _db.Queryable<App_Sys_MenuModel>().Where(q => q.IsDelete == 0 && string.IsNullOrEmpty(q.pid)).ToListAsync();
            //联表查询该用户菜单
            var menulist = await Task.Run(async () =>
            {
                if (_userdata.phone == "admin")
                {
                    return await _db.Queryable<App_Sys_MenuModel>()
                                    .Where(x => x.IsDelete == 0)
                                    .ToListAsync();
                }
                else
                {
                    return await _db.Queryable<App_Sys_RoleUserModel>()
                                        .Where(x => x.roleuserId == _userdata.Id)
                                        .LeftJoin<App_Sys_RoleMenuModel>((o, cus) => o.roleId == cus.roleId)
                                        .LeftJoin<App_Sys_MenuModel>((o, cus, menu) => cus.menuId == menu.Id)
                                        .Where((o, cus, menu) => o.IsDelete == 0 && cus.IsDelete == 0 && menu.IsDelete == 0)
                                        .Select((o, cus, menu) => menu)
                                        .ToListAsync();
                }
            });

            //通过分组父级菜单
            var datalist = menulist.OrderBy(q => q.sortnum)
                                   .GroupBy(q => q.pid)
                                   .Select(q => new { pid = q.Key, dalist = q.OrderBy(q => q.sortnum).ToList() })
                                   .ToList();
            if (datalist.Count > 0)
            {
                pidlist.OrderBy(q => q.sortnum).ToList().ForEach(item =>
                {
                    var data = datalist.Where(q => q.pid == item.Id).FirstOrDefault();
                    var childrenlist = new List<dynamic>();
                    if (data != null)
                    {
                        //添加子菜单
                        data.dalist.ForEach(it =>
                        {
                            childrenlist.Add(new
                            {

                                path = it.path,
                                name = it.name,
                                component = it.component,
                                //redirect = it.redirect,
                                meta = new
                                {
                                    title = it.title,
                                    //hideMenu = it.hideMenu,
                                    //hideBreadcrumb = it.hideBreadcrumb,
                                    //currentActiveMenu = it.currentActiveMenu,
                                    icon = it.icon,
                                },
                            });
                        });
                    }

                    var fjdata = datalist.Where(q => string.IsNullOrEmpty(q.pid)).FirstOrDefault()?.dalist.FirstOrDefault(q => q.Id == item.Id);
                    if (childrenlist.Count > 0 || fjdata != null)
                    {

                        //添加父级菜单
                        list.Add(new
                        {

                            path = item.path,
                            name = item.name,
                            component = item.component,
                            //redirect = data.redirect,
                            meta = new
                            {
                                title = item.title,
                                //hideChildrenInMenu = data.hideChildrenInMenu,
                                icon = item.icon,
                            },
                            children = childrenlist
                        });
                    }
                });
            }

            result.IsSucceed = true;
            result.result = list;
            return result;
        }
        #endregion
    }
}