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

using Elight.Entity;
using Elight.Logic;
using Elight.Logic.SystemModel;
using Elight.Utility;
using Elight.Utility.Code;
using Elight.Utility.Extensions;
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>
        /// 系统用户分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryUser0")]
        public async Task<Result> QueryUser0(App_Sys_UserInput UserModel)
        {
            var list = await _db.Queryable<App_Sys_UserModel>()
                .WhereIF(!UserModel.name.IsNullOrEmpty(), q => q.name.Contains(UserModel.name))
                .WhereIF(!UserModel.phone.IsNullOrEmpty(), q => q.phone.Contains(UserModel.phone))
                .WhereIF(!UserModel.duties.IsNullOrEmpty(), q => q.duties.Contains(UserModel.duties))
                .WhereIF(!UserModel.cardId.IsNullOrEmpty(), q => q.cardId.Contains(UserModel.cardId))
                .Where(q => q.IsDeleted == 0 && q.usertype == 0)
                .ToPageListAsync(UserModel.PageIndex, UserModel.PageSize);
            var data = new QueryResult<App_Sys_UserModel>(UserModel, list);
            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.IsNullOrEmpty(), q => q.name.Contains(UserModel.name))
                .WhereIF(!UserModel.phone.IsNullOrEmpty(), q => q.phone.Contains(UserModel.phone))
                .WhereIF(!UserModel.duties.IsNullOrEmpty(), q => q.duties.Contains(UserModel.duties))
                .WhereIF(!UserModel.cardId.IsNullOrEmpty(), 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.phone == UserModel.phone).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>
        /// APP添加用户
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpPost]
        [Route("AddUser1")]
        public async Task<Result> AddUser1(App_Sys_UserModel UserModel)
        {
            try
            {
                var data = await _db.Queryable<App_Sys_UserModel>().Where(q => q.phone == UserModel.phone).FirstAsync();
                if (data != null)
                {
                    result.IsSucceed = false;
                    result.Message = "电话号码已存在！";
                    return result;
                }
                _db.BeginTran();
                UserModel.Id = Guid.NewGuid().ToString();
                UserModel.usertype = 1;
                //默认密码
                UserModel.Password = Elight.Utility.Encrypt.Md5.Encrypt32($"{UserModel.Password}").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("用户管理", "添加APP端用户", 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;
        }
        #endregion

        #region 角色管理
        /// <summary>
        /// 角色分页查询
        /// </summary>
        /// <param name="info"></param>
        /// <returns></returns>
        [HttpPost]
        [Route("QueryRole")]
        public async Task<Result> QueryRole(App_Sys_RoleInput roledata)
        {
            var totalCount = 0;
            var list = await _db.Queryable<App_Sys_RoleModel>()
                .WhereIF(!string.IsNullOrEmpty(roledata.name), q => q.name.Contains(roledata.name))
                .Where(q => q.IsDeleted == 0).ToPageListAsync(roledata.PageIndex, roledata.PageSize);
            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.IsNullOrEmpty(), 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(List<App_Sys_RoleMenuModel> RoleMenulist)
        {
            try
            {
                _db.BeginTran();
                RoleMenulist.ForEach(RoleMenudata =>
                {
                    RoleMenudata.Id = Guid.NewGuid().ToString();
                    RoleMenudata.userId = _userdata.Id.ToString();
                    RoleMenudata.username = _userdata.name;
                });
                var num = await _db.Insertable(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(!string.IsNullOrEmpty(roledata.roleId), 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.IsNullOrEmpty(), q => q.unitCode.Contains(Unitdata.unitCode))
                .WhereIF(!Unitdata.unitname.IsNullOrEmpty(), q => q.unitname.Contains(Unitdata.unitname))
                .WhereIF(!Unitdata.unitjc.IsNullOrEmpty(), 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.IsNullOrEmpty(), q => q.unitCode.Contains(Unitdata.unitCode))
                .WhereIF(!Unitdata.unitname.IsNullOrEmpty(), q => q.unitname.Contains(Unitdata.unitname))
                .WhereIF(!Unitdata.unitjc.IsNullOrEmpty(), 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.Child, 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.IsNullOrEmpty(), q => q.unitId.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)
        {
            var list = await _db.Queryable<App_Sys_DepartModel>()
                .WhereIF(!Departdata.departCode.IsNullOrEmpty(), q => q.departCode.Contains(Departdata.departCode))
                .WhereIF(!Departdata.departjc.IsNullOrEmpty(), q => q.departjc.Contains(Departdata.departjc))
                .WhereIF(!Departdata.departname.IsNullOrEmpty(), q => q.departname.Contains(Departdata.departname))
                .WhereIF(!Departdata.unitId.IsNullOrEmpty(), q => q.unitId.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);
            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 && !string.IsNullOrEmpty(q.pid)).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("QueryMenupage")]
        public async Task<Result> QueryMenupage(App_Sys_MenuInput Menudata)
        {
            var totalCount = 0;
            var list = await _db.Queryable<App_Sys_MenuModel>()
                .WhereIF(!Menudata.name.IsNullOrEmpty(), q => q.name.Contains(Menudata.name))
                .WhereIF(!Menudata.pid.IsNullOrEmpty(), q => q.pid.Contains(Menudata.pid))
                .Where(q => q.IsDelete == 0).ToPageListAsync(Menudata.PageIndex, Menudata.PageSize);
            var data = new QueryResult<App_Sys_MenuModel>(Menudata, list);
            result.IsSucceed = true;
            result.result = data;
            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;
            }
            _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;
            }
            _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;
            }
            _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).First();
                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
    }
}