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

using com.sun.xml.@internal.ws.api.model;
using Elight.Entity;
using Elight.Logic;
using Elight.Logic.SystemModel;
using Elight.Utility;
using Elight.Utility.Code;
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;//日志
        Result result = new Result();
        public SystemControllerController(ILogger<LoginController> logger, SqlSugarClient db, WriteSysLog logs, User user)
        {
            _logger = logger;
            _db = db;
            _logs = logs;
            _userdata = user.Userdata();
        }
        #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.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).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 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.usertype == 0&&q.unitCode==_userdata.unitCode&&q.phone!="admin")
                .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
                });
            });
            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)
        {
            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.usertype == 1).ToPageListAsync(UserModel.PageIndex, UserModel.PageSize);
            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_UserModel UserModel)
        {
            try
            {
                var data = await _db.Queryable<App_Sys_UserModel>().Where(q => q.IsDeleted == 0 && q.phone == UserModel.phone || q.cardId == UserModel.cardId).FirstAsync();
                if (data != null)
                {
                    result.IsSucceed = false;
                    result.Message = "电话号码或身份证号已存在！";
                    return result;
                }
                _db.BeginTran();
                UserModel.Id = Guid.NewGuid().ToString();
                UserModel.createuserId = _userdata.Id.ToString();
                UserModel.createusername = _userdata.name;
                UserModel.usertype = 0;
                //默认密码
                UserModel.Password = Elight.Utility.Encrypt.Md5.Encrypt32($"mr123456").ToLower();
                var num = await _db.Insertable(UserModel).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_UserModel UserModel)
        {
            try
            {
                _db.BeginTran();
                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>
        /// 删除用户
        /// </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;
        }
        #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>
        /// 获取角色下的所有菜单信息
        /// </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.IsDeleted == 0).Select(x => x.menuId).ToListAsync();
            //roledata.PageCount = totalCount;
            //var data = new QueryResult<App_Sys_RoleModel>(roledata, list);
            result.IsSucceed = true;
            result.result = list;
            return result;
        }

        /// <summary>
        /// 添加角色菜单
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("AddRoleMenu")]
        public async Task<Result> AddRoleMenu(App_Sys_RoleMenuAdd RoleMenudata)
        {
            try
            {
                //查询角色下的菜单
               var list=await _db.Queryable<App_Sys_RoleMenuModel>().Where(q => q.roleId== RoleMenudata.Id).ToListAsync();
                _db.BeginTran();
                //删除角色下的菜单
                await _db.Deleteable(list).ExecuteCommandAsync();
                //添加角色菜单
                RoleMenudata.RoleMenulist.ForEach(data =>
                {
                    data.Id = Guid.NewGuid().ToString();
                    data.roleId = RoleMenudata.Id;
                    data.userId = _userdata.Id.ToString();
                    data.username = _userdata.name;
                });
                var num = await _db.Insertable(RoleMenudata.RoleMenulist).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.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>
        /// 获取角色下的所有用户
        /// </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.IsDeleted == 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(List<App_Sys_RoleUserModel> RoleUserlist)
        {
            try
            {
                _db.BeginTran();
                RoleUserlist.ForEach(RoleMenudata =>
                {
                    RoleMenudata.Id = Guid.NewGuid().ToString();
                    RoleMenudata.userId = _userdata.Id.ToString();
                    RoleMenudata.username = _userdata.name;
                });
                var num = await _db.Insertable(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.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>
        /// 单位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")]
        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).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).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("GetQueryMenusssslist")]
        public async Task<Result> GetQueryMenusssslist()
        {
            var list = await _db.Queryable<App_Sys_MenuModel>().Where(q => q.IsDelete == 0 && q.pid.IsNull()).Select(q => new { q.Id, q.name }).ToListAsync();
            result.IsSucceed = true;
            result.result = list;
            return result;
        }

        /// <summary>
        /// 单位树型查询
        /// </summary>
        /// <param name="info"></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.Desc).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).ToListAsync();
            //联表查询该用户菜单
            var menulist = await _db.Queryable<App_Sys_RoleUserModel>().Where(q => q.roleuserId == _userdata.Id)
     .LeftJoin<App_Sys_RoleMenuModel>((o, cus) => o.roleId == cus.roleId)
     .LeftJoin<App_Sys_MenuModel>((o, cus, menu) => o.roleId == cus.roleId)
     .Where((o, cus, menu) => o.IsDeleted == 0 && cus.IsDeleted == 0 && menu.IsDelete == 0)
     .Select((o, cus, menu) => menu)
     .ToListAsync();
            //通过分组父级菜单
            var datalist = menulist.GroupBy(q => q.pid).Select(q => new { pid = q.Key, dalist = q.ToList() }).ToList();

            datalist.ForEach(item =>
            {
                var data = pidlist.Where(q => q.Id == item.pid).FirstOrDefault();
                if (data != null)
                {
                    var childrenlist = new List<dynamic>();
                    //添加子菜单
                    item.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,
                            },
                        });
                    });

                    //添加父级菜单
                    list.Add(new
                    {
                        path = data.path,
                        name = data.name,
                        component = data.component,
                        //redirect = data.redirect,
                        meta = new
                        {
                            title = data.title,
                            //hideChildrenInMenu = data.hideChildrenInMenu,
                            icon = data.icon,
                        },
                        children = childrenlist
                    });
                }
            });

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