@k3000/s1 0.1.0

package/admin/base.mjs

@@ -0,0 +1,447 @@
+import {Base} from 'tools2/router.mjs'
+import {fromJWT} from "../common/tools.mjs";
+import {store1} from './service.mjs'
+import {adminLifetime} from "../common/config.mjs";
+
+export const NoActionParams = Symbol('NoActionParams')
+
+export class NoActionHandle extends String {
+
+    static is(target) {
+
+        if (!target) return false
+
+        return target instanceof NoActionHandle
+    }
+
+    constructor(...arg) {
+
+        super(...arg);
+    }
+}
+
+export class Admin extends Base {
+
+    pk = ''
+    set = ''
+    route = ''
+
+    static req = Symbol('req')
+    static res = Symbol('res')
+    static files = Symbol('files')
+    static params = Symbol('params')
+
+    /**
+     * @type {Array<{
+     *     token: String,
+     *     time: Date
+     * }>}
+     */
+    static #authPool = []
+
+    get path() {
+
+        return [this.route, this.route + '/:action'];
+    }
+
+    appendToken(token) {
+
+        const auth = Admin.#authPool.find(item => item.token === token)
+
+        const now = Date.now()
+
+        if (auth) {
+
+            auth.time = now
+
+        } else {
+
+            Admin.#authPool.push({
+                token,
+                time: now
+            })
+        }
+    }
+
+    updateToken(token) {
+
+        const index = Admin.#authPool.findIndex(item => item.token === token)
+
+        const auth = Admin.#authPool[index]
+
+        if (auth === undefined) return false
+
+        const now = Date.now()
+
+        if (now - auth.time > adminLifetime) {
+
+            Admin.#authPool.splice(index, 1)
+
+            return false
+        }
+
+        auth.time = now
+
+        return true
+    }
+
+    addCode200(data) {
+
+        Reflect.set(data, 'code', 200)
+
+        return data
+    }
+
+    /**
+     * @param {Object} data
+     * @param {{
+     *     req: Request,
+     *     res: Response,
+     *     time: Date,
+     *     ok: Boolean,
+     *     userInfo: Object
+     * }} extra
+     */
+    RES(data, extra) {
+
+        let msg
+
+        if (data instanceof Error) {
+
+            data = JSON.stringify({
+                code: 500,
+                msg: msg = data.message
+            })
+
+        } else if (typeof data === "object" && data !== null) {
+
+            if (Reflect.has(data, 'code')) {
+
+                data = JSON.stringify(data)
+
+            } else {
+
+                data = JSON.stringify({code: 200, data})
+            }
+
+        } else if (!extra.ok && typeof data === "string") {
+
+            data = JSON.stringify({
+                code: 500,
+                msg: msg = data
+            })
+        }
+
+        extra.ok = true
+
+        super.RES(data, extra)
+
+        const req = extra.req
+
+        if (req.method === 'GET') return
+
+        const log = {
+            title: this.constructor.name,
+            businessType: 0,
+            method: '响应',
+            requestMethod: req.method,
+            operatorType: 1,
+            operName: extra.userInfo?.userName,
+            operUrl: req.url,
+            operIp: this.getClientIp(req),
+            operLocation: req.headers['origin'],
+            operParam: JSON.stringify(req.query),
+            jsonResult: data,
+            status: extra.ok ? 0 : 1,
+            errorMsg: msg,
+            operTime: extra.time,
+            costTime: new Date() - extra.time
+        }
+
+        if (extra.userInfo) return store1.getDeptNameById(extra.userInfo.deptId)
+            .then(res => {
+                log.deptName = res.toString()
+                store1.log(log)
+            })
+            .catch(_ => store1.log(log))
+
+        store1.log(log)
+    }
+
+    call(data, extra) {
+
+        const req = extra.req
+
+        if (!Reflect.has(req.params, 'action') || req.params.action === undefined) return NoActionParams
+
+        if (typeof this[req.params.action] !== "function") return new NoActionHandle(req.params.action)
+
+        return this[req.params.action](data, extra)
+    }
+
+    getClientIp(req) {
+
+        return req.headers['x-forwarded-for'] ||
+            req.ip ||
+            req.connection.remoteAddress ||
+            req.socket.remoteAddress ||
+            req.connection.socket.remoteAddress ||
+            '';
+    }
+
+    /**
+     *
+     * @param {Object} query
+     * @param {String} timeKey
+     * @param {Boolean} all
+     */
+    page(query, timeKey = 'createTime', all = false) {
+
+        return store1.genericPage({
+            name: this.set,
+            query,
+            timeKey,
+            all,
+        })
+    }
+
+    /**
+     *
+     * @param {Object} target
+     * @param {Object} source
+     */
+    update(target, source) {
+
+        for (const [key, value] of Object.entries(source)) {
+
+            if (!Reflect.has(target, key)) continue
+
+            Reflect.set(target, key, value)
+        }
+    }
+
+    GET(data, extra) {
+
+        const value = this.call(data, extra)
+
+        if (value === NoActionParams || !NoActionHandle.is(value)) return value
+
+        return store1.genericFind({name: this.set, key: this.pk, value})
+    }
+
+    DELETE(data, extra) {
+
+        const values = this.call(data, extra)
+
+        if (values === NoActionParams || !NoActionHandle.is(values)) return values
+
+        return store1.genericRemove({name: this.set, key: this.pk, values})
+    }
+
+    POST(body, extra) {
+
+        const result = this.call(body, extra)
+
+        if (result !== NoActionParams) return result
+
+        body.createBy = body.userInfo.userName
+
+        return store1.genericPush({name: this.set, body})
+    }
+
+    PUT(body, extra) {
+
+        const result = this.call(body, extra)
+
+        if (result !== NoActionParams) return result
+
+        body.updateBy = body.userInfo.userName
+
+        return store1.genericUpdate({name: this.set, key: this.pk, body})
+    }
+
+    list(query) {
+
+        return this.page(query, undefined)
+    }
+
+    clean() {
+
+        return store1.genericClean(this.set)
+    }
+
+    changeStatus(body) {
+
+        return store1.genericFilter({name: this.set, key: this.pk, value: body[this.pk]})
+    }
+
+    /**
+     * @param {Array} list
+     * @param {String} name
+     */
+    export(list, name, extra) {
+
+        if (!Array.isArray(list)) {
+
+            let args = []
+
+            switch (this.list.length) {
+
+                case 3:
+                    // case 2:
+                    args.push(extra.req)
+                    args.push(extra.res)
+                case 1:
+                    args.push(true)
+            }
+
+            const data = this.list(...args)
+
+            list = [Object.keys(data.rows[0] || {})]
+
+            for (const row of data.rows) {
+
+                list.push(list[0].map(key => key.endsWith('Time')
+                    ? (new Date(row[key])).format('yyyy/MM/dd HH:mm:ss') : row[key]))
+            }
+        }
+
+        const workbook = new Excel.Workbook();
+
+        workbook.creator = extra.req.cookies.username;
+        workbook.created = new Date()
+
+        const sheet = workbook.addWorksheet(typeof name === "string" ? name : 'Sheet1');
+
+        for (let r = 0; r < list.length; r++) {
+
+            const arr = list[r]
+
+            if (!Array.isArray(arr)) continue
+
+            for (let c = 0; c < arr.length; c++) {
+
+                const cell = sheet.getCell(r + 1, c + 1)
+
+                cell.value = arr[c]
+            }
+        }
+
+        workbook.xlsx.writeBuffer().then(buffer => extra.res.end(buffer))
+    }
+}
+
+export class AdminAuth extends Admin {
+
+    AUTH(req, res, next) {
+
+        if (Reflect.has(req.headers, 'authorization') && req.headers.authorization.startsWith('Bearer ')) {
+
+            return next()
+        }
+
+        res.status(401)
+        res.end()
+    }
+
+    REQ(extra) {
+
+        const token = extra.req.headers.authorization.substring(7)
+
+        const userInfo = fromJWT(token)
+
+        if (!userInfo) return Promise.reject({code: 401, msg: '请登录'})
+
+        if (this.updateToken(token) === false) return Promise.reject({code: 401, msg: '请登录'})
+
+        return Promise.resolve(super.REQ(extra)).then(extra => Object.defineProperty(extra, 'userInfo', {
+            value: userInfo,
+            enumerable: false
+        }))
+    }
+}
+
+const permsMap = {
+    GET: 'query',
+    POST: 'add',
+    PUT: 'edit',
+    DELETE: 'remove',
+}
+
+export class AdminAuthPerm extends AdminAuth {
+
+    #perms = ''
+    verify = undefined
+    except = []
+
+    getPerms() {
+
+        if (this.verify !== undefined && !Array.isArray(this.verify)) {
+
+            this.verify = [this.verify]
+        }
+
+        if (!Array.isArray(this.except)) {
+
+            this.except = [this.except]
+        }
+
+        const perms = {
+            verify: this.verify,
+            except: this.except,
+        }
+
+        let route = this.route.split('/').filter(line => line.length)
+
+        this.#perms = `${route[0]}:${route[1]}`
+
+        this.getPerms = () => perms
+
+        return perms
+    }
+
+    REQ(extra) {
+
+        return super.REQ(extra).then(data => store1.getPerms(data.userInfo.userId).then(perms => {
+
+            if (data.userInfo.perms !== perms) data.userInfo.perms = perms
+
+            if (perms.some(perms => perms === '*:*:*')) return data
+
+            const perm = this.getPerms()
+
+            let action = ''
+
+            const req = extra.req
+
+            if (req.params.action) {
+
+                if (typeof this[req.params.action] === "function") {
+
+                    action = req.params.action
+
+                } else if (['GET', 'PUT', 'DELETE'].includes(req.method)) {
+
+                    action = permsMap[req.method]
+                }
+
+            } else if (['GET', 'POST', 'PUT'].includes(req.method)) {
+
+                action = permsMap[req.method]
+            }
+
+            if (perm.except.includes(action)) return data
+
+            if (perm.verify !== undefined && !perm.verify.includes(action)) return data
+
+            if (!perms.some(p => p === `${this.#perms}:${action}`)) {
+
+                console.log(perm, req.method, action)
+
+                return Promise.reject('为获取到访问权限，请刷新重试')
+            }
+
+            return data
+        }))
+    }
+}

package/admin/index.mjs

@@ -0,0 +1,19 @@
+import {Express} from "tools2/router.mjs";
+import bodyParser from "body-parser";
+import fileUpload from "express-fileupload";
+import {adminServicePort} from "../common/config.mjs";
+import {resolve} from "node:path";
+
+const app = new Express({
+    port: adminServicePort,
+    callback: () => console.log('running on ' + adminServicePort),
+})
+
+app.use(fileUpload({createParentPath: true}));
+app.use(bodyParser.urlencoded({extended: true}));
+
+const prevDir = process.cwd()
+
+app.load(resolve(`${prevDir}/admin/monitor`))
+app.load(resolve(`${prevDir}/admin/system`))
+app.load(resolve(`${prevDir}/admin/tool`))

package/admin/monitor/job.mjs

@@ -0,0 +1,24 @@
+import {AdminAuthPerm} from "../base.mjs";
+import {store1} from "../service.mjs";
+
+export class Job extends AdminAuthPerm {
+
+    pk = 'jobId'
+    set = 'sysJob'
+    route = '/monitor/job'
+    except = ['run']
+
+    run(data, {req, res}) {
+
+        store1.genericFind({name: this.set, key: this.pk, value: data.jobId})
+            .then(job => {
+
+                job.status = 1
+                job.jobMessage = '执行失败'
+                job.exceptionInfo = '功能还未实现'
+
+                return store1.genericPush({name: this.set, body: job})
+
+            }).finally(_ => this.RES(new Error('功能未实现'), req, res))
+    }
+}

package/admin/monitor/jobLog.mjs

@@ -0,0 +1,8 @@
+import {AdminAuth} from "../base.mjs";
+
+export class JobLog extends AdminAuth {
+
+    pk = 'jobLogId'
+    set = 'sysJobLog'
+    route = '/monitor/jobLog'
+}

package/admin/monitor/logininfor.mjs

@@ -0,0 +1,23 @@
+import {AdminAuth, AdminAuthPerm} from "../base.mjs";
+import {store1} from "../service.mjs";
+
+export class Logininfor extends AdminAuthPerm {
+
+    pk = 'infoId'
+    set = 'sysLogininfor'
+    route = '/monitor/logininfor'
+    except = ['clean']
+}
+
+export class LogininforUnlock extends AdminAuth {
+
+    get path() {
+
+        return '/monitor/logininfor/unlock/:usn'
+    }
+
+    GET(data, {req}) {
+
+        return store1.LogininforUnlock(req.params.usn)
+    }
+}

package/admin/monitor/operlog.mjs

@@ -0,0 +1,9 @@
+import {AdminAuthPerm} from "../base.mjs";
+
+export class Operlog extends AdminAuthPerm {
+
+    pk = 'operId'
+    set = 'sysOperLog'
+    route = '/monitor/operlog'
+    except = ['clean']
+}

package/admin/monitor/server.mjs

@@ -0,0 +1,54 @@
+import {cpu, disk, mem, node, sys} from "tools2/info.mjs"
+import {AdminAuth} from "../base.mjs";
+
+export class Server extends AdminAuth {
+
+    get path() {
+
+        return '/monitor/server'
+    }
+
+    GET(_, {req, res}) {
+
+        return  {
+            "msg": "操作成功",
+            "code": 200,
+            "data": {
+                node: node(),
+                cpu: cpu(),
+                mem: mem(),
+                // jvm: {},
+                sys: sys(),
+                sysFiles: disk().map(disk => {
+
+                    const info = {
+                        dirName: disk.Name || disk.Mounted,
+                        sysTypeName: disk.FileSystem || disk.Filesystem,
+                        typeName: disk.CreationClassName || disk.Mounted,
+                    }
+
+                    if (disk.SystemCreationClassName.includes('Win32')) {
+
+                        const total = (disk.Size / 1024 / 1024 / 1024).toFixed(2)
+                        const free = (disk.FreeSpace / 1024 / 1024 / 1024).toFixed(2)
+
+                        info.total = total + 'GB'
+                        info.free = free + 'GB'
+
+                        info.used = (total - free).toFixed(2) + 'G'
+                        info.usage = ((total - free) * 100 / total).toFixed(2)
+
+                    } else {
+
+                        info.total = disk.Size + 'B'
+                        info.free = disk.Avail + 'B'
+                        info.used = disk.Used + 'B'
+                        info.usage = disk['Use%']
+                    }
+
+                    return info
+                })
+            }
+        }
+    }
+}

package/admin/service.mjs

@@ -0,0 +1,10 @@
+import createServer from 'tools2/server.mjs'
+import {adminUdpPort as port} from "../common/config.mjs";
+import {service as pools} from '../common/service.mjs'
+
+/*const service = */createServer({pools, port})
+
+console.log('running on ' + port)
+
+export const store1 = pools.store1
+export const jwt = pools.jwt

package/admin/system/component.mjs

@@ -0,0 +1,16 @@
+import {AdminAuth} from "../base.mjs";
+import {getFilePath} from "../../common/tools.mjs";
+import {uiDevViewDir} from "../../common/config.mjs";
+
+export class Component extends AdminAuth {
+
+    get path() {
+
+        return '/system/component/list'
+    }
+
+    GET() {
+
+        return getFilePath(uiDevViewDir, '.vue')
+    }
+}

package/admin/system/config.mjs

@@ -0,0 +1,8 @@
+import {AdminAuthPerm} from "../base.mjs";
+
+export class Config extends AdminAuthPerm {
+
+    pk = 'configId'
+    set = 'sysConfig'
+    route = '/system/config'
+}

package/admin/system/dept.mjs

@@ -0,0 +1,24 @@
+import {AdminAuth, AdminAuthPerm} from "../base.mjs";
+import {store1} from "../service.mjs";
+
+export class Dept extends AdminAuthPerm {
+
+    pk = 'deptId'
+    set = 'sysDept'
+    route = '/system/dept'
+
+    list = store1.getDeptList
+}
+
+export class DeptListExclude extends AdminAuth {
+
+    get path() {
+
+        return '/system/dept/list/exclude/:id'
+    }
+
+    GET(data, {req}) {
+
+        return store1.getDeptListExcludeById(req.params.id)
+    }
+}

package/admin/system/dict.mjs

@@ -0,0 +1,34 @@
+import {AdminAuth} from "../base.mjs";
+import {store1} from "../service.mjs";
+
+export class SystemDictDataType extends AdminAuth {
+
+    get path() {
+
+        return '/system/dict/data/type/:type'
+    }
+
+    GET(data, {req}) {
+
+        return store1.genericFilter({name: 'sysDictData', key: 'dictType', value: req.params.type})
+    }
+}
+
+export class DictType extends AdminAuth {
+
+    pk = 'dictId'
+    set = 'sysDictType'
+    route = '/system/dict/type'
+
+    optionselect() {
+
+        return store1.genericFilter({name: this.set, key: 'status', value: '0'})
+    }
+}
+
+export class DictData extends AdminAuth {
+
+    pk = 'dictCode'
+    set = 'sysDictData'
+    route = '/system/dict/data'
+}