midway-fatcms 0.0.1-beta.55 → 0.0.1-beta.57

package/src/controller/manage/CrudStandardDesignApi.ts

@@ -0,0 +1,406 @@
+import { Config, Controller, Post } from '@midwayjs/core';
+import { BaseApiController } from '../base/BaseApiController';
+import { parseCreateSqlToTitleMap, parseTableFieldTitleFromComment } from '@/libs/utils/parseCreateSql';
+import { checkPermission } from '@/middleware/permission.middleware';
+import { SystemFuncCode } from '@/models/SystemPerm';
+import { KeyOfCrudTypes, KeysOfSimpleSQL, SqlDbType } from '@/libs/crud-pro/models/keys';
+import { SystemTables } from '@/models/SystemTables';
+import { CommonException } from '@/libs/crud-pro/exceptions';
+import { parseDatabaseName, toDatabaseNameStr } from '@/libs/crud-pro/utils/DatabaseName';
+import { CommonResult } from '@/libs/utils/common-dto';
+
+function getObjectKeysWithValue(obj: any): string[] {
+  const keys = Object.keys(obj || {});
+  return keys.filter((key: string) => {
+    const valueObj = obj[key];
+    const valueKeys = Object.keys(valueObj || {});
+    return valueKeys.length > 0;
+  });
+}
+
+@Controller('/ns/api/manage/CrudStandardDesignApi', { middleware: [checkPermission(SystemFuncCode.CrudStandardDesignRead)] })
+export class CrudStandardDesignApi extends BaseApiController {
+  @Config('mysql2')
+  private mysql2Config: any;
+
+  @Config('postgres2')
+  private postgres2Config: any;
+
+  @Config('sqlserver2')
+  private sqlserver2Config: any;
+
+  @Post('/getDataBaseList')
+  async getDataBaseList() {
+    const mysqlList = getObjectKeysWithValue(this.mysql2Config);
+    const postgresList = getObjectKeysWithValue(this.postgres2Config);
+    const sqlServerList = getObjectKeysWithValue(this.sqlserver2Config);
+
+    const toSelectList = (dbCfgNameList: string[], dbType: SqlDbType) => {
+      return dbCfgNameList.map(dbName => {
+        const value = toDatabaseNameStr(dbType, dbName);
+        return { value, label: value, dbName, dbType };
+      });
+    };
+
+    const mysqlObjList = toSelectList(mysqlList, SqlDbType.mysql);
+    const postgresObjList = toSelectList(postgresList, SqlDbType.postgres);
+    const sqlserverObjList = toSelectList(sqlServerList, SqlDbType.sqlserver);
+
+    const databaseList = [...mysqlObjList, ...postgresObjList, ...sqlserverObjList].filter((obj: any) => {
+      const value = '' + obj.value;
+      return !value.endsWith('_fatcms_inner_demo_config');
+    });
+
+    return {
+      success: true,
+      data: databaseList,
+    };
+  }
+
+  @Post('/getTableList')
+  async getTableList(): Promise<CommonResult> {
+    const { databaseName } = this.ctx.request.body as any;
+    const { dbType, dbName } = parseDatabaseName(databaseName);
+
+    if (dbType === SqlDbType.postgres) {
+      return this.getTableListOfPostgreSQL(dbName);
+    }
+
+    if (dbType === SqlDbType.sqlserver) {
+      return this.getTableListOfSqlserver(dbName);
+    }
+
+    const res = await this.curdMixService.executeSQL({
+      executeSql: 'SHOW TABLES',
+      sqlDatabase: dbName,
+      sqlDbType: SqlDbType.mysql,
+      crudType: KeyOfCrudTypes.SYS_QUERY,
+    });
+
+    const arr = JSON.parse(JSON.stringify(res));
+    const tableNames: string[] = arr.map(a => {
+      const v = Object.values(a);
+      const tableName = v[0];
+      return {
+        value: tableName,
+        label: tableName,
+        dbName,
+        dbType,
+        tableName,
+      };
+    });
+    return CommonResult.successRes(tableNames);
+  }
+
+  @Post('/getTableFields')
+  async getTableFields() {
+    const { databaseName, tableName } = this.ctx.request.body as any;
+    const { dbType, dbName } = parseDatabaseName(databaseName);
+
+    if (dbType === SqlDbType.postgres) {
+      return this.getTableFieldsOfPostgreSQL(dbName, tableName);
+    }
+
+    if (dbType === SqlDbType.sqlserver) {
+      return this.getTableFieldsOfSqlServer(dbName, tableName);
+    }
+
+    const tableDescribe = await this.curdMixService.executeSQL({
+      executeSql: 'describe ' + tableName,
+      sqlDatabase: dbName,
+      sqlDbType: SqlDbType.mysql,
+      crudType: KeyOfCrudTypes.SYS_QUERY,
+    });
+    const tableCreate = await this.curdMixService.executeSQL({
+      executeSql: 'show create table ' + tableName,
+      sqlDatabase: dbName,
+      sqlDbType: SqlDbType.mysql,
+      crudType: KeyOfCrudTypes.SYS_QUERY,
+    });
+
+    const tableCreateStr = tableCreate[0]['Create Table'];
+    const { fieldsTitleMap, tableTitle } = parseCreateSqlToTitleMap(tableCreateStr);
+
+    const tableDescribe2 = JSON.parse(JSON.stringify(tableDescribe));
+    const fields = tableDescribe2.map(fieldObj => {
+      const { Default, Extra, Field, Key, Null, Type } = fieldObj;
+      const fieldTitle = fieldsTitleMap[Field];
+      return {
+        fieldIndex: Field || '',
+        fieldTitle: fieldTitle || Field || '',
+        isNullable: Null,
+        defaultValue: Default,
+        extra: Extra,
+        key: Key,
+        type: Type,
+      };
+    });
+
+    return {
+      success: true,
+      data: {
+        fields,
+        tableName,
+        tableTitle,
+      },
+    };
+  }
+
+  /**
+   * 获取角色列表
+   */
+  @Post('/getRoleOptionsList')
+  async getRoleOptionsList() {
+    return this.executeSysSimpleSQL(SystemTables.sys_perm_role, KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+  }
+
+  /**
+   * 获取功能点列表
+   */
+  @Post('/getFuncOptionsList')
+  async getFuncOptionsList() {
+    return this.executeSysSimpleSQL(SystemTables.sys_perm_func, KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+  }
+
+  private async getTableListOfSqlserver(dbName: string): Promise<CommonResult> {
+    const dbConfig = this.sqlserver2Config[dbName];
+    if (!dbConfig) {
+      throw new CommonException('DB_NOT_FOUND', '数据库配置没有找到：' + dbName);
+    }
+
+    const dbType = SqlDbType.sqlserver;
+
+    const sql = 'SELECT name as tablename FROM sys.tables';
+    const arr = await this.curdMixService.executeSQL({
+      executeSql: sql,
+      sqlDatabase: dbName,
+      sqlDbType: dbType,
+      crudType: KeyOfCrudTypes.SYS_QUERY,
+      executeSqlArgs: [],
+    });
+
+    const tableNames: string[] = arr.map(v => {
+      const tableName = v.tablename;
+      return {
+        value: tableName, //[dbName, dbType, tableName].join(SPLIT_CONST),
+        label: tableName,
+        dbName,
+        dbType,
+        tableName,
+      };
+    });
+    return CommonResult.successRes(tableNames);
+  }
+
+  private async getTableListOfPostgreSQL(dbName: string): Promise<CommonResult> {
+    const dbConfig = this.postgres2Config[dbName];
+    if (!dbConfig) {
+      throw new CommonException('DB_NOT_FOUND', '数据库配置没有找到：' + dbName);
+    }
+
+    const dbType = SqlDbType.postgres;
+    const schemaname = 'public';
+
+    const tableListSql = '' + 'SELECT tablename\n' + 'FROM pg_tables\n' + `WHERE schemaname = '${schemaname}' \n` + 'ORDER BY tablename;';
+
+    const viewListSql = '' + 'SELECT viewname as tablename\n' + 'FROM pg_views\n' + `WHERE schemaname = '${schemaname}' \n` + 'ORDER BY viewname;';
+
+    const toSelectOptions = async (executeSql: string, tableType: string) => {
+      const arr = await this.curdMixService.executeSQL({
+        executeSql: executeSql,
+        sqlDatabase: dbName,
+        sqlDbType: dbType,
+        crudType: KeyOfCrudTypes.SYS_QUERY,
+        executeSqlArgs: [],
+      });
+      return arr.map(v => {
+        const tableName = v.tablename;
+        return {
+          value: tableName, //[dbName, dbType, tableName].join(SPLIT_CONST),
+          label: tableName,
+          dbName,
+          dbType,
+          tableName,
+          tableType,
+        };
+      });
+    };
+
+    const tableNames: any[] = await toSelectOptions(tableListSql, 'table');
+    const viewNames: any[] = await toSelectOptions(viewListSql, 'view');
+
+    const tableNameMerge = [...tableNames, ...viewNames];
+
+    return CommonResult.successRes(tableNameMerge);
+  }
+
+  private async getTableFieldsOfSqlServer(dbName: string, tableName: string): Promise<CommonResult> {
+    const dbConfig = this.sqlserver2Config[dbName];
+    if (!dbConfig) {
+      throw new CommonException('DB_NOT_FOUND', '数据库配置没有找到：' + dbName);
+    }
+
+    const columnArraySql =
+      '' +
+      'SELECT\n' +
+      '    c.name AS column_name,\n' +
+      '    t.name AS data_type,\n' +
+      '    c.max_length AS max_length,\n' +
+      '    c.precision,\n' +
+      '    c.scale,\n' +
+      '    c.is_nullable,\n' +
+      '    c.is_identity,\n' +
+      '    dc.definition AS column_default,  \n' +
+      '    ep.value AS column_description  \n' +
+      'FROM\n' +
+      '    sys.columns c\n' +
+      '        JOIN\n' +
+      '    sys.types t ON c.user_type_id = t.user_type_id\n' +
+      '        LEFT JOIN\n' +
+      '    sys.default_constraints dc\n' +
+      '    ON c.default_object_id = dc.object_id  \n' +
+      '        LEFT JOIN\n' +
+      '    sys.extended_properties ep\n' +
+      '    ON c.object_id = ep.major_id\n' +
+      '        AND c.column_id = ep.minor_id\n' +
+      'WHERE\n' +
+      `    c.object_id = OBJECT_ID('${tableName}')  \n` +
+      ' ORDER BY\n' +
+      '    c.column_id;';
+
+    const dbType = SqlDbType.sqlserver;
+
+    const columnArray = await this.curdMixService.executeSQL({
+      executeSql: columnArraySql,
+      sqlDatabase: dbName,
+      sqlDbType: dbType,
+      crudType: KeyOfCrudTypes.SYS_QUERY,
+      executeSqlArgs: [],
+    });
+
+    const fields = columnArray.map(columnObj => {
+      const { column_name, is_nullable, column_default, data_type, is_identity, column_description, ...others } = columnObj;
+
+      return {
+        fieldIndex: column_name || '',
+        fieldTitle: column_description || column_name || '',
+        isNullable: is_nullable,
+        defaultValue: column_default || '',
+        extra: others,
+        // key: column_name, // 索引
+        type: data_type,
+        is_identity: is_identity,
+      };
+    });
+
+    return CommonResult.successRes({
+      fields,
+      tableName,
+      tableTitle: tableName,
+    });
+  }
+
+  private async getTableFieldsOfPostgreSQL(dbName: string, tableName: string) {
+    const dbConfig = this.postgres2Config[dbName];
+    if (!dbConfig) {
+      throw new CommonException('DB_NOT_FOUND', '数据库配置没有找到：' + dbName);
+    }
+
+    const schemaname = 'public';
+
+    const columnArraySql = `
+
+    SELECT
+      *
+      FROM information_schema.columns
+      WHERE table_schema = $1 and table_name = $2
+      ORDER BY ordinal_position;
+
+    `.trim();
+
+    const dbType = SqlDbType.postgres;
+
+    const columnArray = await this.curdMixService.executeSQL({
+      executeSql: columnArraySql,
+      sqlDatabase: dbName,
+      sqlDbType: dbType,
+      crudType: KeyOfCrudTypes.SYS_QUERY,
+      executeSqlArgs: [schemaname, tableName],
+    });
+
+    const commentMap = await this.getTableFieldsCommentsMapOfPostgreSQL(dbName, schemaname, tableName);
+
+    const fields = columnArray.map(columnObj => {
+      const { column_name, is_nullable, column_default, data_type, is_identity, ...others } = columnObj;
+
+      return {
+        fieldIndex: column_name || '',
+        fieldTitle: commentMap[column_name] || column_name || '',
+        isNullable: is_nullable,
+        defaultValue: column_default || '',
+        extra: others,
+        // key: column_name, // 索引
+        type: data_type,
+        is_identity: is_identity,
+      };
+    });
+
+    return {
+      success: true,
+      data: {
+        fields,
+        tableName,
+        tableTitle: tableName,
+      },
+    };
+  }
+
+  /**
+   * 获取PostgreSQL建表语句的注释
+   * @param dbName
+   * @param schemaname
+   * @param tableName
+   * @returns
+   */
+  private async getTableFieldsCommentsMapOfPostgreSQL(dbName: string, schemaname: string, tableName: string): Promise<any> {
+    const commentArraySql = `
+            SELECT
+                n.nspname AS schema_name,
+                c.relname AS table_name,  
+                a.attname AS column_name,  
+                d.description AS column_comment 
+            FROM
+                pg_class c
+            JOIN
+                pg_namespace n ON c.relnamespace = n.oid
+            JOIN
+                pg_attribute a ON c.oid = a.attrelid
+            LEFT JOIN
+                pg_description d ON c.oid = d.objoid AND a.attnum = d.objsubid
+            WHERE
+                n.nspname = $1 
+                AND c.relname = $2  
+                AND a.attnum > 0  
+            ORDER BY
+                a.attnum
+    `;
+
+    const dbType = SqlDbType.postgres;
+
+    const commentArray = await this.curdMixService.executeSQL({
+      executeSql: commentArraySql,
+      sqlDatabase: dbName,
+      sqlDbType: dbType,
+      crudType: KeyOfCrudTypes.SYS_QUERY,
+      executeSqlArgs: [schemaname, tableName],
+    });
+
+    const map: any = {};
+    commentArray.forEach(commentObj => {
+      const { column_name, column_comment } = commentObj;
+      map[column_name] = parseTableFieldTitleFromComment(column_comment);
+    });
+
+    return map;
+  }
+}

package/src/controller/manage/DataDictManageApi.ts

@@ -0,0 +1,78 @@
+import { Inject, Controller, Post } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { KeysOfSimpleSQL, KeysOfValidators } from '@/libs/crud-pro/models/keys';
+import { BaseApiController } from '../base/BaseApiController';
+import { checkPermission } from '@/middleware/permission.middleware';
+import { SystemFuncCode } from '@/models/SystemPerm';
+
+@Controller('/ns/api/manage/dataDict', { middleware: [checkPermission(SystemFuncCode.DataDictMangeRead)] })
+export class DataDictManageApi extends BaseApiController {
+  @Inject()
+  protected ctx: Context;
+
+  @Post('/getDataDictList')
+  async getDataDictList() {
+    return this.executeSysSimpleSQL('sys_data_dict', KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+  }
+
+  @Post('/getDataDictOne')
+  async getDataDictOne() {
+    return this.executeSysSimpleSQL('sys_data_dict', KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
+  }
+
+  @Post('/createDataDict', { middleware: [checkPermission(SystemFuncCode.DataDictMangeWrite)] })
+  async createDataDict() {
+    return this.executeSysSimpleSQL('sys_data_dict', KeysOfSimpleSQL.SIMPLE_INSERT, {
+      validateCfg: {
+        'data.dict_code': [KeysOfValidators.REQUIRED],
+      },
+    });
+  }
+
+  @Post('/updateDataDict', { middleware: [checkPermission(SystemFuncCode.DataDictMangeWrite)] })
+  async updateDataDict() {
+    return this.executeSysSimpleSQL('sys_data_dict', KeysOfSimpleSQL.SIMPLE_UPDATE, {
+      validateCfg: {
+        'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.NUMERIC],
+      },
+    });
+  }
+
+  @Post('/deleteDataDict', { middleware: [checkPermission(SystemFuncCode.DataDictMangeWrite)] })
+  async deleteDataDict() {
+    return this.executeSysSimpleSQL('sys_data_dict', KeysOfSimpleSQL.SIMPLE_DELETE, {
+      validateCfg: {
+        'condition.dict_code': [KeysOfValidators.REQUIRED],
+      },
+    });
+  }
+
+  @Post('/getDataDictItemList')
+  async getDataDictItemList() {
+    return this.executeSysSimpleSQL('sys_data_dict_item', KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+  }
+
+  @Post('/getDataDictItemOne')
+  async getDataDictItemOne() {
+    return this.executeSysSimpleSQL('sys_data_dict_item', KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
+  }
+
+  @Post('/createDataDictItem', { middleware: [checkPermission(SystemFuncCode.DataDictMangeWrite)] })
+  async createDataDictItem() {
+    return this.executeSysSimpleSQL('sys_data_dict_item', KeysOfSimpleSQL.SIMPLE_INSERT);
+  }
+
+  @Post('/updateDataDictItem', { middleware: [checkPermission(SystemFuncCode.DataDictMangeWrite)] })
+  async updateDataDictItem() {
+    return this.executeSysSimpleSQL('sys_data_dict_item', KeysOfSimpleSQL.SIMPLE_UPDATE);
+  }
+
+  @Post('/deleteDataDictItem', { middleware: [checkPermission(SystemFuncCode.DataDictMangeWrite)] })
+  async deleteDataDictItem() {
+    return this.executeSysSimpleSQL('sys_data_dict_item', KeysOfSimpleSQL.SIMPLE_DELETE, {
+      validateCfg: {
+        'condition.dict_code': [KeysOfValidators.REQUIRED],
+      },
+    });
+  }
+}

package/src/controller/manage/DeployManageApi.ts

@@ -0,0 +1,175 @@
+import { Controller, Fields, Files, Inject, Post, Query } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { BaseApiController } from '../base/BaseApiController';
+import { checkPermission } from '../../middleware/permission.middleware';
+import { SystemFuncCode } from '../../models/SystemPerm';
+import { CommonResult } from '../../libs/utils/common-dto';
+import { AccessType, UploadCategoryType } from '../../models/bizmodels';
+import { BizException } from '../../models/devops';
+import { FileCenterService, toDownloadPaths } from '../../service/FileCenterService';
+import { SystemTables } from '../../models/SystemTables';
+import { KeysOfSimpleSQL } from '../../libs/crud-pro/models/keys';
+import { WorkbenchService } from '../../service/WorkbenchService';
+import { GLOBAL_STATIC_CONFIG } from '@/libs/global-config/global-config';
+
+interface IReleaseAssetsParams {
+  cdnResources: any[];
+  packageName: string;
+  packageVersion: string;
+}
+
+function toAssetsSchema(fileList: any) {
+  for (let i = 0; i < fileList.length; i++) {
+    const fileListElement = fileList[i];
+    fileListElement.settingKey = 'assets' + i;
+  }
+  return {
+    schema: [
+      {
+        title: '资源配置',
+        name: 'fileList',
+        type: 'array',
+        properties: {
+          fileUrl: { label: '文件URL', component: 'Input', xProps: { hasClear: true }, width: 500 },
+          fileType: {
+            label: '文件类型',
+            component: 'Select',
+            enums: [
+              { label: 'js', value: 'js' },
+              { label: 'css', value: 'css' },
+            ],
+            xProps: {
+              hasClear: true,
+            },
+            width: 500,
+          },
+          isModule: {
+            label: 'isModule',
+            component: 'Select',
+            enums: [
+              { label: 'true', value: true },
+              { label: 'false', value: false },
+            ],
+            xProps: {
+              hasClear: true,
+            },
+            width: 500,
+          },
+        },
+      },
+    ],
+    data: {
+      fileList: fileList,
+    },
+  };
+}
+
+@Controller('/ns/api/manage/deploy', { middleware: [checkPermission([SystemFuncCode.AppMangeRead, SystemFuncCode.WorkbenchMangeRead])] })
+export class DeployManageApi extends BaseApiController {
+  @Inject()
+  protected ctx: Context;
+
+  @Inject()
+  private fileCenterService: FileCenterService;
+
+  @Inject()
+  private workbenchService: WorkbenchService;
+
+  /**
+   * 资源文件上传
+   * @param files
+   * @param fields
+   * @param queryData
+   */
+  @Post('/uploadAssets', { middleware: [checkPermission(SystemFuncCode.AppMangeWrite)] })
+  async uploadAssets(@Files() files, @Fields() fields, @Query() queryData): Promise<CommonResult> {
+    const accessType = AccessType.open;
+    const referer = this.ctx.req.headers.referer;
+
+    if (!fields.uploadPath) {
+      throw new BizException('uploadPath不能为空');
+    }
+
+    const { fileKey, filename, storageUrl } = await this.fileCenterService.uploadFileToOSS(files, accessType, referer, {
+      uploadCategoryType: UploadCategoryType.assets,
+      uploadPath: fields.uploadPath,
+    });
+
+    const origin = this.ctx.request.origin;
+
+    const downloadUrls = toDownloadPaths(origin, fileKey);
+    const data = {
+      fileKey,
+      filename,
+      storageUrl,
+      ...downloadUrls,
+    };
+    return CommonResult.successRes(data);
+  }
+
+  /**
+   * 资源文件让其生效
+   */
+  @Post('/releaseAssets', { middleware: [checkPermission(SystemFuncCode.AppMangeWrite)] })
+  async releaseAssets(): Promise<CommonResult> {
+    const params = this.ctx.request.body as IReleaseAssetsParams;
+    if (!params.packageName) {
+      throw new BizException('packageName参数不存在');
+    }
+
+    if (params.packageName.length < 5) {
+      throw new BizException('packageName参数小于5');
+    }
+
+    const cdnResources = params.cdnResources;
+    if (!Array.isArray(cdnResources) || cdnResources.length === 0) {
+      throw new BizException('cdnResources参数不存在');
+    }
+
+    const { SystemDbName, SystemDbType } = GLOBAL_STATIC_CONFIG.getConfig();
+
+    const workbench = await this.curdMixService.executeCrudByCfg(
+      {
+        data: {
+          package_assets: JSON.stringify(toAssetsSchema(cdnResources)),
+        },
+        condition: {
+          package_name: params.packageName,
+        },
+      },
+      {
+        sqlTable: SystemTables.sys_workbench,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_UPDATE,
+      }
+    );
+
+    const app = await this.curdMixService.executeCrudByCfg(
+      {
+        data: {
+          package_assets: JSON.stringify(toAssetsSchema(cdnResources)),
+        },
+        condition: {
+          package_name: params.packageName,
+        },
+      },
+      {
+        sqlTable: SystemTables.sys_app,
+        sqlDatabase: SystemDbName,
+        sqlDbType: SystemDbType,
+        sqlSimpleName: KeysOfSimpleSQL.SIMPLE_UPDATE,
+      }
+    );
+
+    this.workbenchService.clearCache();
+
+    const workbenchAffected = workbench.getResModelItem('affected') || {};
+    const appAffected = app.getResModelItem('affected') || {};
+
+    const result = CommonResult.successRes({ workbenchAffected, appAffected });
+
+    result.message = `${cdnResources.length}个文件，更新到${workbenchAffected.affectedRows}个站点模版；更新到${appAffected.affectedRows}个应用模版，`;
+    return result;
+  }
+}