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.
558 lines
15 KiB
558 lines
15 KiB
|
|
// import ICINLocker from "./ICINPakage/ICINLocker"
|
|
// const WXAPI = require('./request')
|
|
// import moment from "./moment"
|
|
// var bleall = require('./bleall');
|
|
// import {
|
|
// BLE
|
|
// } from "./btls/ble";
|
|
const app = getApp();
|
|
// const emitter = app.globalData.emitter
|
|
|
|
function 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(':')
|
|
}
|
|
|
|
function formatNumber(n) {
|
|
n = n.toString()
|
|
return n[1] ? n : '0' + n
|
|
}
|
|
|
|
|
|
|
|
function uint8ArrayToString(fileData) {
|
|
let dataString = "";
|
|
for (let i = 0; i < fileData.length; i++) {
|
|
dataString += String.fromCharCode(fileData[i]);
|
|
}
|
|
return dataString
|
|
}
|
|
function stringToUint8Array(string) {
|
|
// if (options.stream) {
|
|
// throw new Error(`Failed to encode: the 'stream' option is unsupported.`);
|
|
// }
|
|
let pos = 0;
|
|
const len = string.length;
|
|
const out = [];
|
|
let at = 0; // output position
|
|
let tlen = Math.max(32, len + (len >> 1) + 7); // 1.5x size
|
|
let target = new Uint8Array((tlen >> 3) << 3); // ... but at 8 byte offset
|
|
while (pos < len) {
|
|
let value = string.charCodeAt(pos++);
|
|
if (value >= 0xd800 && value <= 0xdbff) {
|
|
// high surrogate
|
|
if (pos < len) {
|
|
const extra = string.charCodeAt(pos);
|
|
if ((extra & 0xfc00) === 0xdc00) {
|
|
++pos;
|
|
value = ((value & 0x3ff) << 10) + (extra & 0x3ff) + 0x10000;
|
|
}
|
|
}
|
|
if (value >= 0xd800 && value <= 0xdbff) {
|
|
continue; // drop lone surrogate
|
|
}
|
|
}
|
|
// expand the buffer if we couldn't write 4 bytes
|
|
if (at + 4 > target.length) {
|
|
tlen += 8; // minimum extra
|
|
tlen *= (1.0 + (pos / string.length) * 2); // take 2x the remaining
|
|
tlen = (tlen >> 3) << 3; // 8 byte offset
|
|
const update = new Uint8Array(tlen);
|
|
update.set(target);
|
|
target = update;
|
|
}
|
|
if ((value & 0xffffff80) === 0) { // 1-byte
|
|
target[at++] = value; // ASCII
|
|
continue;
|
|
} else if ((value & 0xfffff800) === 0) { // 2-byte
|
|
target[at++] = ((value >> 6) & 0x1f) | 0xc0;
|
|
} else if ((value & 0xffff0000) === 0) { // 3-byte
|
|
target[at++] = ((value >> 12) & 0x0f) | 0xe0;
|
|
target[at++] = ((value >> 6) & 0x3f) | 0x80;
|
|
} else if ((value & 0xffe00000) === 0) { // 4-byte
|
|
target[at++] = ((value >> 18) & 0x07) | 0xf0;
|
|
target[at++] = ((value >> 12) & 0x3f) | 0x80;
|
|
target[at++] = ((value >> 6) & 0x3f) | 0x80;
|
|
} else {
|
|
continue;
|
|
}
|
|
target[at++] = (value & 0x3f) | 0x80;
|
|
}
|
|
return target.subarray(0, at);;
|
|
}
|
|
// function stringToUint8Array(str) {
|
|
// let arr = [];
|
|
// for (let i = 0, j = str.length; i < j; ++i) {
|
|
// arr.push(str.charCodeAt(i));
|
|
// }
|
|
// let tmpUint8Array = new Uint8Array(arr);
|
|
// return tmpUint8Array
|
|
// }
|
|
// function strToBinary(str){
|
|
// var result = [];
|
|
// var list = str.split("");
|
|
// for(var i=0;i<list.length;i++){
|
|
// if(i != 0){
|
|
// result.push(" ");
|
|
// }
|
|
// var item = list[i];
|
|
// var binaryStr = item.charCodeAt().toString(2);
|
|
// result.push(binartStr);
|
|
// }
|
|
// return result.join("");
|
|
// }
|
|
|
|
function stringToBytesWithPadding(str, length, padding) {
|
|
//try {
|
|
// 使用指定的字符集将此字符串编码为byte序列并存到一个byte数组中
|
|
var len = str.length;
|
|
// var bb = str.charCodeAt();
|
|
let bb = [];
|
|
for (let i = 0, j = str.length; i < j; ++i) {
|
|
bb.push(str[i].charCodeAt());
|
|
}
|
|
console.log(bb, 'bb')
|
|
var bytes = new Array(length);
|
|
for (var i = 0; i < length; i++) {
|
|
if (i < len)
|
|
bytes[i] = bb[i];
|
|
else
|
|
bytes[i] = padding;
|
|
}
|
|
return bytes;
|
|
}
|
|
|
|
|
|
function stringToUint8ArrayWithPadding(str, length, padding) {
|
|
let arr = [];
|
|
for (let i = 0, j = str.length; i < j; ++i) {
|
|
arr.push(str.charCodeAt(i));
|
|
}
|
|
|
|
for (let i = str.length; i < length; i++) {
|
|
arr.push(padding);
|
|
}
|
|
|
|
let tmpUint8Array = new Uint8Array(arr);
|
|
return tmpUint8Array
|
|
}
|
|
|
|
|
|
// 进制转换
|
|
function dec2hex(str) {
|
|
var dec = str.toString().split(""),
|
|
sum = [],
|
|
hex = [],
|
|
i,
|
|
s;
|
|
while (dec.length) {
|
|
s = 1 * dec.shift();
|
|
for (i = 0; s || i < sum.length; i++) {
|
|
s += (sum[i] || 0) * 10;
|
|
sum[i] = s % 16;
|
|
s = (s - sum[i]) / 16;
|
|
}
|
|
}
|
|
while (sum.length) {
|
|
hex.push(sum.pop().toString(16));
|
|
}
|
|
return hex.join("");
|
|
}
|
|
|
|
|
|
// 微信官方给的ArrayBuffer转十六进制示例
|
|
function ab2hex(buffer) {
|
|
let hexArr = Array.prototype.map.call(
|
|
new Uint8Array(buffer),
|
|
function (bit) {
|
|
return ('00' + bit.toString(16)).slice(-2)
|
|
}
|
|
)
|
|
return hexArr.join(',');
|
|
}
|
|
|
|
//转成可展会的文字
|
|
function hexCharCodeToStr(hexCharCodeStr) {
|
|
let trimedStr = hexCharCodeStr.trim();
|
|
let rawStr = trimedStr.substr(0, 2).toLowerCase() === '0x' ? trimedStr.substr(2) : trimedStr;
|
|
let len = rawStr.length;
|
|
let curCharCode;
|
|
let resultStr = [];
|
|
for (let i = 0; i < len; i = i + 2) {
|
|
curCharCode = parseInt(rawStr.substr(i, 2), 16);
|
|
resultStr.push(String.fromCharCode(curCharCode));
|
|
}
|
|
return resultStr.join('');
|
|
}
|
|
|
|
//转换成需要的格式
|
|
function buf2string(buffer) {
|
|
let arr = Array.prototype.map.call(new Uint8Array(buffer), x => x)
|
|
|
|
return arr.map((char, i) => {
|
|
return String.fromCharCode(char);
|
|
}).join('');
|
|
}
|
|
|
|
function decodeHexNibble(c) {
|
|
if (c >= 48 && c <= 57) {
|
|
return c - 48;
|
|
} else if (c >= 65 && c <= 70) {
|
|
return c - 65 + 10;
|
|
} else {
|
|
return c >= 97 && c <= 102 ? c - 97 + 10 : -1;
|
|
}
|
|
}
|
|
|
|
function decodeHexByte(s, pos) {
|
|
let hi = decodeHexNibble(s.charCodeAt(pos));
|
|
let lo = decodeHexNibble(s.charCodeAt(pos + 1));
|
|
return ((hi << 4) + lo);
|
|
}
|
|
|
|
function hexStringToBytesWithPadding(str, byteLen, padding) {
|
|
let len = str.length
|
|
let length = 2 * byteLen
|
|
|
|
if (length >= len && (length & 1) == 0) {
|
|
if (length == 0) {
|
|
return [0];
|
|
} else {
|
|
let bytes = new Uint8Array(length >>> 1);
|
|
|
|
for (let i = 0; i < len; i += 2) {
|
|
bytes[i >>> 1] = decodeHexByte(str, i);
|
|
}
|
|
|
|
for (let i = 0; i < byteLen - len / 2; i++)
|
|
bytes[len / 2 + i] = padding;
|
|
|
|
return bytes;
|
|
}
|
|
} else
|
|
return [0];
|
|
}
|
|
|
|
|
|
function timeStringToBytes(timeStr, timeLen) {
|
|
let s = timeStr;
|
|
if (s.length < timeLen) {
|
|
let tmp = timeLen - s.length
|
|
for (let i = 0; i < tmp; i++)
|
|
s = "0" + s;
|
|
} else
|
|
s = timeStr.substr(s.length - timeLen, s.length);
|
|
|
|
let start = 0
|
|
let length = s.length
|
|
|
|
if (length >= 0 && (length & 1) == 0) {
|
|
if (length == 0) {
|
|
return new byte[0];
|
|
} else {
|
|
let bytes = new Uint8Array(length >>> 1);
|
|
|
|
for (let i = 0; i < length; i += 2) {
|
|
bytes[i >>> 1] = decodeHexByte(s, start + i);
|
|
}
|
|
|
|
return bytes;
|
|
}
|
|
} else
|
|
return [0];
|
|
}
|
|
|
|
function time40ToBytes(dt) {
|
|
|
|
var cs = dt.substring(0, 4) + "/" + dt.substring(4, 6) + "/" + dt.substring(6, 8) + " " + dt.substring(8, 10) + ":" + dt.substring(10, 12) + ":" + dt.substring(12, 14);
|
|
|
|
var milliTs = new Date(cs);
|
|
var milliTs1 = milliTs.getTime()
|
|
var secondTs = parseInt(milliTs1 / 1000)
|
|
|
|
console.log(cs, milliTs1)
|
|
|
|
console.log(secondTs)
|
|
|
|
let ts = secondTs.toString(16)
|
|
let t = timeStringToBytes(ts, 10)
|
|
|
|
console.log(t)
|
|
|
|
return t;
|
|
}
|
|
|
|
function strToBinary(str) {
|
|
var result = [];
|
|
var list = str.split("");
|
|
var binaryStr = ''
|
|
for (var i = 0; i < list.length; i++) {
|
|
if (i != 0) {
|
|
result.push(" ");
|
|
}
|
|
var item = list[i];
|
|
binaryStr = item.charCodeAt().toString(2);
|
|
result.push(binaryStr);
|
|
}
|
|
return result.join("");
|
|
}
|
|
|
|
|
|
//当前时间戳
|
|
function gettimestamp() {
|
|
var timestamp = Date.parse(new Date());
|
|
return timestamp / 1000
|
|
}
|
|
|
|
function gettimestamp1() {
|
|
var timestamp = new Date().getTime()
|
|
return timestamp
|
|
}
|
|
//随机生成N位数字(0到9) 获取随机数
|
|
function getRandomNumber(n) {
|
|
var arr = new Array(n); //用于存放随机数
|
|
var randomNumber = ''; //存放随机数
|
|
for (i = 0; i < arr.length; i++)
|
|
arr[i] = parseInt(Math.random() * 10);
|
|
var flag = 0;
|
|
for (i = 0; i < arr.length - 1; i++) {
|
|
for (j = i + 1; j < arr.length; j++) {
|
|
if (arr[i] == arr[j]) {
|
|
flag = 1;
|
|
break;
|
|
}
|
|
}
|
|
if (flag) break;
|
|
}
|
|
for (var i = 0; i < arr.length; i++) {
|
|
randomNumber += arr[i];
|
|
}
|
|
return randomNumber;
|
|
}
|
|
|
|
// 去重
|
|
function uniqueArray(array, key) {
|
|
var result = [array[0]];
|
|
for (var i = 1; i < array.length; i++) {
|
|
var item = array[i];
|
|
var repeat = false;
|
|
for (var j = 0; j < result.length; j++) {
|
|
if (item[key] == result[j][key]) {
|
|
repeat = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!repeat) {
|
|
result.push(item);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
|
|
// 树形数据转化
|
|
function ztreeToElementTree(data, config) {
|
|
var id = config.id || 'id' // 定义ztree数据存储id（自身的id）的key值，可以自定义但一般都是id、pid这种
|
|
var pid = config.pid || 'pid' // 定义ztree数据存储pid（父id）的key值
|
|
var children = config.children || 'children' // 定义生成的element tree存储子节点的key，可以在element中规定defaultProps: {children: 'children'}
|
|
var idMap = {} // 将原始数据转化为以id为key的map
|
|
var elementTree = [] // 输出的element tree数据
|
|
data.forEach(item => {
|
|
idMap[item.id] = item
|
|
})
|
|
data.forEach(item => {
|
|
// debugger
|
|
if (idMap[item.pid] != idMap[item.id] && idMap[item.pid]) { // 该item项有爸爸，放到对应的父节点下
|
|
!idMap[item.pid].hasOwnProperty(children) && (idMap[item.pid][children] = [])
|
|
idMap[item.pid][children].push(item)
|
|
} else { // 根节点
|
|
elementTree.push(item)
|
|
}
|
|
});
|
|
return elementTree
|
|
}
|
|
/* 部分隐藏处理
|
|
** str 需要处理的字符串
|
|
** frontLen 保留的前几位
|
|
** endLen 保留的后几位
|
|
** cha 替换的字符串
|
|
*/
|
|
function plusXing(str, frontLen, endLen, cha) {
|
|
let content = str.toString()
|
|
var len = content.length - frontLen - endLen;
|
|
var xing = '';
|
|
for (var i = 0; i < len; i++) {
|
|
xing += cha;
|
|
}
|
|
return content.substring(0, frontLen) + xing + content.substring(content.length - endLen);
|
|
};
|
|
function IntToBytesLittleEndian(number, length){
|
|
var bytes = [];
|
|
var i = 0;
|
|
do {
|
|
bytes[i++] = number & (255);
|
|
number = number>>8;
|
|
} while ( i < length )
|
|
return bytes;
|
|
// var bytes = [];
|
|
// var i = length;
|
|
// do {
|
|
// bytes[--i] = number & (255);
|
|
// number = number>>8;
|
|
// } while (i)
|
|
// return bytes;
|
|
}
|
|
|
|
function BytesToIntBigEndian(bytes){
|
|
var val = 0;
|
|
for (var i = bytes.length - 1; i >= 0; i--) {
|
|
val += bytes[i];
|
|
if (i != 0) {
|
|
val = val << 8;
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
function dec2hex1(str) {
|
|
var dec = str.toString().split(""),
|
|
sum = [],
|
|
hex = [],
|
|
i,
|
|
s;
|
|
while (dec.length) {
|
|
s = 1 * dec.shift();
|
|
for (i = 0; s || i < sum.length; i++) {
|
|
s += (sum[i] || 0) * 10;
|
|
sum[i] = s % 16;
|
|
s = (s - sum[i]) / 16;
|
|
}
|
|
}
|
|
while (sum.length) {
|
|
hex.push(sum.pop().toString(16));
|
|
}
|
|
var card = hex.join("")
|
|
var zero = '00000000';
|
|
var tmp = 8 - card.length;
|
|
var clength = zero.substring(0, tmp) + card
|
|
return clength;
|
|
}
|
|
/*函数节流*/
|
|
function throttle(fn, interval) {
|
|
var enterTime = 0;//触发的时间
|
|
var gapTime = interval || 300 ;//间隔时间，如果interval不传，则默认300ms
|
|
return function() {
|
|
var context = this;
|
|
var backTime = new Date();//第一次函数return即触发的时间
|
|
if (backTime - enterTime > gapTime) {
|
|
fn.call(context,arguments);
|
|
enterTime = backTime;//赋值给第一次触发的时间，这样就保存了第二次触发的时间
|
|
}
|
|
};
|
|
}
|
|
|
|
/*函数防抖*/
|
|
function debounce(fn, interval) {
|
|
var timer;
|
|
var gapTime = interval || 1000;//间隔时间，如果interval不传，则默认1000ms
|
|
return function() {
|
|
clearTimeout(timer);
|
|
var context = this;
|
|
var args = arguments;//保存此处的arguments，因为setTimeout是全局的，arguments不是防抖函数需要的。
|
|
timer = setTimeout(function() {
|
|
fn.call(context,args);
|
|
}, gapTime);
|
|
};
|
|
}
|
|
function findIndexArray(data,id,indexArray){
|
|
let arr = Array.from(indexArray);
|
|
for(let i=0,len=data.length;i<len;i++){
|
|
arr.push(data[i].name);
|
|
if(data[i].id===id){
|
|
return arr
|
|
}
|
|
let children=data[i].children;
|
|
if(children&&children.length){
|
|
let result=this.findIndexArray(children,id,arr);
|
|
if(result) return result
|
|
}
|
|
arr.pop()
|
|
}
|
|
return false
|
|
}
|
|
var pako = require('pako');
|
|
var CryptoJS = require("crypto-js");
|
|
var md5 = require("md5");
|
|
function decrypt(word, keyStr) {
|
|
let key = CryptoJS.enc.Utf8.parse(keyStr);
|
|
let decrypt = CryptoJS.AES.decrypt(word, key, {
|
|
mode: CryptoJS.mode.ECB,
|
|
padding: CryptoJS.pad.Pkcs7
|
|
});
|
|
return CryptoJS.enc.Utf8.stringify(decrypt).toString()
|
|
}
|
|
function zlib_unzip(info) {
|
|
var key=md5(String(info.currentTime)+"mdmdmdmdmdvsololololol")
|
|
let b = info.list.split(',').map(function(x) {
|
|
return parseInt(x);
|
|
});
|
|
let c = pako.inflate(b, {
|
|
to: "string"
|
|
});
|
|
let e = decrypt(c,key)
|
|
return JSON.parse(e)
|
|
}
|
|
|
|
function searchParaProcess(obj) {
|
|
var myObj = new Object();
|
|
for (var key in obj) {
|
|
if (obj[key] != "" && obj[key] != 'Invalid date' && obj[key] != null) {
|
|
myObj[key] = obj[key]
|
|
}
|
|
}
|
|
return JSON.stringify(myObj);
|
|
}
|
|
|
|
module.exports = {
|
|
// bluetoothUnlocking,
|
|
// bluetoothConnectivity,
|
|
// bluetoothOperation_ZH,
|
|
decrypt,
|
|
searchParaProcess,
|
|
zlib_unzip,
|
|
findIndexArray,
|
|
throttle,
|
|
debounce,
|
|
IntToBytesLittleEndian,
|
|
BytesToIntBigEndian,
|
|
dec2hex,
|
|
dec2hex1,
|
|
plusXing,
|
|
ztreeToElementTree,
|
|
formatTime: formatTime,
|
|
uint8ArrayToString: uint8ArrayToString,
|
|
stringToUint8Array: stringToUint8Array,
|
|
stringToUint8ArrayWithPadding: stringToUint8ArrayWithPadding,
|
|
ab2hex: ab2hex,
|
|
hexCharCodeToStr,
|
|
hexCharCodeToStr: buf2string,
|
|
decodeHexNibble,
|
|
decodeHexNibble: decodeHexByte,
|
|
hexStringToBytesWithPadding: hexStringToBytesWithPadding,
|
|
timeStringToBytes: timeStringToBytes,
|
|
time40ToBytes: time40ToBytes,
|
|
gettimestamp,
|
|
gettimestamp1,
|
|
getRandomNumber,
|
|
uniqueArray,
|
|
strToBinary,
|
|
stringToBytesWithPadding
|
|
}
|