@k3000/s1 0.1.0

package/store1/store2/index.mjs

@@ -0,0 +1,23 @@
+
+const index = import.meta.url.indexOf('?')
+
+const url = `./1/index.mjs${index > -1 ? import.meta.url.substring(index) : ''}`
+
+let remark0, close0, getStruct0
+
+/**
+ * @type {import('./1/type').Storage}
+ */
+const storage = await new Promise((resolve, reject) => import(url)
+    .then(modules => {
+        remark0 = modules.remark
+        close0 = modules.close
+        getStruct0 = modules.getStruct
+        resolve(modules.default)
+    }).catch(error => reject(error)))
+
+export const remark = remark0
+export const close = close0
+export const getStruct = getStruct0
+
+export default storage

package/store1/system.mjs

@@ -0,0 +1,67 @@
+import {colEqual, colIncludes, Pools} from "../common/tools.mjs";
+import store from "./store/index.mjs";
+
+const map = new Pools()
+
+map.set('/getDeptList', data => {
+
+    return store.sysDept.filter(dept => colIncludes(data.deptName, dept.deptName) && colEqual(data.status, dept.status))
+})
+
+const exclude = (dept, id) => {
+
+    if (dept.deptId === id || dept.parentId === id) return false
+
+    const d = store.sysDept.find(d => d.deptId === dept.parentId)
+
+    if (d === undefined) return true
+
+    return exclude(d, id)
+}
+
+map.set('/getDeptListExcludeById', id => {
+
+    return store.sysDept.filter(dept => exclude(dept, id))
+})
+
+map.set('/getMenuList', data => {
+
+    return store.sysMenu.filter(menu => colIncludes(data.menuName, menu.menuName) && colEqual(data.status, menu.status))
+})
+
+function buildMenu(menus, pid = 0) {
+
+    return menus.filter(menu => menu.parentId === pid).map(menu => {
+
+        const m = {
+            id: menu.menuId,
+            label: menu.menuName,
+        }
+
+        const children = buildMenu(menus, menu.menuId)
+
+        if (children.length > 0) {
+
+            m.children = children
+        }
+
+        return m
+    })
+}
+
+map.set('/getTreeSelect', _ => {
+
+    return buildMenu(store.sysMenu)
+})
+
+map.set('/getRoleMenuTreeSelect', id => {
+
+    return {
+        checkedKeys: store.sysRoleMenu
+            .filter(roleMenu => roleMenu.roleId === Number.parseInt(id))
+            .map(roleMenu => roleMenu.menuId),
+        menus: buildMenu(store.sysMenu)
+    }
+})
+
+export default map

package/store1/tool.mjs

@@ -0,0 +1,472 @@
+import {colIncludes, page, Pools, rowSlice, update} from "../common/tools.mjs";
+import store, {getStruct, remark} from "./store/index.mjs";
+import Query from "tools2/mysql2ssh2.mjs";
+import {mysql, serverDir} from "../common/config.mjs";
+import {
+    columnNameNotEdit,
+    columnNameNotList,
+    columnNameNotQuery, generator, getHtmlByType,
+    hungarianToCamel,
+    o2l, objKeyHungarianToCamel, typeChange
+} from "../admin/tool/helper.mjs";
+import {pm2} from "../common/pm2.mjs";
+
+const map = new Pools()
+
+map.set('/updateGenTable', data => {
+
+    const table = store.genTable.find(table => table.tableId === data.tableId)
+
+    if (table === undefined) return Promise.reject('表信息不存在，刷新重试')
+
+    update(table, data)
+
+    for (const column of data.columns) {
+
+        const col = store.genTableColumn.find(col => col.columnId === column.columnId)
+
+        if (col === undefined) continue
+
+        update(col, column)
+    }
+    // todo
+    console.log(data.params)
+})
+
+const query = new Query(mysql)
+
+const importTable = data => {
+
+    const tablesName = data.tables.split(',')
+
+    for (const [key, value] of Object.entries(getStruct())) {
+
+        if (!tablesName.includes(key)) continue
+
+        const comment = value[remark]
+
+        store.genTable.push({
+            tableName: key,
+            tableComment: comment || key,
+            functionAuthor: data.userName,
+            functionName: key[0].toUpperCase() + key.substring(1),
+            className: key,
+            packageName: key.startsWith('sys') ? 'system' : 'business',
+            moduleName: key.startsWith('sys') ? 'system' : 'business',
+            businessName: key,
+            createBy: data.userName,
+            createTime: new Date(),
+        })
+
+        const {tableId} = store.genTable.find(t => t.tableName === key) || {}
+
+        for (const [k, v] of Object.entries(value)) {
+
+            store.genTableColumn.push({
+                tableId,
+                columnName: k,
+                columnComment: v.remark,
+                columnType: typeChange[v.type],
+                isPk: (v.type === 'id' || Reflect.has(v, 'step')) ? '1' : '0',
+                isIncrement: Reflect.has(v, 'step') ? '1' : '0',
+                isRequired: '0',
+                isInsert: '1',
+                isEdit: columnNameNotEdit.some(name => k.toLowerCase().endsWith(name)) ? '0' : '1',
+                isList: columnNameNotList.some(name => k.toLowerCase().endsWith(name)) ? '0' : '1',
+                isQuery: columnNameNotQuery.some(name => k.toLowerCase().endsWith(name)) ? '0' : '1',
+                htmlType: getHtmlByType(typeChange[v.type], k),
+                queryType: k.toLowerCase().endsWith('name') ? 'LIKE' : 'EQ',
+                sort: 1,
+                createBy: data.userName,
+                createTime: new Date(),
+            })
+        }
+    }
+}
+
+map.set('/genTableImportTable', async data => {
+
+    if (data.other === 'true') return importTable(data)
+
+    const tablesName = data.tables.split(',')
+
+    const tables = await query(`SELECT table_name, table_comment, create_time, update_time FROM
+ information_schema.tables WHERE table_name NOT LIKE 'qrtz_%' AND table_name NOT LIKE 'gen_%' AND
+ table_schema = (SELECT DATABASE()) AND table_name IN (?)`, tablesName)
+
+    const tablesColumn = []
+
+    for (let name of tablesName) {
+
+        tablesColumn.push(await query(`SELECT column_name, (CASE WHEN (is_nullable = 'no' && column_key != 'PRI')
+ THEN '1' ELSE null END) AS is_required, (CASE WHEN column_key = 'PRI' THEN '1' ELSE '0' END) AS is_pk,
+ ordinal_position AS sort, column_comment, (CASE WHEN extra = 'auto_increment' THEN '1' ELSE '0' END) AS is_increment,
+ column_type FROM information_schema.columns WHERE table_schema = (SELECT DATABASE()) AND table_name = ?
+ ORDER BY ordinal_position`, name))
+    }
+
+    for (let [i, table] of tables.entries()) {
+
+        table = o2l(table)
+
+        store.genTable.push({
+            tableName: table.table_name,
+            tableComment: table.table_comment || table.table_name,
+            functionAuthor: data.userName,
+            functionName: hungarianToCamel(table.table_name, true),
+            className: hungarianToCamel(table.table_name),
+            packageName: table.table_name.startsWith('sys') ? 'system' : 'business',
+            moduleName: table.table_name.startsWith('sys') ? 'system' : 'business',
+            businessName: table.table_name,
+            createBy: data.userName,
+            createTime: new Date(),
+        })
+
+        const {tableId} = store.genTable.find(t => t.tableName === table.table_name) || {}
+
+        for (let column of tablesColumn[i]) {
+
+            column = o2l(column)
+
+            store.genTableColumn.push({
+                tableId,
+                columnName: column.column_name,
+                columnComment: column.column_comment,
+                columnType: column.column_type,
+                isPk: column.is_pk,
+                isIncrement: column.is_increment,
+                isRequired: column.is_required,
+                isInsert: '1',
+                isEdit: columnNameNotEdit.some(name => column.column_name.endsWith(name)) ? '0' : '1',
+                isList: columnNameNotList.some(name => column.column_name.endsWith(name)) ? '0' : '1',
+                isQuery: columnNameNotQuery.some(name => column.column_name.endsWith(name)) ? '0' : '1',
+                htmlType: getHtmlByType(column.column_type, column.column_name),
+                queryType: column.column_name.endsWith('name') ? 'LIKE' : 'EQ',
+                sort: column.sort,
+                createBy: data.userName,
+                createTime: new Date(),
+            })
+        }
+    }
+})
+
+map.set('/genTableImportTable2', data => importTable(data))
+
+map.set('/batchGenCode', data => {
+
+    const table = store.genTable.find(table => table.tableName === data.tables)
+
+    const columns = store.genTableColumn.filter(tableColumn => tableColumn.tableId === table.tableId)
+
+    return generator(table, columns, '$$$')
+})
+
+const toolGenDb = data => {
+
+    const rows = Object.entries(getStruct()).map(([key, value]) => ({
+        tableName: key,
+        tableComment: value[remark]
+    })).filter(item => !item.tableName.startsWith('sys')
+        && !store.genTable.some(table => table.tableName === item.tableName))
+
+    return {
+        rows: rowSlice(rows, data),
+        total: rows.length
+    }
+}
+
+map.set('/toolGenDbList', data => {
+
+    if (data.other === 'true') return toolGenDb(data)
+
+    const values = []
+
+    let str = `FROM information_schema.tables
+\t\tWHERE table_schema = (SELECT DATABASE())
+\t\tAND table_name NOT LIKE 'qrtz_%' AND table_name NOT LIKE 'gen_%'`
+
+    const tableName = store.genTable.map(table => table.tableName)
+
+    if (tableName.length) {
+
+        str += ` AND table_name NOT IN (?)`
+
+        values.push(tableName)
+    }
+
+    if (data.tableName) {
+
+        str += ` AND lower(table_name) LIKE LOWER(CONCAT('%', ?, '%'))`
+
+        values.push(data.tableName)
+    }
+
+    if (data.tableComment) {
+
+        str += ` AND LOWER(table_comment) LIKE LOWER(CONCAT('%', ?, '%'))`
+
+        values.push(data.tableComment)
+    }
+
+    if (data.pageNum) {
+
+        values.push((data.pageNum - 1) * data.pageSize)
+        values.push(parseInt(data.pageSize))
+    }
+
+    return Promise.all([
+        query(`SELECT table_name, table_comment, create_time, update_time ${str} LIMIT ?, ?`, ...values),
+        query(`SELECT COUNT(*) ${str}`, ...values),
+    ]).then(([rows, count]) => ({
+        rows: objKeyHungarianToCamel(rows),
+        total: count[0]['COUNT(*)']
+    }))
+})
+
+map.set('/toolGenDbList2', data => toolGenDb(data))
+
+map.set('/genPreview', id => {
+
+    return generator(
+        store.genTable.find(table => table.tableId == id),
+        store.genTableColumn.filter(tableColumn => tableColumn.tableId == id),
+        "../../spd.mjs"
+    )
+})
+
+map.set('/toolPm2List', data => {
+
+    const list1 = pm2.list
+
+    list1.forEach(item => item.status = item.status === 'online' ? 0 : 1)
+
+    const list2 = []
+
+    for (const item of store.service) {
+
+        const service = list1.find(s => s.name === item.name)
+
+        if (service) {
+
+            service.host = item.host
+            service.port = item.port
+            service.type = item.type
+            service.remark = item.remark
+
+            item.status = service.status
+
+        } else {
+
+            pm2.add(item.name, `${item.param1 || ''} ${item.path
+                ? `"${serverDir}/${item.path}.mjs"` : ''} ${item.param2 || ''}`)
+
+            item.status = 0
+
+            list2.push(item)
+        }
+    }
+
+    return page([...list1, ...list2], data)
+})
+
+map.set('/toolPm2AddService', data => {
+
+    if (store.service.some(service => service.name === data.name)) return Promise.reject('服务已存在')
+
+    const result = pm2.add(data.name, `${data.arg1 || ''} ${data.path
+        ? `"${serverDir}/${data.path}.mjs"` : ''} ${data.arg2 || ''}`)
+
+    if (result === false) return Promise.reject('服务已存在')
+
+    store.service.push(data)
+})
+
+map.set('/toolPm2RemoveService', name => {
+
+    pm2.del(name)
+
+    store.service.remove(store.service.find(s => s.name === name))
+    store.serviceData.remove(...store.serviceData.filter(s => s.name === name))
+})
+
+map.set('/toolPm2ChangeStatus', data => {
+
+    if ([0, 1].includes(data.status)) {
+
+        const service = store.service.find(service => service.name === data.name)
+        if (service) service.status = data.status
+    }
+
+    switch (data.status) {
+
+        case 0:
+
+            pm2.start(data.name)
+            break
+
+        case 1:
+
+            pm2.stop(data.name)
+            break
+    }
+})
+
+map.set('/toolPm2Data', data => {
+
+    if (!store.service.some(service => service.name === data.name))
+
+        return Promise.reject('服务不存在')
+
+    const item = store.serviceData.find(s => s.id == data.id)
+
+    if (item) {
+
+        item.method = data.method
+        item.remark = data.remark
+
+        return
+    }
+
+    if (store.serviceData.some(s => s.name === data.name && s.method === data.method))
+
+        return Promise.reject('方法已存在')
+
+    store.serviceData.push(data)
+})
+
+map.set('/toolPm2DataList', data => page(store.serviceData.filter(s => s.name === data.name), data))
+
+map.set('/toolPm2RemoveData', ids => {
+
+    for (const id of ids.toString().split(',')) {
+
+        store.serviceData.remove(...store.serviceData.indexById(id))
+    }
+})
+
+map.set('/toolPm2Export', _ => {
+
+    let funCode = ''
+
+    const code1 = `${store.service.filter(service => service.type === 1).map(item => {
+        const Name = item.name[0].toUpperCase() + item.name.substring(1)
+        funCode += `
+    ${item.name}: {`
+        const code = store.serviceData.filter(service => service.name === item.name).map(service => {
+            const name = service.method[0].toUpperCase() + service.method.substring(1)
+            const index1 = service.remark.indexOf('***')
+            const index2 = service.remark.indexOf('***', index1 + 3)
+            const paramClass = service.remark.substring(1, index1 - 1).replace(/\n /g, '\n')
+            const returnClass = service.remark.substring(index1 + 5, index2 - 1).replace(/\n /g, '\n')
+            let remark = service.remark.substring(index2 + 4)
+            if (remark) {
+                remark = `
+        /**
+         * ${remark.replace(/\n/g, '\n         * ')}
+         */`
+            }
+            remark += `
+        ${service.method}(`
+            let code = ''
+            if (paramClass) {
+                if (paramClass.includes(':')) {
+                    code += `
+interface ${Name}${name}Param {
+    ${paramClass.replace(/\n/g, '\n    ')}
+}
+`
+                    remark += `_: ${Name}${name}Param`
+                } else {
+                    remark += `_: ${paramClass}`
+                }
+            }
+            remark += '): Promise'
+            if (returnClass) {
+                if (returnClass.includes(':')) {
+                    code += `
+interface ${Name}${name}Return {
+    ${returnClass.replace(/\n/g, '\n    ')}
+}
+`
+                    remark += `<${Name}${name}Return>`
+                } else {
+                    remark += `<${returnClass}>`
+                }
+            } else {
+                remark += `<any>`
+            }
+            funCode += remark
+            return code
+        }).join('')
+        funCode += '\n    }'
+        return code
+    }).join('')}
+export interface Service {${funCode}
+}
+`
+
+    const code2 =  `
+/**
+ * @type {import('./type').Service}
+ */
+export const service = {${store.service.filter(service => service.type === 1).map(item => `
+    ${item.name}: {${store.serviceData.filter(service => service.name === item.name).map(service => `
+        ${service.method}: '${item.host}:${item.port}/${service.method}'`).join(',')}
+    }`).join(',')}\n}`
+
+    return [code1, code2]
+})
+
+map.set('/toolPm2StoreList', data => {
+
+    const rows = Object.entries(getStruct()).map(([key, value]) => ({
+        name: key,
+        remark: value[remark],
+        total: store[key].length
+    })).filter(store => data.user.perms.includes('*:*:*') || !['sysDept', 'sysPost', 'sysRole', 'sysMenu'
+            , 'sysUserRole', 'sysRoleMenu', 'sysRoleDept', 'sysUser', 'sysUserPost', 'sysOperLog', 'sysDictType'
+            , 'sysDictData', 'sysLogininfor', 'sysJob', 'sysJobLog', 'sysConfig', 'sysNotice', 'genTable'
+            , 'genTableColumn', 'permissions'].includes(store.name)
+        && colIncludes(data.name, store.name)
+        && colIncludes(data.remark, store.remark)
+    )
+
+    return {
+        rows: rowSlice(rows, data),
+        total: rows.length
+    }
+})
+
+map.set('/toolPm2StoreDataUpdate', data => {
+
+    const [item] = page(store[data.name], data.old, undefined, true)
+
+    if (item === undefined) return Promise.reject('数据不存在')
+
+    for (const [key, value] of Object.entries(data.new)) {
+
+        if (item[key] == value) continue
+
+        item[key] = value
+    }
+})
+
+map.set('/toolPm2RemoveStoreData', data => {
+
+    for (const item of data.list) {
+
+        store[data.name].remove(store[data.name].find(it => {
+
+            for (const [key, value] of Object.entries(item)) {
+
+                if (!Reflect.has(it, key)) return false
+
+                if (it[key] != value) return false
+            }
+
+            return true
+        }))
+    }
+})
+
+export default map