using AutoMapper;
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,
                    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.audit != null, q => q.audit == UserModel.audit)
                .WhereIF(UserModel.isdeactivate >=0, q => q.isdeactivate == UserModel.isdeactivate)
                .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.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;
                }

                _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 }).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>().Where(x => x.Id == _userdata.Id && x.IsDeleted == 0).FirstAsync();
                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>
        /// 删除用户
        /// </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>
        /// 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();
                userlist.ForEach(q =>
                {
                    q.audit = status;
                    q.describe = describe;
                });
                var num = await _db.Updateable(userlist).ExecuteCommandAsync();
                _db.CommitTran();
                if (num > 0)
                {
                    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))
                .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(",");
                var menulist = new List<App_Sys_RoleMenuModel>();
                if (RoleMenulist.Length > 0)
                {
                    //添加角色菜单
                    for (int i = 0; i < RoleMenulist.Length; 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)
                {

                    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.departCode == Departdata.departCode && q.IsDelete == 0).FirstAsync();
                if (data != null)
                {

                    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 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);
            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 _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();
            if (_userdata.phone == "admin")
            {
                menulist = await _db.Queryable<App_Sys_MenuModel>().Where(x => x.IsDelete == 0).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
    }
}