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

using OASystem.Domain.Dtos.QiYeWeChat;
using OASystem.Domain.ViewModels.JuHeExchangeRate;
using OASystem.Domain.ViewModels.QiYeWeChat;
using Org.BouncyCastle.Ocsp;
using SqlSugar;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Text.Json;
using Ubiety.Dns.Core;

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 PersonnelAssistant_Corpsecret = "ig--IJd6TxWDMJ1wT4e-RDRcRX12v5GjB359DNATwJ4"; //人事助手凭证密钥
        private readonly string PunchCard_AgentId = "3010185";            //打卡Id
        private readonly string PunchCard_Corpsecret = "Xhrl37GOqlAjsu0VzUSJECaJdjzkDXQLbvrzRsZQb8M";          //打卡凭证密钥
        private readonly string Email_AgentId = "1000004";   //E-Mail Id
        private readonly string Email_Corpsecret = "NA1zbJM15GmgjPYwDOqz59dIo1Wnug-MbU107MeUemc"; //E-Mail 凭证密钥
        private readonly string AddressBook_Corpsecret = "Y1tnjh7j-BvbqAytAoXZPUbmDR6dqLTL6mXtc6PZ7fo";  //通讯录同步 凭证密钥
        private readonly string Approve_AgentId = "3010040";     //审批 Id
        private readonly string Approve_Corpsecret = "k_Jo69Jw9Hqg_in-Rypbs30PNbxOYa1t4e-dxYuT-kw";  //审批 凭证密钥

        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：审批
        /// </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
            {
                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>
        private 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>
        /// <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>
        /// 获取月打卡数据(redis缓存)
        /// </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;
            }

            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>
        /// 获取月打卡数据(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;
        }

        #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="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>
        private async Task<ApprovalInfoView> GetApprovalInfoAsync(DateTime startDt,DateTime endDt,int sp_status, int record_type)
        {
            Stopwatch sw = new Stopwatch();
            sw.Start();

            ApprovalInfoView approvalInfoView = new ApprovalInfoView();

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

            //获取审批数据 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 = "sp_status", value = sp_status.ToString() },    //筛选条件 审核状态 2 已同意
                new Dic() { key = "record_type", value = record_type.ToString() },  //筛选条件 审批单类型 请假 1
            }; 

            ApprovalInfo_Request approvalInfoReq = new ApprovalInfo_Request()
            {
                access_token = access_Token.access_token,
                starttime = (uint)(startDt - _1970).TotalSeconds,
                endtime = (uint)(endDt - _1970).TotalSeconds,
                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 = System.Text.Json.JsonSerializer.Deserialize<ApprovalInfoView>(stringResponse,
                new JsonSerializerOptions() { PropertyNamingPolicy = JsonNamingPolicy.CamelCase });

            List<string> sp_datas = new List<string>();
            sp_datas.AddRange(approvalInfoView.sp_no_list);


            int index = 0;
            while (true)
            {
                if (string.IsNullOrEmpty(approvalInfoView.new_next_cursor)) break;
                string new_cursor = approvalInfoView.new_next_cursor;
                approvalInfoReq.new_cursor = new_cursor;
                var while_json = System.Text.Json.JsonSerializer.Serialize(approvalInfoReq);
                var while_content = new StringContent(while_json, Encoding.UTF8, "application/json");
                var while_create_Req = await _httpClient.PostAsync(url, while_content);
                var while_stringResponse = await while_create_Req.Content.ReadAsStringAsync();

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

                sp_datas.AddRange(approvalInfoView.sp_no_list); //追加数据
                index++;
            }

            approvalInfoView.sp_no_list = sp_datas;

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

        /// <summary>
        /// 获取审批申请详情
        /// </summary>
        /// <param name="sp_no"></param>
        /// <returns></returns>
        private 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="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,int sp_status, int record_type)
        {

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

            Stopwatch sw = new Stopwatch();
            sw.Start();
            ApprovalInfoView approvalInfoView = new ApprovalInfoView();
            approvalInfoView = await GetApprovalInfoAsync(startDt,endDt, 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
    }
}