@k3000/s1 0.1.0

package/common/tools.mjs

@@ -0,0 +1,314 @@
+import {Cipher} from "tools2";
+import {jwtLifetime, jwtSalt} from "./config.mjs";
+import {readdirSync, statSync} from "node:fs";
+
+/**
+ * 生成固定格式数据
+ * @param {Object | String} result
+ * @param {Number} [code]
+ * @return {Buffer}
+ */
+export const toResultBuffer = (result, code) => Buffer.from(JSON.stringify({
+    code,
+    data: code ? undefined : result,
+    error: code ? result : undefined,
+}))
+
+export const obj2buf = obj => Buffer.from(JSON.stringify(obj))
+
+const cipher = new Cipher
+
+const toBase64 = json => Buffer.from(JSON.stringify(json)).toString('base64').replace(/=/g, '')
+
+const fromBase64 = base64 => {
+
+    try {
+
+        const result = Buffer.from(base64, 'base64').toString()
+
+        return result.startsWith('"') ? result.substring(1, result.length - 1) : result
+
+    } catch (e) {
+
+        return ''
+    }
+}
+
+export const toJWT = (json, sub = 'user info') => {
+
+    const header = toBase64({
+        alg: 'MD5',
+        typ: 'JWT'
+    })
+
+    json.sub = sub
+    json.exp = Date.now() + jwtLifetime
+
+    const payload = toBase64(json)
+
+    const signature = toBase64(cipher.md5(`${header}.${payload}.${jwtSalt}`))
+
+    return `${header}.${payload}.${signature}`
+}
+
+export const fromJWT = (jwt, exp = true) => {
+
+    const [header, payload, signature] = jwt.split('.')
+
+    if (cipher.md5(`${header}.${payload}.${jwtSalt}`) !== fromBase64(signature)) return null
+
+    const json = JSON.parse(fromBase64(payload))
+
+    if (exp && Date.now() > json.exp) return null
+
+    return json
+}
+
+export const MD5 = string => cipher.md5(string)
+
+export const buildDeptTree = (deptList, pid = 0) => deptList.filter(dept => dept.parentId === pid).map(dept => {
+
+    const d = {
+        id: dept.deptId,
+        label: dept.deptName,
+    }
+
+    const children = buildDeptTree(deptList, dept.deptId)
+
+    if (children.length > 0) {
+
+        d.children = children
+    }
+
+    return d
+})
+
+export const buildMenu = (menus, pid = 0) => {
+
+    menus = menus.filter(menu => menu.parentId === pid && ['M', 'C'].includes(menu.menuType))
+        .map(menu => ({
+            name: menu.path ? menu.path[0].toUpperCase() + menu.path.substring(1) : null,
+            path: menu.isFrame === 1 && pid === 0 ? '/' + menu.path : menu.path,
+            hidden: menu.visible === '1',
+            meta: {
+                icon: menu.icon,
+                noCache: menu.isCache === 1,
+                title: menu.menuName,
+                link: menu.isFrame === 1 ? null : menu.path
+            },
+            children: buildMenu(menus, menu.menuId),
+            component: menu.component || (menu.parentId === 0 ? 'Layout' : 'ParentView'),
+            alwaysShow: menu.isFrame === 1 && menu.menuType === 'M' ? true : undefined,
+            redirect: menu.isFrame === 1 && menu.menuType === 'M' ? 'noRedirect' : undefined
+        }))
+
+    menus.forEach(menu => {
+
+        for (let [key, value] of Object.entries(menu)) {
+
+            if (value === undefined) {
+
+                delete menu[key]
+            }
+        }
+
+        if (menu.children.length === 0) {
+
+            delete menu.children
+        }
+    })
+
+    return menus
+}
+
+/**
+ * @param {Array} list
+ * @param {Object} query
+ * @param {String} timeKey
+ * @param {Boolean} all
+ * @returns {Object | Array}
+ */
+export const page = (list, query, timeKey = 'createTime', all = false) => {
+
+    const rows = list.filter(item => {
+
+        for (const [key, value] of Object.entries(query)) {
+
+            switch (typeof value) {
+
+                case "string":
+
+                    if (!Reflect.has(item, key)) continue
+                    if (!String(item[key]).includes(value)) return false
+
+                    break
+
+                case "object":
+
+                    if (Array.isArray(value)) {
+
+                        if (!Reflect.has(item, key)) continue
+                        if (!value.includes(item[key])) return false
+
+                    } else if (Reflect.has(value, 'beginTime')
+                        && (item[timeKey] < new Date(value.beginTime).getTime()
+                            || item[timeKey] > new Date(value.endTime + ' 23:59:59.999').getTime())
+                    ) return false
+
+                    break
+
+                case "boolean":
+                case "number":
+
+                    if (!Reflect.has(item, key)) continue
+                    if (value != item[key]) return false
+
+                    break
+            }
+        }
+
+        return true
+    })
+
+    if (all) return rows
+
+    if (query.orderByColumn) {
+
+        rows.sort((a, b) => query.isAsc === 'ascending'
+            ? a[query.orderByColumn] - b[query.orderByColumn]
+            : b[query.orderByColumn] - a[query.orderByColumn])
+    }
+
+    return {
+        code: 200,
+        rows: rows.slice((query.pageNum - 1) * query.pageSize, query.pageNum * query.pageSize),
+        total: rows.length
+    }
+}
+
+export class Pools extends Map {
+
+    #ping = '/ping'
+
+    constructor(...arg) {
+
+        super(...arg)
+
+        this.set(this.#ping, _ => Date.now())
+    }
+
+    /**
+     * @param {String} key
+     * @param {Function} value
+     * @returns {Map}
+     */
+    set(key, value) {
+
+        if (this.has(key)) console.warn(`\x1B[;33m\x1B[4m${key}\x1B[0m\x1B[;33m is already set\x1B[0m`)
+
+        if (typeof value === "function") return super.set(key, value)
+    }
+
+    /**
+     * @param {Promise<{readonly default?: Map<any, any>}>} other
+     */
+    append(other) {
+
+        Promise.resolve(other).then(result => {
+
+            if (!(result.default instanceof Map)) return
+
+            for (const [key, value] of result.default.entries()) {
+
+                if (key === this.#ping) continue
+
+                this.set(key, value)
+            }
+        })
+
+        return this
+    }
+}
+
+/**
+ * @param {Object} target
+ * @param {Object} source
+ */
+export const update = (target, source) => {
+
+    for (const [key, value] of Object.entries(source)) {
+
+        if (!Reflect.has(target, key)) continue
+
+        Reflect.set(target, key, value)
+    }
+}
+
+export const getFilePath = (absolute, suffix, relative = '', list = []) => {
+
+    for (const name of readdirSync(`${absolute}${relative}`)) {
+
+        const path = `${absolute}${relative}/${name}`
+        const stat = statSync(path)
+
+        if (stat.isDirectory()) {
+
+            getFilePath(absolute, suffix, `${relative}/${name}`, list)
+
+        } else if (name.endsWith(suffix)) {
+
+            list.push(path.substring(absolute.length + 1, path.length - suffix.length))
+        }
+    }
+
+    return list
+}
+
+/**
+ *
+ * @param {String} qValue
+ * @param {String | Array} aValue
+ * @return {Boolean}
+ */
+export const colIncludes = (qValue, aValue) => {
+
+    return !qValue || aValue.includes(qValue)
+}
+
+export const colEqual = (qValue, aValue) => {
+
+    return !qValue || aValue == qValue
+}
+
+/**
+ *
+ * @param {Object} params
+ * @param {Number} time
+ * @param {String} start
+ * @param {String} end
+ * @return {Boolean}
+ */
+export const colRange = (params, time, start = 'beginTime', end = 'endTime') => {
+
+    return !params || !params[start] || !params[end] || time >= new Date(params[start]).getTime()
+        && time <= new Date(params[end] + ' 23:59:59.999').getTime()
+}
+
+/**
+ *
+ * @param {Array} rows
+ * @param {Object | Number | String} index
+ * @param {Number | String} [size]
+ * @return {Array}
+ */
+export const rowSlice = (rows, index, size) => {
+
+    if (typeof index === "object" && Reflect.has(index, 'pageNum') && Reflect.has(index, 'pageSize')) {
+
+        size = index.pageSize
+        index = index.pageNum
+    }
+
+    return rows.slice((index - 1) * size, index * size)
+}
+