OA2023/OASystem/OASystem.Api/OAMethodLib/PayrollComputation.cs

using Google.Protobuf.WellKnownTypes;
using NPOI.OpenXmlFormats.Spreadsheet;
using NPOI.SS.Formula.Functions;
using OASystem.API.OAMethodLib.QiYeWeChatAPI;
using OASystem.Domain;
using OASystem.Domain.Entities.PersonnelModule;
using OASystem.Domain.ViewModels.PersonnelModule;
using OASystem.Domain.ViewModels.QiYeWeChat;
using OASystem.Infrastructure.Repositories.Groups;
using System;
using System.Diagnostics.Eventing.Reader;
using System.Linq.Expressions;
using TencentCloud.Ocr.V20181119.Models;

namespace OASystem.API.OAMethodLib
{
    /// <summary>
    /// 工资计算
    /// </summary>
    public static class PayrollComputation
    {
        private static Result _result = new Result();
        private static readonly IQiYeWeChatApiService _qiYeWeChatApiService = AutofacIocManager.Instance.GetService<IQiYeWeChatApiService>(); 
        private static readonly UsersRepository _usersRep = AutofacIocManager.Instance.GetService<UsersRepository>();
        private static readonly IMapper _mapper = AutofacIocManager.Instance.GetService<IMapper>();
        private static readonly decimal _chengDuMinimumWage = 2100.00M;

        /// <summary>
        /// 计算工资
        /// </summary>
        /// <param name="pm_WageSheetDattaSources"></param>
        /// <param name="userNames"></param>
        /// <param name="thisYearMonth"></param>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public static async Task<Result> SalaryCalculatorAsync(
            List<Pm_WageSheet> pm_WageSheetDattaSources, List<UserNameView> userNames, int userId, string thisYearMonth, DateTime startDt, DateTime endDt)
        {
            if (pm_WageSheetDattaSources.Count <= 0)
            {
                _result.Msg = "计算工资传入数据为空!";
                return _result;
            }

            if (userNames.Count <= 0)
            {
                var nameData = await _usersRep.GetUserNameList(1);
                userNames = nameData.Data;
            }

            //计算时间段内工作日

            int work_days = GetWorkDays(startDt, endDt);

            //获取所有打卡数据
            CheckInView checkIn = await _qiYeWeChatApiService.GetCheckin_MonthDataAsync(startDt, endDt); //时间段内所有 打卡数据
            if (checkIn.errcode != 0)
            {
                _result.Msg = "【企业微信】【打卡】【获取所有月打卡数据】【Msg】" + checkIn.errmsg;
                return _result;
            }

            List<Data> checkInDatas = checkIn.datas;

            //获取 请假类型 Sp_Detail.template_id
            string leave_template_id = "C4NzTJCh1onCUK915rRkvy7Fh5Vqz4YbiEV9jrBY1";
            List<VacationLeaveTypeView> vacationLeaveTypes = await GetVacationLeaveTypes(leave_template_id);
            if (vacationLeaveTypes.Count <= 0)
            {
                _result.Msg = startDt + " - " + endDt + "请假 类型数据 获取失败!";
                return _result;
            }

            _result.Msg = string.Empty;

            try
            {
                foreach (var pm_wsInfo in pm_WageSheetDattaSources)
                {
                    string itemName = userNames.Where(it => it.Id == pm_wsInfo.UserId).FirstOrDefault().CnName;

                    //补贴 金额
                    decimal meal_subsidy = 0.00M;  // 午餐(午餐10元/天)  补贴 * 计算方式：单日上午请假时长(小时)大于或者等于三小时 没有餐补

                    //事假 病假 总金额
                    decimal personalLeaveTotal = 0.00M,  // 事假 日薪 *计算方式：日平均工资 = 月工资/当月应出勤天数。
                            sickLeaveTotal = 0.00M;      // 病假 日薪 *计算方式：日平均工资 = 成都市最低工资标准的80%/当月应出勤天数。 短期病假=当月15天内  

                    //扣款金额
                    decimal beLate_deduction = 0.00M,         // 迟到 扣款金额 *计算方式：
                                                              // 一个自然月内，不足 10 分钟的迟到/早退，不超过 2 次的部分，不做处罚；3 次及以上，按50元 / 次处罚；
                                                              // 超过 10 分钟（含 10 分钟），不足 60 分钟的迟到/早退，按 50 元/次处罚；
                                                              // 超过 60 分钟（含 60 分钟），不足 3 小时的迟到/早退，且无请假者，按旷工半日处理；超过3 小时的迟到 / 早退，且无请假者，按旷工一日处理。

                            early_deduction = 0.00M,          // 早退 扣款金额
                            absenteeism_deduction = 0.00M,    // 旷工 扣款金额 *计算方式：旷工扣发当日工资
                            unprinted_deduction = 0.00M,      // 未打卡 扣款金额 *计算方式：
                                                              // 试用期员工每月有 2 次 补卡机会，超过 2 次不足 5 次的部分，按 10 元 / 次处罚，5 次及以上的漏卡，按 50 元 / 次处罚；
                                                              // 正式员工每月 3 次以内的补卡，按 10 元 / 次处罚，3 次及以上的漏卡，按 50 元 / 次处罚。
                            sickLeave_deduction = 0.00M,      // 病假
                            other_deduction = 0.00M;          // 其他 扣款金额

                    decimal meal_deduction = 0.00M;           // 餐补 扣款金额
                    decimal reissuecard_deduction = 0.00M;    // 补卡 扣款金额
                                                              //打卡数据
                    Data? checkInData = checkInDatas.Where(it => it.base_info.name == itemName).FirstOrDefault();

                    if (checkInData == null) { continue; }
                    string acctid = checkInData.base_info.acctid; //用户Id

                    //当月总计数据
                    Summary_Info? summary_Info = checkInData.summary_info;
                    if (summary_Info == null) { continue; }

                    int dk_work_days = summary_Info.work_days - 1;   //应出勤天数 
                    //int regular_days = summary_Info.regular_days - 1;  //正常出勤天数

                    meal_subsidy = dk_work_days * 10; //应发放餐补


                    #region 计算日工资 正常日薪 事假日薪 病假日薪

                    //月 - 应发工资
                    decimal amountPayable = pm_wsInfo.Basic + pm_wsInfo.Floats + pm_wsInfo.PostAllowance + pm_wsInfo.InformationSecurityFee + pm_wsInfo.OtherSubsidies;

                    // 日薪 = *计算方式：日平均工资 = 月工资/当月应出勤天数。
                    decimal dailyWage = ConvertToDecimal(amountPayable / work_days);

                    // 病假日薪 *计算方式：日平均工资 = 成都市最低工资标准的80%/当月应出勤天数。 短期病假=当月15天内 
                    decimal sickLeave_dailywage = ConvertToDecimal(_chengDuMinimumWage / work_days);

                    //病假 一天扣款  
                    sickLeave_deduction = dailyWage - sickLeave_dailywage;

                    List<Ex_Items> ex_Items = new List<Ex_Items>();//假勤 And 打卡备注集合

                    #endregion

                    if (itemName != "张海麟") //不算考勤
                    {
                        int annualLeaveNum = 0,    //年假
                            personalLeaveNum = 0,  //事假
                            sickLeaveNum = 0,      //病假
                            lieuLeaveNum = 0,      //调休假
                            marriageLeaveNum = 0,  //婚嫁
                            maternityLeaveNum = 0, //产假
                            paternityLeaveNum = 0, //陪产假
                            funeralLeaveNum = 0,   //丧假
                            reissueCardNum = 0,    //补卡 次数
                            evectionNum = 0,       //出差 次数
                            outIngNum = 0,         //外出 次数
                            outWorkNum = 0,        //外勤 次数
                            otherLeaveNum = 0;     //其他


                        #region 假勤 处理  1-请假；2-补卡；3-出差；4-外出；100-外勤；

                        List<Sp_Item>? sp_items = checkInData.sp_items.Where(it => it.count != 0).ToList();
                        if (sp_items != null && sp_items.Count > 0)
                        {
                            annualLeaveNum = Fallibilitydispose(sp_items, 1, "年假");
                            personalLeaveNum = Fallibilitydispose(sp_items, 1, "事假");
                            sickLeaveNum = Fallibilitydispose(sp_items, 1, "病假");
                            lieuLeaveNum = Fallibilitydispose(sp_items, 1, "调休假");
                            marriageLeaveNum = Fallibilitydispose(sp_items, 1, "婚嫁");
                            maternityLeaveNum = Fallibilitydispose(sp_items, 1, "产假");
                            paternityLeaveNum = Fallibilitydispose(sp_items, 1, "陪产假");
                            funeralLeaveNum = Fallibilitydispose(sp_items, 1, "丧假");
                            otherLeaveNum = Fallibilitydispose(sp_items, 1, "其他");
                            reissueCardNum = Fallibilitydispose(sp_items, 2, "补卡次数");
                            evectionNum = Fallibilitydispose(sp_items, 3, "出差");
                            outIngNum = Fallibilitydispose(sp_items, 4, "外出");
                            outWorkNum = Fallibilitydispose(sp_items, 3, "外勤");
                        }

                        #region 请假类型金额/餐补 处理

                        List<Sp_Detail> sp_leave_details = new List<Sp_Detail>();
                        sp_leave_details = await _qiYeWeChatApiService.GetApprovalDetailsAsync(startDt, endDt, acctid, 2, 1); //时间段内所有 已同意的 请假 审批数据
                        if (sp_leave_details.Count <= 0)
                        {
                            _result.Msg += startDt + " - " + endDt + "  " + itemName + "  请假 审批数据获取未获取到!\r\n";
                            //continue;
                        }


                        Ex_Items ex_Items_jq = new Ex_Items() { Type = "假勤" };   //假勤
                        List<Ex_Item> ex_ItemInfos = new List<Ex_Item>();

                        foreach (Sp_Detail sp_item in sp_leave_details)
                        {
                            Apply_data? apply_data = sp_item.apply_data;
                            if (apply_data != null)
                            {
                                List<ContentsItem> contents = apply_data.contents;
                                ContentsItem content_Vacation = contents.Where(it => it.control == "Vacation").FirstOrDefault();  //请假类型 
                                ContentsItem content_Textarea = contents.Where(it => it.control == "Textarea").FirstOrDefault(); //多行文本 

                                if (content_Vacation != null)
                                {
                                    Vacation vacation = content_Vacation.value.vacation;
                                    Attendance attendance = vacation.attendance; //假勤组件
                                    Selector selector = vacation.selector;       //请假类型

                                    List<OptionsItem> optionsItems = selector.options; //key 请假类型 id
                                    List<TitleItem> value = optionsItems[0].value; // value 文本描述值

                                    int leaveType = int.Parse(optionsItems[0].key);  //key 请假子类型 id
                                    Date_range date_Range = attendance.date_range;

                                    //筛选 不在工作日内的假勤申请
                                    if (startDt >= date_Range.new_begin_dt && date_Range.new_end_dt <= endDt)
                                    {
                                        continue;
                                    }

                                    decimal thisTypeDeduction = 0.00M;//当前类型扣款
                                    string leave_starttime = date_Range.new_begin_dt.ToString("HH:mm");
                                    string leave_endtime = date_Range.new_end_dt.ToString("HH:mm");

                                    string typeName = string.Empty;
                                    string unit = string.Empty;
                                    int leaveTypeId = leaveType;
                                    var leaveTypeData = vacationLeaveTypes.Where(it => it.id == leaveTypeId).FirstOrDefault();

                                    if (leaveTypeData != null) { typeName = leaveTypeData.name; }

                                    string startTime = string.Empty;
                                    string endTime = string.Empty;
                                    //计算请假类型扣款金额
                                    decimal new_duration = 0.00M;
                                    if (date_Range.type == "halfday")
                                    {
                                        new_duration = Convert.ToDecimal(date_Range.new_duration) / 86400M;
                                        unit = "天";
                                        startTime = date_Range.new_begin_dt.ToString("yyyy-MM-dd") + " 09:00";
                                        endTime = date_Range.new_begin_dt.ToString("yyyy-MM-dd") + " 18:00";
                                    }
                                    else if (date_Range.type == "hour")
                                    {
                                        new_duration = Convert.ToDecimal(date_Range.new_duration) / 3600M;
                                        unit = "小时";
                                        startTime = date_Range.new_begin_dt.ToString("yyyy-MM-dd HH:mm:ss");
                                        endTime = date_Range.new_end_dt.ToString("yyyy-MM-dd HH:mm:ss");
                                    }
                                    decimal leave_meals = 0.00M;

                                    //计算餐补 假勤类型扣款
                                    CalculateTypeFee(leaveType, date_Range.type, startTime, endTime, amountPayable, work_days, new_duration,
                                        out leave_meals, out thisTypeDeduction);

                                    #region 累计类型扣款
                                    //1年假；2事假；3病假；4调休假；5婚假；6产假；7陪产假；8其他；9丧假

                                    if (leaveType == 2) //事假
                                    {
                                        personalLeaveTotal += thisTypeDeduction;
                                    }
                                    else if (leaveType == 3) //病假
                                    {
                                        sickLeaveTotal = thisTypeDeduction;
                                    }

                                    #endregion

                                    meal_deduction += leave_meals;


                                    Ex_Item ex_Item = new Ex_Item()
                                    {
                                        SubTypeId = leaveType,
                                        SubType = typeName,
                                        StartTimeDt = Convert.ToDateTime(startTime),
                                        EndTimeDt = Convert.ToDateTime(endTime),
                                        Duration = new_duration,
                                        Unit = unit,
                                        Deduction = thisTypeDeduction,
                                        //Reason = apply_data.reason,
                                        Apply_time_dt = Convert.ToDateTime(sp_item.apply_time_dt.ToString("yyyy-MM-dd HH:mm:ss")),
                                        //Approval_name = sp_item.approval_name,
                                    };
                                    ex_ItemInfos.Add(ex_Item);
                                }
                            }
                        }

                        if (ex_ItemInfos.Count > 0)
                        {
                            ex_Items_jq.Ex_ItemInfo = ex_ItemInfos.OrderBy(it => it.SubTypeId).ThenBy(it => it.Apply_time_dt).ToList();
                            ex_Items.Add(ex_Items_jq);
                        }

                        #endregion

                        #endregion

                        Ex_Items ex_Items_dk = new Ex_Items() { Type = "打卡" };    //打卡
                        List<Ex_Item> ex_reissuecard_Items = new List<Ex_Item>();
                        #region 打卡补卡 补卡次数 处理

                        if (reissueCardNum > 0)
                        {

                            List<Sp_Detail> sp_buka_details = new List<Sp_Detail>();
                            sp_leave_details = await _qiYeWeChatApiService.GetApprovalDetailsAsync(startDt, endDt, acctid, 2, 2); //时间段内所有 已同意的 请假 审批数据

                            int bukaNum = 1;
                            foreach (var item in sp_leave_details)
                            {
                                decimal bukaPrice = 0.00M;
                                if (bukaNum <= 2)
                                {
                                    bukaPrice = 10.00M;
                                }
                                else
                                {
                                    bukaPrice = 50.00M;
                                }
                                var app_data = item.apply_data;
                                var punch_correction1 = app_data.contents[0].value.punch_correction; //未打卡时间
                                var punch_correction2 = app_data.contents[1].value;

                                Ex_Item ex_reissueCard = new Ex_Item()
                                {
                                    SubTypeId = 7,
                                    SubType = "打卡补卡",
                                    StartTimeDt = Convert.ToDateTime(punch_correction1.time_dt.ToString("yyyy-MM-dd HH:mm:ss")),  //未打卡时间
                                    Deduction = bukaPrice,
                                    Reason = punch_correction2.text,
                                    Unit = string.Empty
                                };
                                unprinted_deduction += bukaPrice;
                                ex_reissuecard_Items.Add(ex_reissueCard);
                                bukaNum++;
                            }
                        }

                        #endregion

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

                        #region 迟到早退处理

                        //统计迟到次数
                        int beLateNum = 0,           // 1-迟到；
                            leaveEarlyNum = 0,       // 2-早退；
                            dummyDeckNum = 0,        // 3-缺卡；
                            minerNum = 0,            // 4-旷工；
                            locationAnomalyNum = 0,  // 5-地点异常；
                            unitExNum = 0;           // 6-设备异常；

                        if (summary_Info.except_days > 0)
                        {
                            List<Exception_Info>? ex_infos = checkInData.exception_infos;
                            if (ex_infos != null && ex_infos.Count >= 0)
                            {
                                beLateNum = ExceptionStatistics(ex_infos, 1);
                                leaveEarlyNum = ExceptionStatistics(ex_infos, 2);
                                dummyDeckNum = ExceptionStatistics(ex_infos, 3);
                                minerNum = ExceptionStatistics(ex_infos, 4);
                                locationAnomalyNum = ExceptionStatistics(ex_infos, 5);
                                unitExNum = ExceptionStatistics(ex_infos, 6);
                            }
                        }

                        //打卡记录
                        CheckInDataView checkInDataView = new CheckInDataView();
                        checkInDataView = await _qiYeWeChatApiService.GetCheckinDataAsync(new List<string>() { acctid }, 3, startDt, endDt);

                        if (checkInDataView.errcode != 0)
                        {
                            _result.Msg += startDt + " - " + endDt + "  " + itemName + " 打卡记录 " + checkInDataView.errmsg + " \r\n";
                        }

                        //筛选时间异常的打卡记录
                        List<CheckInDataInfo> checkInDataInfos = checkInDataView.checkindata.Where(it => !string.IsNullOrEmpty(it.exception_type)).ToList();

                        //处理 未打卡的记录是否已经通过假勤审批
                        List<CheckInDataInfo> leave_checkInDataInfos = new List<CheckInDataInfo>();
                        if (checkInDataInfos.Count > 0)
                        {
                            foreach (var leaveItem in ex_ItemInfos)
                            {
                                if (leaveItem.StartTimeDt.ToString("yyyy-MM-dd").Equals(leaveItem.EndTimeDt.ToString("yyyy-MM-dd"))) //单天
                                {
                                    leave_checkInDataInfos.AddRange(checkInDataInfos.Where(it => it.checkin_time_dt.ToString("yyyy-MM-dd") == leaveItem.StartTimeDt.ToString("yyyy-MM-dd")).ToList());
                                }
                                else //多天
                                {
                                    leave_checkInDataInfos.AddRange(checkInDataInfos.Where(it => it.checkin_time_dt >= leaveItem.StartTimeDt && it.checkin_time_dt <= leaveItem.EndTimeDt).ToList());

                                }
                            }
                        }

                        //处理 时间异常的记录是否已经通过补卡审批
                        List<CheckInDataInfo> pullcard_checkInDataInfos = new List<CheckInDataInfo>();
                        if (leave_checkInDataInfos.Count > 0)
                        {
                            //获取异常打卡数据 并且 未通过假勤审批
                            pullcard_checkInDataInfos = checkInDataInfos.Except(leave_checkInDataInfos).ToList();

                            if (pullcard_checkInDataInfos.Count > 0)
                            {
                                CheckInDayDataView checkInDayDataView = await _qiYeWeChatApiService.GetCheckInDayDataAsync(new List<string>() { acctid }, startDt, endDt);

                                if (checkInDayDataView.errcode != 0)
                                {
                                    _result.Msg += startDt + " - " + endDt + "  " + itemName + "  异常信息数据获取未获取到!\r\n";

                                }
                                List<Root> roots_words = checkInDayDataView.datas.Where(it => it.base_info.day_type == 0).ToList(); //获取工作日日报信息
                                List<Root> roots_exs = checkInDayDataView.datas.Where(it => it.exception_infos.Count > 0).ToList();

                                int user_cd_zt_num = 0;
                                foreach (var roots_ex in roots_exs)
                                {
                                    foreach (var exception_info in roots_ex.exception_infos)
                                    {
                                        decimal timelength = ConvertToDecimal((Convert.ToDecimal(exception_info.duration) / 3600.00M) * 60.00M);  //时长 分钟

                                        if (timelength == 9) timelength = 7.50M;

                                        int exception = exception_info.exception; //异常类型
                                        decimal day_miner_unit = ConvertToDecimal(dailyWage / 15);  //以0.5小时为单位 

                                        //1：一个自然月内，不足 10 分钟的迟到/早退，不超过 2 次的部分，不做处罚；3 次及以上，按50 元 / 次处罚；
                                        //2：超过 10 分钟（含 10 分钟），不足 60 分钟的迟到 / 早退，按 50 元 / 次处罚；
                                        //3：超过 60 分钟（含 60 分钟），不足 3 小时的迟到 / 早退，且无请假者，按旷工半日处理；超过 3 小时的迟到 / 早退，且无请假者，按旷工一日处理。

                                        long date = roots_ex.base_info.date; //当日工作日期
                                        long earliest_time = roots_ex.summary_info.earliest_time; //最早打卡时间
                                        long lastest_time = roots_ex.summary_info.lastest_time; //最晚打卡时间
                                        long this_date = date + earliest_time;
                                        DateTime thisDt = TimeZone.CurrentTimeZone.ToLocalTime(new DateTime(1970, 1, 1)).AddTicks(this_date * 10000000);

                                        string thisDtStr = thisDt.ToString("yyyy-MM-dd");

                                        Ex_Item beLate_belate_ex = new Ex_Item()
                                        {
                                            SubTypeId = 4,
                                            SubType = "旷工",
                                            Duration = timelength,
                                            StartTimeDt = Convert.ToDateTime(roots_ex.base_info.dateDt.ToString("yyyy-MM-dd HH:mm:ss")),
                                            Unit = "分钟",
                                        };


                                        decimal day_deduction = 0.00M;
                                        //1 - 迟到；2 - 早退；3 - 缺卡；4 - 旷工；5 - 地点异常；6 - 设备异常
                                        if (exception == 1)   //迟到
                                        {
                                            if (timelength < 10)
                                            {
                                                user_cd_zt_num++;
                                                beLate_belate_ex.SubTypeId = 1;
                                                beLate_belate_ex.SubType = "迟到";

                                                if (reissueCardNum >= 3)
                                                {
                                                    day_deduction = 50.00M;
                                                }
                                                else
                                                {
                                                    day_deduction = 0.00M;
                                                }
                                                beLate_deduction += day_deduction; //迟到扣款 总额
                                            }
                                            else if (timelength >= 10 && timelength <= 60)
                                            {
                                                day_deduction = 50.00M;
                                                beLate_deduction += day_deduction; //迟到扣款 总额
                                                beLate_belate_ex.SubTypeId = 1;
                                                beLate_belate_ex.SubType = "迟到";
                                            }
                                            else if (timelength > 60 && timelength <= 180)
                                            {
                                                day_deduction = day_miner_unit * 6; //3小时
                                                meal_deduction += 10.00M;  //餐补扣款
                                                absenteeism_deduction += day_deduction; //矿工半日
                                            }
                                            else
                                            {
                                                day_deduction = dailyWage;
                                                absenteeism_deduction += day_deduction; //矿工一日
                                                meal_deduction += 10.00M;
                                            }

                                            beLate_belate_ex.Deduction = day_deduction;
                                            ex_reissuecard_Items.Add(beLate_belate_ex);
                                        }
                                        else if (exception == 2)  //早退
                                        {
                                            if (timelength < 10)
                                            {
                                                user_cd_zt_num++;
                                                beLate_belate_ex.SubTypeId = 2;
                                                beLate_belate_ex.SubType = "早退";

                                                if (reissueCardNum >= 3)
                                                {
                                                    day_deduction = 50.00M;
                                                }
                                                else
                                                {
                                                    day_deduction = 0.00M;
                                                }
                                                early_deduction += day_deduction;  //早退扣款 总计
                                            }
                                            else if (timelength >= 10 && timelength <= 60)
                                            {
                                                day_deduction = 50.00M;
                                                early_deduction += day_deduction;  //早退扣款 总计
                                                beLate_belate_ex.SubTypeId = 2;
                                                beLate_belate_ex.SubType = "早退";
                                            }
                                            else if (timelength > 60 && timelength <= 180)
                                            {
                                                day_deduction = day_miner_unit * 6; //3小时
                                                absenteeism_deduction += day_deduction; //矿工半日

                                            }
                                            else
                                            {
                                                day_deduction = dailyWage;
                                                meal_deduction += 10.00M;
                                                absenteeism_deduction += day_deduction; //矿工一日
                                            }

                                            beLate_belate_ex.Deduction = day_deduction;
                                            ex_reissuecard_Items.Add(beLate_belate_ex);
                                        }
                                        else if (exception == 3) //缺卡
                                        {

                                            if (roots_ex.exception_infos.Count == 2)
                                            {
                                                day_deduction = dailyWage;
                                                meal_deduction += 10.00M;
                                                absenteeism_deduction += day_deduction;
                                                beLate_belate_ex.Reason = "上午-下午 缺卡/未打卡为旷工 一天";
                                                beLate_belate_ex.Deduction = day_deduction;
                                                ex_reissuecard_Items.Add(beLate_belate_ex);

                                            }
                                            else if (roots_ex.exception_infos.Count == 1)
                                            {

                                                if (earliest_time == lastest_time)
                                                {
                                                    DateTime thisDt1 = Convert.ToDateTime(thisDtStr + " 12:00");

                                                    //ex_ItemInfos

                                                    Ex_Item zt_jq = new Ex_Item();
                                                    zt_jq = ex_ItemInfos.Where(it => it.StartTimeDt.ToString("yyyy-MM-dd") == thisDtStr).FirstOrDefault();

                                                    if (thisDt <= thisDt1)  //旷工 下午
                                                    {
                                                        if (zt_jq != null) if (zt_jq.EndTimeDt == Convert.ToDateTime(thisDtStr + " 18:00")) continue; //排除已有假期的缺卡

                                                        day_deduction = day_miner_unit * 9; //4.5小时
                                                        meal_deduction += 10.00M;
                                                        absenteeism_deduction += day_deduction; //矿工半日
                                                        beLate_belate_ex.Reason = thisDtStr + " 下午(18:00)缺卡/未打卡视为下午旷工(4.5小时)";

                                                        beLate_belate_ex.Deduction = day_deduction;
                                                        ex_reissuecard_Items.Add(beLate_belate_ex);
                                                    }
                                                    else if (thisDt >= thisDt1) //旷工下午
                                                    {
                                                        if (zt_jq != null) if (zt_jq.EndTimeDt == Convert.ToDateTime(thisDtStr + " 09:00")) continue; //排除已有假期的缺卡
                                                        day_deduction = day_miner_unit * 6; //3小时
                                                        absenteeism_deduction += day_deduction; //矿工半日
                                                        beLate_belate_ex.Reason = thisDtStr + " 上午(09:00)缺卡/未打卡视为上午旷工(3小时)";

                                                        beLate_belate_ex.Deduction = day_deduction;
                                                        ex_reissuecard_Items.Add(beLate_belate_ex);
                                                    }
                                                    else //矿工一日
                                                    {

                                                        day_deduction = dailyWage;
                                                        meal_deduction += 10.00M;
                                                        absenteeism_deduction += day_deduction;
                                                        beLate_belate_ex.Reason = thisDtStr + " 上午(09:00)-下午(18:00) 缺卡/未打视为旷工一天(7.5小时)";

                                                        beLate_belate_ex.Deduction = day_deduction;
                                                        ex_reissuecard_Items.Add(beLate_belate_ex);
                                                    }


                                                }
                                            }
                                        }
                                        else if (exception == 4) //旷工
                                        {
                                            if (timelength > 60 && timelength <= 180)
                                            {
                                                day_deduction = day_miner_unit * 6; //3小时
                                                beLate_belate_ex.Reason = thisDtStr + " 缺卡/未打视为旷工上午(3小时)";
                                                meal_deduction += 10.00M;
                                                absenteeism_deduction += day_deduction; //矿工半日

                                            }
                                            else
                                            {
                                                day_deduction = dailyWage;
                                                beLate_belate_ex.Reason = thisDtStr + " 上午(09:00)-下午(18:00) 缺卡/未打视为旷工一天(7.5小时)";
                                                meal_deduction += 10.00M;
                                                absenteeism_deduction += day_deduction; //矿工一日
                                            }

                                            beLate_belate_ex.Deduction = day_deduction;
                                            ex_reissuecard_Items.Add(beLate_belate_ex);
                                        }

                                    }
                                }
                            }
                        }

                        if (ex_reissuecard_Items.Count > 0)
                        {
                            ex_Items_dk.Ex_ItemInfo = ex_reissuecard_Items;
                            ex_Items_dk.Ex_ItemInfo = ex_reissuecard_Items.OrderBy(it => it.SubTypeId).ThenBy(it => it.StartTimeDt).ToList();
                            ex_Items.Add(ex_Items_dk);
                        }

                        #endregion
                    }
                    else
                    {
                        meal_subsidy = work_days * 10.00M;
                    }
                    
                    
                    #region 应发合计 实发合计 扣款合计(假勤扣款,其他扣款,社保扣款,公积金代扣,个税扣款)

                    decimal mealTotal = meal_subsidy - meal_deduction;  //餐补
                    decimal salaryTotal = 0.00M;
                    if (dk_work_days >= work_days)
                    {
                        dk_work_days = work_days;
                        salaryTotal = amountPayable + mealTotal;    //应发合计
                    }
                    else
                    {
                        salaryTotal = (dk_work_days * dailyWage) + mealTotal;    //应发合计
                    }
                     

                    //扣款合计 不含个税
                    decimal eductionTotal = sickLeaveTotal + personalLeaveTotal + beLate_deduction + early_deduction + absenteeism_deduction + unprinted_deduction + other_deduction +
                        pm_wsInfo.WithholdingInsurance + pm_wsInfo.ReservedFunds + pm_wsInfo.OtherDeductions;
                    decimal actualReleaseTotal = salaryTotal - eductionTotal; //实发合计 * 不含个税

                    #endregion

                    #region 处理当月工资数据
                    pm_wsInfo.YearMonth = thisYearMonth;
                    pm_wsInfo.StartDate = startDt.ToString("yyyy-MM-dd");
                    pm_wsInfo.EndDate = endDt.AddDays(-1).ToString("yyyy-MM-dd");
                    pm_wsInfo.WorkDays = work_days;        //当月应出勤天数
                    pm_wsInfo.RegularDays = dk_work_days;  //当月正常出勤天数

                    pm_wsInfo.SickLeave = sickLeaveTotal;           //病假
                    pm_wsInfo.SomethingFalse = personalLeaveTotal;  //事假
                    pm_wsInfo.LateTo = beLate_deduction;            //迟到
                    pm_wsInfo.LeaveEarly = early_deduction;         //早退
                    pm_wsInfo.Absenteeism = absenteeism_deduction;  //旷工
                    pm_wsInfo.NotPunch = unprinted_deduction;       //未打卡
                    pm_wsInfo.OtherDeductions = other_deduction;    //其他
                    pm_wsInfo.Ex_ItemsRemark = JsonConvert.SerializeObject(ex_Items);  //
                    pm_wsInfo.Mealsupplement = mealTotal;          //餐补

                    pm_wsInfo.Should = salaryTotal;               //应发合计
                    pm_wsInfo.TotalDeductions = eductionTotal;    //扣款合计
                    pm_wsInfo.TotalRealHair = actualReleaseTotal; //实发合计
                    pm_wsInfo.AfterTax = actualReleaseTotal - pm_wsInfo.WithholdingTax; //税后工资

                    pm_wsInfo.LastUpdateUserId = userId;
                    pm_wsInfo.LastUpdateDt = DateTime.Now;
                    pm_wsInfo.CreateUserId = userId;
                    pm_wsInfo.CreateTime = DateTime.Now;
                    pm_wsInfo.DeleteUserId = null;
                    pm_wsInfo.DeleteTime = null;
                    #endregion

                }

            }
            catch (Exception ex)
            {

                _result.Msg = ex.Message;

                return _result;
            }

            _result.Code = 0;
            _result.Data = pm_WageSheetDattaSources;

            return _result;
        }

        /// <summary>
        /// 计算工资
        /// </summary>
        /// <param name="pm_WageSheetDattaSources"></param>
        /// <param name="userNames"></param>
        /// <param name="thisYearMonth"></param>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public static async Task<Result> SalaryCalculatorAsync1(
            List<Pm_WageSheet> pm_WageSheetDattaSources, List<UserNameView> userNames, int userId, string thisYearMonth, DateTime startDt, DateTime endDt)
        {
            if (pm_WageSheetDattaSources.Count <= 0)
            {
                _result.Msg = "计算工资传入数据为空!";
                return _result;
            }

            if (userNames.Count <= 0)
            {
                var nameData = await _usersRep.GetUserNameList(1);
                userNames = nameData.Data;
            }

            //计算时间段内工作日
            int work_days = GetWorkDays(startDt, endDt);

            UserIdListView userIdListView = await _qiYeWeChatApiService.GetUserIdListAsync();
            if (userIdListView.errcode != 0)
            {
                _result.Msg = "【企业微信】【打卡】【获取员工ID】【Msg】" + userIdListView.errmsg;
                return _result;
            }

            List<string> qyWhchatIdList = userIdListView.dept_user.Select(it => it.userid).ToList();
            CheckInDayDataView checkInDayDataView = await _qiYeWeChatApiService.GetCheckInDayDataAsync(qyWhchatIdList, startDt, endDt);
            if (checkInDayDataView.errcode != 0)
            {
                _result.Msg = "【企业微信】【打卡】【获取时间段内所有日打卡】【Msg】" + checkInDayDataView.errmsg;
                return _result;
            }
            //筛选出工作日日报
            List<Root> workday_userRoots = checkInDayDataView.datas.Where(it => it.base_info.day_type == 0).ToList(); //工作日日报

            //获取 请假类型 Sp_Detail.template_id
            string leave_template_id = "C4NzTJCh1onCUK915rRkvy7Fh5Vqz4YbiEV9jrBY1";
            List<VacationLeaveTypeView> vacationLeaveTypes = await GetVacationLeaveTypes(leave_template_id);
            if (vacationLeaveTypes.Count <= 0)
            {
                _result.Msg = "【企业微信】【审批】【获取审批类型】【Msg】" + startDt + " - " + endDt + "请假 类型数据 获取失败!";
                return _result;
            }

            try
            {
                foreach (var pm_wsInfo in pm_WageSheetDattaSources)
                {
                    string itemName = userNames.Where(it => it.Id == pm_wsInfo.UserId).FirstOrDefault().CnName;

                    //补贴 金额
                    decimal meal_subsidy = 0.00M;  // 午餐(午餐10元/天)  补贴 * 计算方式：单日上午请假时长(小时)大于或者等于三小时 没有餐补

                    //事假 病假 总金额
                    decimal personalLeaveTotal = 0.00M,  // 事假 日薪 *计算方式：日平均工资 = 月工资/当月应出勤天数。
                            sickLeaveTotal = 0.00M;      // 病假 日薪 *计算方式：日平均工资 = 成都市最低工资标准的80%/当月应出勤天数。 短期病假=当月15天内  

                    //扣款金额
                    decimal beLate_deduction = 0.00M,         // 迟到 扣款金额 *计算方式：
                                                              // 一个自然月内，不足 10 分钟的迟到/早退，不超过 2 次的部分，不做处罚；3 次及以上，按50元 / 次处罚；
                                                              // 超过 10 分钟（含 10 分钟），不足 60 分钟的迟到/早退，按 50 元/次处罚；
                                                              // 超过 60 分钟（含 60 分钟），不足 3 小时的迟到/早退，且无请假者，按旷工半日处理；超过3 小时的迟到 / 早退，且无请假者，按旷工一日处理。
                            early_deduction = 0.00M,          // 早退 扣款金额
                            absenteeism_deduction = 0.00M,    // 旷工 扣款金额 *计算方式：旷工扣发当日工资
                            unprinted_deduction = 0.00M,      // 未打卡 扣款金额 *计算方式：
                                                              // 试用期员工每月有 2 次 补卡机会，超过 2 次不足 5 次的部分，按 10 元 / 次处罚，5 次及以上的漏卡，按 50 元 / 次处罚；
                                                              // 正式员工每月 3 次以内的补卡，按 10 元 / 次处罚，3 次及以上的漏卡，按 50 元 / 次处罚。
                            sickLeave_deduction = 0.00M,      // 病假
                            other_deduction = 0.00M;          // 其他 扣款金额

                    decimal meal_deduction = 0.00M;           // 餐补 扣款金额
                    decimal reissuecard_deduction = 0.00M;    // 补卡 扣款金额

                    #region 计算日工资 正常日薪 事假日薪 病假日薪

                    //月 - 应发工资
                    decimal amountPayable = pm_wsInfo.Basic + pm_wsInfo.Floats + pm_wsInfo.PostAllowance + pm_wsInfo.InformationSecurityFee + pm_wsInfo.OtherSubsidies;

                    // 日薪 = *计算方式：日平均工资 = 月工资/当月应出勤天数。
                    decimal dailyWage = ConvertToDecimal(amountPayable / work_days);

                    // 病假日薪 *计算方式：日平均工资 = 成都市最低工资标准的80%/当月应出勤天数。 短期病假=当月15天内 
                    decimal sickLeave_dailywage = ConvertToDecimal(_chengDuMinimumWage / work_days);

                    //病假 一天扣款  
                    sickLeave_deduction = dailyWage - sickLeave_dailywage;

                    List<Ex_Items> ex_Items = new List<Ex_Items>();//假勤 And 打卡备注集合

                    #endregion

                    List<Root> userRoots = workday_userRoots.Where(it => it.base_info.name == itemName && it.base_info.day_type == 0).ToList(); //工作日日报

                    int dk_work_days = userRoots.Count;   //应出勤天数 

                    meal_subsidy = dk_work_days * 10; //应发放餐补


                    if (!itemName.Equals("张海麟"))
                    {
                        foreach (var root in userRoots)
                        {
                            List<Holiday_infos> holiday_Infos = root.holiday_infos; //当天假勤信息
                            List<Exception_infos> exception_infos = root.exception_infos; //当天校准状态信息
                            List<Sp_items> sp_Items = root.sp_items;//当天假勤统计信息
                            #region 假勤处理
                            if (sp_Items.Count > 0)
                            {

                            }


                            #endregion

                            #region 打卡补卡

                            #endregion

                            #region 迟到 早退 矿工


                            #endregion
                        }

                    }
                    else
                    {
                        meal_subsidy = work_days * 10.00M;
                    }

                    #region 应发合计 实发合计 扣款合计(假勤扣款,其他扣款,社保扣款,公积金代扣,个税扣款)

                    decimal mealTotal = meal_subsidy - meal_deduction;  //餐补
                    decimal salaryTotal = 0.00M;
                    if (dk_work_days >= work_days)
                    {
                        dk_work_days = work_days;
                        salaryTotal = amountPayable + mealTotal;    //应发合计
                    }
                    else
                    {
                        salaryTotal = (dk_work_days * dailyWage) + mealTotal;    //应发合计
                    }


                    //扣款合计 不含个税
                    decimal eductionTotal = sickLeaveTotal + personalLeaveTotal + beLate_deduction + early_deduction + absenteeism_deduction + unprinted_deduction + other_deduction +
                        pm_wsInfo.WithholdingInsurance + pm_wsInfo.ReservedFunds + pm_wsInfo.OtherDeductions;
                    decimal actualReleaseTotal = salaryTotal - eductionTotal; //实发合计 * 不含个税

                    #endregion

                    #region 处理当月工资数据
                    pm_wsInfo.YearMonth = thisYearMonth;
                    pm_wsInfo.StartDate = startDt.ToString("yyyy-MM-dd");
                    pm_wsInfo.EndDate = endDt.AddDays(-1).ToString("yyyy-MM-dd");
                    pm_wsInfo.WorkDays = work_days;        //当月应出勤天数
                    pm_wsInfo.RegularDays = dk_work_days;  //当月正常出勤天数

                    pm_wsInfo.SickLeave = sickLeaveTotal;           //病假
                    pm_wsInfo.SomethingFalse = personalLeaveTotal;  //事假
                    pm_wsInfo.LateTo = beLate_deduction;            //迟到
                    pm_wsInfo.LeaveEarly = early_deduction;         //早退
                    pm_wsInfo.Absenteeism = absenteeism_deduction;  //旷工
                    pm_wsInfo.NotPunch = unprinted_deduction;       //未打卡
                    pm_wsInfo.OtherDeductions = other_deduction;    //其他
                    pm_wsInfo.Ex_ItemsRemark = JsonConvert.SerializeObject(ex_Items);  //
                    pm_wsInfo.Mealsupplement = mealTotal;          //餐补

                    pm_wsInfo.Should = salaryTotal;               //应发合计
                    pm_wsInfo.TotalDeductions = eductionTotal;    //扣款合计
                    pm_wsInfo.TotalRealHair = actualReleaseTotal; //实发合计
                    pm_wsInfo.AfterTax = actualReleaseTotal - pm_wsInfo.WithholdingTax; //税后工资

                    pm_wsInfo.LastUpdateUserId = userId;
                    pm_wsInfo.LastUpdateDt = DateTime.Now;
                    pm_wsInfo.CreateUserId = userId;
                    pm_wsInfo.CreateTime = DateTime.Now;
                    pm_wsInfo.DeleteUserId = null;
                    pm_wsInfo.DeleteTime = null;
                    #endregion

                }

            }
            catch (Exception ex)
            {

                _result.Msg = ex.Message;

                return _result;
            }

            _result.Code = 0;
            _result.Data = pm_WageSheetDattaSources;

            return _result;
        }

        /// <summary>
        /// decimal 保留两位小数 不四舍五入
        /// </summary>
        /// <param name="number"></param>
        /// <returns></returns>
        public static decimal ConvertToDecimal(decimal number)
        {
            return Convert.ToDecimal(number.ToString("0.00"));
        }

        /// <summary>
        /// 获取请假类型
        /// </summary>
        /// <param name="template_id"></param>
        /// <returns></returns>
        public static async Task<List<VacationLeaveTypeView>> GetVacationLeaveTypes(string template_id)
        {
            List<VacationLeaveTypeView> vacationLeaveTypes = new List<VacationLeaveTypeView>();

            TemplateDetailView templateDetailView = new TemplateDetailView();
            templateDetailView = await _qiYeWeChatApiService.GetTemplateDetailAsync(template_id);
            if (templateDetailView.errcode != 0) 
            {
                Serilog.Log.Error("【企业微信】【审批】【获取假勤类型的审批】【Msg】"+ templateDetailView.errmsg);
                return vacationLeaveTypes;
            }
            List<VacationItemInfo> VacationItemInfos = templateDetailView.vacation_list.item;

            foreach (var item in VacationItemInfos)
            {
                ValueItem valueInfo = item.name.Where(it => it.lang == "zh_CN").FirstOrDefault();
                if (valueInfo != null)
                {
                    vacationLeaveTypes.Add(
                    new VacationLeaveTypeView()
                    {
                        id = item.id,
                        name = valueInfo.text
                    });
                }
            }

            return vacationLeaveTypes;
        }

        /// <summary>
        /// 计算类型费用
        /// </summary>
        /// <param name="leaveType">
        /// 1年假；2事假；3病假；4调休假；5婚假；6产假；7陪产假；8其他；9丧假
        /// </param>
        /// <param name="date_Range_type">
        /// halfday 全天
        /// hour  小时
        /// </param>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="duration"></param>
        /// <param name="mealDeduction"></param>
        /// <param name="typeDeduction"></param>
        public static void CalculateTypeFee(int leaveType, string date_Range_type, string startTime, string endTime,decimal amountPayable,int work_days,
            decimal duration, out decimal mealDeduction, out decimal typeDeduction)
        {
            typeDeduction = 0;
            mealDeduction = 0;

            string am_starttime = "08:59";
            string am_endtime = "13:01";

            

            decimal personalkLeave_dailywage_day = ConvertToDecimal( amountPayable / work_days); //日薪 = 事假日薪 *计算方式：日平均工资 = 当月应发工资 /当月应出勤天数。

            //半小时单位
            decimal halfHour = Convert.ToDecimal(7.5) / Convert.ToDecimal(0.5);

            switch (leaveType)
            {
                case 1: //年假
                    CalculateTypeFeeSub(date_Range_type, startTime, endTime, duration, out mealDeduction);
                    break;
                case 2: //2事假
                    // 事假日薪 *计算方式：日平均工资 = 当月应发工资 /当月应出勤天数。 
                    decimal personalkLeave_dailywage_halfhour = ConvertToDecimal( personalkLeave_dailywage_day / halfHour); //事假单位 0.5小时

                    if (date_Range_type == "halfday")
                    {
                        mealDeduction = 10; //餐补扣款 
                        typeDeduction = personalkLeave_dailywage_day;
                    }
                    else if (date_Range_type == "hour")
                    {
                        decimal leave_halfHour = Convert.ToDecimal(duration) / Convert.ToDecimal(0.5);
                        typeDeduction = personalkLeave_dailywage_halfhour * leave_halfHour;
                        if (duration >= 3 && duration <= 7.5M) //单天请假三小时 && 请假时间在上午 则没有餐补
                        {
                            //处理开始时间
                            if (startTime.CompareTo(am_starttime) > 0 && startTime.CompareTo(am_endtime) < 0)
                            {
                                //处理结束时间
                                //if (endTime.CompareTo(am_starttime) > 0 && endTime.CompareTo(am_endtime) > 0)
                                //{
                                    mealDeduction = 10; //餐补扣款
                                //}
                            }
                        }
                        else if (duration > 7.5M) //多天计算
                        {
                            decimal leave_halfHour1 = Convert.ToDecimal(duration) / Convert.ToDecimal(0.5);
                            typeDeduction = personalkLeave_dailywage_halfhour * leave_halfHour1;

                            decimal leaveDays = duration / 7.5M;
                            if (leaveDays % 1 == 0)
                            {
                                mealDeduction = 10 * leaveDays; //餐补扣款
                            }
                            else
                            {
                                mealDeduction = 10 * Convert.ToInt32(leaveDays);

                                //得到最后一天的请假时间 是否有餐补
                                int lastHours = (Convert.ToDateTime(endTime) - Convert.ToDateTime("09:00")).Hours;
                                if (lastHours >= 3)
                                {
                                    //处理结束时间
                                    if (endTime.CompareTo(am_starttime) > 0 && endTime.CompareTo(am_endtime) < 0)
                                    {
                                        mealDeduction += 10; //餐补扣款
                                    }
                                }
                            }
                        }
                    }

                    break;
                case 3: //3病假
                    // 病假日薪 *计算方式：日平均工资 = 成都市最低工资标准的80% /当月应出勤天数。 短期病假=当月15天内 

                    decimal chengDuMinimumWage_halrHour = ConvertToDecimal( _chengDuMinimumWage / work_days) / halfHour;
                    decimal sickLeave_dailywage_halfhour_deduction = personalkLeave_dailywage_day - chengDuMinimumWage_halrHour; //病假单位 0.5小时 扣款金额

                    if (date_Range_type == "halfday")
                    {
                        mealDeduction = 10; //餐补扣款 
                        typeDeduction = sickLeave_dailywage_halfhour_deduction * halfHour;
                    }
                    else if (date_Range_type == "hour")
                    {
                        decimal sickLeave_halfHour = duration / 0.5M;
                        typeDeduction = sickLeave_dailywage_halfhour_deduction *sickLeave_halfHour ;
                        if (duration >= 3 && duration <= 7.5M) //单天请假三小时 && 请假时间在上午 则没有餐补
                        {
                            //处理开始时间
                            if (startTime.CompareTo(am_starttime) > 0 && startTime.CompareTo(am_endtime) < 0)
                            {
                                //处理结束时间
                                if (endTime.CompareTo(am_starttime) > 0 && endTime.CompareTo(am_endtime) < 0)
                                {
                                    mealDeduction = 10; //餐补扣款
                                }
                            }
                        }
                        else if (duration > 7.5M) //多天计算
                        {
                            decimal sickLeave_halfHour1 = duration / 0.5M;
                            typeDeduction = sickLeave_dailywage_halfhour_deduction * sickLeave_halfHour1;

                            decimal leaveDays = Convert.ToDecimal(duration / 7.5M);
                            if (leaveDays % 1 == 0)
                            {
                                mealDeduction = 10 * leaveDays; //餐补扣款
                            }
                            else
                            {
                                mealDeduction = 10 * Convert.ToInt32(leaveDays);

                                //得到最后一天的请假时间 是否有餐补
                                int lastHours = (Convert.ToDateTime(endTime) - Convert.ToDateTime("09:00")).Hours;
                                if (lastHours >= 3)
                                {
                                    //处理结束时间
                                    if (endTime.CompareTo(am_starttime) > 0 && endTime.CompareTo(am_endtime) < 0)
                                    {
                                        mealDeduction += 10; //餐补扣款
                                    }
                                }
                            }
                        }
                    }
                    break;
                case 4: //4调休假
                    CalculateTypeFeeSub(date_Range_type, startTime, endTime, duration, out mealDeduction);
                    break;
                case 5: //5婚假
                    CalculateTypeFeeSub(date_Range_type, startTime, endTime, duration, out mealDeduction);
                    break;
                case 6: //6产假
                    CalculateTypeFeeSub(date_Range_type, startTime, endTime, duration, out mealDeduction);
                    break;
                case 7: //7陪产假
                    CalculateTypeFeeSub(date_Range_type, startTime, endTime, duration, out mealDeduction);
                    break;
                case 8: //8其他
                    CalculateTypeFeeSub(date_Range_type, startTime, endTime, duration, out mealDeduction);
                    break;
                case 9: //9丧假
                    CalculateTypeFeeSub(date_Range_type, startTime, endTime, duration, out mealDeduction);
                    break;

            }
        }

        /// <summary>
        /// 计算类型费用
        /// </summary>
        /// <param name="date_Range_type">
        /// halfday 全天
        /// hour  小时
        /// </param>
        /// <param name="startTime"></param>
        /// <param name="endTime"></param>
        /// <param name="duration"></param>
        /// <param name="mealDeduction"></param>
        public static void CalculateTypeFeeSub(string date_Range_type, string startTime, string endTime, decimal duration, out decimal mealDeduction)
        {
            mealDeduction = 0;
            string am_starttime = "08:59";
            string am_endtime = "13:01";

            if (date_Range_type == "halfday")
            {
                mealDeduction = 10; //餐补扣款 
            }
            else if (date_Range_type == "hour")
            {
                if (duration >= 3 && duration < 7) //单天请假三小时 && 请假时间在上午 则没有餐补
                {
                    //处理开始时间
                    if (startTime.CompareTo(am_starttime) > 0 && startTime.CompareTo(am_endtime) < 0)
                    {
                        //处理结束时间
                        if (endTime.CompareTo(am_starttime) > 0 && endTime.CompareTo(am_endtime) < 0)
                        {
                            mealDeduction = 10; //餐补扣款
                        }
                    }
                }
                else if (duration >= 7 && duration <= 7.50M )
                {
                    mealDeduction = 10; //餐补扣款
                }
                else if (duration >= 7.50M) //多天计算
                {
                    decimal leaveDays = Convert.ToDecimal(duration / 7.50M);

                    if (leaveDays % 1 == 0)
                    {
                        mealDeduction = 10 * leaveDays; //餐补扣款
                    }
                    else
                    {
                        mealDeduction = 10 * Convert.ToInt32(leaveDays);

                        //得到最后一天的请假时间 是否有餐补
                        int lastHours = (Convert.ToDateTime(endTime) - Convert.ToDateTime("09:00")).Hours;
                        if (lastHours >= 3)
                        {
                            //处理结束时间
                            if (endTime.CompareTo(am_starttime) > 0 && endTime.CompareTo(am_endtime) < 0)
                            {
                                mealDeduction += 10; //餐补扣款
                            }
                        }
                    }
                }
            }
        }

        /// <summary>
        /// 获取打卡补卡类型
        /// </summary>
        /// <param name="template_id"></param>
        /// <returns></returns>
        public static async Task<List<VacationLeaveTypeView>> GetVacationReissueCardTypes(string template_id)
        {
            List<VacationLeaveTypeView> vacationLeaveTypes = new List<VacationLeaveTypeView>();

            TemplateDetailView templateDetailView = new TemplateDetailView();
            templateDetailView = await _qiYeWeChatApiService.GetTemplateDetailAsync(template_id);
            if (templateDetailView.errcode != 0)
            {
                return vacationLeaveTypes;
            }
            List<VacationItemInfo> VacationItemInfos = templateDetailView.vacation_list.item;

            foreach (var item in VacationItemInfos)
            {
                ValueItem valueInfo = item.name.Where(it => it.lang == "zh_CN").FirstOrDefault();
                if (valueInfo != null)
                {
                    vacationLeaveTypes.Add(
                    new VacationLeaveTypeView()
                    {
                        id = item.id,
                        name = valueInfo.text
                    });
                }
            }

            return vacationLeaveTypes;
        }

        /// <summary>
        /// 打卡数据
        /// 假勤数据 统计
        /// </summary>
        /// <param name="datas">数据源</param>
        /// <param name="type">
        /// 1-请假；2-补卡；3-出差；4-外出；100-外勤；
        /// </param>
        /// <param name="subTypeName">
        /// 年假 事假 病假 调休假 婚嫁 产假  陪产假 丧假 补卡次数 出差 外出数 外勤 其他
        /// </param>
        /// <returns></returns>
        private static int Fallibilitydispose(List<Sp_Item> datas, int type, string? subTypeName)
        {
            int num = 0;

            Sp_Item _Info = datas.Where(it => it.type == type && it.name == subTypeName).FirstOrDefault();
            if (_Info != null) { num = _Info.count; }

            return num;
        }

        /// <summary>
        /// 打卡数据
        /// 异常数据 统计
        /// </summary>
        /// <returns></returns>
        private static int ExceptionStatistics(List<Exception_Info> datas, int type)
        {
            int num = 0;

            Exception_Info _Info = datas.Where(it => it.exception == type).FirstOrDefault();
            if (_Info != null) { num = _Info.count; }

            return num;
        }

        /// <summary>
        /// 获取时间段内除周末 节假日外的 工作日
        /// </summary>
        /// <param name="startDt"></param>
        /// <param name="endDt"></param>
        /// <returns></returns>
        public static int GetWorkDays(DateTime startDt,DateTime endDt) 
        {
            string startYear = startDt.ToString("yyyy");
            string endYear = endDt.ToString("yyyy");

            var holidays = AppSettingsHelper.Get<HoliDaysDataSourceView>("HoliDayDataSource");
            List<HoliDaysDataSourceView> holiDatas = new List<HoliDaysDataSourceView>();
            if (startYear.Equals(endYear))
            {
                holiDatas.Add(holidays.Where(it => it.Year == startYear).FirstOrDefault());
            }
            else
            {
                holiDatas.Add(holidays.Where(it => it.Year == startYear).FirstOrDefault());
                holiDatas.Add(holidays.Where(it => it.Year == endYear).FirstOrDefault());
            }

            int _totalDays = (int)(endDt - startDt).TotalDays;
            List<HolidaysInfo> _holidays = new List<HolidaysInfo>();
            List<HolidaysInfo> _weekdys = new List<HolidaysInfo>();
            List<HolidaysInfo> _workdays = new List<HolidaysInfo>();
            string[] Day = new string[] { "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六" };

            for (int i = 0; i <= _totalDays; i++)
            {
                string thisYear = startDt.ToString("yyyy");
                string thisDt = startDt.ToString("MM-dd");
                string thisYMD = startDt.ToString("yyyy-MM-dd");
                string thisWeek = Day[Convert.ToInt32(startDt.DayOfWeek.ToString("d"))].ToString();


                HoliDaysDataSourceView holiDaysData = new HoliDaysDataSourceView();
                holiDaysData = holiDatas.Where(it => it.Year == thisYear).FirstOrDefault();
                //周末
                if (thisWeek.Equals("星期六") || thisWeek.Equals("星期日"))
                {
                    HolidaysInfo holidaysInfo = new HolidaysInfo();
                    holidaysInfo = holiDaysData.Holidays.Where(it => it.HoliDate == thisDt).FirstOrDefault();
                    if (holidaysInfo != null)
                    {
                        if (holidaysInfo.HoliName.Equals("工作日"))
                        {
                            _workdays.Add(new HolidaysInfo { HoliDate = thisYMD, HoliName = Day[Convert.ToInt32(startDt.DayOfWeek.ToString("d"))].ToString() });
                            startDt = startDt.AddDays(1);
                            continue;
                        }
                    }
                    _weekdys.Add(new HolidaysInfo { HoliDate = thisYMD, HoliName = thisWeek });
                    startDt = startDt.AddDays(1);
                    continue;
                }
                
                //节假日
                if (holiDaysData != null)
                {
                    HolidaysInfo holidaysInfo = new HolidaysInfo();
                    holidaysInfo = holiDaysData.Holidays.Where(it => it.HoliDate == thisDt).FirstOrDefault();
                    if (holidaysInfo != null)
                    {
                        _holidays.Add(new HolidaysInfo { HoliDate = thisYMD, HoliName = holidaysInfo.HoliName });
                        startDt = startDt.AddDays(1);
                        continue;
                    }
                }
                //工作日
                _workdays.Add(new HolidaysInfo { HoliDate = thisYMD, HoliName = Day[Convert.ToInt32(startDt.DayOfWeek.ToString("d"))].ToString() });

                startDt = startDt.AddDays(1);
            }

            return _workdays.Count();
        }
    }
}