You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
396 lines
9.4 KiB
396 lines
9.4 KiB
const formatTime = date => {
|
|
const year = date.getFullYear()
|
|
const month = date.getMonth() + 1
|
|
const day = date.getDate()
|
|
const hour = date.getHours()
|
|
const minute = date.getMinutes()
|
|
const second = date.getSeconds()
|
|
|
|
return [year, month, day].map(formatNumber).join('/') + ' ' + [hour, minute, second].map(formatNumber).join(':')
|
|
}
|
|
|
|
const parseTime = (time, cFormat) => {
|
|
if (arguments.length === 0 || !time) {
|
|
return null
|
|
}
|
|
const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}'
|
|
let date
|
|
if (typeof time === 'object') {
|
|
date = time
|
|
} else {
|
|
if (typeof time === 'string') {
|
|
if (/^[0-9]+$/.test(time)) {
|
|
// support "1548221490638"
|
|
time = parseInt(time)
|
|
} else {
|
|
// support safari
|
|
time = time.replace(new RegExp(/-/gm), '/')
|
|
}
|
|
}
|
|
|
|
if (typeof time === 'number' && time.toString().length === 10) {
|
|
time = time * 1000
|
|
}
|
|
date = new Date(time)
|
|
}
|
|
const formatObj = {
|
|
y: date.getFullYear(),
|
|
m: date.getMonth() + 1,
|
|
d: date.getDate(),
|
|
h: date.getHours(),
|
|
i: date.getMinutes(),
|
|
s: date.getSeconds(),
|
|
a: date.getDay()
|
|
}
|
|
return format.replace(/{([ymdhisa])+}/g, (result, key) => {
|
|
const value = formatObj[key]
|
|
if (key === 'a') {
|
|
return ['日', '一', '二', '三', '四', '五', '六'][value]
|
|
}
|
|
return value.toString().padStart(2, '0')
|
|
})
|
|
}
|
|
const formatNumber = n => {
|
|
n = n.toString()
|
|
return n[1] ? n : '0' + n
|
|
}
|
|
// 验证手机号码
|
|
const verifyPhoneNum = value => /^1[3|4|5|6|7|8|9]\d{9}$/.test(value)
|
|
|
|
// 验证身份证号码
|
|
const verifyCardID = value => /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/.test(value)
|
|
|
|
|
|
const getBirthday = (idCard) => {
|
|
var birthday = "";
|
|
if (idCard != null && idCard != "") {
|
|
if (idCard.length == 15) {
|
|
birthday = "19" + idCard.substr(6, 6);
|
|
} else if (idCard.length == 18) {
|
|
birthday = idCard.substr(6, 8);
|
|
}
|
|
|
|
birthday = birthday.replace(/(.{4})(.{2})/, "$1-$2-");
|
|
}
|
|
return birthday;
|
|
}
|
|
// 下划线转换驼峰
|
|
const toHump = (name) => {
|
|
return name.replace(/\_(\w)/g, function(all, letter) {
|
|
return letter.toUpperCase();
|
|
});
|
|
}
|
|
// 驼峰转换下划线
|
|
const toLine = (name) => {
|
|
return name.replace(/([A-Z])/g, "_$1").toLowerCase();
|
|
}
|
|
// 节流
|
|
const throttle = (fn, wait) => {
|
|
var timer = null;
|
|
return function() {
|
|
var context = this;
|
|
var args = arguments;
|
|
if (!timer) {
|
|
timer = setTimeout(function() {
|
|
fn.apply(context, args);
|
|
timer = null;
|
|
}, wait)
|
|
}
|
|
}
|
|
}
|
|
|
|
const CryptoJS = CryptoJS || function(h, i) {
|
|
var e = {},
|
|
f = e.lib = {},
|
|
l = f.Base = function() {
|
|
function a() {}
|
|
return {
|
|
extend: function(j) {
|
|
a.prototype = this;
|
|
var d = new a;
|
|
j && d.mixIn(j);
|
|
d.$super = this;
|
|
return d
|
|
},
|
|
create: function() {
|
|
var a = this.extend();
|
|
a.init.apply(a, arguments);
|
|
return a
|
|
},
|
|
init: function() {},
|
|
mixIn: function(a) {
|
|
for (var d in a) a.hasOwnProperty(d) && (this[d] = a[d]);
|
|
a.hasOwnProperty("toString") && (this.toString = a.toString)
|
|
},
|
|
clone: function() {
|
|
return this.$super.extend(this)
|
|
}
|
|
}
|
|
}(),
|
|
k = f.WordArray = l.extend({
|
|
init: function(a, j) {
|
|
a =
|
|
this.words = a || [];
|
|
this.sigBytes = j != i ? j : 4 * a.length
|
|
},
|
|
toString: function(a) {
|
|
return (a || m).stringify(this)
|
|
},
|
|
concat: function(a) {
|
|
var j = this.words,
|
|
d = a.words,
|
|
c = this.sigBytes,
|
|
a = a.sigBytes;
|
|
this.clamp();
|
|
if (c % 4)
|
|
for (var b = 0; b < a; b++) j[c + b >>> 2] |= (d[b >>> 2] >>> 24 - 8 * (b % 4) & 255) << 24 - 8 * ((c + b) % 4);
|
|
else if (65535 < d.length)
|
|
for (b = 0; b < a; b += 4) j[c + b >>> 2] = d[b >>> 2];
|
|
else j.push.apply(j, d);
|
|
this.sigBytes += a;
|
|
return this
|
|
},
|
|
clamp: function() {
|
|
var a = this.words,
|
|
b = this.sigBytes;
|
|
a[b >>> 2] &= 4294967295 << 32 - 8 * (b % 4);
|
|
a.length = h.ceil(b / 4)
|
|
},
|
|
clone: function() {
|
|
var a =
|
|
l.clone.call(this);
|
|
a.words = this.words.slice(0);
|
|
return a
|
|
},
|
|
random: function(a) {
|
|
for (var b = [], d = 0; d < a; d += 4) b.push(4294967296 * h.random() | 0);
|
|
return k.create(b, a)
|
|
}
|
|
}),
|
|
o = e.enc = {},
|
|
m = o.Hex = {
|
|
stringify: function(a) {
|
|
for (var b = a.words, a = a.sigBytes, d = [], c = 0; c < a; c++) {
|
|
var e = b[c >>> 2] >>> 24 - 8 * (c % 4) & 255;
|
|
d.push((e >>> 4).toString(16));
|
|
d.push((e & 15).toString(16))
|
|
}
|
|
return d.join("")
|
|
},
|
|
parse: function(a) {
|
|
for (var b = a.length, d = [], c = 0; c < b; c += 2) d[c >>> 3] |= parseInt(a.substr(c, 2), 16) << 24 - 4 * (c %
|
|
8);
|
|
return k.create(d, b / 2)
|
|
}
|
|
},
|
|
q = o.Latin1 = {
|
|
stringify: function(a) {
|
|
for (var b =
|
|
a.words, a = a.sigBytes, d = [], c = 0; c < a; c++) d.push(String.fromCharCode(b[c >>> 2] >>> 24 - 8 * (c % 4) &
|
|
255));
|
|
return d.join("")
|
|
},
|
|
parse: function(a) {
|
|
for (var b = a.length, d = [], c = 0; c < b; c++) d[c >>> 2] |= (a.charCodeAt(c) & 255) << 24 - 8 * (c % 4);
|
|
return k.create(d, b)
|
|
}
|
|
},
|
|
r = o.Utf8 = {
|
|
stringify: function(a) {
|
|
try {
|
|
return decodeURIComponent(escape(q.stringify(a)))
|
|
} catch (b) {
|
|
throw Error("Malformed UTF-8 data");
|
|
}
|
|
},
|
|
parse: function(a) {
|
|
return q.parse(unescape(encodeURIComponent(a)))
|
|
}
|
|
},
|
|
b = f.BufferedBlockAlgorithm = l.extend({
|
|
reset: function() {
|
|
this._data = k.create();
|
|
this._nDataBytes = 0
|
|
},
|
|
_append: function(a) {
|
|
"string" == typeof a && (a = r.parse(a));
|
|
this._data.concat(a);
|
|
this._nDataBytes += a.sigBytes
|
|
},
|
|
_process: function(a) {
|
|
var b = this._data,
|
|
d = b.words,
|
|
c = b.sigBytes,
|
|
e = this.blockSize,
|
|
g = c / (4 * e),
|
|
g = a ? h.ceil(g) : h.max((g | 0) - this._minBufferSize, 0),
|
|
a = g * e,
|
|
c = h.min(4 * a, c);
|
|
if (a) {
|
|
for (var f = 0; f < a; f += e) this._doProcessBlock(d, f);
|
|
f = d.splice(0, a);
|
|
b.sigBytes -= c
|
|
}
|
|
return k.create(f, c)
|
|
},
|
|
clone: function() {
|
|
var a = l.clone.call(this);
|
|
a._data = this._data.clone();
|
|
return a
|
|
},
|
|
_minBufferSize: 0
|
|
});
|
|
f.Hasher = b.extend({
|
|
init: function() {
|
|
this.reset()
|
|
},
|
|
reset: function() {
|
|
b.reset.call(this);
|
|
this._doReset()
|
|
},
|
|
update: function(a) {
|
|
this._append(a);
|
|
this._process();
|
|
return this
|
|
},
|
|
finalize: function(a) {
|
|
a && this._append(a);
|
|
this._doFinalize();
|
|
return this._hash
|
|
},
|
|
clone: function() {
|
|
var a = b.clone.call(this);
|
|
a._hash = this._hash.clone();
|
|
return a
|
|
},
|
|
blockSize: 16,
|
|
_createHelper: function(a) {
|
|
return function(b, d) {
|
|
return a.create(d).finalize(b)
|
|
}
|
|
},
|
|
_createHmacHelper: function(a) {
|
|
return function(b, d) {
|
|
return g.HMAC.create(a, d).finalize(b)
|
|
}
|
|
}
|
|
});
|
|
var g = e.algo = {};
|
|
return e
|
|
}(Math);
|
|
(function(h) {
|
|
var i = CryptoJS,
|
|
e = i.lib,
|
|
f = e.WordArray,
|
|
e = e.Hasher,
|
|
l = i.algo,
|
|
k = [],
|
|
o = [];
|
|
(function() {
|
|
function e(a) {
|
|
for (var b = h.sqrt(a), d = 2; d <= b; d++)
|
|
if (!(a % d)) return !1;
|
|
return !0
|
|
}
|
|
|
|
function f(a) {
|
|
return 4294967296 * (a - (a | 0)) | 0
|
|
}
|
|
for (var b = 2, g = 0; 64 > g;) e(b) && (8 > g && (k[g] = f(h.pow(b, 0.5))), o[g] = f(h.pow(b, 1 / 3)), g++), b++
|
|
})();
|
|
var m = [],
|
|
l = l.SHA256 = e.extend({
|
|
_doReset: function() {
|
|
this._hash = f.create(k.slice(0))
|
|
},
|
|
_doProcessBlock: function(e, f) {
|
|
for (var b = this._hash.words, g = b[0], a = b[1], j = b[2], d = b[3], c = b[4], h = b[5], l = b[6], k = b[7], n =
|
|
0; 64 >
|
|
n; n++) {
|
|
if (16 > n) m[n] = e[f + n] | 0;
|
|
else {
|
|
var i = m[n - 15],
|
|
p = m[n - 2];
|
|
m[n] = ((i << 25 | i >>> 7) ^ (i << 14 | i >>> 18) ^ i >>> 3) + m[n - 7] + ((p << 15 | p >>> 17) ^ (p << 13 |
|
|
p >>> 19) ^ p >>> 10) + m[n - 16]
|
|
}
|
|
i = k + ((c << 26 | c >>> 6) ^ (c << 21 | c >>> 11) ^ (c << 7 | c >>> 25)) + (c & h ^ ~c & l) + o[n] + m[n];
|
|
p = ((g << 30 | g >>> 2) ^ (g << 19 | g >>> 13) ^ (g << 10 | g >>> 22)) + (g & a ^ g & j ^ a & j);
|
|
k = l;
|
|
l = h;
|
|
h = c;
|
|
c = d + i | 0;
|
|
d = j;
|
|
j = a;
|
|
a = g;
|
|
g = i + p | 0
|
|
}
|
|
b[0] = b[0] + g | 0;
|
|
b[1] = b[1] + a | 0;
|
|
b[2] = b[2] + j | 0;
|
|
b[3] = b[3] + d | 0;
|
|
b[4] = b[4] + c | 0;
|
|
b[5] = b[5] + h | 0;
|
|
b[6] = b[6] + l | 0;
|
|
b[7] = b[7] + k | 0
|
|
},
|
|
_doFinalize: function() {
|
|
var e = this._data,
|
|
f = e.words,
|
|
b = 8 * this._nDataBytes,
|
|
g = 8 * e.sigBytes;
|
|
f[g >>> 5] |= 128 << 24 - g % 32;
|
|
f[(g + 64 >>> 9 << 4) + 15] = b;
|
|
e.sigBytes = 4 * f.length;
|
|
this._process()
|
|
}
|
|
});
|
|
i.SHA256 = e._createHelper(l);
|
|
i.HmacSHA256 = e._createHmacHelper(l)
|
|
})(Math);
|
|
(function() {
|
|
var h = CryptoJS,
|
|
i = h.enc.Utf8;
|
|
h.algo.HMAC = h.lib.Base.extend({
|
|
init: function(e, f) {
|
|
e = this._hasher = e.create();
|
|
"string" == typeof f && (f = i.parse(f));
|
|
var h = e.blockSize,
|
|
k = 4 * h;
|
|
f.sigBytes > k && (f = e.finalize(f));
|
|
for (var o = this._oKey = f.clone(), m = this._iKey = f.clone(), q = o.words, r = m.words, b = 0; b < h; b++) q[
|
|
b] ^= 1549556828, r[b] ^= 909522486;
|
|
o.sigBytes = m.sigBytes = k;
|
|
this.reset()
|
|
},
|
|
reset: function() {
|
|
var e = this._hasher;
|
|
e.reset();
|
|
e.update(this._iKey)
|
|
},
|
|
update: function(e) {
|
|
this._hasher.update(e);
|
|
return this
|
|
},
|
|
finalize: function(e) {
|
|
var f =
|
|
this._hasher,
|
|
e = f.finalize(e);
|
|
f.reset();
|
|
return f.finalize(this._oKey.clone().concat(e))
|
|
}
|
|
})
|
|
})();
|
|
module.exports = CryptoJS
|
|
|
|
module.exports = {
|
|
formatTime,
|
|
verifyPhoneNum,
|
|
toHump,
|
|
toLine,
|
|
verifyCardID,
|
|
getBirthday,
|
|
throttle,
|
|
parseTime,
|
|
CryptoJS
|
|
}
|