//#region

Namespace.register("U.MT");
//把数据库的时间戳转换成可读时间
//1、带一个参数  
//参数一：时间格式  
//   1、javascrpt 自带的时间格式 datetime类型 Sun Mar 04 2018 18:45:54 GMT+0800 (中国标准时间)
//   2、sqlserver 时间格式 /Date(1364812396843)/
//   3、mongodb 时间格式 2018/01/01 01:01:01
//   4、mysql 时间格式 2018-01-01 01:01:01
//   5、nodejs的json时间"2018-03-04T11:14:27.878Z"

//js转换mysql中datetime日期格式为00-00-00 00:00:00,转换后为：2016:11:23 09:09:09格式


//U.MT.formatDateToArray = function (UOD, UTF) {
//    var _UTP = typeof UOD == "string",
//        _ude = ["getFullYear", "getMonth", "getDate", "getHours", "getMinutes", "getSeconds"];
//    if (!UOD || !_UTP || (_UTP && UOD.indexOf("Date") > -1)) {
//        UOD = _UTP ? new Date(parseInt(UOD.match(/[0-9]+/g)[0])) : (UOD || new Date());
//        for (i = 0; i < _ude.length; i++) {
//            _ude[i] = UOD[_ude[i]]() + (i == 1 ? 1 : 0);
//            _ude[i] = i > 2 ? _ude[i].prefixInteger() : _ude[i];
//        }
//    } //返回时间
//    else if (_UTP) {
//        UOD = new Date(UOD); //获取当前的时间
//        _ude = U.MT.formatDateToArray(UOD, true);
//    } //mysql返回的时间


//    return (UTF ? _ude : _ude.slice(0, 3).join("-") + "  " + _ude.slice(3, 6).join(":")); //返回数据

//    ///Date(1364812396843)/
//    //2018/01/01 01:01:01
//    //2018-01-01 01:01:01
//}

//U.MT.formatDateToArray = function (UOD, UTF) {
//    try {
//        var _UTP = typeof UOD == "string",
//        _ude = ["getFullYear", "getMonth", "getDate", "getHours", "getMinutes", "getSeconds"];
//        if (!UOD || !_UTP || (_UTP && UOD.indexOf("Date") > -1)) {
//            UOD = _UTP ? new Date(parseInt(UOD.match(/[0-9]+/g)[0])) : (UOD || new Date());
//            for (i = 0; i < _ude.length; i++) {
//                _ude[i] = UOD[_ude[i]]() + (i == 1 ? 1 : 0);
//                _ude[i] = i > 2 ? _ude[i].prefixInteger() : _ude[i];
//            }
//        } //返回时间
//        else if (_UTP) {
//            UOD = new Date(UOD); //获取当前的时间
//            _ude = U.MT.formatDateToArray(UOD, true);
//        } //mysql返回的时间
//        return (UTF ? _ude : _ude.slice(0, 3).join("-") + "  " + _ude.slice(3, 6).join(":")); //返回数据
//    } catch (e) { return UOD; }
//}


//把2018/01/01 01:01:01转换为"2017-11-06 09:24:32"

//把2018-01-01 01:01:01时间转换为数组格式[2018,01,01,01,01,01]
//方便用户自己拼接不同格式的时间。
//参数一：时间格式  
//   1、javascrpt 自带的时间格式 datetime类型 Sun Mar 04 2018 18:45:54 GMT+0800 (中国标准时间)
//   2、sqlserver 时间格式 /Date(1364812396843)/
//   3、mongodb 时间格式 2018/01/01 01:01:01
//   4、mysql 时间格式 2018-01-01 01:01:01
//   5、nodejs的json时间"2018-03-04T11:14:27.878Z"
U.MT.formatDateToArray = function (date) {
    var _datearr = [];
    //javascript自带时间无需处理，并且不是string类型
    if (typeof date == "string") {
        if (date.indexOf("Date") > -1) { //sqlserver 格式处理
            date = new Date(parseInt(date.match(/[0-9]+/g)[0])); //正则会把2-4种时间格式转换为第一种格式. 2018/01/01 01:01:01 => 20180101010101
        }
        else {
            date = new Date(date);
        }
    }
    return [
            date.getFullYear(),
            date.getMonth() + 1, //月份加1
            date.getDate(),
            date.getHours(),
            date.getMinutes(),
            date.getSeconds()
    ];
}

//把数据库的时间戳转换成可读时间
//参数一：时间格式  
//   1、javascrpt 自带的时间格式 datetime类型 Sun Mar 04 2018 18:45:54 GMT+0800 (中国标准时间)
//   2、sqlserver 时间格式 /Date(1364812396843)/
//   3、mongodb 时间格式 2018/01/01 01:01:01
//   4、mysql 时间格式 2018-01-01 01:01:01
//   5、nodejs的json时间"2018-03-04T11:14:27.878Z"
//获取时间戳对应的可读事件 Array返回数组事件 string 返回年月日处理
//得到年月日,格式为：2018-01-01
U.MT.getYearMonthDay = function (date) {
    date = U.MTformatDateToArray(date); //把时间格式化为数组
    date = date.slice(0, 3).join("-"); //拼凑需要的格式
    return date;
}


//把数据库的时间戳转换成可读时间
//参数一：时间格式  
//   1、javascrpt 自带的时间格式 datetime类型 Sun Mar 04 2018 18:45:54 GMT+0800 (中国标准时间)
//   2、sqlserver 时间格式 /Date(1364812396843)/
//   3、mongodb 时间格式 2018/01/01 01:01:01
//   4、mysql 时间格式 2018-01-01 01:01:01
//   5、nodejs的json时间"2018-03-04T11:14:27.878Z"
//获取时间戳对应的可读事件 Array返回数组事件 string 返回年月日处理
//得到年月日,格式为：2018-01-01
U.MT.getHoursMinutesSecond = function (date) {
    date = U.MT.formatDateToArray(date, true); //把时间格式化为数组
    date = date.slice(3, 6).join(":"); //拼凑需要的格式
    return date;
}


//参数一：时间格式  
//   1、javascrpt 自带的时间格式 datetime类型 Sun Mar 04 2018 18:45:54 GMT+0800 (中国标准时间)
//   2、sqlserver 时间格式 /Date(1364812396843)/
//   3、mongodb 时间格式 2018/01/01 01:01:01
//   4、mysql 时间格式 2018-01-01 01:01:01
//   5、nodejs的json时间"2018-03-04T11:14:27.878Z"
U.MT.getFullTime = function (date) {
    date = U.MT.formatDateToArray(date, true); //把时间格式化为数组
    date = date.slice(0, 3).join("-") + "  " + date.slice(3, 6).join(":"); //拼凑需要的格式
    return date;
}

//
//判断现在时间和从前时间的间隔，精确到分钟,小时，天数.超过3天则返回 月日时分 超过1年则返回 年月日时分
//参数一：时间格式  
//   1、javascrpt 自带的时间格式 datetime类型 Sun Mar 04 2018 18:45:54 GMT+0800 (中国标准时间)
//   2、sqlserver 时间格式 /Date(1364812396843)/
//   3、mongodb 时间格式 2018/01/01 01:01:01
//   4、mysql 时间格式 2018-01-01 01:01:01
//   5、nodejs的json时间"2018-03-04T11:14:27.878Z"
//  让学生重写
U.MT.getDateInterval = function (date) {
    var _return,                                                                  //申明变量
        _nowTime = U.MT.formatDateToArray(new Date(), "Array"),                          //申明变量_nowTime 并赋值
        _pastTime = U.MT.formatDateToArray(date, "Array");                                  //申明变量_pastTime 并赋值
    if (_nowTime[0] == _pastTime[0]) {                                                       //当年份为同一年时候
        if (_nowTime[2] - _pastTime[2] < 3) {                                                  //判断是否是三天内发的
            if (_nowTime[2] == _pastTime[2]) {                                               //判断是否是同一天的
                if (_nowTime[3] == _pastTime[3]) {                                           //判断是否是同一小时的
                    _return = _nowTime[4] - _pastTime[4] + '分钟前';                           //是同一小时的 就给_return赋值
                } else {
                    _return = _nowTime[3] - _pastTime[3] + '小时前';                           //不是同一小时的 就给_return赋值
                }
            } else {
                _return = _nowTime[2] - _pastTime[2] + '天前';                                //不是同一天时的 就给_return赋值
            }
        } else {
            _return = _pastTime[1] + '月' + _pastTime[2] + '日' + _pastTime[3] + '点' + _pastTime[4] + '分';        //不是三天之内的 就给_return赋值
        }
    } else {
        _return = _pastTime[0] + '年' + _pastTime[1] + '月' + _pastTime[2] + '日' + _pastTime[3] + '点' + _pastTime[4] + '分'; //不是同一小年的 就给_return赋值
    }
    return _return;
}



//可读时间转化成标准时间类或者时间戳sqlserver 时间格式 /Date(1364812396843)/
//U.MT.toTimeStamp(UWE.birth_year + "-" + UWE.birth_month + "-" + UWE.birth_day, "-")
//把javascript时间统一为sqlserver的时间,即时间戳。
//第二个参数不要.Time stamp
U.MT.toTimeStamp = function (uod, utf) {
    var _timestamp;
    if (U.Ut.isString(uod)) {
        _timestamp = Date.parse(uod);           //如果不需要 转换获取时间戳
    }
    else if (U.Ut.isArray(uod)) {                       //判断参数一是不是数组
        _timestamp = Date.UTC(uod[0], uod[1] - 1 || 1, uod[2] || 1, uod[3] - 8 || 1, uod[4] || 1, uod[5] || 1);
    }                                                   //转换获取时间戳
    else if (U.Ut.isDate(uod) || !uod) {                //判断参数一是不是 日期 类型
        _timestamp = Date.parse(uod || new Date());     //转换获取时间戳
    }
    return "/Date(" + _timestamp + ")/";
}





//获取指定年月的天数,如果为2018年2月，则返回28天。
//参数一：
//   1、javascrpt 自带的时间格式 datetime类型 Sun Mar 04 2018 18:45:54 GMT+0800 (中国标准时间)
//   2、sqlserver 时间格式 /Date(1364812396843)/
//   3、mongodb 时间格式 2018/01/01 01:01:01
//   4、mysql 时间格式 2018-01-01 01:01:01
//   5、nodejs的json时间"2018-03-04T11:14:27.878Z"
U.MT.getDayOfMonth = function (date) {
    var _arrDate = U.MT.formatDateToArray(date);                                                     //把时间转换成数组形式
    if (_arrDate[1] == 2) {                                                                        //判断输入的月份是否是2月
        if (_arrDate[0] % 4 != 0 && _arrDate[0] % 100 == 0 && _arrDate[0] % 400 != 0 && _arrDate[0] % 3200 == 0) {
            //是的话判断其是否不是闰年
            return 28;                                                                  //不是就输出 28
        }
        return 29;                                                                              //是的话输出 29
    } else {
        if (_arrDate[2] == 4 || _arrDate[2] == 6 || _arrDate[2] == 9 || _arrDate[2] == 11) {
            //判断 月份 是不是 4 6 9 11 月
            return 30;  //是就输出30
        }
        return 31;  //不是就输出31
    }
}



//比较两个时间的大小，2015-10-10  > 2014-10-10  ..文件夹或者文件从数据库取出来后是升序，现在前端做降序，则会调用冒泡排序。这里是冒泡排序比较时间
//参数一：时间
//参数二：时间
//返回字符串，"true"或者"false"，如果时间一大于时间二，则为true，否则为false.相等返回euqal
//SizeComparison
U.MT.SizeComparison = function (date, date1) {
    var _date = U.MT.formatDateToArray(date),              //把时间处理成数组    并赋值
        _date1 = formatDateToArray(date1);
    for (var _i = 0; _i < _date.length; _i++) {      //循环时间
        if (_date[_i] > _date1[_i]) return true;          //判断数组中每一个元素的大小
        if (_date1[_i] > _date[_i]) return false;          //date 大就返回true date1 大就返回 false
    }
    return 'equal';                                 //如果一模一样 返回'equal'
}



//Lowercase to uppercase
//小写时间转大写时间
U.MT.LowerToUpper = function (date) {
    var _i, _j,
        _dateArr = "",
        _dateWord = "",
        _word = [["零", "一", "二", "三", "四", "五", "六", "七", "八", "九", "十"],
            ["", "十", "百", "千", "万", "亿", "兆"],
            ["年", "月", "日", "点", "分", "秒"]];
    !date ? date = new Date() : '';                                                                      //默认为当前时间
    date = U.MT.formatDateToArray(date);                                                                   //把时间转换成数组
    for (_i = 0; _i < date.length; _i++) {                                                            //遍历数组
        _dateArr = String(date[_i]);                                                                      //转换为字符串
        if (_i == 1) {                                                                               //当处理到年时
            for (_j = 0; _j < _dateArr.length; _j++) {                                                   //遍历字符串
                _dateWord += _word[0][_dateArr[_j]];                                                           //循环按照顺序大写
            }                                                                                       //写进_dateWord
        } else {                                                                                     //当处理其他时候
            if (Number(_dateArr) > 10) {                                                                   //判断时间是否大于十
                _dateWord += _word[0][_dateArr[0]] + _word[0][10] + (_dateArr[1] == '0' ? '' : _word[0][_dateArr[1]]); //大于十就在两个之间插个大写十
            } else {
                _dateWord += _word[0][_dateArr[0]];                                                           //就变大写
            }
        }
        _dateWord += _word[2][_i];                                                                          //加上单位('年')之类
    }
    return _dateWord;
}

/*-----------------------------------------------未使用的函数------------------------------------------*/
//js倒计处理
U.MT.DJS = (function () {
    var _UFN = function (UDE, UFN) {
        var _UTF = false,
         _UL = UDE.length - 1,
         i = _UL, _UCE = [1, 24, 60, 60];
        for (; i > -1; i--) {
            if (UDE[i] > 0) {
                UDE[i]--; if (i < _UL) {
                    UDE[i + 1] = _UCE[i + 1] - 1;
                } _UTF = !_UTF; break;
            }
        }
        (_UTF) && ((UFN) && (UFN(UDE)), setTimeout(U.M.apply(this, [[_UFN, [UDE, UFN]]]), 1000)); //回调计时
    }
    //设置时间
    return function (UTM, UFN) {
        var i, j, _UZ,
        _UKE = [60, 60, 24, 1],
        _ude = [],
        _UTS = ((new Date(UTM[0], UTM[1] - 1, UTM[2],
         UTM[3] || 0, UTM[4] || 0,
         UTM[5] || 0)) - (new Date())) / 1000;
        for (i = _UKE.length - 1; i >= 0; i--) {
            _UZ = _UTS;
            for (j = 0; j <= i; j++) {
                j == i ? _UZ %= _UKE[j] : _UZ /= _UKE[j];
            }
            _ude.push(parseInt(_UZ, 10));
        }
        _UFN(_ude, UFN); //获取倒计时的时间
    }
})();

//#endregion