midway-fatcms 0.0.1-beta.1

package/src/controller/manage/AppMangeApi.ts

@@ -0,0 +1,53 @@
+import { Controller, Inject, 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/app', { middleware: [checkPermission(SystemFuncCode.AppMangeRead)] })
+export class AppMangeApi extends BaseApiController {
+  @Inject()
+  ctx: Context;
+
+  @Post('/getAppList')
+  async getAppList() {
+    return this.executeSysSimpleSQL('sys_app', KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+  }
+
+  @Post('/getAppOne')
+  async getAppOne() {
+    return this.executeSysSimpleSQL('sys_app', KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
+  }
+
+  @Post('/createApp', { middleware: [checkPermission(SystemFuncCode.AppMangeWrite)] })
+  async createApp() {
+    return this.executeSysSimpleSQL('sys_app', KeysOfSimpleSQL.SIMPLE_INSERT, {
+      validateCfg: {
+        'data.app_code': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+        'data.app_name': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+        'data.app_type': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+      },
+    });
+  }
+
+  @Post('/updateApp',{ middleware: [checkPermission(SystemFuncCode.AppMangeWrite)] })
+  async updateApp() {
+    return this.executeSysSimpleSQL('sys_app', KeysOfSimpleSQL.SIMPLE_UPDATE, {
+      validateCfg: {
+        'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.INTEGER],
+        'condition.app_code': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+      },
+    });
+  }
+
+  @Post('/deleteApp',{ middleware: [checkPermission(SystemFuncCode.AppMangeWrite)] })
+  async deleteApp() {
+    return this.executeSysSimpleSQL('sys_app', KeysOfSimpleSQL.SIMPLE_DELETE, {
+      validateCfg: {
+        'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.INTEGER],
+        'condition.app_code': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+      },
+    });
+  }
+}

package/src/controller/manage/AppPageMangeApi.ts

@@ -0,0 +1,52 @@
+import { Controller, Inject, 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/appPage', { middleware: [checkPermission(SystemFuncCode.AppPageMangeRead)] })
+export class AppPageMangeApi extends BaseApiController {
+  @Inject()
+  ctx: Context;
+
+  @Post('/getAppPageList')
+  async getAppPageList() {
+    return this.executeSysSimpleSQL('sys_app_page', KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+  }
+
+  @Post('/getAppPageOne')
+  async getAppPageOne() {
+    return this.executeSysSimpleSQL('sys_app_page', KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
+  }
+
+  @Post('/createAppPage', { middleware: [checkPermission(SystemFuncCode.AppPageMangeWrite)] })
+  async createAppPage() {
+    return this.executeSysSimpleSQL('sys_app_page', KeysOfSimpleSQL.SIMPLE_INSERT, {
+      validateCfg: {
+        'data.app_code': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+        'data.app_name': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+        'data.page_path': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+        'data.page_name': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+      },
+    });
+  }
+
+  @Post('/updateAppPage', { middleware: [checkPermission(SystemFuncCode.AppPageMangeWrite)] })
+  async updateAppPage() {
+    return this.executeSysSimpleSQL('sys_app_page', KeysOfSimpleSQL.SIMPLE_UPDATE, {
+      validateCfg: {
+        'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.INTEGER],
+      },
+    });
+  }
+
+  @Post('/deleteAppPage', { middleware: [checkPermission(SystemFuncCode.AppPageMangeWrite)] })
+  async deleteAppPage() {
+    return this.executeSysSimpleSQL('sys_app_page', KeysOfSimpleSQL.SIMPLE_DELETE, {
+      validateCfg: {
+        'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.INTEGER],
+      },
+    });
+  }
+}

package/src/controller/manage/AppSchemaHistoryApi.ts

@@ -0,0 +1,49 @@
+import { Controller, Inject, Post } from '@midwayjs/core';
+import { Context } from '@midwayjs/koa';
+import { KeysOfSimpleSQL, KeysOfValidators } from '../../libs/crud-pro/models/keys';
+import { BaseApiController } from '../base/BaseApiController';
+
+const tableName = 'sys_app_schema_history';
+
+@Controller('/ns/api/manage/AppSchemaHistory')
+export class AppSchemaHistoryApi extends BaseApiController {
+  @Inject()
+  ctx: Context;
+
+  @Post('/getAppSchemaHistoryList')
+  async getAppSchemaHistoryList() {
+    return this.executeSysSimpleSQL(tableName, KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+  }
+
+  @Post('/getAppSchemaHistoryOne')
+  async getAppSchemaHistoryOne() {
+    return this.executeSysSimpleSQL(tableName, KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
+  }
+
+  @Post('/createAppSchemaHistory')
+  async createAppSchemaHistory() {
+    return this.executeSysSimpleSQL(tableName, KeysOfSimpleSQL.SIMPLE_INSERT, {
+      validateCfg: {
+        'data.app_code': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+      },
+    });
+  }
+
+  @Post('/updateAppSchemaHistory')
+  async updateAppSchemaHistory() {
+    return this.executeSysSimpleSQL(tableName, KeysOfSimpleSQL.SIMPLE_UPDATE, {
+      validateCfg: {
+        'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.INTEGER],
+      },
+    });
+  }
+
+  @Post('/deleteAppSchemaHistory')
+  async deleteAppSchemaHistory() {
+    return this.executeSysSimpleSQL(tableName, KeysOfSimpleSQL.SIMPLE_DELETE, {
+      validateCfg: {
+        'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.INTEGER],
+      },
+    });
+  }
+}

package/src/controller/manage/CrudMethodsMangeApi.ts

@@ -0,0 +1,49 @@
+import { Controller, Inject, 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/crudMethod', { middleware: [checkPermission(SystemFuncCode.CrudMethodApiRead)] })
+export class CrudMethodsMangeApi extends BaseApiController {
+  @Inject()
+  ctx: Context;
+
+  @Post('/getCrudMethodList')
+  async getCrudMethodList() {
+    return this.executeSysSimpleSQL('sys_crud_methods', KeysOfSimpleSQL.SIMPLE_QUERY_PAGE);
+  }
+
+  @Post('/getCrudMethodOne')
+  async getCrudMethodOne() {
+    return this.executeSysSimpleSQL('sys_crud_methods', KeysOfSimpleSQL.SIMPLE_QUERY_ONE);
+  }
+
+  @Post('/createCrudMethod', { middleware: [checkPermission(SystemFuncCode.CrudMethodApiWrite)] })
+  async createCrudMethod() {
+    return this.executeSysSimpleSQL('sys_crud_methods', KeysOfSimpleSQL.SIMPLE_INSERT, {
+      validateCfg: {
+        'data.method': [KeysOfValidators.REQUIRED, KeysOfValidators.STRING],
+      },
+    });
+  }
+
+  @Post('/updateCrudMethod', { middleware: [checkPermission(SystemFuncCode.CrudMethodApiWrite)] })
+  async updateCrudMethod() {
+    return this.executeSysSimpleSQL('sys_crud_methods', KeysOfSimpleSQL.SIMPLE_UPDATE, {
+      validateCfg: {
+        'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.INTEGER],
+      },
+    });
+  }
+
+  @Post('/deleteCrudMethod', { middleware: [checkPermission(SystemFuncCode.CrudMethodApiWrite)] })
+  async deleteCrudMethod() {
+    return this.executeSysSimpleSQL('sys_crud_methods', KeysOfSimpleSQL.SIMPLE_DELETE, {
+      validateCfg: {
+        'condition.id': [KeysOfValidators.REQUIRED, KeysOfValidators.INTEGER],
+      },
+    });
+  }
+}

package/src/controller/manage/CrudStandardDesignApi.ts

@@ -0,0 +1,353 @@
+import * as _ from 'lodash';
+import { Config, Controller, Post } from '@midwayjs/core';
+import { BaseApiController } from '../base/BaseApiController';
+import { parseCreateSqlToTitleMap } 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";
+
+
+
+
+@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 = Object.keys(this.mysql2Config || {});
+    const postgresList = Object.keys(this.postgres2Config || {});
+    const sqlServerList = Object.keys(this.sqlserver2Config || {});
+
+    const toSelectList= (dbCfgNameList:string[], dbType: SqlDbType)=> {
+      return dbCfgNameList.map(item => {
+        const dbName = item;
+        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];
+
+    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,
+      sqlDdType: 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,
+      sqlDdType: SqlDbType.mysql,
+      crudType: KeyOfCrudTypes.SYS_QUERY,
+    });
+    const tableCreate = await this.curdMixService.executeSQL({
+      executeSql: 'show create table ' + tableName,
+      sqlDatabase: dbName,
+      sqlDdType: 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 \n" +
+      "FROM sys.tables" +
+      "";
+    const arr = await this.curdMixService.executeSQL({
+      executeSql: sql,
+      sqlDatabase: dbName,
+      sqlDdType: 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 schemaname = "public"
+
+    const sql = "" +
+      "SELECT tablename\n" +
+      "FROM pg_tables\n" +
+      `WHERE schemaname = '${schemaname}' \n` +
+      "ORDER BY tablename;"
+
+    const dbType = SqlDbType.postgres;
+
+    const arr = await this.curdMixService.executeSQL({
+      executeSql: sql,
+      sqlDatabase: dbName,
+      sqlDdType: 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 getTableFieldsOfSqlServer(dbName: string, tableName: string): Promise<CommonResult> {
+    const dbConfig = this.sqlserver2Config[dbName];
+    if (!dbConfig) {
+      throw new CommonException("DB_NOT_FOUND","数据库配置没有找到：" +dbName);
+    }
+
+    const columnArraySql = "" +
+      "\n" +
+      "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,
+      sqlDdType: 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,
+      sqlDdType: dbType,
+      crudType: KeyOfCrudTypes.SYS_QUERY,
+      executeSqlArgs: [ 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: 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,
+      },
+    };
+  }
+}

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()
+  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],
+      },
+    });
+  }
+
+  @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],
+      },
+    });
+  }
+}