OA2023/OASystem/OASystem.Api/OAMethodLib/QiYeWeChatAPI/QiYeWeChatApiService.cs

using EyeSoft.Extensions;
using OASystem.Domain.Dtos.QiYeWeChat;
using OASystem.Domain.ViewModels.QiYeWeChat;
using System.Diagnostics;
using System.Text.Json;

namespace OASystem.API.OAMethodLib.QiYeWeChatAPI
{
    /// <summary>
    /// 聚合Api 服务
    /// </summary>
    public class QiYeWeChatApiService : IQiYeWeChatApiService
    {
        private readonly HttpClient _httpClient;
        //private readonly string CorpId = "wwe978bef5495a0728";   //企业Id
        //private readonly string PersonnelAssistant_AgentId = "3010011";   //人事助手Id
        //private readonly string PunchCard_AgentId = "3010185";            //打卡Id
        //private readonly string Email_AgentId = "1000004";   //E-Mail Id
        //private readonly string Approve_AgentId = "3010040";     //审批 Id
        //private readonly string GroupStatus_AgentId = "1000008"; //OA通知 Id
        private readonly string PersonnelAssistant_Corpsecret = "ig--IJd6TxWDMJ1wT4e-RDRcRX12v5GjB359DNATwJ4"; //人事助手凭证密钥
        private readonly string PunchCard_Corpsecret = "Xhrl37GOqlAjsu0VzUSJECaJdjzkDXQLbvrzRsZQb8M";          //打卡凭证密钥
        private readonly string Email_Corpsecret = "NA1zbJM15GmgjPYwDOqz59dIo1Wnug-MbU107MeUemc"; //E-Mail 凭证密钥
        private readonly string AddressBook_Corpsecret = "Y1tnjh7j-BvbqAytAoXZPUbmDR6dqLTL6mXtc6PZ7fo";  //通讯录同步 凭证密钥
        private readonly string Approve_Corpsecret = "k_Jo69Jw9Hqg_in-Rypbs30PNbxOYa1t4e-dxYuT-kw";  //审批 凭证密钥
        private readonly string GroupStatus_Corpsecret = "7J_ST3jTPzbZpFwl7ttToTVufjEx6O2wuApvKHxt2Ak"; //OA通知Secret

        private readonly DateTime _1970 = new DateTime(1970, 1, 1, 0, 0, 0, 0);
        private readonly JobPostRepository _jobPostRep;

        /// <summary>
        /// 初始化
        /// </summary>
        /// <param name="clientFactory"></param>
        /// <param name="jobPostRep"></param>
        public QiYeWeChatApiService(IHttpClientFactory clientFactory, JobPostRepository jobPostRep)
        {
            _httpClient = clientFactory.CreateClient("PublicQiYeWeChatApi"); ;
            _jobPostRep = jobPostRep;
        }

        /// <summary>
        /// 获取access_token
        /// </summary>
        /// <param name="applicationType">
        /// 1：人事助手 
        /// 2：打卡
        /// 3：邮件
        /// 4：通讯录同步
        /// 5：审批
        /// 6：团组状态通知
        /// </param>
        /// <returns></returns>
        private async Task<Access_TokenView> GetTokenAsync(int applicationType)
        {
            Access_TokenView tokenResult = new Access_TokenView();
            Access_Token_Request access_Token = new Access_Token_Request();
            string cacheName = string.Empty;

            if (applicationType == 1)
            {
                access_Token.corpsecret = PersonnelAssistant_Corpsecret; //人事助手
                cacheName = "PersonnelAssistant_Access_Token";
            }
            else if (applicationType == 2)
            {
                access_Token.corpsecret = PunchCard_Corpsecret; //打卡
                cacheName = "PunchCard_Access_Token";
            }
            else if (applicationType == 3)
            {
                access_Token.corpsecret = Email_Corpsecret; //E-Mail
                cacheName = "Enail_Access_Token";
            }
            else if (applicationType == 4)       //通讯录同步
            {
                access_Token.corpsecret = AddressBook_Corpsecret;
                cacheName = "AddressBook_Access_Token";
            }
            else if (applicationType == 5) //审批
            {
                access_Token.corpsecret = Approve_Corpsecret;
                cacheName = "Approve_Access_Token";
            }
            else if (applicationType == 6) //团组状态通知
            {
                access_Token.corpsecret = GroupStatus_Corpsecret;
                cacheName = "GroupStatus_Access_Token";
            }
            else
            {
                tokenResult.errmsg = "未识别应用类型Id!";
                return tokenResult;
            }


            string access_token = await RedisRepository.RedisFactory
                                                    .CreateRedisRepository()
                                                    .StringGetAsync<string>(cacheName);//string 取

            if (string.IsNullOrEmpty(access_token))
            {
                string access_token_url = string.Format(@"/cgi-bin/gettoken?corpid={0}&corpsecret={1}", access_Token.corpid, access_Token.corpsecret);

                var access_tokenReq = await _httpClient.GetAsync(access_token_url);
                if (access_tokenReq.IsSuccessStatusCode)
                {
                    var stringResponse = await access_tokenReq.Content.ReadAsStringAsync();

                    tokenResult = System.Text.Json.JsonSerializer.Deserialize<Access_TokenView>(stringResponse,
                        new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

                    if (tokenResult.errcode == 0)
                    {
                        TimeSpan ts = DateTime.Now.AddMinutes(118) - DateTime.Now; //设置redis 过期时间 118分钟
                        await RedisRepository
                            .RedisFactory
                            .CreateRedisRepository()
                            .StringSetAsync<string>(cacheName, tokenResult.access_token, ts);//string 存
                    }
                }
                else
                {
                    tokenResult.errmsg = "企业微信Token未获取到!";
                }
            }
            else
            {
                tokenResult.errcode = 0;
                tokenResult.access_token = access_token;
            }

            return tokenResult;
        }

        #region 添加员工

        /// <summary>
        /// 获取成员ID列表
        /// </summary>
        /// <returns></returns>
        public async Task<UserIdListView> GetUserIdListAsync()
        {
            UserIdListView userIdListView = new UserIdListView();
            Access_TokenView access_Token = await GetTokenAsync(4);
            if (access_Token.errcode != 0)
            {
                userIdListView.errcode = access_Token.errcode;
                userIdListView.errmsg = access_Token.errmsg;
                return userIdListView;
            }

            string url = string.Format("/cgi-bin/user/list_id?access_token={0}&debug=1", access_Token.access_token);

            var jsonData = new
            {
                access_token = access_Token.access_token, //调用接口凭证
            };

            var json = System.Text.Json.JsonSerializer.Serialize(jsonData);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            userIdListView = System.Text.Json.JsonSerializer.Deserialize<UserIdListView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            return userIdListView;
        }

        /// <summary>
        /// 获取成员信息
        /// </summary>
        /// <returns></returns>
        public async Task<QYWX_UserInfosView> GetUserInfosAsync()
        {

            QYWX_UserInfosView infoViews = new QYWX_UserInfosView();

            //获取员工useridList
            UserIdListView useridView = await GetUserIdListAsync();

            if (useridView.errcode != 0)
            {
                infoViews.errcode = useridView.errcode;
                infoViews.errmsg = useridView.errmsg;
                return infoViews;
            }

            Access_TokenView access_Token = await GetTokenAsync(4);
            if (access_Token.errcode != 0)
            {
                infoViews.errcode = access_Token.errcode;
                infoViews.errmsg = access_Token.errmsg;
                return infoViews;
            }

            List<QYWX_UserInfo> items = new List<QYWX_UserInfo>();

            string urlTitle = string.Format("/cgi-bin/user/get?access_token={0}", access_Token.access_token);

            foreach (var item in useridView.dept_user)
            {
                if (!string.IsNullOrEmpty(item.userid))
                {
                    QYWX_UserInfoView _UserInfoView = new QYWX_UserInfoView();
                    string url = string.Format("{0}&userid={1}", urlTitle, item.userid);
                    var create_Req = await _httpClient.GetAsync(url);

                    if (create_Req.IsSuccessStatusCode)
                    {
                        var stringResponse = await create_Req.Content.ReadAsStringAsync();

                        _UserInfoView = System.Text.Json.JsonSerializer.Deserialize<QYWX_UserInfoView>(stringResponse,
                            new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
                        if (_UserInfoView.errcode == 0)
                        {
                            items.Add(new QYWX_UserInfo()
                            {
                                userid = _UserInfoView.QYWX_User.userid,
                                name = _UserInfoView.QYWX_User.name,
                                mobile = _UserInfoView.QYWX_User.mobile,
                                position = _UserInfoView.QYWX_User.position,
                                email = _UserInfoView.QYWX_User.email,
                                biz_mail = _UserInfoView.QYWX_User.biz_mail,
                            });
                        }
                    }
                }
            }

            infoViews.errcode = 0;
            infoViews.errmsg = "操作成功!";
            infoViews.QYWX_Users = items;
            return infoViews;
        }

        /// <summary>
        /// 获取部门列表
        /// </summary>
        /// <param name="access_token"></param>
        /// <returns></returns>
        private async Task<DepartmentListView> GetDepartmentAsync(string access_token)
        {
            DepartmentListView result = new DepartmentListView();

            string dep_url = string.Format("/cgi-bin/department/list?access_token={0}&debug=1", access_token);


            var depReq = await _httpClient.GetAsync(dep_url);
            if (depReq.IsSuccessStatusCode)
            {
                var stringResponse = await depReq.Content.ReadAsStringAsync();

                result = System.Text.Json.JsonSerializer.Deserialize<DepartmentListView>(stringResponse,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });


            }
            else
            {
                result.errcode = -1;
                result.errmsg = "企业微信部门列表未获取到!";
            }

            return result;
        }

        /// <summary>
        /// 创建员工
        /// </summary>
        /// <param name="create_Request"></param>
        /// <returns></returns>
        public async Task<ResponseBase> CreateAsync(Create_Request create_Request)
        {
            ResponseBase responseBase = new ResponseBase();

            #region 职位
            string depName = string.Empty,
                   jobName = string.Empty;

            List<Sys_JobPostI> jobs = await _jobPostRep.QueryJobPost(string.Empty);

            Sys_JobPostI jobPost = jobs.Where(it => it.IsDel == 0 && it.Id == Convert.ToInt32(create_Request.position)).FirstOrDefault();

            if (jobPost != null)
            {
                depName = jobPost.DepName;
                jobName = jobPost.JobName;
            }
            create_Request.position = jobName;

            if (string.IsNullOrEmpty(create_Request.biz_mail))
            {
                create_Request.biz_mail = string.Format("{0}@pan-american-intl.com", create_Request.userid);
            }

            #endregion

            Access_TokenView access_Token = new Access_TokenView();
            access_Token = await GetTokenAsync(4);
            if (access_Token.errcode == 0)
            {
                create_Request.access_token = access_Token.access_token;

                #region 处理部门
                Access_TokenView dep_Access_Token = await GetTokenAsync(1);
                if (dep_Access_Token.errcode != 0)
                {
                    responseBase.errcode = dep_Access_Token.errcode;
                    responseBase.errmsg = dep_Access_Token.errmsg;
                }

                DepartmentListView depData = await GetDepartmentAsync(dep_Access_Token.access_token);

                if (depData.errcode == 0)
                {
                    var depData1 = depData.department.Where(x => x.name == depName).FirstOrDefault();
                    if (depData1 != null)
                    {
                        create_Request.department = new List<long> { depData1.id };
                    }
                    else
                    {
                        responseBase.errcode = -1;
                        responseBase.errmsg = "未在企业微信上找到OA内设置的部门";
                        return responseBase;
                    }
                }
                else
                {
                    responseBase.errcode = depData.errcode;
                    responseBase.errmsg = depData.errmsg;
                    return responseBase;
                }

                #endregion

                create_Request.access_token = access_Token.access_token;
                string create_url = string.Format("/cgi-bin/user/create?access_token={0}", create_Request.access_token);

                var json = System.Text.Json.JsonSerializer.Serialize(create_Request);
                var content = new StringContent(json, Encoding.UTF8, "application/json");
                var create_Req = await _httpClient.PostAsync(create_url, content);
                var stringResponse = await create_Req.Content.ReadAsStringAsync();

                responseBase = System.Text.Json.JsonSerializer.Deserialize<ResponseBase>(stringResponse,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });


            }
            else
            {
                responseBase.errcode = access_Token.errcode;
                responseBase.errmsg = access_Token.errmsg;
            }

            return responseBase;
        }
        #endregion

        #region 打卡

        /// <summary>
        /// 获取企业所有打卡规则
        /// </summary>
        /// <returns></returns>
        public async Task<CorpCheckInRuleView> GetCheckIn_CorpCheckInOptionAsync()
        {
            CorpCheckInRuleView corpCheckInRuleView = new CorpCheckInRuleView();

            //获取打卡数据 token
            Access_TokenView access_Token = await GetTokenAsync(2);
            if (access_Token.errcode != 0)
            {
                corpCheckInRuleView.errcode = access_Token.errcode;
                corpCheckInRuleView.errmsg = string.Format("【企业微信】【获取月打卡数据】【Token】【Msg】{0}", access_Token.errmsg);
                return corpCheckInRuleView;
            }

            string url = string.Format("/cgi-bin/checkin/getcorpcheckinoption?access_token={0}", access_Token.access_token);

            var content = new StringContent(string.Empty, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            corpCheckInRuleView = System.Text.Json.JsonSerializer.Deserialize<CorpCheckInRuleView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });


            return corpCheckInRuleView;
        }


        /// <summary>
        /// 获取月打卡记录数据
        /// </summary>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public async Task<CheckInView> GetCheckin_MonthDataAsync1(DateTime startDt, DateTime endDt)
        {
            CheckInView checkInView = new CheckInView();

            //获取员工Id
            UserIdListView userIdListView = await GetUserIdListAsync();
            if (userIdListView.errcode != 0)
            {
                checkInView.errcode = userIdListView.errcode;
                checkInView.errmsg = string.Format("【企业微信】【获取员工IdList】【Msg】{0}", userIdListView.errmsg);
                return checkInView;
            }

            if (userIdListView.dept_user == null || userIdListView.dept_user.Count <= 0)
            {
                checkInView.errmsg = string.Format("【企业微信】【获取员工IdList】【Msg】未查出员工Id");
                return checkInView;
            }

            //获取打卡数据 token
            Access_TokenView access_Token = await GetTokenAsync(2);
            if (access_Token.errcode != 0)
            {
                checkInView.errcode = access_Token.errcode;
                checkInView.errmsg = string.Format("【企业微信】【获取月打卡数据】【Token】【Msg】{0}", access_Token.errmsg);
                return checkInView;
            }

            string url = string.Format("/cgi-bin/checkin/getcheckin_monthdata?access_token={0}", access_Token.access_token);

            Checkin_MonthData_Request checkInReq = new Checkin_MonthData_Request();
            checkInReq.access_token = access_Token.access_token;

            checkInReq.starttime = (uint)(startDt - _1970).TotalSeconds;
            checkInReq.endtime = (uint)(endDt - _1970).TotalSeconds;
            checkInReq.useridlist = userIdListView.dept_user.Select(it => it.userid!).ToList();


            var json = System.Text.Json.JsonSerializer.Serialize(checkInReq);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            checkInView = System.Text.Json.JsonSerializer.Deserialize<CheckInView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });


            return checkInView;
        }

        /// <summary>
        /// 获取月打卡记录数据
        /// </summary>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public async Task<CheckInView> GetCheckin_MonthDataAsync(DateTime startDt, DateTime endDt)
        {
            CheckInView checkInView = new CheckInView();

            //获取员工Id
            UserIdListView userIdListView = await GetUserIdListAsync();
            if (userIdListView.errcode != 0)
            {
                checkInView.errcode = userIdListView.errcode;
                checkInView.errmsg = string.Format("【企业微信】【获取员工IdList】【Msg】{0}", userIdListView.errmsg);
                return checkInView;
            }

            if (userIdListView.dept_user == null || userIdListView.dept_user.Count <= 0)
            {
                checkInView.errmsg = string.Format("【企业微信】【获取员工IdList】【Msg】未查出员工Id");
                return checkInView;
            }

            //获取打卡数据 token
            Access_TokenView access_Token = await GetTokenAsync(2);
            if (access_Token.errcode != 0)
            {
                checkInView.errcode = access_Token.errcode;
                checkInView.errmsg = string.Format("【企业微信】【获取月打卡数据】【Token】【Msg】{0}", access_Token.errmsg);
                return checkInView;
            }


            #region 处理超31天的月报表数据

            string url = string.Format("/cgi-bin/checkin/getcheckin_monthdata?access_token={0}", access_Token.access_token);

            Checkin_MonthData_Request checkInReq = new Checkin_MonthData_Request();
            checkInReq.access_token = access_Token.access_token;
            checkInReq.useridlist = userIdListView.dept_user.Select(it => it.userid ?? "").ToList();

            uint starttimeOne, endtimeOne, starttimeTwo, endtimeTwo;
            int days = (int)(endDt - startDt).TotalDays;

            if (days > 32)
            {
                starttimeOne = (uint)((startDt.ToUniversalTime().Ticks - 621355968000000000) / 10000000);
                endtimeOne = (uint)((startDt.AddDays(31).ToUniversalTime().Ticks - 621355968000000000) / 10000000);
                starttimeTwo = (uint)((startDt.AddDays(32).ToUniversalTime().Ticks - 621355968000000000) / 10000000);
                endtimeTwo = (uint)((endDt.ToUniversalTime().Ticks - 621355968000000000) / 10000000);

                checkInReq.starttime = starttimeOne;
                checkInReq.endtime = endtimeOne;
                CheckInView checkInViewOne = new CheckInView();

                var jsonOne = System.Text.Json.JsonSerializer.Serialize(checkInReq);
                var contentOne = new StringContent(jsonOne, Encoding.UTF8, "application/json");
                var create_ReqOne = await _httpClient.PostAsync(url, contentOne);
                var stringResponseOne = await create_ReqOne.Content.ReadAsStringAsync();

                checkInViewOne = System.Text.Json.JsonSerializer.Deserialize<CheckInView>(stringResponseOne,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

                if (checkInViewOne.errcode != 0)
                {
                    return checkInViewOne;
                }

                checkInReq.starttime = starttimeTwo;
                checkInReq.endtime = endtimeTwo;
                CheckInView checkInViewTwo = new CheckInView();



                var jsonTwo = System.Text.Json.JsonSerializer.Serialize(checkInReq);
                var contentTwo = new StringContent(jsonTwo, Encoding.UTF8, "application/json");
                var create_ReqTwo = await _httpClient.PostAsync(url, contentTwo);
                var stringResponseTwo = await create_ReqTwo.Content.ReadAsStringAsync();

                checkInViewTwo = System.Text.Json.JsonSerializer.Deserialize<CheckInView>(stringResponseTwo,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

                if (checkInViewTwo.errcode != 0)
                {
                    return checkInViewTwo;
                }

                #region 整合月报表数据 

                foreach (var item_one in checkInViewOne.datas)
                {
                    foreach (var item_two in checkInViewTwo.datas)
                    {
                        if (item_one.base_info.acctid.Equals(item_two.base_info.acctid))
                        {
                            #region summary_info 汇总信息整合
                            item_one.summary_info.work_days += item_two.summary_info.work_days; //应打卡天数
                            item_one.summary_info.regular_days += item_two.summary_info.regular_days;  //正常天数
                            item_one.summary_info.except_days += item_two.summary_info.except_days;   //异常天数
                            item_one.summary_info.regular_work_sec += item_two.summary_info.regular_work_sec;  //实际工作时长，为统计周期每日实际工作时长之和
                            item_one.summary_info.standard_work_sec += item_two.summary_info.standard_work_sec; //标准工作时长，为统计周期每日标准工作时长之和
                            #endregion

                            #region exception_infos 异常状态统计信息 整合
                            item_one.exception_infos.AddRange(item_two.exception_infos);
                            #endregion

                            #region sp_items 	假勤统计信息整合
                            item_one.sp_items.AddRange(item_two.sp_items);
                            #endregion

                            #region overwork_info 加班情况 整合
                            item_one.overwork_info.workday_over_sec += item_two.overwork_info.workday_over_sec;   //工作日加班时长
                            item_one.overwork_info.holidays_over_sec += item_two.overwork_info.holidays_over_sec;   //节假日加班时长
                            item_one.overwork_info.restdays_over_sec += item_two.overwork_info.restdays_over_sec;   //休息日加班时长
                            #endregion
                            break;
                        }
                    }
                }
                #endregion
                checkInView = checkInViewOne;
            }
            else
            {
                checkInReq.starttime = (uint)((startDt.ToUniversalTime().Ticks - 621355968000000000) / 10000000);
                checkInReq.endtime = (uint)((endDt.ToUniversalTime().Ticks - 621355968000000000) / 10000000);

                var json = System.Text.Json.JsonSerializer.Serialize(checkInReq);
                var content = new StringContent(json, Encoding.UTF8, "application/json");
                var create_Req = await _httpClient.PostAsync(url, content);
                var stringResponse = await create_Req.Content.ReadAsStringAsync();

                checkInView = System.Text.Json.JsonSerializer.Deserialize<CheckInView>(stringResponse,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
            }


            #endregion

            return checkInView;
        }


        /// <summary>
        /// 获取月打卡数据(redis缓存)
        /// </summary>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public async Task<CheckInView> GetCheckin_MonthDataRedisAsync(DateTime startDt, DateTime endDt)
        {
            CheckInView checkInView = new CheckInView();

            string checkInDatastring = await RedisRepository.RedisFactory
                                                    .CreateRedisRepository()
                                                    .StringGetAsync<string>("Checkin_MonthData");//List<T> 取


            if (!string.IsNullOrEmpty(checkInDatastring))
            {

                checkInView = JsonConvert.DeserializeObject<CheckInView>(checkInDatastring);
                return checkInView;
            }

            //获取员工Id
            UserIdListView userIdListView = await GetUserIdListAsync();
            if (userIdListView.errcode != 0)
            {
                checkInView.errcode = userIdListView.errcode;
                checkInView.errmsg = string.Format("【企业微信】【获取员工IdList】【Msg】{0}", userIdListView.errmsg);
                return checkInView;
            }

            if (userIdListView.dept_user == null || userIdListView.dept_user.Count <= 0)
            {
                checkInView.errmsg = string.Format("【企业微信】【获取员工IdList】【Msg】未查出员工Id");
                return checkInView;
            }

            //获取月打卡数据 token
            Access_TokenView access_Token = await GetTokenAsync(2);
            if (access_Token.errcode != 0)
            {
                checkInView.errcode = access_Token.errcode;
                checkInView.errmsg = string.Format("【企业微信】【获取月打卡数据】【Token】【Msg】{0}", access_Token.errmsg);
                return checkInView;
            }

            string url = string.Format("/cgi-bin/checkin/getcheckin_monthdata?access_token={0}", access_Token.access_token);

            Checkin_MonthData_Request checkInReq = new Checkin_MonthData_Request();
            checkInReq.access_token = access_Token.access_token;

            checkInReq.starttime = (uint)(startDt - _1970).TotalSeconds;
            checkInReq.endtime = (uint)(endDt - _1970).TotalSeconds;
            checkInReq.useridlist = userIdListView.dept_user.Select(it => it.userid!).ToList();

            var json = System.Text.Json.JsonSerializer.Serialize(checkInReq);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            checkInView = System.Text.Json.JsonSerializer.Deserialize<CheckInView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });


            if (checkInView.errcode == 0)
            {
                TimeSpan ts = DateTime.Now.AddMinutes(60) - DateTime.Now; //设置redis 过期时间 60分钟
                await RedisRepository
                    .RedisFactory
                    .CreateRedisRepository()
                    .StringSetAsync<string>("Checkin_MonthData", JsonConvert.SerializeObject(checkInView), ts);//List<T> 存
            }


            return checkInView;
        }

        public async Task<object> QueryAssessmentByUser(DateTime startDt, DateTime endDt, List<string> qiyeUidList)
        {
            AssessmentByUserListView assessmentByUserListView = new AssessmentByUserListView();
            List<AssessmentByUserView> AssessmentByUserView = new  List<AssessmentByUserView>();
            assessmentByUserListView.Data = AssessmentByUserView;
            assessmentByUserListView.errcode = 0;  
            assessmentByUserListView.errmsg = "成功";

            CheckInView? checkInView = new CheckInView();

            //获取打卡数据 token
            Access_TokenView access_Token = await GetTokenAsync(2);
            if (access_Token.errcode != 0)
            {
                assessmentByUserListView.errcode = access_Token.errcode;
                assessmentByUserListView.errmsg = string.Format("【企业微信】【获取月打卡数据】【Token】【Msg】{0}", access_Token.errmsg);
                return assessmentByUserListView;
            }

            string url = string.Format("/cgi-bin/checkin/getcheckin_monthdata?access_token={0}", access_Token.access_token);

            Checkin_MonthData_Request checkInReq = new Checkin_MonthData_Request();
            checkInReq.access_token = access_Token.access_token;

            checkInReq.starttime = (uint)(startDt - _1970).TotalSeconds;
            checkInReq.endtime = (uint)(endDt - _1970).TotalSeconds;
            checkInReq.useridlist = qiyeUidList;

            var json = System.Text.Json.JsonSerializer.Serialize(checkInReq);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            checkInView = System.Text.Json.JsonSerializer.Deserialize<CheckInView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            if (checkInView == null)
            {
                assessmentByUserListView.errcode = -1;
                assessmentByUserListView.errmsg = "checkInView Deserialize Error";
                return assessmentByUserListView;
            }

            if (checkInView.errcode != 0)
            {
                assessmentByUserListView.errcode = checkInView.errcode;
                assessmentByUserListView.errmsg = checkInView.errmsg;
                return assessmentByUserListView;
            }

            var errorUserList = new List<string>();

            //遍历用户数据
            foreach (var item in checkInView.datas)
            {

                //有异常状态的情况下获取具体异常信息
                if (item.summary_info.except_days > 0)
                {
                    errorUserList.Add(item.base_info.acctid);
                }

                assessmentByUserListView.Data.Add(new Domain.ViewModels.QiYeWeChat.AssessmentByUserView
                {
                    Accid = item.base_info.acctid,
                    Except_days = item.summary_info.except_days,
                    Name = item.base_info.name,
                    Regular_days = item.summary_info.regular_days,
                    Exception_info_List = new List<Exception_info>(),
                    Work_days = item.summary_info.work_days
                });
            }

            if (errorUserList.Count > 0) {

                var dayInfo = await GetCheckinDataAsync(errorUserList, 3, startDt, endDt);

                if (dayInfo.errcode != 0)
                {
                    assessmentByUserListView.errcode = dayInfo.errcode;
                    assessmentByUserListView.errmsg = dayInfo.errmsg;
                    assessmentByUserListView.Data = new List<AssessmentByUserView>();
                    return assessmentByUserListView;
                }

                var dic = new Dictionary<ErrorType, List<string>>()
                {
                    { ErrorType.迟到 , new List<string>{ "时间异常" } },
                    { ErrorType.缺卡 , new List<string>{ "未打卡" } },
                };

                foreach (var item in dayInfo.checkindata)
                {
                    foreach (var user in assessmentByUserListView.Data)
                    {
                        if (user.Accid == item.userid)
                        {
                            //遍历异常信息
                            if (!item.exception_type.IsNullOrWhiteSpace())
                            {
                                var linqFind = dic.First(x => x.Value.Contains(item.exception_type));

                                var errinfo =  new Exception_info
                                {
                                    Date = item.checkin_time_dt,
                                    Type = linqFind.Key,
                                    Info = item.exception_type
                                };

                                user.Exception_info_List.Add(errinfo);
                            }
                        }
                    }
                }

            }

            return assessmentByUserListView;
        }

        /// <summary>
        /// 获取打卡记录数据
        /// </summary>
        /// <param name="useridlist">需要获取打卡记录的用户列表</param>
        /// <param name="opencheckindatatype">打卡类型。1：上下班打卡；2：外出打卡；3：全部打卡</param>
        /// <param name="startDt">获取打卡记录的开始时间。Unix时间戳</param>
        /// <param name="endDt">获取打卡记录的结束时间。Unix时间戳</param>
        /// <returns></returns>
        public async Task<CheckInDataView> GetCheckinDataAsync(List<string> useridlist, int opencheckindatatype, DateTime startDt, DateTime endDt)
        {
            CheckInDataView checkInDataView = new CheckInDataView();

            //参数处理
            if (useridlist.Count <= 0)
            {
                checkInDataView.errmsg = "请填写企业微信用户id，可为多个!";
                return checkInDataView;
            }

            if (useridlist.Count > 100)
            {
                checkInDataView.errmsg = "用户列表不超过100个。若用户超过100个，请分批获取!";
                return checkInDataView;
            }

            //获取打卡数据 token
            Access_TokenView access_Token = await GetTokenAsync(2);
            if (access_Token.errcode != 0)
            {
                checkInDataView.errcode = access_Token.errcode;
                checkInDataView.errmsg = string.Format("【企业微信】【获取打卡数据】【Token】【Msg】{0}", access_Token.errmsg);
                return checkInDataView;
            }

            string url = string.Format("/cgi-bin/checkin/getcheckindata?access_token={0}", access_Token.access_token);

            DateTime centerDt = startDt.AddDays(30);

            long startTs = (long)(startDt - _1970).TotalSeconds;
            long centerTs = (long)(centerDt - _1970).TotalSeconds;
            long endTs = (long)(endDt - _1970).TotalSeconds;
            CheckInData_Request checkInData_Req = new CheckInData_Request()
            {
                access_token = access_Token.access_token,
                opencheckindatatype = opencheckindatatype,
                useridlist = useridlist,
                starttime = startTs,
                endtime = centerTs
            };

            var json = System.Text.Json.JsonSerializer.Serialize(checkInData_Req);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            checkInDataView = System.Text.Json.JsonSerializer.Deserialize<CheckInDataView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });


            if (centerDt < endDt)
            {
                checkInData_Req.starttime = centerTs;
                checkInData_Req.endtime = endTs;

                var json1 = System.Text.Json.JsonSerializer.Serialize(checkInData_Req);
                var content1 = new StringContent(json1, Encoding.UTF8, "application/json");
                var create_Req1 = await _httpClient.PostAsync(url, content1);
                var stringResponse1 = await create_Req1.Content.ReadAsStringAsync();

                CheckInDataView checkInDataView1 = System.Text.Json.JsonSerializer.Deserialize<CheckInDataView>(stringResponse1,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
                if (checkInDataView1.errcode != 0)
                {
                    return checkInDataView1;
                }
                checkInDataView.checkindata.AddRange(checkInDataView1.checkindata);
                return checkInDataView;
            }


            return checkInDataView;
        }

        /// <summary>
        /// 获取打卡日报数据
        /// </summary>
        /// <param name="useridlist"></param>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public async Task<CheckInDayDataView> GetCheckInDayDataAsync1(List<string> useridlist, DateTime startDt, DateTime endDt)
        {
            CheckInDayDataView checkInDayDataView = new CheckInDayDataView();

            //参数处理
            if (useridlist.Count <= 0)
            {
                checkInDayDataView.errmsg = "请填写企业微信用户id，可为多个!";
                return checkInDayDataView;
            }


            //获取打卡数据 token
            Access_TokenView access_Token = await GetTokenAsync(2);
            if (access_Token.errcode != 0)
            {
                checkInDayDataView.errcode = access_Token.errcode;
                checkInDayDataView.errmsg = string.Format("【企业微信】【获取打卡日报数据】【Token】【Msg】{0}", access_Token.errmsg);
                return checkInDayDataView;
            }

            string url = string.Format("/cgi-bin/checkin/getcheckin_daydata?access_token={0}&debug=1", access_Token.access_token);

            long startTs = (startDt.ToUniversalTime().Ticks - 621355968000000000) / 10000000;
            long endTs = (endDt.ToUniversalTime().Ticks - 621355968000000000) / 10000000;

            var checkInData_Req = new
            {
                access_token = access_Token.access_token,
                useridlist = useridlist,
                starttime = startTs,
                endtime = endTs
            };

            var json = System.Text.Json.JsonSerializer.Serialize(checkInData_Req);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            checkInDayDataView = System.Text.Json.JsonSerializer.Deserialize<CheckInDayDataView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            return checkInDayDataView;
        }


        /// <summary>
        /// 获取打卡日报数据
        /// </summary>
        /// <param name="useridlist"></param>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public async Task<CheckInDayDataView> GetCheckInDayDataAsync(List<string> useridlist, DateTime startDt, DateTime endDt)
        {
            CheckInDayDataView checkInDayDataView = new CheckInDayDataView();

            //参数处理
            if (useridlist.Count <= 0)
            {
                checkInDayDataView.errmsg = "请填写企业微信用户id，可为多个!";
                return checkInDayDataView;
            }


            //获取打卡数据 token
            Access_TokenView access_Token = await GetTokenAsync(2);
            if (access_Token.errcode != 0)
            {
                checkInDayDataView.errcode = access_Token.errcode;
                checkInDayDataView.errmsg = string.Format("【企业微信】【获取打卡日报数据】【Token】【Msg】{0}", access_Token.errmsg);
                return checkInDayDataView;
            }

            string url = string.Format("/cgi-bin/checkin/getcheckin_daydata?access_token={0}&debug=1", access_Token.access_token);

            int days = (int)(endDt - startDt).TotalDays;
            if (days > 31)
            {
                long startTs_One = (startDt.ToUniversalTime().Ticks - 621355968000000000) / 10000000;
                long endTs_One = (startDt.AddDays(31).ToUniversalTime().Ticks - 621355968000000000) / 10000000;
                long startTs_Two = (startDt.AddDays(31).ToUniversalTime().Ticks - 621355968000000000) / 10000000;
                long endTs_Two = (endDt.ToUniversalTime().Ticks - 621355968000000000) / 10000000;

                var checkInData_ReqOne = new
                {
                    access_token = access_Token.access_token,
                    useridlist = useridlist,
                    starttime = startTs_One,
                    endtime = endTs_One
                };

                var jsonOne = System.Text.Json.JsonSerializer.Serialize(checkInData_ReqOne);
                var contentOne = new StringContent(jsonOne, Encoding.UTF8, "application/json");
                var create_ReqOne = await _httpClient.PostAsync(url, contentOne);
                var stringResponseOne = await create_ReqOne.Content.ReadAsStringAsync();

                CheckInDayDataView checkInDayDataViewOne = System.Text.Json.JsonSerializer.Deserialize<CheckInDayDataView>(stringResponseOne,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

                if (checkInDayDataViewOne.errcode != 0)
                {
                    return checkInDayDataViewOne;
                }

                var checkInData_ReqTwo = new
                {
                    access_token = access_Token.access_token,
                    useridlist = useridlist,
                    starttime = startTs_Two,
                    endtime = endTs_Two
                };

                var jsonTwo = System.Text.Json.JsonSerializer.Serialize(checkInData_ReqTwo);
                var contentTwo = new StringContent(jsonTwo, Encoding.UTF8, "application/json");
                var create_ReqTwo = await _httpClient.PostAsync(url, contentTwo);
                var stringResponseTwo = await create_ReqTwo.Content.ReadAsStringAsync();

                CheckInDayDataView checkInDayDataViewTwo = System.Text.Json.JsonSerializer.Deserialize<CheckInDayDataView>(stringResponseTwo,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
                if (checkInDayDataViewTwo.errcode != 0)
                {
                    return checkInDayDataViewTwo;
                }
                checkInDayDataViewOne.datas.AddRange(checkInDayDataViewTwo.datas);
                return checkInDayDataViewOne;
            }
            else
            {
                long startTs = (startDt.ToUniversalTime().Ticks - 621355968000000000) / 10000000;
                long endTs = (endDt.ToUniversalTime().Ticks - 621355968000000000) / 10000000;

                var checkInData_Req = new
                {
                    access_token = access_Token.access_token,
                    useridlist = useridlist,
                    starttime = startTs,
                    endtime = endTs
                };

                var json = System.Text.Json.JsonSerializer.Serialize(checkInData_Req);
                var content = new StringContent(json, Encoding.UTF8, "application/json");
                var create_Req = await _httpClient.PostAsync(url, content);
                var stringResponse = await create_Req.Content.ReadAsStringAsync();

                checkInDayDataView = System.Text.Json.JsonSerializer.Deserialize<CheckInDayDataView>(stringResponse,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });
            }


            return checkInDayDataView;
        }

        #endregion

        #region 审批

        /// <summary>
        /// 获取审批数据（旧）
        /// </summary>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public async Task<ApprovalDataView> GetApprovalDataAsync(DateTime startDt, DateTime endDt)
        {
            ApprovalDataView approvalDataView = new ApprovalDataView();

            //获取审批数据 token
            Access_TokenView access_Token = await GetTokenAsync(5);
            if (access_Token.errcode != 0)
            {
                approvalDataView.errcode = access_Token.errcode;
                approvalDataView.errmsg = string.Format("【企业微信】【获取审批数据】【Token】【Msg】{0}", access_Token.errmsg);
                return approvalDataView;
            }

            string url = string.Format("/cgi-bin/corp/getapprovaldata?access_token={0}", access_Token.access_token);

            ApprovalData_Request approvalDataReq = new ApprovalData_Request();
            approvalDataReq.access_token = access_Token.access_token;
            approvalDataReq.starttime = (uint)(startDt - _1970).TotalSeconds;
            approvalDataReq.endtime = (uint)(endDt - _1970).TotalSeconds;

            var json = System.Text.Json.JsonSerializer.Serialize(approvalDataReq);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            approvalDataView = System.Text.Json.JsonSerializer.Deserialize<ApprovalDataView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            List<Sp_Info> sp_datas = new List<Sp_Info>();
            sp_datas.AddRange(approvalDataView.data);

            int index = 0;
            //多次访问审批接口
            if (approvalDataView.total >= 100)
            {
                approvalDataView.total -= 100;
                int forTotal = approvalDataView.total % 100 == 0 ? approvalDataView.total / 100 : approvalDataView.total / 100 + 1;

                long? next_spnum = approvalDataView.next_spnum;
                approvalDataReq.next_spnum = next_spnum;


                for (int i = 0; i < forTotal; i++)
                {
                    index++;
                    var for_json = System.Text.Json.JsonSerializer.Serialize(approvalDataReq);
                    var for_content = new StringContent(for_json, Encoding.UTF8, "application/json");
                    var for_create_Req = await _httpClient.PostAsync(url, for_content);
                    var for_stringResponse = await for_create_Req.Content.ReadAsStringAsync();

                    ApprovalDataView for_approvalDataView = System.Text.Json.JsonSerializer.Deserialize<ApprovalDataView>(for_stringResponse,
                        new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

                    approvalDataReq.next_spnum = for_approvalDataView.next_spnum;  //重新定义游标
                    sp_datas.AddRange(for_approvalDataView.data); //追加数据
                }

                approvalDataView.total += 100;
            }

            approvalDataView.data = sp_datas;
            return approvalDataView;
        }

        /// <summary>
        /// 获取审批数据（旧）(redis缓存)
        /// </summary>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public async Task<List<Sp_Info>> GetApprovalDatasAsync(DateTime startDt, DateTime endDt)
        {
            List<Sp_Info> sp_Infos = new List<Sp_Info>();

            //获取所有打卡补卡，审批 数据 前后范围增加10天
            DateTime sp_startDt = startDt.AddDays(-10);
            DateTime sp_centerDt = sp_startDt.AddDays(30);
            DateTime sp_endDt = endDt.AddDays(10);

            ApprovalDataView approvalData_1 = await GetApprovalDataAsync(sp_startDt, sp_centerDt);  //时间段内所有 审批数据
            ApprovalDataView approvalData_2 = await GetApprovalDataAsync(sp_centerDt, sp_endDt);    //时间段内所有 审批数据
            if (approvalData_1.errcode != 0)
            {
                Log.Error("企业微信 获取 " + sp_startDt + " - " + sp_centerDt + " 内审批 Msg：" + approvalData_1.errmsg);

                return sp_Infos;
            }
            sp_Infos.AddRange(approvalData_1.data);
            if (approvalData_2.errcode != 0)
            {
                Log.Error("企业微信 获取 " + sp_centerDt + " - " + sp_endDt + " 内审批 Msg：" + approvalData_2.errmsg);

                return sp_Infos;
            }
            sp_Infos.AddRange(approvalData_2.data);

            sp_Infos = sp_Infos.Where(it => it.sp_status == 2).ToList(); //存储已审核的数据


            return sp_Infos;
        }

        /// <summary>
        /// 获取审批数据（旧）(redis缓存)
        /// </summary>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public async Task<List<Sp_Info>> GetApprovalDatasRedisAsync(DateTime startDt, DateTime endDt)
        {
            List<Sp_Info> sp_Infos = new List<Sp_Info>();

            //获取所有打卡补卡，审批 数据 前后范围增加10天
            DateTime sp_startDt = startDt.AddDays(-10);
            DateTime sp_centerDt = sp_startDt.AddDays(30);
            DateTime sp_endDt = endDt.AddDays(10);


            string redisName = "ApprovalData" + sp_startDt.ToString("yyyyMMdd") + "-" + sp_endDt.ToString("yyyyMMdd");
            string sp_InfosString = string.Empty;

            //sp_InfosString = await RedisRepository.RedisFactory
            //                            .CreateRedisRepository()
            //                            .StringGetAsync<string>(redisName);//string 取



            if (string.IsNullOrEmpty(sp_InfosString))
            {
                ApprovalDataView approvalData_1 = await GetApprovalDataAsync(sp_startDt, sp_centerDt);  //时间段内所有 审批数据
                ApprovalDataView approvalData_2 = await GetApprovalDataAsync(sp_centerDt, sp_endDt);    //时间段内所有 审批数据
                if (approvalData_1.errcode != 0)
                {
                    Log.Error("企业微信 获取 " + sp_startDt + " - " + sp_centerDt + " 内审批 Msg：" + approvalData_1.errmsg);

                    return sp_Infos;
                }
                sp_Infos.AddRange(approvalData_1.data);
                if (approvalData_2.errcode != 0)
                {
                    Log.Error("企业微信 获取 " + sp_centerDt + " - " + sp_endDt + " 内审批 Msg：" + approvalData_2.errmsg);

                    return sp_Infos;
                }
                sp_Infos.AddRange(approvalData_2.data);

                sp_Infos = sp_Infos.Where(it => it.sp_status == 2).ToList(); //存储已审核的数据

                TimeSpan ts = DateTime.Now.AddMinutes(60) - DateTime.Now; //设置redis 过期时间 60分钟
                await RedisRepository
                    .RedisFactory
                    .CreateRedisRepository()
                    .StringSetAsync<string>(redisName, JsonConvert.SerializeObject(sp_Infos), ts);//string 存
            }
            else
            {
                sp_Infos = JsonConvert.DeserializeObject<List<Sp_Info>>(sp_InfosString);
            }

            return sp_Infos;
        }

        /// <summary>
        /// 批量获取审批单号
        /// </summary>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <param name="creator">
        /// 申请人
        /// </param>
        /// <param name="sp_status">
        /// sp_status-审批单状态（1-审批中；2-已通过；3-已驳回；4-已撤销；6-通过后撤销；7-已删除；10-已支付）
        /// </param>
        /// <param name="record_type">
        /// record_type == 0 ALL  有值 请填写对应值
        /// record_type - 审批单类型属性，1-请假；2-打卡补卡；3-出差；4-外出；5-加班； 6- 调班；7-会议室预定；8-退款审批；9-红包报销审批
        /// </param>
        /// <returns></returns>
        private async Task<ApprovalInfoView> GetApprovalInfoAsync(DateTime startDt, DateTime endDt, string creator, int sp_status, int record_type)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();

            ApprovalInfoView approvalInfoView = new ApprovalInfoView();

            //获取所有打卡补卡，审批 数据 向前增加30天 向后范围增加15天
            DateTime sp_startDt = startDt.AddDays(-30);
            DateTime sp_endDt = endDt.AddDays(15);

            //获取审批数据 token
            Access_TokenView access_Token = await GetTokenAsync(5);
            if (access_Token.errcode != 0)
            {
                approvalInfoView.errcode = access_Token.errcode;
                approvalInfoView.errmsg = string.Format("【企业微信】【批量获取审批单号】【Token】【Msg】{0}", access_Token.errmsg);
                return approvalInfoView;
            }

            string url = string.Format("/cgi-bin/oa/getapprovalinfo?access_token={0}", access_Token.access_token);

            List<Dic> filters = new List<Dic> {
                new Dic() { key = "creator", value = creator },  //筛选条件 申请人
                new Dic() { key = "sp_status", value = sp_status.ToString() },    //筛选条件 审核状态 2 已同意
            };

            if (record_type != 0)
            {
                filters.Add(new Dic() { key = "record_type", value = record_type.ToString() });  //筛选条件 审批单类型 请假 1
            }

            int days = (sp_endDt - sp_startDt).Days;
            decimal runCount = days % 30;
            int runCount1 = 0;
            if (runCount == 0) runCount1 = (int)(days % 30.00M);
            else runCount1 = (int)Math.Ceiling(days / 30.00M);


            List<string> sp_no_lists = new List<string>();
            for (int i = 0; i < runCount1; i++)
            {
                DateTime for_sp_startDt = sp_startDt;
                DateTime for_sp_endDt = sp_startDt.AddDays(30);
                sp_startDt = sp_startDt.AddDays(30);
                if (for_sp_endDt >= sp_endDt)
                {
                    for_sp_endDt = sp_endDt;
                }

                ApprovalInfo_Request approvalInfoReq = new ApprovalInfo_Request()
                {
                    access_token = access_Token.access_token,
                    starttime = (uint)ConvertToTimeSpan(for_sp_startDt),
                    endtime = (uint)ConvertToTimeSpan(for_sp_endDt),
                    filters = filters.ToList(),
                };
                var json = System.Text.Json.JsonSerializer.Serialize(approvalInfoReq);
                var content = new StringContent(json, Encoding.UTF8, "application/json");
                var create_Req = await _httpClient.PostAsync(url, content);
                var stringResponse = await create_Req.Content.ReadAsStringAsync();

                ApprovalInfoView approvalInfoView1 = System.Text.Json.JsonSerializer.Deserialize<ApprovalInfoView>(stringResponse,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

                #region 分页调用  new_next_cursor != null 
                string new_cursor = approvalInfoView1.new_next_cursor;

                while (!string.IsNullOrEmpty(new_cursor))
                {
                    approvalInfoReq.new_cursor = new_cursor;

                    var json1 = System.Text.Json.JsonSerializer.Serialize(approvalInfoReq);
                    var content1 = new StringContent(json, Encoding.UTF8, "application/json");
                    var create_Req1 = await _httpClient.PostAsync(url, content1);
                    var stringResponse1 = await create_Req1.Content.ReadAsStringAsync();

                    ApprovalInfoView approvalInfoView11 = System.Text.Json.JsonSerializer.Deserialize<ApprovalInfoView>(stringResponse1,
                        new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

                    if (approvalInfoView11.errcode != 0)
                    {
                        return approvalInfoView1;
                    }
                    new_cursor = approvalInfoView11.new_next_cursor;
                    if (approvalInfoView11.sp_no_list.Count > 0 || approvalInfoView11.sp_no_list != null)
                    {
                        sp_no_lists.AddRange(approvalInfoView1.sp_no_list);
                    }
                }
                #endregion

                if (approvalInfoView1.errcode != 0)
                {
                    return approvalInfoView1;
                }

                if (approvalInfoView1.sp_no_list.Count > 0 || approvalInfoView1.sp_no_list != null)
                {
                    sp_no_lists.AddRange(approvalInfoView1.sp_no_list);
                }

            }
            approvalInfoView.errcode = 0;

            if (sp_no_lists.Count > 0)
            {
                sp_no_lists = sp_no_lists.Distinct().ToList();
            }

            approvalInfoView.sp_no_list = sp_no_lists;
            sw.Stop();
            approvalInfoView.errmsg = approvalInfoView.errmsg + " 耗时：" + sw.Elapsed.TotalMilliseconds + "ms";
            return approvalInfoView;
        }

        /// <summary>
        /// 获取审批申请详情
        /// </summary>
        /// <param name="sp_no"></param>
        /// <returns></returns>
        public async Task<ApprovalDetailView> GetApprovalDetailAsync(string sp_no)
        {
            ApprovalDetailView ApprovalDetailView = new ApprovalDetailView();

            if (string.IsNullOrEmpty(sp_no))
            {
                return ApprovalDetailView;
            }
            //获取审批数据 token
            Access_TokenView access_Token = await GetTokenAsync(5);
            if (access_Token.errcode != 0)
            {
                ApprovalDetailView.errcode = access_Token.errcode;
                ApprovalDetailView.errmsg = string.Format("【企业微信】【审批申请详情】【Token】【Msg】{0}", access_Token.errmsg);
                return ApprovalDetailView;
            }

            string url = string.Format("/cgi-bin/oa/getapprovaldetail?access_token={0}", access_Token.access_token);

            ApprovalDetail_Request approvalDetail_Req = new ApprovalDetail_Request()
            {
                access_token = access_Token.access_token,
                sp_no = sp_no,
            };

            var json = System.Text.Json.JsonSerializer.Serialize(approvalDetail_Req);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            ApprovalDetailView = System.Text.Json.JsonSerializer.Deserialize<ApprovalDetailView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            return ApprovalDetailView;
        }

        /// <summary>
        /// 批量获取审批详情
        /// </summary>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <param name="creator">
        /// 申请人
        /// </param>
        /// <param name="sp_status">
        /// sp_status-审批单状态（1-审批中；2-已通过；3-已驳回；4-已撤销；6-通过后撤销；7-已删除；10-已支付）
        /// </param>
        /// <param name="record_type">
        /// record_type - 审批单类型属性，1-请假；2-打卡补卡；3-出差；4-外出；5-加班； 6- 调班；7-会议室预定；8-退款审批；9-红包报销审批
        /// </param>
        /// <returns></returns>
        public async Task<List<Sp_Detail>> GetApprovalDetailsAsync(DateTime startDt, DateTime endDt, string creator, int sp_status, int record_type)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();

            List<Sp_Detail> details = new List<Sp_Detail>();

            if (string.IsNullOrEmpty(creator))
            {
                return details;
            }

            ApprovalInfoView approvalInfoView = new ApprovalInfoView();
            approvalInfoView = await GetApprovalInfoAsync(startDt, endDt, creator, sp_status, record_type);
            if (approvalInfoView.errcode != 0)
            {
                return details;
            }
            //循环查询详情
            foreach (var item in approvalInfoView.sp_no_list)
            {
                ApprovalDetailView approvalDetailView = new ApprovalDetailView();
                approvalDetailView = await GetApprovalDetailAsync(item);
                if (approvalDetailView.errcode != 0)
                {
                    Log.Error("【GetApprovalDetailsAsync】 record_type:" + record_type + " ErrorMsg：" + approvalDetailView.errmsg);
                    break;
                }

                details.Add(approvalDetailView.info);
            }
            sw.Stop();
            double hs = sw.Elapsed.TotalMilliseconds;
            return details;
        }

        /// <summary>
        /// 获取审批模板详情
        /// </summary>
        /// <param name="template_id">模板Id</param>
        /// <returns></returns>
        public async Task<TemplateDetailView> GetTemplateDetailAsync(string template_id)
        {
            TemplateDetailView templateDetailView = new TemplateDetailView();

            if (string.IsNullOrEmpty(template_id))
            {
                templateDetailView.errmsg = "template_id为空!";
                return templateDetailView;
            }
            //获取审批数据 token
            Access_TokenView access_Token = await GetTokenAsync(5);
            if (access_Token.errcode != 0)
            {
                templateDetailView.errcode = access_Token.errcode;
                templateDetailView.errmsg = string.Format("【企业微信】【审批申请详情】【Token】【Msg】{0}", access_Token.errmsg);
                return templateDetailView;
            }

            string url = string.Format("/cgi-bin/oa/gettemplatedetail?access_token={0}", access_Token.access_token);

            var approvalDetail_Req = new
            {
                access_token = access_Token.access_token,
                template_id = template_id,
            };

            var json = System.Text.Json.JsonSerializer.Serialize(approvalDetail_Req);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            templateDetailView = System.Text.Json.JsonSerializer.Deserialize<TemplateDetailView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            return templateDetailView;
        }
        #endregion

        #region hook机器人


        /// <summary>
        /// 发送团组信息给财务群
        /// </summary>
        /// <param name="msg"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<ResponseBase> RobotSendMsg_GroupInfo(string msg)
        {
            string key = "b4fe152f-a97a-48b1-830f-ab447f6d2f5f";
            string url = string.Format("/cgi-bin/webhook/send?key={0}", key);

            RobotSendMsg_GroupInfo_Content contentStr = new RobotSendMsg_GroupInfo_Content() { content = msg };

            RobotSendMsg_GroupInfo_Param reqJson = new RobotSendMsg_GroupInfo_Param()
            {
                msgtype = "markdown",
                markdown = contentStr
            };

            var json = System.Text.Json.JsonSerializer.Serialize(reqJson);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            ResponseBase sendMsgView = System.Text.Json.JsonSerializer.Deserialize<ResponseBase>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            return sendMsgView;
        }

        #endregion

        #region 团组状态通知

        /// <summary>
        /// 获取部门成员
        /// </summary>
        /// <param name="departmentId"></param>
        /// <returns></returns>
        public async Task<GroupStatus_UserSimplelistView> GroupStatus_GetUserList(int departmentId = 8402038)
        {
            GroupStatus_UserSimplelistView result = new GroupStatus_UserSimplelistView();

            Access_TokenView access_Token = await GetTokenAsync(6);
            if (access_Token.errcode != 0)
            {
                result.errcode = access_Token.errcode;
                result.errmsg = string.Format("【企业微信】【团组状态通知】【Token】【Msg】{0}", access_Token.errmsg);
                return result;
            }

            string url = string.Format("/cgi-bin/user/simplelist?access_token={0}&department_id={1}", access_Token.access_token, departmentId);

            var simplelist_Req = await _httpClient.GetAsync(url);

            if (simplelist_Req.IsSuccessStatusCode)
            {
                var stringResponse = await simplelist_Req.Content.ReadAsStringAsync();

                result = System.Text.Json.JsonSerializer.Deserialize<GroupStatus_UserSimplelistView>(stringResponse,
                    new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });


            }
            else
            {
                result.errcode = -1;
                result.errmsg = "企业微信部门列表未获取到!";
            }


            return result;
        }

        /// <summary>
        /// 创建群聊
        /// </summary>
        /// <param name="chatName"></param>
        /// <param name="owner"></param>
        /// <param name="userList"></param>
        /// <param name="chatId"></param>
        /// <returns></returns>
        public async Task<GroupStatus_CreateChatView> GroupStatus_CreateChat(string chatName, string owner, List<string> userList, string chatId)
        {
            GroupStatus_CreateChatView result = new GroupStatus_CreateChatView();

            Access_TokenView access_Token = await GetTokenAsync(6);
            if (access_Token.errcode != 0)
            {
                result.errcode = access_Token.errcode;
                result.errmsg = string.Format("【企业微信】【团组状态通知】【Token】【Msg】{0}", access_Token.errmsg);
                return result;
            }

            GroupStatus_CreateChat reqJson = new GroupStatus_CreateChat()
            {
                chatid = chatId,
                name = chatName,
                owner = owner,
                userlist = userList
            };

            string url = string.Format("/cgi-bin/appchat/create?access_token={0}&debug=1", access_Token.access_token);
            var json = System.Text.Json.JsonSerializer.Serialize(reqJson);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            result = System.Text.Json.JsonSerializer.Deserialize<GroupStatus_CreateChatView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            return result;
        }

        /// <summary>
        /// 向群聊发送信息
        /// </summary>
        /// <param name="chatId"></param>
        /// <param name="msgContent"></param>
        /// <param name="msgType"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<ResponseBase> GroupStatus_SendChatMsg_Markdown(string chatId, string msgContent, string msgType = "markdown")
        {
            ResponseBase result = new ResponseBase();

            Access_TokenView access_Token = await GetTokenAsync(6);
            if (access_Token.errcode != 0)
            {
                result.errcode = access_Token.errcode;
                result.errmsg = string.Format("【企业微信】【团组状态通知】【Token】【Msg】{0}", access_Token.errmsg);
                return result;
            }

            RobotSendMsg_GroupInfo_Content markdown = new RobotSendMsg_GroupInfo_Content() { content = msgContent };

            GroupStatus_AppChatSend_Markdown reqJson = new GroupStatus_AppChatSend_Markdown()
            {
                chatid = chatId,
                msgtype = msgType,
                markdown = markdown
            };

            string url = string.Format("/cgi-bin/appchat/send?access_token={0}", access_Token.access_token);
            var json = System.Text.Json.JsonSerializer.Serialize(reqJson);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            result = System.Text.Json.JsonSerializer.Deserialize<ResponseBase>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            return result;
        }

        /// <summary>
        /// 向用户发送Markdown信息
        /// </summary>
        /// <param name="toUser"></param>
        /// <param name="msgContent"></param>
        /// <param name="msgType"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        public async Task<GroupStatus_SendMessageView> GroupStatus_SendMessage_ToUser_Markdown(List<string> toUser, string msgContent, string msgType = "markdown")
        {
            GroupStatus_SendMessageView result = new GroupStatus_SendMessageView();

            Access_TokenView access_Token = await GetTokenAsync(6);
            if (access_Token.errcode != 0)
            {
                result.errcode = access_Token.errcode;
                result.errmsg = string.Format("【企业微信】【团组状态通知】【Token】【Msg】{0}", access_Token.errmsg);
                return result;
            }

            RobotSendMsg_GroupInfo_Content markdown = new RobotSendMsg_GroupInfo_Content() { content = msgContent };
            string userIds = "";
            toUser.ForEach(s => userIds += s + "|");
            userIds = userIds.TrimEnd('|');

            GroupStatus_AppSend_Markdown reqJson = new GroupStatus_AppSend_Markdown()
            {
                markdown = markdown,
                touser = userIds
            };


            string url = string.Format("/cgi-bin/message/send?access_token={0}&debug=1", access_Token.access_token);
            var json = System.Text.Json.JsonSerializer.Serialize(reqJson);
            var content = new StringContent(json, Encoding.UTF8, "application/json");
            var create_Req = await _httpClient.PostAsync(url, content);
            var stringResponse = await create_Req.Content.ReadAsStringAsync();

            result = System.Text.Json.JsonSerializer.Deserialize<GroupStatus_SendMessageView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            return result;
        }


        #endregion

        public long ConvertToTimeSpan(DateTime dt)
        {
            return (dt.ToUniversalTime().Ticks - 621355968000000000) / 10000000;
        }

       
    }
}