OA2023/OASystem/OASystem.Api/Controllers/SystemController.cs

using AutoMapper.Execution;
using Google.Protobuf.WellKnownTypes;
using Microsoft.AspNetCore.Mvc.Formatters;
using Microsoft.AspNetCore.Mvc.ModelBinding;
using Newtonsoft.Json.Linq;
using OASystem.Domain.Dtos.System;
using OASystem.Domain.ViewModels.QiYeWeChat;
using Org.BouncyCastle.Asn1.Cms;
using System.Collections;
using System.Xml.Linq;
using static OASystem.API.OAMethodLib.GeneralMethod;
using static OpenAI.GPT3.ObjectModels.SharedModels.IOpenAiModels;

namespace OASystem.API.Controllers
{
    /// <summary>
    /// 系统设置
    /// </summary>
    //[Authorize]
    [Route("api/[controller]/[action]")]
    public class SystemController : ControllerBase
    {
        private readonly CompanyRepository _syscomRep;
        private readonly DepartmentRepository _sysDepRep;
        private readonly UsersRepository _userRep;
        private readonly IMapper _mapper;
        private readonly SqlSugarClient _sqlSugar;
        private readonly MessageRepository _messageRep;
        private readonly SetDataRepository _setDataRepository;
        private readonly SystemMenuPermissionRepository _SystemMenuPermissionRepository;
        private readonly CompanyRepository _CompanyRepository;
        private readonly PageFunctionPermissionRepository _PageFunctionPermissionRepository;
        private readonly SystemMenuAndFunctionRepository _SystemMenuAndFunctionRepository;
        private readonly JobPostAuthorityRepository _JobPostAuthorityRepository;
        private readonly JobPostRepository _jobRep;
        private readonly SetDataTypeRepository _setDataTypeRep;
        private readonly UserAuthorityRepository _UserAuthorityRepository;


        private readonly List<int> _operationTypeList = new List<int>() { 1, 2, 3, 4, 5 }; //操作通知所属类型
        private readonly List<int> _taskTypeList = new List<int>() { 6 };//任务通知 TaskNotification

        public SystemController( CompanyRepository syscom, DepartmentRepository sysDepRep, UsersRepository userRep,
            IMapper mapper,SqlSugarClient sqlSugar, SetDataRepository setDataRepository, CompanyRepository companyRepository,
            SystemMenuPermissionRepository systemMenuPermissionRepository, PageFunctionPermissionRepository pageFunctionPermissionRepository,
            SystemMenuAndFunctionRepository systemMenuAndFunctionRepository, JobPostAuthorityRepository jobPostAuthorityRepository, 
            JobPostRepository jobRep,UserAuthorityRepository userAuthorityRepository, MessageRepository messageRep,SetDataTypeRepository setDataTypeRep)
            
        {
            _syscomRep = syscom;
            _sysDepRep = sysDepRep;
            _messageRep = messageRep;
            _userRep = userRep;
            _mapper = mapper;
            _sqlSugar = sqlSugar;
            _setDataRepository = setDataRepository;
            _CompanyRepository = companyRepository;
            _SystemMenuPermissionRepository = systemMenuPermissionRepository;
            _PageFunctionPermissionRepository = pageFunctionPermissionRepository;
            _SystemMenuAndFunctionRepository = systemMenuAndFunctionRepository;
            _JobPostAuthorityRepository = jobPostAuthorityRepository;
            _UserAuthorityRepository = userAuthorityRepository;
            _jobRep = jobRep;
            _setDataTypeRep = setDataTypeRep;
        }
        #region 消息

        /// <summary>
        /// 获取消息列表-整合版
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> PsotMsgPageList(MsgDto dto)
        {
            var msgData = await _messageRep.GetMsgList(dto);

            if (msgData.Code != 0)
            {
                return Ok(JsonView(false, msgData.Msg));
            }

            return Ok(JsonView(msgData.Data));
        }

        #region 消息列表 - 分开

        /// <summary>
        /// 系统消息
        /// 消息类型  2024-03-06 14：37
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> PotsMsgTypeData(MsgTypeDto dto)
        {
            if (dto.PortType < 1 || dto.PortType > 3)
            {
                return Ok(JsonView(false, "请输入有效的PortType参数。1 Web 2 Android 3 IOS"));
            }

            if (dto.UserId < 1)
            {
                return Ok(JsonView(false, "请输入有效的UserId参数。"));
            }

            var msgData = await _messageRep.PotsMsgTypeData(dto);

            if (msgData.Code != 0)
            {

                return Ok(JsonView(400, msgData.Msg, new string[] { }));
            }

            return Ok(JsonView(true, msgData.Msg, msgData.Data));
        }
        
        /// <summary>
        /// 系统消息
        /// 消息List  2024-03-06 14：54
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> PotsMessagePageList(PotsMessagePageListDto dto)
        {
            #region 参数验证

            if (dto.PortType < 1 || dto.PortType > 3)
            {
                return Ok(JsonView(false, "请输入有效的PortType参数。1 Web 2 Android 3 IOS"));
            }

            var typeData = await _sqlSugar.Queryable<Sys_SetData>().Where(it => it.STid == 77).Select(it => it.Id).ToListAsync();
            if (typeData.Count < 0)
            {
                return Ok(JsonView(false, "消息类型不存在"));
            }

            if (!typeData.Contains( dto.Type))
            {
                return Ok(JsonView(false, "请输入有效的Type参数。1021 团组操作通知 1020 任务操作通知 "));
            }
            if (dto.UserId < 1)
            {
                return Ok(JsonView(false, "请输入有效的UserId参数。"));
            }

            if (dto.ReadStatus < 1 || dto.ReadStatus > 3)
            {
                return Ok(JsonView(false, "请输入有效的ReadStatus参数。1 全部(包含已读/未读) 2 未读 3 已读"));
            }

            #endregion

            //userId
            string msgSqlWhere = $" And smra.ReadableUId = {dto.UserId}";

            //消息类型
            string typeStr = "";
            List<NotificationTypeView> messageTypeViews = AppSettingsHelper.Get<NotificationTypeView>("MessageNotificationType");
            if (dto.Type == 1020) //任务操作通知 
            {
                typeStr = String.Join(",", messageTypeViews.Where(it => it.TypeId == 1020).FirstOrDefault().MsgTypeIds.ToList());
            }
            else if (dto.Type == 1021)//团组操作通知
            {
                typeStr = String.Join(",", messageTypeViews.Where(it => it.TypeId == 1021).FirstOrDefault().MsgTypeIds.ToList());
            }
            else if (dto.Type == 1022)//公告通知
            {
                typeStr = String.Join(",", messageTypeViews.Where(it => it.TypeId == 1022).FirstOrDefault().MsgTypeIds.ToList());
            }
           
            if (!string.IsNullOrEmpty(typeStr))
            {
                msgSqlWhere += $" And sm.Type In ({typeStr})";
            }

            //是否已读处理 1 全部(包含已读/未读) 2 未读 3 已读
            if (dto.ReadStatus == 1) msgSqlWhere += "";
            else if (dto.ReadStatus == 2) msgSqlWhere += $" And smra.IsRead = {0}";
            else if (dto.ReadStatus == 3) msgSqlWhere += $" And smra.IsRead = {1}";


            string msgSql = string.Format(@"Select * From(
                                                Select row_number() over(order by sm.ReleaseTime Desc) as RowNumber,
                                                    sm.Id,sm.Type,sm.Title,sm.Content,sd.DepName issuerDep,su.CnName issuerUser, 
                                                    sm.ReleaseTime,smra.ReadableUId,smra.IsRead,sm.DiId,sm.Param
                                                From Sys_Message sm 
                                                Inner Join Sys_MessageReadAuth smra On sm.Id = smra.MsgId
                                                Inner Join Sys_Users su On sm.IssuerId = su.Id
                                                Inner Join Sys_Department sd On su.DepId = sd.Id
                                                Inner Join Sys_Users suAuth On smra.ReadableUId = suAuth.Id
                                                Where sm.IsDel = 0
                                                And smra.IsDel = 0 {0}
                                            ) Temp", msgSqlWhere);


            try
            {
                RefAsync<int> totalCount = 0;
                var data = await _sqlSugar.SqlQueryable<MessageListView>(msgSql).ToPageListAsync(dto.PageIndex, dto.PageSize, totalCount);


                return Ok(JsonView(true, "操作成功!", data, totalCount));
            }
            catch (Exception ex )
            {

                return Ok(JsonView(false, ex.Message));
            }
           
        }


        /// <summary>
        /// 系统消息
        /// 获取消息未读条数
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> PotsMessageUnreadTotalCount(PotsMessageUnreadTotalCountDto dto)
        {
            #region 参数验证

            if (dto.UserId < 1)
            {
                return Ok(JsonView(false, "请输入有效的UserId参数。"));
            }

            #endregion

            try
            {
                int messageUnReadCount = 0;
                int announcementUnReadCount = 0;
                var data = await _messageRep.GetUnReadCount(dto.UserId);
                if (data != null)
                {
                    messageUnReadCount = data;

                }
                var data1 = await _messageRep.GetAnnouncementUnReadCount(dto.UserId);
                if (data1 != null)
                {
                    announcementUnReadCount = data1;
                }

                return Ok(JsonView(true, "操作成功!", new { messageUnReadCount = messageUnReadCount, announcementUnReadCount = announcementUnReadCount }));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, ex.Message));
            }

        }

        #endregion

        /// <summary>
        /// 获取消息详细信息
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> PostMsgInfo(MsgInfoDto dto)
        {
            if (dto.PortType < 1 || dto.PortType > 3)
            {
                return Ok(JsonView(false, "请输入有效的PortType参数。1 Web 2 Android 3 IOS"));
            }

            var msgData = await _messageRep.GetMsgInfo(dto);

            if (msgData.Code != 0)
            {
                return Ok(JsonView(false, msgData.Msg));
            }

            return Ok(JsonView(true, "操作成功!",msgData.Data));
        }

        /// <summary>
        /// 消息设置已读
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> SetMessageRead(MsgSetReadDto dto)
        {
            var msgData = await _messageRep.SetMsgRead(dto);

            if (msgData.Code != 0)
            {
                return Ok(JsonView(false, msgData.Msg));
            }

            return Ok(JsonView(true));
        }

        /// <summary>
        /// 消息 删除
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> DeleMsg(MsgDeleteDto dto)
        {
            var msgData = await _messageRep.DelMsg(dto);

            if (msgData.Code != 0)
            {
                return Ok(JsonView(false, msgData.Msg));
            }

            return Ok(JsonView(true));
        }
        #endregion

        #region 数据类型资料
        /// <summary>
        /// 根据类型查询数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> QuerySetData(SetDataDto dto)
        {
            try
            {
                if (dto.DataType == 0)
                {
                    return Ok(JsonView(false, "请传类型Id！"));
                }
                var setData = _setDataRepository.QueryDto<Sys_SetData, SetDataView>(s => s.STid == dto.DataType && s.IsDel==0).ToList();
                if (setData.Count == 0)
                {
                    return Ok(JsonView(false, "暂无数据！"));
                }
                return Ok(JsonView(true, "查询成功！", setData));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }
        /// <summary>
        /// 数据类型表查询
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> QuerySetDataType(SetDataTypeDto dto)
        {
            try
            {
                Result setDataType = await _setDataTypeRep.QuerySetDataType(dto);
                if (setDataType.Code == 0)
                {
                    return Ok(JsonView(true, "查询成功", setDataType.Data));
                }
                else
                {
                    return Ok(JsonView(false, setDataType.Msg));
                }
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }

        /// <summary>
        /// 数据类型表操作（Status:1.新增,2.修改）
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> OperationSetDataType(OperationSetDataTypeDto dto)
        {
            try
            {
                if (dto.Name == "")
                {
                    return Ok(JsonView(false, "请检查类型名称是否填写！"));
                }
                Result result = await _setDataTypeRep.OperationSetDataType(dto);
                if (result.Code != 0)
                {
                    return Ok(JsonView(false, result.Msg));
                }
                return Ok(JsonView(true, result.Msg));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }

        /// <summary>
        /// 数据类型表操作删除
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> DelSetDataType(DelSetDataTypeDto dto)
        {
            try
            {
                var res = await _setDataTypeRep.SoftDeleteByIdAsync<Sys_SetDataType>(dto.Id.ToString(), dto.DeleteUserId);
                if (!res)
                {
                    return Ok(JsonView(false, "删除失败"));
                }
                return Ok(JsonView(true, "删除成功！"));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }
        #endregion

        #region 数据类型板块
        /// <summary>
        /// 数据类型板块表查询
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> QuerySetDataInfo(SetDataIDto dto)
        {
            try
            {
                Result setData = await _setDataRepository.QuerySetData(dto);
                if (setData.Code == 0)
                {
                    return Ok(JsonView(true, "查询成功", setData.Data));
                }
                else
                {
                    return Ok(JsonView(false, setData.Msg));
                }
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }

        /// <summary>
        /// 数据类型板块表操作（Status:1.新增,2.修改）
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> OperationSetData(OperationSetDataDto dto)
        {
            try
            {
                if (dto.Name == "")
                {
                    return Ok(JsonView(false, "请检查板块名称是否填写！"));
                }
                Result result = await _setDataRepository.OperationSetData(dto);
                if (result.Code != 0)
                {
                    return Ok(JsonView(false, result.Msg));
                }
                return Ok(JsonView(true, result.Msg));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }

        /// <summary>
        /// 数据类型表操作删除
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> DelSetData(DelSetDataDto dto)
        {
            try
            {
                var res = await _setDataRepository.SoftDeleteByIdAsync<Sys_SetData>(dto.Id.ToString(), dto.DeleteUserId);
                if (!res)
                {
                    return Ok(JsonView(false, "删除失败"));
                }
                return Ok(JsonView(true, "删除成功！"));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }
        #endregion

        #region 企业操作
        /// <summary>
        /// 查询企业数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> getCompanyList(DtoBase dto)
        {
            try
            {
                if (dto.PortType == 1)
                {
                    var CompanyDataResult = _CompanyRepository.GetCompanyData();
                    if (CompanyDataResult.Code != 0)
                    {
                        return Ok(JsonView(CompanyDataResult.Msg));
                    }
                    List<CompanyView> companyListView = _mapper.Map<List<CompanyView>>(CompanyDataResult.Data);
                    for (int i = 0; i < companyListView.Count; i++)
                    {
                        if (companyListView[i].ParentCompanyId != 0)
                        {
                            companyListView[i].ParentCompanyName = companyListView.Find(x => x.Id == companyListView[i].ParentCompanyId).CompanyName;
                        }
                        if (companyListView[i].ContactUserId!=0)
                        {
                            var user = _userRep.QueryDto<Sys_Users,UserInfoWebView>(x => x.Id == companyListView[i].ContactUserId).ToList();
                            if (user.Count!=0)
                            {
                                companyListView[i].ContactUserName = user[0].CnName;
                            }
                           
                        }

                    }
                    return Ok(JsonView(true, "查询成功！", companyListView));
                }
                else if (dto.PortType == 2)
                {
                    var CompanyDataResult = _CompanyRepository.GetCompanyData();
                    if (CompanyDataResult.Code != 0)
                    {
                        return Ok(JsonView(CompanyDataResult.Msg));
                    }
                    
                    return Ok(JsonView(true,"查询成功！", CompanyDataResult.Data));
                }
                else if (dto.PortType == 3)
                {
                    return Ok(JsonView(false, "暂无数据！"));
                }
                else
                {
                    return Ok(JsonView(false, "暂无数据！"));
                }
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }

        /// <summary>
        /// 添加企业数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView),StatusCodes.Status200OK)]
        public async Task<IActionResult> AddCompany(AddCompanyDto dto)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(dto.CompanyName) || dto.CreateUserId == 0 || string.IsNullOrWhiteSpace(dto.CompanyCode))
                {
                    return Ok(JsonView(false, "请检查信息是否输入完整！"));
                }
                else if (string.IsNullOrWhiteSpace(dto.Tel))
                {
                    return Ok(JsonView(false, "请检查联系方式是否输入正确！"));
                }
                else
                {
                    Sys_Company _Company = _mapper.Map<Sys_Company>(dto);
                    Result data = await _syscomRep.AddCompany(_Company);
                    if (data.Code != 0)
                    {
                        return Ok(JsonView(false, "添加失败！"));

                    }
                    return Ok(JsonView(true,"添加成功"));
                }
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
            
            
        }

        /// <summary>
        /// 企业修改
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult>EditCompany(EditCompanyDto dto)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(dto.CompanyName) || string.IsNullOrWhiteSpace(dto.CompanyCode) || string.IsNullOrWhiteSpace(dto.Address)  || dto.ContactUserId == 0)
                {
                    return Ok(JsonView(false, "请检查信息是否输入完整！"));
                }
                else if (string.IsNullOrWhiteSpace(dto.Tel))
                {
                    return Ok(JsonView(false, "请检查联系方式是否输入正确！"));
                }
                else
                {
                    bool res = await _syscomRep.UpdateAsync(a => a.Id == dto.Id, a => new Sys_Company
                    {
                        CompanyName = dto.CompanyName,
                        CompanyCode = dto.CompanyCode,
                        Address = dto.Address,
                        ParentCompanyId = dto.ParentCompanyId,
                        Tel = dto.Tel,
                        ContactUserId = dto.ContactUserId,
                        Remark=dto.Remark,
                    });
                    if (!res) { return Ok(JsonView(false, "修改失败")); }
                    return Ok(JsonView(true,"修改成功！"));
                }
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
            
            
        }

         /// <summary>
        /// 企业删除
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> DelCompany(DelCompanyDto dto)
        {
            try
            {
                bool res = await _syscomRep.SoftDeleteAsync<Sys_Company>(dto.Id.ToString());
                if (!res) { return Ok(JsonView(false, "删除失败")); }
                return Ok(JsonView(true, "删除成功"));
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
           
            

        }
        #endregion

        #region 部门操作

        /// <summary>
        /// 查询部门数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> QueryDepartmentList(DepartmentDto dto)
        {
            try
            {
                if (dto.PortType==1)
                {
                    if (dto.CompanyId!=0)
                    {
                        var result = _sysDepRep.QueryDto<Sys_Department, DepartmentIView>(s => s.CompanyId == dto.CompanyId).ToList();
                        if (result.Count == 0)
                        {

                            return Ok(JsonView(false, "暂无数据！"));
                        }
                        for (int i = 0; i < result.Count; i++)
                        {
                            if (result[i].ParentDepId != 0)
                            {
                                result[i].ParentDepName = result.Find(x => x.Id == result[i].ParentDepId).ParentDepName;
                            }
                            var company = _sysDepRep.QueryDto<Sys_Company, CompanyView>(s => s.Id == result[i].CompanyId).ToList();
                            if (company.Count != 0)
                            {
                                result[i].CompanyName = company[0].CompanyName;
                            }
                            return Ok(JsonView(true, "查询成功！", result));
                        }
                    }
                    else
                    {
                        var result = _sysDepRep.QueryDto<Sys_Department, DepartmentIView>(s => s.IsDel <=1).ToList();
                        if (result.Count == 0)
                        {

                            return Ok(JsonView(false, "暂无数据！"));
                        }
                        for (int i = 0; i < result.Count; i++)
                        {
                            if (result[i].ParentDepId != 0)
                            {
                                result[i].ParentDepName = result.Find(x => x.Id == result[i].ParentDepId).ParentDepName;
                            }
                            var company = _sysDepRep.QueryDto<Sys_Company, CompanyView>(s => s.Id == result[i].CompanyId).ToList();
                            if (company.Count != 0)
                            {
                                result[i].CompanyName = company[0].CompanyName;
                            }
                        }
                        return Ok(JsonView(true, "查询成功！", result));
                    }
                    return Ok(JsonView(false, "暂无数据！"));


                }
                else if (dto.PortType==2)
                {
                    var result = _sysDepRep.QueryDto<Sys_Department, DepartmentIView>(s => s.CompanyId == dto.CompanyId).ToList();
                    if (result.Count == 0)
                    {
                        return Ok(JsonView(400, "暂无数据！", new List<string>()));
                    }
                    return Ok(JsonView(true,"查询成功！",result));
                }
                else if (dto.PortType == 3)
                {
                    return Ok(JsonView(false, "暂无数据！"));
                }
                else
                {
                    return Ok(JsonView(false, "暂无数据！"));
                }
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
         
        }
        /// <summary>
        /// 部门添加
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> AddDepartment(AddDepartmentDto dto)
        {
            try
            {
                if (dto.CreateUserId == 0 || string.IsNullOrWhiteSpace(dto.DepName) || dto.CompanyId == 0 || string.IsNullOrWhiteSpace(dto.DepCode))
                {
                    return Ok(JsonView(false, "请检查信息是否输入完整！"));
                }
                else
                {
                    Sys_Department _Department = _mapper.Map<Sys_Department>(dto);
                    int id = await _sysDepRep.AddAsyncReturnId(_Department);
                    if (id == 0)
                    {
                        return Ok(JsonView(false, "添加失败！"));
                    }
                    return Ok(JsonView(true, "添加成功！", new { Id = id }));
                }
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
            
           
        }

        /// <summary>
        /// 部门修改
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> EditDepartment(EditDepartmentDto dto)
        {
            try
            {
                if (dto.Id==0 || string.IsNullOrWhiteSpace(dto.DepName) || dto.CompanyId == 0 || string.IsNullOrWhiteSpace(dto.DepCode))
                {
                    return Ok(JsonView(false, "请检查信息是否输入完整！"));
                }
                else
                {
                    bool res = await _sysDepRep.UpdateAsync<Sys_Department>(a => a.Id == dto.Id, a => new Sys_Department
                    {
                        CompanyId=dto.CompanyId,
                        DepCode=dto.DepCode,
                        DepName=dto.DepName,
                        ParentDepId=dto.ParentDepId,
                        Remark=dto.Remark,
                     });
                    if (!res)
                    {
                        return Ok(JsonView(false, "修改失败！"));
                    }
                    return Ok(JsonView(true, "修改成功！"));
                }
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }


        }

        /// <summary>
        /// 部门删除
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> DelDepartment(DelDepartmentDto dto)
        {
            try
            {
                if (dto.Id == 0)
                {
                    return Ok(JsonView(-1, "请检查信息是否输入完整！", null));
                }
                else
                {
                    bool res =await _sysDepRep.SoftDeleteAsync<Sys_Department>(dto.Id.ToString());
                    if (!res)
                    {
                        return Ok(JsonView(false, "删除失败！"));
                    }
                    return Ok(JsonView(true, "删除成功！"));
                }
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }


        }
        #endregion

        #region 岗位板块
        /// <summary>
        /// 岗位查询
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> QueryJobPost(QueryJobPostDto dto)
        {
            try
            {
                if (dto.PortType == 1)
                {
                    string sqlWhere = string.Empty;
                    if (dto.CompanyId != 0)
                    {
                        sqlWhere += string.Format(@" And jp.CompanyId={0}", dto.CompanyId);
                    }
                    if (dto.DepId != 0)
                    {
                        sqlWhere += string.Format(@" And jp.DepId={0}", dto.DepId);
                    }
                    sqlWhere += string.Format(@" And jp.IsDel={0}", 0);
                    if (!string.IsNullOrEmpty(sqlWhere.Trim()))
                    {
                        Regex r = new Regex("And");
                        sqlWhere = r.Replace(sqlWhere, "Where", 1);
                    }
                    List<Sys_JobPostI> jobList = await _jobRep.QueryJobPost(sqlWhere);

                    List<JobPostView> List = _mapper.Map<List<JobPostView>>(jobList);
                    if (jobList.Count == 0)
                    {
                        return Ok(JsonView(false, "暂无数据！"));
                    }
                    return Ok(JsonView(true, "查询成功！", jobList));
                }
                else if (dto.PortType == 2)
                {
                    var result = _jobRep.QueryDto<Sys_JobPost, JobPostView>(s => s.CompanyId == dto.CompanyId && s.DepId==dto.DepId).ToList();
                    if (result.Count == 0)
                    {
                        return Ok(JsonView(false, "暂无数据！"));
                    }
                    return Ok(JsonView(true, "查询成功！", result));
                }
                else if (dto.PortType == 3)
                {
                    return Ok(JsonView(false, "暂无数据！"));
                }
                else
                {
                    return Ok(JsonView(false, "暂无数据！"));
                }
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }
        /// <summary>
        /// 添加岗位
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> AddJobPost(AddJobPostDto dto)
        {
            try
            {
                Sys_JobPost sys_Job = _mapper.Map<Sys_JobPost>(dto);
                int id = await _jobRep.AddAsyncReturnId(sys_Job);
                if (id == 0)
                {
                    return Ok(JsonView(false, "添加失败"));
                }
                return Ok(JsonView(true, "添加成功", new { Id = id }));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }
        /// <summary>
        /// 修改岗位
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> EditJobPost(EditJobPostDto dto)
        {
            try
            {
                bool res = await _jobRep.UpdateAsync<Sys_JobPost>(a=>a.Id==dto.Id,a =>new Sys_JobPost
                {
                    CompanyId=dto.CompanyId,
                    DepId=dto.DepId,
                    JobName=dto.JobName,
                    Remark=dto.Remark,
                });
                if (!res)
                {
                    return Ok(JsonView(false, "修改失败"));
                }
                return Ok(JsonView(true, "修改成功"));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }
        /// <summary>
        /// 删除岗位
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> DelJobPost(DelJobPostDto dto)
        {
            try
            {
                bool res = await _jobRep.SoftDeleteAsync<Sys_JobPost>(dto.Id.ToString());
                if (!res)
                {
                    return Ok(JsonView(false, "删除失败！"));
                }
                return Ok(JsonView(true, "删除成功"));
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }
        #endregion

        #region 用户操作

        /// <summary>
        /// 查询所有员工名称
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> GetUserNameList(DtoBase dto)
        {
            try
            {
                var result = _userRep.GetUserNameList(dto.PortType);
                if (result.Result.Code != 0)
                {
                    return Ok(JsonView(false, "暂无数据！"));

                }
                return Ok(JsonView(true, "查询成功！", result.Result.Data));
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }

        /// <summary>
        /// 查询所有员工（web）
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> GetUserList(DtoBase dto)
        {
            try
            {
                var result = _userRep.GetUserList(dto.PortType, string.Empty);
                if (result.Result.Code != 0)
                {
                    return Ok(JsonView(false, "暂无数据！"));

                }
                return Ok(JsonView(true, "查询成功！", result.Result.Data));
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }

        /// <summary>
        /// 查询用户数据
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> QueryUserList(UserDto dto)
        {
            try
            {
                string sqlWhere = string.Format(" Where su.IsDel = 0 ");
                if (dto.CompanyId!=0)
                {
                    sqlWhere += string.Format(@" And su.CompanyId={0}", dto.CompanyId);
                }
                if (dto.DepId != 0)
                {
                    sqlWhere += string.Format(@" And su.DepId={0}", dto.DepId);
                }
                if (dto.JobPostId != 0)
                {
                    sqlWhere += string.Format(@" And su.JobPostId={0}", dto.JobPostId);
                }
               
                List<UserInfo> _userList =await _userRep.QueryUser(sqlWhere);
                if (_userList.Count == 0)
                {
                    return Ok(JsonView(400, "暂无数据！", new List<String>()));
                }
                List<UserInfoWebView> userList = _mapper.Map<List<UserInfoWebView>>(_userList);
                return Ok(JsonView(true,"查询成功！", userList));
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
           
        }

        /// <summary>
        /// 修改用户信息（上级修改/分配 公司、部门、岗位、工号等信息）
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> EditUser(EditUserDto dto)
        {
            try
            {
                bool res = await _userRep.UpdateAsync<Sys_Users>(a => a.Id == dto.Id, a => new Sys_Users
                {
                    Number = dto.Number,
                    CompanyId = dto.CompanyId,
                    DepId = dto.DepId,
                    JobPostId = dto.JobPostId,
                    Ext = dto.Ext,
                    UsePeriod = dto.UsePeriod,
                    //HrAudit = dto.HrAudit
                });
                if (!res) 
                {
                    return Ok(JsonView(false, "修改失败！"));
                }

                return Ok(JsonView(true, "修改成功！"));
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
            }
        }

        /// <summary>
        /// 修改用户信息（登录用户修改个人信息）
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> EditMyUser(EditMyUserDto dto)
        {
            try
            {
                if (string.IsNullOrWhiteSpace(dto.CnName) || string.IsNullOrWhiteSpace(dto.Address) || string.IsNullOrWhiteSpace(dto.IDCard) || dto.Sex != 0 && dto.Sex != 1 ||
                    string.IsNullOrWhiteSpace(dto.MaritalStatus) || string.IsNullOrWhiteSpace(dto.HomeAddress)|| dto.Birthday>=DateTime.Now.AddYears(-1))
                {
                    return Ok(JsonView(false, "请完善你的个人信息！"));
                }
                else if (string.IsNullOrWhiteSpace(dto.GraduateInstitutions) || string.IsNullOrWhiteSpace(dto.Professional) || dto.Education == 0 || string.IsNullOrWhiteSpace(dto.GraduateInstitutions))
                {
                    return Ok(JsonView(false, "请完善你的学历信息！"));
                }
                else if (string.IsNullOrWhiteSpace(dto.Phone) || string.IsNullOrWhiteSpace(dto.UrgentPhone) || string.IsNullOrWhiteSpace(dto.Email))
                {
                    return Ok(JsonView(false, "请检查联系方式、紧急联系人及邮箱输写是否正确!"));
                }
                else
                {
                    bool res = await _userRep.UpdateAsync<Sys_Users>(a => a.Id == dto.Id, a => new Sys_Users
                    {
                        CnName = dto.CnName,
                        EnName = dto.EnName,
                        Sex = dto.Sex,
                        Phone = dto.Phone,
                        UrgentPhone = dto.UrgentPhone,
                        Email = dto.Email,
                        Address = dto.Address,
                        Edate = dto.Edate,
                        Birthday = dto.Birthday,
                        IDCard = dto.IDCard,
                        GraduateInstitutions = dto.GraduateInstitutions,
                        Professional = dto.Professional,
                        Education = dto.Education,
                        TheOrAdultEducation = dto.TheOrAdultEducation,
                        MaritalStatus = dto.MaritalStatus,
                        HomeAddress = dto.HomeAddress,
                        WorkExperience = dto.WorkExperience,
                        Certificate = dto.Certificate
                    });
                    if (!res)
                    {
                        return Ok(JsonView(false, "修改失败！"));
                    }
                    return Ok(JsonView(true, "修改成功！"));
                }
                
            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }

        /// <summary>
        /// 删除用户信息
        /// 即为离职
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> PostUserDelById(UserDelDto dto)
        {
            try
            {
                if (dto == null)
                {
                    return Ok(JsonView(false, "参数不能为空！"));
                }
                Sys_Users _Users=_sqlSugar.Queryable<Sys_Users>().First(a=>a.IsDel==0 && a.Id==dto.Id);
                if (_Users != null)
                {
                    List<Sys_Users> sys_UsersList=_sqlSugar.Queryable<Sys_Users>().Where(a=>a.IsDel==0 && a.CompanyId==_Users.CompanyId).ToList();
                    if (sys_UsersList.Count==1)
                    {
                        return Ok(JsonView(false, "该人员为公司最后一位，不可删除！"));
                    }
                }
                
                bool res = await _userRep.UpdateAsync<Sys_Users>(a => a.Id == dto.Id, a => new Sys_Users
                {
                    IsDel = 1,
                    DeleteUserId = dto.OperateUserId,
                    DeleteTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
                    Rdate = Convert.ToDateTime(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"))
                });
                if (!res)
                {
                    return Ok(JsonView(false, "操作失败！"));
                }
                return Ok(JsonView(true, "操作成功！"));

            }
            catch (Exception)
            {
                return Ok(JsonView(false, "程序错误！"));
            }
        }

        /// <summary>
        /// 员工信息 
        /// 人事审核
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> PersonnelAudit(PersonnelAuditDto dto)
        {
            if (dto.UserId < 1) return Ok(JsonView(false, "请传入有效的UserId参数！"));
            if (dto.Id < 1) return Ok(JsonView(false, "请传入有效的Id参数！"));
            if (dto.IsAudit < 1 || dto.IsAudit > 2) return Ok(JsonView(false, "请传入有效的IsAudit参数！1：通过 2拒绝"));

            bool res = await _userRep.UpdateAsync<Sys_Users>(a =>
                                      a.Id == dto.Id,
                                      a => new Sys_Users
                                      {
                                          HrAudit = dto.IsAudit
                                      });
            if (res)
            {
                //审核成功添加员工基础页面权限
                var userData = _sqlSugar.Queryable<Sys_Users>().Where(it => it.Id == dto.Id).First();
                int depId = 0, postId = 0;
                if (userData != null) { depId = userData.DepId; postId = userData.JobPostId; }

                bool s = DefaultPostAuth(depId, postId, dto.Id, dto.UserId);
                string str = $"基础页面权限添加失败!";
                if (s) str = $"基础页面权限添加成功!";

                return Ok(JsonView(true, $"操作成功！{str}"));
            }
            return Ok(JsonView(false, "操作失败！"));

        }
        #endregion

        #region 权限模块
        /// <summary>
        /// 权限数据页面初始化
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        //[Authorize]
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> GetAuth(AuthDto dto)
        {
            Result result = new Result();
            //模块数据
            var setDataResult = await _setDataRepository.GetSySDefultModule();
            if (setDataResult.Code != 0)
            {
                return Ok(JsonView(setDataResult.Msg));
            }

            //操作方式
            var PageOperation = _PageFunctionPermissionRepository.QueryDto<Sys_PageFunctionPermission, Sys_PageFunctionPermission>(x=>x.IsEnable == 1).ToList();

            //获取所有关联页面
            var Sys_SystemMenuAndFunction = _SystemMenuAndFunctionRepository.QueryDto<Sys_SystemMenuAndFunction, SystemMenuAndFunctionView>().ToList();


            //页面数据
            var SystemMenuPermissionData = _SystemMenuPermissionRepository.QueryDto<Sys_SystemMenuPermission, SystemMenuPermissionView>(x=>x.Mid == dto.moduleId && x.IsEnable == 1).ToList();
            if (SystemMenuPermissionData == null || SystemMenuPermissionData.Count() == 0)
            {
                return Ok(JsonView("暂无数据"));
            }

            ArrayList viewData = new ArrayList();
            //组合页面数据
            foreach (var item in SystemMenuPermissionData)
            {
                ArrayList ids = new ArrayList();
                foreach (var viewop in PageOperation)
                {
                    var op =  Sys_SystemMenuAndFunction.FirstOrDefault(x => x.SmId == item.Id && x.FId == viewop.Id);
                    if (op != null)
                    {
                        ids.Add(viewop.Id);
                    }
                }
                viewData.Add(new
                {
                    Id = item.Id,
                    Mid = item.Mid,
                    Name = item.Name,
                    SystemMenuCode = item.SystemMenuCode,
                    opList = ids,
                    selList = new string[0]
                }) ;
            }

            //公司数据
            var CompanyDataResult = _CompanyRepository.GetCompanyData();
            if (CompanyDataResult.Code != 0)
            {
                return Ok(JsonView(CompanyDataResult.Msg));
            }

            result.Code = 0;
            result.Msg = "成功！";
            var Dyresult = new
            {
                setDataResult = setDataResult.Data,
                CompanyDataResult = CompanyDataResult.Data,
                SystemMenuPermissionData = viewData,
                PageOperation = PageOperation,
            };

            return Ok(JsonView(200, "成功！", Dyresult));
        }
        /// <summary>
        /// 获取职务权限
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public IActionResult QueryJobAuth(QueryJobAuthDto dto)
        {
            //选中的操作权限
            var DBdata = _JobPostAuthorityRepository.QueryDto<Sys_JobPostAuthority, JobPostAuthorityView>(x=>x.JpId == dto.jobid).ToList();
            var SystemMenuPermissionData = _SystemMenuPermissionRepository.QueryDto<Sys_SystemMenuPermission, SystemMenuPermissionView>(x => x.Mid == dto.moduleId).ToList();
            if (SystemMenuPermissionData == null || SystemMenuPermissionData.Count() == 0)
            {
                return Ok(JsonView("暂无数据"));
            }

            //所有操作
            var PageOperation = _PageFunctionPermissionRepository.QueryDto<Sys_PageFunctionPermission, Sys_PageFunctionPermission>().ToList();

            //获取所有关联页面
            var Sys_SystemMenuAndFunction = _SystemMenuAndFunctionRepository.QueryDto<Sys_SystemMenuAndFunction, SystemMenuAndFunctionView>().ToList();

            ArrayList viewData = new ArrayList();
            //组合页面数据
            foreach (var item in SystemMenuPermissionData)
            {
                ArrayList ids = new ArrayList();
                foreach (var viewop in PageOperation)
                {
                    var op = Sys_SystemMenuAndFunction.FirstOrDefault(x => x.SmId == item.Id && x.FId == viewop.Id);
                    if (op != null)
                    {
                        ids.Add(viewop.Id);
                    }
                }

                //获取本职务的页面拥有的权限
                var DBwhere =  DBdata.Where(x => x.SmId == item.Id && x.JpId == dto.jobid).ToList();

                viewData.Add(new
                {
                    Id = item.Id,
                    Mid = item.Mid,
                    Name = item.Name,
                    SystemMenuCode = item.SystemMenuCode,
                    opList = ids,
                    selList = DBwhere.Select(x => x.FId)
                }) ;
            }

            return Ok(JsonView(200, "成功!", viewData));
        }
        /// <summary>
        /// 保存岗位权限
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> SaveJobAuth(SaveJobDto dto)
        {
            //获取所有关联页面
            var Sys_SystemMenuAndFunction = _SystemMenuAndFunctionRepository.QueryDto<Sys_SystemMenuAndFunction, SystemMenuAndFunctionView>().ToList();

            var RemoveJobPostAuthList = _SystemMenuAndFunctionRepository._sqlSugar.SqlQueryable<Sys_JobPostAuthority>($@"
                  select a.* from Sys_JobPostAuthority a, Sys_SetData b ,Sys_SystemMenuPermission c
                  where a.SmId = c.Id and c.Mid = b.Id and JpId = {dto.Jpid} and  c.Mid ={dto.modulId} 
            ").ToList();

            List<Sys_JobPostAuthority> adds = new List<Sys_JobPostAuthority>();
            foreach (var item in dto.Savejobs)
            {
                foreach (var fid in item.FIds)
                {
                    var whereobj = Sys_SystemMenuAndFunction.FirstOrDefault(x => x.FId == fid && x.SmId == item.SmId);
                    if (whereobj != null)
                    {
                        adds.Add(new Sys_JobPostAuthority
                        {
                            CreateTime = DateTime.Now,
                            CreateUserId = dto.UserId,
                            FId = fid,
                            JpId = dto.Jpid,
                            SmId = item.SmId
                        });
                    }
                }
            }

            _JobPostAuthorityRepository.BeginTran();
            try
            {   //删除岗位
                bool isdel = await _JobPostAuthorityRepository.DeletesAsync<Sys_JobPostAuthority>(RemoveJobPostAuthList);
                int UpRows = _JobPostAuthorityRepository.Adds<Sys_JobPostAuthority>(adds);

                //获取所有职位员工
                var jobUserAll = await QueryUserList(new UserDto { PortType = 2, JobPostId = dto.Jpid });
                List<UserInfoWebView> users = null;
                var QueryUserListApiResult = (((jobUserAll as OkObjectResult).Value) as OASystem.Domain.ViewModels.JsonView);
                if (QueryUserListApiResult != null)
                {
                    if (QueryUserListApiResult.Code == 200)
                    {
                        users = QueryUserListApiResult.Data as List<UserInfoWebView>;
                    }
                }

                if (users != null && users.Count > 0)
                {
                    List<Sys_UserAuthority> userAuth = null;
                    var uids = string.Join(',', users.Select(x => x.Id)).TrimEnd(',');
                    var RemoveUserAuthorityListAndTemp = _UserAuthorityRepository._sqlSugar.SqlQueryable<Sys_UserAuthority>($@"
                           select a.* from Sys_UserAuthority a, Sys_SetData b ,Sys_SystemMenuPermission c
                           where a.SmId = c.Id and c.Mid = b.Id and uid in ({uids}) and  c.Mid = {dto.modulId} and IsTemp = 1                       
                    ").ToList();

                    foreach (var user in users)
                    {
                        //删除个人级岗位权限
                        isdel = await _UserAuthorityRepository.DeletesAsync<Sys_UserAuthority>
                            (RemoveUserAuthorityListAndTemp.FindAll(x=>x.UId == user.Id));

                        userAuth = adds.Select(x=> new Sys_UserAuthority
                        {
                            CreateTime = DateTime.Now,
                            CreateUserId = dto.UserId,
                            FId = x.FId,
                            SmId = x.SmId,
                            UId = user.Id,
                            IsTemp = 1,
                        }).ToList();

                        //添加个人级别岗位
                        int AddRows = _UserAuthorityRepository.Adds<Sys_UserAuthority>(userAuth);
                    }
                }
            }
            catch (Exception ex)
            {
                _JobPostAuthorityRepository.RollbackTran();
                return Ok(JsonView("系统错误！"));
            }

            _JobPostAuthorityRepository.CommitTran();
            return Ok(JsonView(200, "成功", new { }));
        }


        /// <summary>
        /// 获取员工权限
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public IActionResult QueryUserAuth(QueryUserAuthDto dto)
        {
            //选中的员工操作权限
            var DBdata = _UserAuthorityRepository.QueryDto<Sys_UserAuthority, UserAuthorityView>(x => x.UId == dto.Userid).ToList();
            var SystemMenuPermissionData = _SystemMenuPermissionRepository.QueryDto<Sys_SystemMenuPermission, SystemMenuPermissionView>(x => x.Mid == dto.moduleId).ToList();
            if (SystemMenuPermissionData == null || SystemMenuPermissionData.Count() == 0)
            {
                return Ok(JsonView("暂无数据"));
            }

            //所有操作
            var PageOperation = _PageFunctionPermissionRepository.QueryDto<Sys_PageFunctionPermission, Sys_PageFunctionPermission>(x=>x.IsEnable == 1).ToList();

            //获取所有关联页面
            var Sys_SystemMenuAndFunction = _SystemMenuAndFunctionRepository.QueryDto<Sys_SystemMenuAndFunction, SystemMenuAndFunctionView>().ToList();

            ArrayList viewData = new ArrayList();
            //组合页面数据
            foreach (var item in SystemMenuPermissionData)
            {
                ArrayList ids = new ArrayList();
                foreach (var viewop in PageOperation)
                {
                    var op = Sys_SystemMenuAndFunction.FirstOrDefault(x => x.SmId == item.Id && x.FId == viewop.Id);
                    if (op != null)
                    {
                        ids.Add(viewop.Id);
                    }
                }

                //获取本员工拥有的权限
                var DBwhere = DBdata.Where(x => x.SmId == item.Id && x.UId == dto.Userid).ToList();

                viewData.Add(new
                {
                    Id = item.Id,
                    Mid = item.Mid,
                    Name = item.Name,
                    SystemMenuCode = item.SystemMenuCode,
                    opList = ids,
                    selList = DBwhere.Select(x => x.FId)
                });
            }

            return Ok(JsonView(200, "成功!", viewData));
        }


        /// <summary>
        /// 保存员工权限
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> SaveUserAuth(SaveUserDto dto)
        {
            //获取所有关联页面
            var Sys_SystemMenuAndFunction = _SystemMenuAndFunctionRepository.QueryDto<Sys_SystemMenuAndFunction, SystemMenuAndFunctionView>().ToList();
            //获取用户当前模块所有启用页面
            var userpageList = _SystemMenuPermissionRepository._sqlSugar.SqlQueryable<Sys_UserAuthority>($@"
                  select a.* from Sys_UserAuthority a, Sys_SetData b ,Sys_SystemMenuPermission c
                    where a.SmId = c.Id and c.Mid = b.Id and uid = {dto.uid} and  c.Mid ={dto.Modulid} 
            ").ToList();

            List<Sys_UserAuthority> adds = new List<Sys_UserAuthority>();
            foreach (var item in dto.Savejobs)
            {
                foreach (var fid in item.FIds)
                {
                    var whereobj = Sys_SystemMenuAndFunction.FirstOrDefault(x => x.FId == fid && x.SmId == item.SmId);
                    if (whereobj != null)
                    {
                        adds.Add(new Sys_UserAuthority
                        {
                            CreateTime = DateTime.Now,
                            CreateUserId = dto.UserId,
                            FId = fid,
                            UId = dto.uid,
                            SmId = item.SmId,
                            IsTemp = 0
                        });
                    }
                }
            }

            _JobPostAuthorityRepository.BeginTran();
            try
            {
                List<Sys_UserAuthority> userAuth = null;
                //删除个人级岗位权限
                bool isdel = await _UserAuthorityRepository.DeletesAsync<Sys_UserAuthority>(userpageList);

                userAuth = adds.Select(x => new Sys_UserAuthority
                {
                    CreateTime = DateTime.Now,
                    CreateUserId = dto.UserId,
                    FId = x.FId,
                    SmId = x.SmId,
                    UId = dto.uid,
                    IsTemp = 0,
                }).ToList();

                //添加个人级别岗位
                int AddRows = _UserAuthorityRepository.Adds<Sys_UserAuthority>(userAuth);
            }
            catch (Exception ex)
            {
                _JobPostAuthorityRepository.RollbackTran();
                return Ok(JsonView("系统错误！"));
            }

            _JobPostAuthorityRepository.CommitTran();
            return Ok(JsonView(200, "成功", new { }));
        }
        #endregion

        #region 页面配置

        /// <summary>
        /// 页面配置界面数据初始化
        /// </summary>
        /// <returns></returns>
        //[Authorize]
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> PageConfigInit()
        {
            ArrayList arr = new ArrayList();
            var viewList = await _setDataRepository.GetSetDataAndPageInfoBySTId();
            if (viewList.Code != 0)
            {
                return Ok(JsonView(viewList.Msg));
            }
            var ModList = await _setDataRepository.GetSySDefultModule();

            return Ok(JsonView(new
            {
                viewList,
                ModList,
            }));
        }


        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> EditPageInfo(SetDataAndPageInfoDto dto)
        {
            JsonView view = null;
            _SystemMenuPermissionRepository.BeginTran();

            var istrue = await _SystemMenuPermissionRepository.UpdateAsync(x=>x.Id == dto.Pageid ,x=> new Sys_SystemMenuPermission
            {
                AndroidUrl = dto.AndroidUrl,
                CreateTime = DateTime.Now,
                Icon = dto.Icon,
                IosUrl = dto.IosUrl,
                Name = dto.PageName,
                PhoneIsEnable = dto.PagePhoneIsEnable,
                CreateUserId = dto.UserId,
                IsDel = 0,
                IsEnable = dto.PageIsEnable,
                Mid = dto.Modulid,
                Remark = dto.PageRemark,
                SystemMenuCode = dto.SystemMenuCode,
                WebUrl = dto.WebUrl,
            });

            if (istrue)
            {

                //删除页面绑定的操作后重新绑定
                await _SystemMenuAndFunctionRepository.DeleteAsync(x => x.SmId == dto.Pageid);

                List<Sys_SystemMenuAndFunction> binFun = new List<Sys_SystemMenuAndFunction>();

                foreach (var item in dto.FunArr)
                {
                    binFun.Add(new Sys_SystemMenuAndFunction
                    {
                        CreateTime = DateTime.Now,
                        CreateUserId = dto.UserId,
                        FId = item,
                        SmId = dto.Pageid,
                        IsDel = 0,
                    });
                }
               int number = _SystemMenuAndFunctionRepository.Adds<Sys_SystemMenuAndFunction>(binFun);

                view = JsonView(istrue);
                _SystemMenuPermissionRepository.CommitTran();
            }
            else
            {
                _SystemMenuPermissionRepository.RollbackTran();
                view = JsonView("添加失败");
            }
            return Ok(view);
        }
        

        /// <summary>
        /// 添加一个页面
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> AddPageInfo(SetDataAndPageInfoDto dto)
        {
            JsonView view = null;

            _SystemMenuPermissionRepository.BeginTran();

            int number = await _SystemMenuPermissionRepository.AddAsyncReturnId(new Sys_SystemMenuPermission
            {
                AndroidUrl = dto.AndroidUrl,
                CreateTime = DateTime.Now,
                Icon = dto.Icon,
                IosUrl = dto.IosUrl,
                Name = dto.PageName,
                PhoneIsEnable = dto.PagePhoneIsEnable,
                CreateUserId = dto.UserId,
                IsDel = 0,
                IsEnable = dto.PageIsEnable,
                Mid = dto.Modulid,
                Remark = dto.PageRemark,
                SystemMenuCode = dto.SystemMenuCode,
                WebUrl = dto.WebUrl,
            });

            List<Sys_SystemMenuAndFunction> binFun = new List<Sys_SystemMenuAndFunction>();

            foreach (var item in dto.FunArr)
            {
                binFun.Add(new Sys_SystemMenuAndFunction
                {
                    CreateTime = DateTime.Now,
                    CreateUserId = dto.UserId,
                    FId = item,
                    SmId = number,
                    IsDel = 0,
                });
            }

            number =  _SystemMenuAndFunctionRepository.Adds<Sys_SystemMenuAndFunction>(binFun);

            if (number > 0)
            {
                view = JsonView(number);
                _SystemMenuPermissionRepository.CommitTran();
            }
            else
            {
                _SystemMenuPermissionRepository.RollbackTran();
                view = JsonView("添加失败");
            }

            return Ok(view);
        }

        /// <summary>
        /// 删除页面
        /// </summary>
        /// <param></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> DelPageInfo(List<SystemMenuDelDto> Dto)
        {
            JsonView view = new JsonView();
            if (Dto.Count > 0)
            {
                try
                {
                    _SystemMenuPermissionRepository.BeginTran();
                    bool istrue = false;
                    foreach (var item in Dto)
                    {
                        istrue = await _SystemMenuPermissionRepository.SoftDeleteAsync(item.Pageid.ToString());
                        if (!istrue)
                        {
                            throw new Exception("修改失败");
                        }
                    }
                    
                    view.Code = 200;
                    view.Msg = "删除成功！";
                    view.Data = istrue;
                    _SystemMenuPermissionRepository.CommitTran();
                }
                catch (Exception)
                {
                    _SystemMenuPermissionRepository.RollbackTran();
                }
            }
            return Ok(JsonView(view));
        }
        
        /// <summary>
        /// 获取页面绑定的操作
        /// </summary>
        /// <param name="Dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> QueryPageFunById(PageFunDto Dto)
        {
            //页面与操作关联表
            var pageAndFunList =  _SystemMenuAndFunctionRepository.QueryDto<Sys_SystemMenuAndFunction, SystemMenuAndFunctionView>().ToList();
            //页面功能表
            var pageFunList = _PageFunctionPermissionRepository.QueryDto<Sys_PageFunctionPermission, Sys_PageFunctionPermission>(x => x.IsEnable == 1).ToList();

            ArrayList arr = new ArrayList();  
            foreach (var item in pageFunList)
            {
                var FindVal = pageAndFunList.Find(x => x.SmId == Dto.Pageid && x.FId == item.Id);
                if (FindVal == null)
                {
                    arr.Add(new
                    {
                        id = item.Id,
                        name = item.FunctionName,
                        value =false
                    });
                }
                else
                {
                    arr.Add( new {
                        id = item.Id,
                        name = item.FunctionName,
                        value = true
                    });
                }
            }
            return Ok(JsonView(arr));
        }
        #endregion

        #region 页面操作
        /// <summary>
        /// 操作权限功能表
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> PageFunInit()
        {
            try
            {
                var PageFunInit = _PageFunctionPermissionRepository.QueryDto<Sys_PageFunctionPermission, PageFunctionPermissionView>().ToList();
                if (PageFunInit == null)
                {
                    return Ok(JsonView(false, "暂无数据！"));
                }
                return Ok(JsonView(true, "查询成功！", PageFunInit));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }

        /// <summary>
        /// 操作权限功能表操作（Status 1：添加，2：编辑）
        /// </summary>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> OperationFun(OperationFunInitDta dto)
        {
            try
            {
                Result result = await _PageFunctionPermissionRepository.OperationFunInit(dto);
                if (result.Code != 0)
                {
                    return Ok(JsonView(false, result.Msg));
                }
                return Ok(JsonView(true, result.Msg));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
                throw;
            }
        }

        /// <summary>
        /// 删除功能
        /// </summary>
        /// <param name="dto"></param>
        /// <returns></returns>
        [HttpPost]
        [ProducesResponseType(typeof(JsonView), StatusCodes.Status200OK)]
        public async Task<IActionResult> DelFun(DelFunInitDta dto)
        {
            try
            {
                var res = await _PageFunctionPermissionRepository.SoftDeleteByIdAsync<Sys_PageFunctionPermission>(dto.Id.ToString(), dto.DeleteUserId);
                if (!res)
                {
                    return Ok(JsonView(false, "删除失败"));
                }
                return Ok(JsonView(true, "删除成功！"));
            }
            catch (Exception ex)
            {
                return Ok(JsonView(false, "程序错误！"));
            }
        }
        
        #endregion
    }
}