邦达新HR系统

增强日历，首页直接显示打卡日历信息，有问题请反馈[email protected]
当前为 2022-07-29 提交的版本，查看最新版本。
换行
// ==UserScript==
// @name         邦达新HR系统
// @namespace    http://tampermonkey.net/
// @version      1.0.7
// @description  增强日历，首页直接显示打卡日历信息，有问题请反馈[email protected]
// @author       GodLin
// @match        *im.bondex.com.cn:8092/*
// @match        *i.bondex.com.cn/*
// @require      https://cdn.staticfile.org/jquery/3.6.0/jquery.min.js
// @grant        GM_xmlhttpRequest
// @grant        unsafeWindow
// @license MIT
// ==/UserScript==

(function() {
    'use strict';
    // config
    // 基础加班费 12元/h
    var baseOvertimeMoneys = 12;
    // 基础可用迟到时长 30分钟
    var baseLate = 30;
    // 基础迟到扣钱，迟到1分钟5块钱
    var baseDeductLate = 5
    // 基础未打卡，扣50
    var baseDeducNotLock = 50
    // base
    var weekDay = ["星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"];
    var today = new Date()
    var todayStr = today.getFullYear() + "-" + ((today.getMonth() + 1) < 10 ? ("0" + (today.getMonth() + 1)) : (today.getMonth() + 1)) + "-" + (today.getDate() < 10 ? ("0" + today.getDate()) : today.getDate());

    // 添加css
    var cssHtml = '<link rel="stylesheet" href="http://i.bondex.com.cn/Content/css/bootstrap.css">';

    cssHtml += '<style>'
    cssHtml += '#index{background-color:#fff;}'
    cssHtml += '.table-bordered, .table-bordered>tbody>tr>td, .table-bordered>tbody>tr>th, .table-bordered>tfoot>tr>td, .table-bordered>tfoot>tr>th, .table-bordered>thead>tr>td, .table-bordered>thead>tr>th{border-color:#ccc;}'
    cssHtml += '.table>tbody>tr>td{padding: 5px;}'
    cssHtml += '.table>tbody>tr>td>p{line-height:90%;}'
    cssHtml += '</style>';
    $("head").append(cssHtml)

    // 等元素出现后操作
    function wait(selector, func, times, interval) {
        var _times = times || -1, //100次
            _interval = interval || 20, //20毫秒每次
            _self = $(selector),
            _selector = selector, //选择器
            _iIntervalID; //定时器id
        if( _self.length ){ //如果已经获取到了，就直接执行函数
            func && func.call(_self);
        } else {
            _iIntervalID = setInterval(function() {
                if(!_times) { //是0就退出
                    clearInterval(_iIntervalID);
                }
                _times <= 0 || _times--; //如果是正数就 --
                _self = $(_selector); //再次选择
                if( _self.length ) { //判断是否取到
                    func && func.call(_self);
                    clearInterval(_iIntervalID);
                }
            }, _interval);
        }
        return _self;
    }

    /**
    * 获取日期范围内的每天
    */
    function dealDate(start,end){
        let dateList = [];
        var startTime = new Date(start);;
        var endTime = new Date(end);;

        while ((endTime.getTime() - startTime.getTime()) >= 0) {
            var year = startTime.getFullYear();
            var month = startTime.getMonth() + 1 < 10 ? '0' + (startTime.getMonth() + 1) : startTime.getMonth() + 1;
            var day = startTime.getDate().toString().length == 1 ? "0" + startTime.getDate() : startTime.getDate();
            dateList.push(year + "-"+ month + "-" + day);
            startTime.setDate(startTime.getDate() + 1);
        }
        return dateList;
    }

    var Sleep ={
        setId_xml:async function(objs){
            while(true){
                await this.sleep(10);
                if(objs.loadingNum==0){
                    break;
                }
            }
        },
        sleep:function(ms) {
            return new Promise(resolve => setTimeout(resolve, ms));
        },
    }

    // 页面加载完执行
    $(function(){
        // 判断如果是 邦达首页则跳过
        if(window.location.href.indexOf("i.bondex.com.cn") != -1 ){
            return;
        }
        // 获取日历
        loadThreeMonthsCalendarData()
        // 获取审批
        getApprove()
        // 获取工期
        getWorkCycle()
        // 初始化
        initTopMenuBtn()
        // 加班日历元素加载
        calendarLoad(calendarIndex,()=>{
            wait(".topRouterWrapper li[title=单据申请]" , ()=>{
                // 等待菜单加载完成，可能是首页
                if($(".topRouterWrapper li").first() .hasClass("active")){
                    // 首页才进行渲染
                    // 隐藏快捷方式
                    wait(".el-carousel__indicators",function(){
                        $(".el-carousel__indicators").hide();
                    },100,100)
                    wait(".customHomePageBox",function(){
                        $(".customHomePageBox[id!='calendarBox']").hide();
                        // 重新渲染
                        renderCalendarHtml()
                    },100,100)
                }
            })
        });
    })

    // 加载顶部切换按钮
    function initTopMenuBtn(){
        // 上方菜单追加元素
        $(".topRouterWrapper").append("<li title='打卡日历' class='ellipsis' id='jiabanrili'>打卡日历</li><li title='快捷入口' class='ellipsis' id='kuaiJieRuKou'>快捷入口</li>")
        // 加载点击事件
        wait(".topRouterWrapper li[title=单据申请]" , ()=>{
            $(".topRouterWrapper").find("*").on('click',function () {
                $(this).parent().find("*").removeClass("active");
                $(this).addClass("active");
            });
        })
        // 显示快捷入口按钮
        wait("#kuaiJieRuKou",function(){
            $("#kuaiJieRuKou").click(function(){
                // 判断是否是在首页
                var homePage = $(".topRouterWrapper li").first()
                if(!(homePage .hasClass("active"))){
                    // 不是在首页，则点击首页按钮
                    homePage.click();
                }
                // 判断是否存在empCard左侧信息，没有的话说明是第一次进，不需要处理，如果不是第一次，需要隐藏和显示
                var empCard = $("#empCard")
                if(empCard.length!=0){
                    $("#calendarBox").hide();
                    $(".customHomePageBox[id!='calendarBox']").show();
                    $(".el-carousel__indicators").show();
                }
            })
        })
        // 显示日历按钮
        wait("#jiabanrili",()=>{
            $("#jiabanrili").click(function(){
                // 显示日历
                // 判断是否是在首页
                var homePage = $(".topRouterWrapper li").first()
                if(!(homePage.hasClass("active"))){
                    // 不是在首页，则点击首页按钮
                    homePage.click();
                }
                // 判断是否存在empCard左侧信息，没有的话说明是第一次进，需要延迟加载
                var empCard = $("#empCard")
                // 判断是否存在calendarBox，存在则直接显示 不存在则从calendarBoxHtml中获取渲染
                if(empCard.length!=0){
                    var calendarBox = $('#calendarBox')
                    if(calendarBox.length==0){
                        wait("#calendarBoxHtml" ,()=>{
                            // 隐藏蓝点
                            $(".el-carousel__indicators").hide();
                            // 隐藏快捷方式
                            $(".customHomePageBox[id!='calendarBox']").hide();
                            // 重新渲染
                            renderCalendarHtml()
                        },100,100)
                    } else {
                        // 隐藏蓝点
                        $(".el-carousel__indicators").hide();
                        // 隐藏快捷方式
                        $(".customHomePageBox[id!='calendarBox']").hide();
                        calendarBox.show();
                    }
                }else{
                    // 如果是第一次进
                    wait(".customHomePageBox[id!='calendarBox']",()=>{
                        // 隐藏蓝点
                        $(".el-carousel__indicators").hide();
                        // 隐藏快捷方式
                        $(".customHomePageBox[id!='calendarBox']").hide();
                        wait("#calendarBoxHtml" ,()=>{
                            // 重新渲染
                            renderCalendarHtml()
                        },100,100)
                    })
                }
            })
        })
    }

    // 加班日历元素加载
    // index =0 本月 只能获取到 上月 上上月 不能小于-2
    var calendarIndex = 0;
    // 日历表的html
    var calendarHtml = '';
    // 重新日历赋按钮予点击事件
    function calendarEvent(){
        // 上月按钮点击事件
        wait('#calendarPrevious',()=>{
            $('#calendarPrevious').click(()=>{
                calendarIndex -= 1;
                // 重新加载html
                loadCalendarHtml()
                // 如果=-2 禁用按钮
                if(calendarIndex==-2){
                    $("#calendarPrevious").attr("disabled",true);
                    $("#calendarPrevious").html("无");
                }
            });
        })
        // 本月
        wait('#calendarNow',()=>{
            $('#calendarNow').click(()=> {
                calendarIndex = 0;
                // 重新加载html
                loadCalendarHtml()
                // 取消禁用
                $("#calendarPrevious").attr("disabled",false);
                $("#calendarPrevious").html("上月");
            });
        })
    }

    // 加载日历
    function loadCalendarHtml(){
        // 重新加载
        calendarLoad(calendarIndex,()=>{
            renderCalendarHtml()
        });
    }

    // 渲染日历html 单位时间只能执行一次
    var renderingCalendar = false;
    function renderCalendarHtml(){
        if(!renderingCalendar){
            renderingCalendar = true
            $("#calendarBox").remove();
            $(".customHomePageBox[id!='calendarBox']").parent().append($("#calendarBoxHtml").html())
            // 加载日历事件
            calendarEvent()
            renderingCalendar = false
        }
    }

    // 时间戳 构建时间对象
    function calcTime(ticks) {
        var leftSecond = parseInt(ticks / 1000);
        var day = Math.floor(leftSecond / (60 * 60 * 24));
        var hour = Math.floor((leftSecond - day * 24 * 60 * 60) / 3600);
        var minute = Math.floor((leftSecond - day * 24 * 60 * 60 - hour * 3600) / 60);
        var second = Math.floor(leftSecond - day * 24 * 60 * 60 - hour * 3600 - minute * 60);
        return { day: day, hour: hour, minute: minute, second: second };
    }

    // 获取前 up 月的日期 比如 202206上1个月日期为 202205，需要传入负数
    function getUpDate(up){
        // 如果大于0或者没传 默认给0
        if( !!!up || up>0){
            up = 0;
        }
        // 当前年月
        var year = today.getFullYear()
        // 经过计算后的月数
        var month = (today.getMonth() + 1) + up
        // 取余 取商
        var upMonth = parseInt( month % 12 );
        var upYear = parseInt(month / 12);
        if( upMonth < 1 ){
            upMonth = 12 + upMonth
            year = year - 1 - upYear;
        }
        if(upMonth <10){
            upMonth = "0" + upMonth
        }
        return { year: year + "", month: upMonth + ""};
    }

    // 判断日期字符串或者date在范围内  start <= date <= end
    function dateInScope(start,end,date){
        let _start = 0;
        if( typeof start == 'string'){
            if( start.indexOf( ":") == -1){
                start = start+ " 00:00:00"
            }
            _start = new Date(start).getTime()
        }else{
            _start = _start.getTime()
        }
        let _end = 0;
        if( typeof end == 'string'){
            if( end.indexOf( ":") == -1){
                end = end+ " 00:00:00"
            }
            _end = new Date(end).getTime()
        }else{
            _end = end.getTime()
        }
        let _date = 0;
        if( typeof date == 'string'){
            if( date.indexOf( ":") == -1){
                date = date+ " 00:00:00"
            }
            _date = new Date(date).getTime()
        }else{
            _date = date.getTime()
        }
        return (_date >= _start && _date<= _end )
    }

    // 处理html
    function calendarHandleHtml(param){
        // 参数
        let index = param.index,
            data = param.data,
            func = param.func,
            startDate = param.startDate,
            endDate = param.endDate;
        // 本账期
        let paymentDays = {
            remainLate:baseLate, // 可用迟到数量
            deductMoneys: 0, // 扣钱 （包括未打卡扣50，迟到1分钟5块钱）
            lateMinutes:0, // 迟到分钟数
            overtimeHour : 0.0, // 有效加班小时
            overtimeTotalMinutes : 0, // 总加班分钟
            notPassDays : false, // 审批为通过
        }
        // 下一账期（本月最后几天）
        let lastPaymentDays = {
            flag : false, // 是否到了下一账期
            remainLate:baseLate, // 可用迟到数量
            deductMoneys: 0, // 扣钱 （包括未打卡扣50，迟到1分钟5块钱）
            lateMinutes:0, // 迟到分钟数
            overtimeHour : 0.0, // 有效加班小时
            overtimeTotalMinutes : 0, // 总加班分钟
            notPassDays : false, // 审批为通过
        }
        // 顶层总览按钮
        // 获取前 up 月的日期
        var upDate = getUpDate(index)
        calendarHtml = '<div id="btn-group" class="row" style="padding-top:10px;">'

        calendarHtml += '<div class="col-xs-12 text-center">' +
            '<div class="btn-group" role="group" aria-label="按钮组">' +
            '<button type="button" class="btn btn-primary btn-sm" id="calendarPrevious" >上月</button>' +
            '<button type="button" class="btn btn-primary btn-sm">' + upDate.year + ' - ' + upDate.month + '</button>' +
            '<button type="button" class="btn btn-primary btn-sm" id="calendarNow">本月</button>' +
            '</div>' +
            '</div>'
        // 账期汇总
        calendarHtml += '<div class="col-xs-12">#{paymentDaysSummary}</div>'
        calendarHtml += '<div class="col-xs-12">#{lastPaymentDaysSummary}</div>'

        calendarHtml += '</div>';
        // table插槽
        calendarHtml += '<div>#{calendarTable}</div>'
        // 拼接的html
        var calendarTableHtml = "";
        calendarTableHtml += '<table class="table table-bordered">';
        calendarTableHtml += '<thead>';
        calendarTableHtml += '<tr>';
        // 渲染 周标体
        $.each(weekDay, function (i, v) {
            if (i === 0 || i === 6) {
                calendarTableHtml += '<th class="col-xs-1 text-center" style="color:#fff;background-color:#f39c12;"><span class="label">' + v + '</span></th>';
            } else {
                calendarTableHtml += '<th class="col-xs-2 text-center" style="color:#fff;background-color:#777;"><span class="label label-default" style="color:#fff;background-color:#777;">' + v + '</span></th>';
            }
        });
        calendarTableHtml += '</tr>';
        calendarTableHtml += '</thead>';
        calendarTableHtml += '<tbody>';
        // 获取审批数据
        let approveJson = $('#approveJson').html()
        while(!!!approveJson){
            Sleep.sleep(50)
            approveJson = $('#approveJson').html()
        }
        let approve = JSON.parse(approveJson)
        let askOff = approve.askOff;
        let signIn = approve.signIn;
        // 处理数据
        $.each(data, function (i, v) {
            // 账期
            let cunrrentDays = {}
            if(dateInScope(startDate,endDate,v.Date_Sign)){
                cunrrentDays = paymentDays
            }else{
                cunrrentDays = lastPaymentDays
                cunrrentDays.flag = true
            }
            // 判断是否眼签卡单，如果有，优先签卡单覆盖上下班时间
            if(signIn.up[v.Date_Sign]){
                v.Time_SignIn = signIn.up[v.Date_Sign]
            }
            if(signIn.down[v.Date_Sign]){
                v.Time_SignOut = signIn.down[v.Date_Sign]
            }
            //上午打卡时间
            let dateSignIn = new Date(v.Date_Sign + ' ' + v.Time_SignIn);
            //下午打卡时间
            let dateSignOut = new Date(v.Date_Sign + ' ' + v.Time_SignOut);

            //上午上班时间 08:30
            let dateBaseSignIn = new Date(v.Date_Sign + ' ' + v.BaseSignIn);
            //下午下班时间 17:30
            let dateBaseSignOut = new Date(v.Date_Sign + ' ' + v.BaseSignOut);

            //中午下班时间 12:00
            let RelaxStartTime = new Date(v.Date_Sign + ' ' + v.RelaxStartTime);
            //下午上班时间 13:30
            let RelaxEndTime = new Date(v.Date_Sign + ' ' + v.RelaxEndTime);

            // 获取星期几
            let day = new Date(v.Date_Sign);
            let week = weekDay[day.getDay()];
            // 是否是工作日 true
            //  IsHoliday有点问题，调休和放假都算节假日
            // let isWorking  = (day.getDay() != 0 && day.getDay() != 6) && v.IsHoliday == false;
            // 存在上班时间、IsHoliday、info里面有上班字眼
            let isWorking = false
            if( v.IsHoliday){
                // true 可能是调休上班 也可能是调休休假，只能通过判断HolidayInfo
                isWorking = v.HolidayInfo ? ( v.HolidayInfo.indexOf('上班') != -1 ) : false
            }else{
                // false代表不是假期,不是假期直接判断有没有上班时间即可
                isWorking = !!(v.BaseSignIn)
            }

            // 第一天 给个 <tr> 开始
            if (day.getDay() === 0) {
                calendarTableHtml += '<tr>';
            }

            if (i === 0) {
                for (var j = 0; j < day.getDay() - i; j++) {
                    if (j == 0 || j == 6) {
                        calendarTableHtml += '<td class="col-xs-1"></td>';
                    } else {
                        calendarTableHtml += '<td class="col-xs-2"></td>';
                    }
                }
            }
            // 日期
            calendarTableHtml += '<td class="col-xs-' + (day.getDay() === 0 || day.getDay() === 6 ? '1' : '2') + '"><p><span class="badge ' + (day.getDay() === 0 || day.getDay() === 6 ? 'bg-yellow' : '') + '">' + day.getDate() + '</span></p>';
            // 调休等消息
            if(v.HolidayInfo){
                calendarTableHtml += '<p class="text-info"><span class="label label-success">'+v.HolidayInfo+'</span></p>'
            }
            if (todayStr == v.Date_Sign) {
                // 判断如果是当天则不算
                calendarTableHtml += '<p><span class="label label-default">今天不算</span></p>';
            }
            else {
                if(isWorking){
                    // 工作日
                    // 上午
                    // 未打卡 (上午打卡时间 > 中午下班时间 || 上午未打卡 )
                    if (dateSignIn > RelaxStartTime || v.Time_SignIn == "") {
                        if (askOff.up[v.Date_Sign] || v.ApproveInfo.indexOf("已通过") != -1) {
                            calendarTableHtml += '<p><span class="label label-default">上班未打卡</span> <span class="label label-default">已通过</span></p>';
                        } else {
                            // 审批未通过 扣50
                            cunrrentDays.deductMoneys -=baseDeducNotLock
                            calendarTableHtml += '<p><span class="label label-danger">上班未打卡</span> <span class="label label-danger">￥'+baseDeducNotLock+'</span></p>';
                            // 未通过标记
                            cunrrentDays.notPassDays = true;
                        }
                    }
                    //上班迟到 (上午打卡时间 > 上午上班时间)
                    else if (dateSignIn > dateBaseSignIn) {
                        if(askOff.up[v.Date_Sign] || v.ApproveInfo.indexOf("已通过") != -1){
                            // 迟到了，但是提交了审批
                            calendarTableHtml += '<p class="text-warning"><span class="label label-danger">' + v.Time_SignIn + '</span></p>'
                            calendarTableHtml += '<p><span class="label label-default">上班未打卡</span> <span class="label label-default">已通过</span></p>';
                        }else{
                            //迟到了
                            let timer = calcTime(dateSignIn - dateBaseSignIn);
                            // 迟到分钟数 秒不算
                            let loseMinute = (timer.hour + timer.day * 24) * 60 + timer.minute;
                            if (loseMinute > 0) {
                                // 总迟到分钟数
                                cunrrentDays.lateMinutes += loseMinute;
                                // 今天扣钱
                                let deductmoney = 0;
                                if( cunrrentDays.remainLate >0){
                                    // 可能可以抵扣
                                    if( cunrrentDays.remainLate < loseMinute){
                                        // 如果迟到分钟大于剩余可用迟到分钟，真迟到了
                                        // 真实应该扣钱的迟到分钟
                                        let realLoseMinute = loseMinute - cunrrentDays.remainLate;
                                        // 迟到扣钱
                                        deductmoney = realLoseMinute * baseDeductLate;
                                    }
                                }else{
                                    // 别想了，肯定扣钱
                                    deductmoney = loseMinute * baseDeductLate;
                                }
                                // 总扣钱
                                cunrrentDays.deductMoneys += deductmoney;
                                calendarTableHtml += '<p class="text-warning"><span class="label label-danger">' + v.Time_SignIn + '</span></p><p><span class="label label-danger">' + loseMinute + 'min</span>'+ (cunrrentDays.deductMoneys ? ('<span class="label label-danger">￥' + deductmoney + '</span>') :'' )+'</p>';
                                // 剩余可用迟到分钟
                                cunrrentDays.remainLate -= loseMinute;
                            } else {
                                //一分钟内不算
                                calendarTableHtml += '<p><span class="label label-default" style="color:#fff;background-color:#777;">' + v.Time_SignIn + '</span></p><p>&nbsp;</p>';
                            }
                        }
                    }
                    else {
                        // 没迟到
                        calendarTableHtml += '<p><span class="label label-default" style="color:#fff;background-color:#777;">' + v.Time_SignIn + '</span></p><p>&nbsp;</p>';
                    }

                    // 下午
                    // 下班未打卡
                    if (dateSignOut < dateBaseSignOut || v.Time_SignOut == "") {
                        if (askOff.down[v.Date_Sign] || v.ApproveInfo.indexOf("已通过") != -1) {
                            calendarTableHtml += '<p><span class="label label-default">下班未打卡</span> <span class="label label-default">已通过</span></p>';
                        }else {
                            //未通过 扣50
                            cunrrentDays.deductMoneys -= baseDeducNotLock;
                            calendarTableHtml += '<p><span class="label label-danger">下班未打卡</span> <span class="label label-danger">￥'+baseDeducNotLock+'</span></p>';
                            // 未通过标记
                            cunrrentDays.notPassDays = true;
                        }
                    }
                    //下班打卡
                    else if (dateSignOut > dateBaseSignOut) {
                        //加班了
                        let timer = calcTime(dateSignOut - dateBaseSignOut);
                        // 今日加班分钟
                        let overtimeMinute = (timer.hour + timer.day * 24) * 60 + timer.minute;
                        // 有效小时数
                        let overtimeHour = parseFloat((overtimeMinute - overtimeMinute % 30) / 60);
                        // 有效加班费
                        let overtimeMoney = overtimeHour * baseOvertimeMoneys;

                        cunrrentDays.overtimeTotalMinutes += overtimeMinute
                        cunrrentDays.overtimeHour += overtimeHour;

                        if (overtimeMoney > 0) {
                            calendarTableHtml += '<p class="text-info"><span class="label label-primary">' + (v.Time_SignOut === v.Time_SignIn ? '' : v.Time_SignOut) + '</span></p><p><span class="label label-primary">' + overtimeMinute + 'min</span> <span class="label label-primary">￥' + overtimeMoney + '</span></p>';
                        } else {
                            calendarTableHtml += '<p class="text-info"><span class="label label-default" style="color:#fff;background-color:#777;">' + (v.Time_SignOut === v.Time_SignIn ? '' : v.Time_SignOut) + '</span></p><p><span class="label label-default" style="color:#fff;background-color:#777;">' + overtimeMinute + 'min</span></p>';
                        }
                    } else {
                        if(askOff.down[v.Date_Sign] || v.ApproveInfo.indexOf("已通过") != -1){
                            calendarTableHtml += '<p><span class="label label-default" style="color:#fff;background-color:#777;">' + (v.Time_SignOut === v.Time_SignIn ? '' : v.Time_SignOut) + '</span> </p><p>&nbsp;</p>';
                        }else{
                            //早退了
                            let timer = calcTime(dateBaseSignOut - dateSignOut);
                            let leaveEarlyMinute = (timer.hour + timer.day * 24) * 60 + timer.minute;
                            if(!!!leaveEarlyMinute){
                                // 早退不到1分钟，也算1分钟
                                leaveEarlyMinute = 1
                            }
                            cunrrentDays.deductMoneys -= (leaveEarlyMinute * baseDeductLate);
                            calendarTableHtml += '<p><span class="label label-default" style="color:#fff;background-color:#777;">' + (v.Time_SignOut === v.Time_SignIn ? '' : v.Time_SignOut) + '</span> <span class="label label-danger">早退￥'+leaveEarlyMinute * baseDeductLate+'</span></p><p>&nbsp;</p>';
                            // 未通过标记
                            cunrrentDays.notPassDays = true;
                        }
                    }
                }else{
                    // 休息日
                    if(!!(v.Time_SignIn)){
                        // 休息日有打卡
                        // 上班时间
                        calendarTableHtml += '<p><span class="label label-default" style="color:#fff;background-color:#777;">' + v.Time_SignIn + '</span></p><p>&nbsp;</p>';
                        if(!!!(v.Time_SignOut) ){
                            // 只有上班没有下班
                            calendarTableHtml += '<p class="text-info"><span class="label label-primary">下班未打卡，好家伙钱都不要了！</span></p>';
                        }else{
                            let approveOvertime = approve.overtime[v.Date_Sign]
                            if(approveOvertime){
                                // 审批通过
                                // 取加班单与打卡时间交集最小值
                                let approveOvertimeBegin = new Date(v.Date_Sign + " " + approveOvertime.begin)
                                let approveOvertimeEnd = new Date(v.Date_Sign + " " +approveOvertime.end)
                                let timerLong = 0;
                                //上午打卡时间
                                if(dateSignOut <= approveOvertimeBegin || approveOvertimeEnd <= dateSignIn){
                                    timerLong = 0;
                                }else {
                                    let overtimeArray = [ dateSignIn,dateSignOut,approveOvertimeBegin,approveOvertimeEnd ]
                                    // 正序
                                    overtimeArray.sort(function (a, b) {
                                        return a > b ? 1 : -1;
                                    })
                                    timerLong = overtimeArray[2]-overtimeArray[1]
                                }
                                // 加班了
                                let timer = calcTime(timerLong);
                                // 今日加班分钟
                                let overtimeMinute = (timer.hour + timer.day * 24) * 60 + timer.minute;
                                // 有效小时数
                                let overtimeHour = parseFloat((overtimeMinute - overtimeMinute % 30) / 60);
                                // 有效加班费
                                let overtimeMoney = overtimeHour * baseOvertimeMoneys;

                                cunrrentDays.overtimeTotalMinutes += overtimeMinute
                                cunrrentDays.overtimeHour += overtimeHour;

                                if (overtimeMinute > 0) {
                                    calendarTableHtml += '<p class="text-info"><span class="label label-primary">' + (v.Time_SignOut === v.Time_SignIn ? '' : v.Time_SignOut) + '</span></p><p><span class="label label-primary">' + overtimeMinute + 'min</span> <span class="label label-primary">￥' + overtimeMoney + '</span></p>';
                                } else {
                                    calendarTableHtml += '<p class="text-info"><span class="label label-default" style="color:#fff;background-color:#777;">' + (v.Time_SignOut === v.Time_SignIn ? '' : v.Time_SignOut) + '</span></p><p><span class="label label-default" style="color:#fff;background-color:#777;">' + overtimeMinute + 'min</span></p>';
                                    calendarTableHtml +='<p class="text-info"><span class="label label-primary">加班了，但是没完全加！</span></p>'
                                }
                            }else{
                                // 没审批通过
                                // 加班了
                                let timer = calcTime(dateSignOut - dateSignIn);
                                // 今日加班分钟
                                let overtimeMinute = (timer.hour + timer.day * 24) * 60 + timer.minute;
                                cunrrentDays.overtimeTotalMinutes += overtimeMinute
                                calendarTableHtml += '<p class="text-info"><span class="label label-default" style="color:#fff;background-color:#777;">' + (v.Time_SignOut === v.Time_SignIn ? '' : v.Time_SignOut) + '</span></p><p><span class="label label-default" style="color:#fff;background-color:#777;">' + overtimeMinute + 'min</span></p>';
                                calendarTableHtml +='<p class="text-info"><span class="label label-primary">加班了，但是没完全加！</span></p>'
                            }
                        }
                    }else{
                        calendarTableHtml += '<p class="text-info"><span class="label label-success">加班是不可能加班的</span></p>'
                    }
                }
            }
            calendarTableHtml += '</td>';
            if (day.getDay() === 6) {
                calendarTableHtml += '</tr>';
            }
        });

        calendarTableHtml += '</tbody>';
        calendarTableHtml += '</table>';
        // 等快捷方式出现后，渲染页面
        // 渲染日历表
        // 替换表格
        calendarHtml = calendarHtml.replace("#{calendarTable}",calendarTableHtml)
        // 替换标题  合计,放到paymentDaysSummaryHtml下
        var paymentDaysSummaryHtml = '&nbsp;&nbsp;' +
            '当前账期<span class="label label-primary">'+ startDate.substring(0,10) + '——'+ endDate.substring(0,10)+'&nbsp;</span>&nbsp;共迟到：<span class="label label-warning">' +paymentDays.lateMinutes + 'min</span> <span class="label label-danger">余额' + paymentDays.remainLate + 'min</span> ' +
            '共加班：<span class="label label-primary">' + paymentDays.overtimeTotalMinutes + 'min</span> ' +
            '有效加班：<span class="label label-primary">' + paymentDays.overtimeHour * 60 + 'min</span> <span class="badge">' + paymentDays.overtimeHour + 'h</span> ' +
            '扣除工资：<span class="label label-danger">￥' + paymentDays.deductMoneys + '</span> ' +
            '加班奖励工资：<span class="label label-primary">￥' + paymentDays.overtimeHour * baseOvertimeMoneys + '</span>'+
            (paymentDays.notPassDays ?( '<span class="label label-danger">有没通过的的审批，要扣钱啦，快在'+endDate.substring(0,10)+'之前提交审批</span>' ): "");
        calendarHtml = calendarHtml.replace("#{paymentDaysSummary}",paymentDaysSummaryHtml)

        // 判断是否到了下一账期进行处理
        var lastPaymentDaysHtml = ""
        if( lastPaymentDays.flag){
            lastPaymentDaysHtml = '&nbsp;&nbsp;' +
                '下月账期共迟到：<span class="label label-warning">' +lastPaymentDays.lateMinutes + 'min</span> <span class="label label-danger">余额' + lastPaymentDays.remainLate + 'min</span> ' +
                '共加班：<span class="label label-primary">' + lastPaymentDays.overtimeTotalMinutes + 'min</span> ' +
                '有效加班：<span class="label label-primary">' + lastPaymentDays.overtimeHour * 60 + 'min</span> <span class="badge">' + lastPaymentDays.overtimeHour + 'h</span> ' +
                '扣除工资：<span class="label label-danger">￥' + lastPaymentDays.deductMoneys + '</span> ' +
                '加班奖励工资：<span class="label label-primary">￥' + lastPaymentDays.overtimeHour * baseOvertimeMoneys + '</span>'+
                (lastPaymentDays.notPassDays ? '  <span class="label label-danger">有没通过的的审批，要扣钱啦，快在'+endDate.substring(0,10)+'之前提交审批</span>' : "");
        }
        calendarHtml = calendarHtml.replace("#{lastPaymentDaysSummary}",lastPaymentDaysHtml)

        // 添加日历box
        var calendarBoxHtml = '<div class="customHomePageBox" id="calendarBox"  style="height: 100%; flex: 75 1 0%;"><div id="calendarItem" style="width:100%!important;"></div>'
        calendarBoxHtml += calendarHtml
        calendarBoxHtml += "</div>"
        var calendarBoxHtmlJq = $("#calendarBoxHtml")
        if(calendarBoxHtmlJq.length ==0){
            $("body").append('<script type="text/html" id="calendarBoxHtml">'+calendarBoxHtml+'</script>')
        }else{
            calendarBoxHtmlJq.html(calendarBoxHtml)
        }
        // 回调函数
        func && func.call();
    }

    /**
    * 日历加载请求，存入script
    * func 回调方法
    */
    function calendarLoad(index,func) {
        wait("#workCycleJson",()=>{
            // 账期数据存在后
            wait("#threeMonthsCalendarDataJson",()=>{
                // 日历数据存在后
                let workCycleJson = JSON.parse($("#workCycleJson").html());
                let threeMonthsCalendarDataJson = JSON.parse($("#threeMonthsCalendarDataJson").html());
                // 获取到账期日期
                let startDate =workCycleJson[ (today.getMonth() + 1 + index) + "start"]
                let endDate = workCycleJson[ (today.getMonth() + 1 + index) + "end"]
                let _endDate = endDate;
                // 处理数据 需要账期数据和日历数据同时存在
                if(index ==0){
                    // 本账期，取start到今天的data    非本月账期，按照账期日期获取data
                    _endDate = today
                }
                // 处理data，只要账期内的
                let data = threeMonthsCalendarDataJson.filter(item => {
                    return dateInScope(startDate,_endDate,item.Date_Sign)
                })
                // 准备处理html
                let param ={
                    startDate: startDate,
                    endDate:endDate,
                    data : data,
                    index: index,
                    func : func
                }
                calendarHandleHtml(param)
            } )
        } )
    }

    // 获取工作周期 3个月，注意使用workCycle
    var workCycle = {}
    function getWorkCycle(count){
        // 删除工期json
        $("#workCycleJson").remove()
        workCycle = {}
        // 获取登录(不可用)人信息，用于获取工期
        var empOriginId = "";
        $.ajax({
            type:"GET",
            async: false,
            url:"/perUser/getUser",
            dataType:"json",
            success:function (data) {
                empOriginId = data.rows.perUser.empOriginId
            }
        })
        // 准备获取工期
        count = count || 3
        // 循环获取每个月的工期
        for(var i = 0;i<count;i++ ){
            var upDate = getUpDate(-i)
            var param = {"empOriginIds":[empOriginId],"yearMonthText": upDate.year+""+upDate.month }
            // 获取工期
            $.ajax({
                type:"POST",
                url:"/attAttendanceRecordEmp/listEmpScheduleNew",
                contentType: "application/json",
                dataType:"json",
                data:JSON.stringify(param),
                success:function (data) {
                    var workList = data.data.scheduleDetailList
                    var currentMonth = new Date( workList[parseInt(workList.length/2) ].scheduleDate ).getMonth() + 1
                    workCycle[currentMonth + "start"] = workList[0].scheduleDate
                    workCycle[currentMonth + "end"] = workList[workList.length-1 ].scheduleDate
                }
            })
        }
        // 条件成立后执行
        var _iIntervalID; //定时器id
        var _times = 100
        // 定时器异步，需要函数执行
        _iIntervalID = setInterval(function() {
            if(!_times) { //是0就退出
                clearInterval(_iIntervalID);
            }
            _times--;
            if( Object.keys(workCycle).length == count*2) {
                // 获取完工期后的操作 存入到页面 json字符串
                $("body").append('<script type="text/html" id="workCycleJson">'+JSON.stringify(workCycle)+'</script>')
                // 清除定时任务
                clearInterval(_iIntervalID);
            }
        }, 50);
    }

    // 加载日历数据，存储到script中
    var threeMonthsCalendarData = {}
    function loadThreeMonthsCalendarData(){
        threeMonthsCalendarData = {}
        // 删除日历数据json
        $("#threeMonthsCalendarDataJson").remove()
        // 直接拉取3个月数据
        var url1 = 'http://i.bondex.com.cn/My/CheckData';
        // 油猴跨域访问
        GM_xmlhttpRequest({
            method: "post",
            url: url1,
            headers: { "Content-Type": "application/x-www-form-urlencoded" },
            onload: function (data) {
                // 重新登录(不可用)可能会返回网页，需要捕获重新加载
                try {
                    data = JSON.parse(data.responseText)
                }catch(e) {
                    if(data.responseText.indexOf('注意：请使用邦达黄页的用户名密码登录(不可用)') != -1){
                        // cookie过期，重新登录(不可用)，跳转到i.bomdex，从该页面进入
                        window.location.href='http://i.bondex.com.cn/'
                    }else{
                        // 可能加载到页面元素，重新加载
                        loadThreeMonthsCalendarData()
                    }
                    return;
                }
                threeMonthsCalendarData.current = data;
            }
        });

        var url2 = 'http://i.bondex.com.cn/My/CheckData?flag=prepre';
        // 油猴跨域访问
        GM_xmlhttpRequest({
            method: "post",
            url: url2,
            headers: { "Content-Type": "application/x-www-form-urlencoded" },
            onload: function (data) {
                // 重新登录(不可用)可能会返回网页，需要捕获重新加载
                try {
                    data = JSON.parse(data.responseText)
                }catch(e) {
                    if(data.responseText.indexOf('注意：请使用邦达黄页的用户名密码登录(不可用)') != -1){
                        // cookie过期，重新登录(不可用)
                        window.location.href='http://i.bondex.com.cn/'
                    }else{
                        // 可能加载到页面元素，重新加载
                        loadThreeMonthsCalendarData()
                    }
                    return;
                }
                threeMonthsCalendarData.prepre = data;
            }
        });

        // 条件成立后执行
        var _iIntervalID; //定时器id
        var _times = 100
        // 定时器异步，需要函数执行
        _iIntervalID = setInterval(function() {
            if(!_times) { //是0就退出
                clearInterval(_iIntervalID);
            }
            _times--;
            if( Object.keys(threeMonthsCalendarData).length == 2) {
                let threeMonthsCalendarDataArray = threeMonthsCalendarData.prepre
                threeMonthsCalendarDataArray.push.apply(threeMonthsCalendarDataArray,threeMonthsCalendarData.current);
                // 获取完工期后的操作 存入到页面 json字符串 使用wait去监控
                $("body").append('<script type="text/html" id="threeMonthsCalendarDataJson">'+JSON.stringify(threeMonthsCalendarDataArray)+'</script>')
                // 清除定时任务
                clearInterval(_iIntervalID);
            }
        }, 50);
    }

    // 获取全部审批数据 请假、签到、加班
    var approve = {
        "askOff":{"up":{}, "down":{}},
        "signIn":{"up":{}, "down":{}},
        "overtime":{},
    }
    function getApprove(){
        // 删除工期json
        $("#approveJson").remove()
        approve = {
            "askOff":{"up":{}, "down":{}},
            "signIn":{"up":{}, "down":{}},
            "overtime":{},
        }
        let queryCount = 0;
        // 获取请假单
        $.ajax({
            type:"POST",
            url:"/attHolidayLeaveOrder/listCustomSearch?tId=1158666390359023618&pageNum=0&pageSize=99999&sort=create_date%20&order=descending",
            contentType: "application/json",
            dataType:"json",
            data:JSON.stringify({}),
            success:function (data) {
                queryCount ++;
                let rows = data.rows
                if(Array.isArray(rows) ){
                    // 过滤出审批通过的
                    rows =$.grep( rows, function(n,i){
                        return n.audit_status =="3" || n.audit_status == "5"
                    });
                    rows.forEach( item =>{
                        // leave_way 1整天 2上半天 3下半天 4连续整天
                        let leaveWay = item.leave_way
                        if(leaveWay == "1" || leaveWay == "2" || leaveWay == "3"){
                            let approveDate= item.begin_date.substring(0,10)
                            if(leaveWay == "1" ){
                                // 整天
                                approve.askOff.up[approveDate] = true
                                approve.askOff.down[approveDate] = true
                            }else if(leaveWay == "2"){
                                // 上
                                approve.askOff.up[approveDate] = true
                            }else{
                                // 下
                                approve.askOff.down[approveDate] = true
                            }
                        }else if(leaveWay == "4"){
                            let approveDateArr = dealDate(item.begin_date,item.end_date)
                            approveDateArr.forEach(e =>{
                                approve.askOff.up[e] = true
                                approve.askOff.down[e] = true
                            })
                        }else{
                            // 补签卡，补签，直接覆盖原上下班时间
                            let signDate = item.sign_date.substring(0,10)
                            let signTime= item.sign_time
                            // 判断上午下午
                            if("12:30" > signTime ){
                                // 上午
                                approve.signIn.up[signDate] =signTime+":00"
                            }else {
                                // 下午
                                approve.signIn.down[signDate] =signTime+":00"
                            }
                        }
                    })
                }
            }
        })
        // 签卡单
        $.ajax({
            type:"POST",
            url:"/attHolidayLeaveOrder/listCustomSearch?tId=1158673087379054595&pageNum=0&pageSize=99999&sort=create_date%20&order=descending",
            contentType: "application/json",
            dataType:"json",
            data:JSON.stringify({}),
            success:function (data) {
                queryCount ++;
                let rows = data.rows
                if(Array.isArray(rows) ){
                    // 过滤出审批通过的
                    rows =$.grep( rows, function(n,i){
                        return n.audit_status =="3" || n.audit_status == "5"
                    });
                    rows.forEach( item =>{
                        // 补签卡，补签，直接覆盖原上下班时间
                        let signDate = item.sign_date.substring(0,10)
                        let signTime= item.sign_time
                        // 判断上午下午
                        if("12:30" > signTime ){
                            // 上午
                            approve.signIn.up[signDate] =signTime+":00"
                        }else {
                            // 下午
                            approve.signIn.down[signDate] =signTime+":00"
                        }
                    })
                }
            }
        })
        // 加班单
        $.ajax({
            type:"POST",
            url:"/attHolidayLeaveOrder/listCustomSearch?tId=1158674612583178242&pageNum=0&pageSize=99999&sort=create_date%20&order=descending",
            contentType: "application/json",
            dataType:"json",
            data:JSON.stringify({}),
            success:function (data) {
                queryCount ++;
                let rows = data.rows
                if(Array.isArray(rows) ){
                    // 过滤出审批通过的
                    rows =$.grep( rows, function(n,i){
                        return n.audit_status =="3" || n.audit_status == "5"
                    });
                    rows.forEach( item =>{
                        // 补签卡，补签，直接覆盖原上下班时间]
                        let attendanceDate = item.attendance_date.substring(0,10)
                        approve.overtime[attendanceDate] = {}
                        approve.overtime[attendanceDate].begin =item.begin_time
                        approve.overtime[attendanceDate].end =item.end_time
                    })
                }
            }
        })
        // 条件成立后执行
        var _iIntervalID; //定时器id
        var _times = 1000
        // 定时器异步，需要函数执行
        _iIntervalID = setInterval(function() {
            if(!_times) { //是0就退出
                clearInterval(_iIntervalID);
            }
            _times--;
            if(queryCount == 3) {
                // 获取审批后的操作 存入到页面 json字符串
                $("body").append('<script type="text/html" id="approveJson">'+JSON.stringify(approve)+'</script>')
                // 清除定时任务
                clearInterval(_iIntervalID);
            }
        }, 50);
    }
})();
欢迎访问Greasy Fork镜像
