最新版本升级

openhis-server-new/core-generator/pom.xml

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns="http://maven.apache.org/POM/4.0.0"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <groupId>com.openhis</groupId>
+        <artifactId>openhis-server</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.core</groupId>
+    <artifactId>core-generator</artifactId>
+
+    <description>
+        generator代码生成
+    </description>
+
+    <dependencies>
+
+        <!-- velocity代码生成使用模板 -->
+        <dependency>
+            <groupId>org.apache.velocity</groupId>
+            <artifactId>velocity-engine-core</artifactId>
+        </dependency>
+
+        <!-- 通用工具-->
+        <dependency>
+            <groupId>com.core</groupId>
+            <artifactId>core-common</artifactId>
+        </dependency>
+
+        <!-- 阿里数据库连接池 -->
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid-spring-boot-starter</artifactId>
+        </dependency>
+
+    </dependencies>
+
+</project>

openhis-server-new/core-generator/src/main/java/com/core/generator/config/GenConfig.java

@@ -0,0 +1,64 @@
+package com.core.generator.config;
+
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.context.properties.ConfigurationProperties;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.stereotype.Component;
+
+/**
+ * 读取代码生成相关配置
+ * 
+ * @author system
+ */
+@Component
+@ConfigurationProperties(prefix = "gen")
+@PropertySource(value = {"classpath:generator.yml"})
+public class GenConfig {
+    /** 作者 */
+    public static String author;
+
+    /** 生成包路径 */
+    public static String packageName;
+
+    /** 自动去除表前缀，默认是false */
+    public static boolean autoRemovePre;
+
+    /** 表前缀(类名不会包含表前缀) */
+    public static String tablePrefix;
+
+    public static String getAuthor() {
+        return author;
+    }
+
+    @Value("${author}")
+    public void setAuthor(String author) {
+        GenConfig.author = author;
+    }
+
+    public static String getPackageName() {
+        return packageName;
+    }
+
+    @Value("${packageName}")
+    public void setPackageName(String packageName) {
+        GenConfig.packageName = packageName;
+    }
+
+    public static boolean getAutoRemovePre() {
+        return autoRemovePre;
+    }
+
+    @Value("${autoRemovePre}")
+    public void setAutoRemovePre(boolean autoRemovePre) {
+        GenConfig.autoRemovePre = autoRemovePre;
+    }
+
+    public static String getTablePrefix() {
+        return tablePrefix;
+    }
+
+    @Value("${tablePrefix}")
+    public void setTablePrefix(String tablePrefix) {
+        GenConfig.tablePrefix = tablePrefix;
+    }
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/controller/GenController.java

@@ -0,0 +1,451 @@
+package com.core.generator.controller;
+
+import java.io.BufferedWriter;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletResponse;
+
+import org.apache.commons.io.IOUtils;
+import org.apache.poi.ss.usermodel.*;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.multipart.MultipartFile;
+
+import com.alibaba.druid.DbType;
+import com.alibaba.druid.sql.SQLUtils;
+import com.alibaba.druid.sql.ast.SQLStatement;
+import com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlCreateTableStatement;
+import com.core.common.annotation.Log;
+import com.core.common.core.controller.BaseController;
+import com.core.common.core.domain.AjaxResult;
+import com.core.common.core.page.TableDataInfo;
+import com.core.common.core.text.Convert;
+import com.core.common.enums.BusinessType;
+import com.core.common.utils.SecurityUtils;
+import com.core.common.utils.StringUtils;
+import com.core.common.utils.sql.SqlUtil;
+import com.core.generator.domain.GenTable;
+import com.core.generator.domain.GenTableColumn;
+import com.core.generator.service.IGenTableColumnService;
+import com.core.generator.service.IGenTableService;
+
+/**
+ * 代码生成 操作处理
+ * 
+ * @author system
+ */
+@RestController
+@RequestMapping("/tool/gen")
+public class GenController extends BaseController {
+    @Autowired
+    private IGenTableService genTableService;
+
+    @Autowired
+    private IGenTableColumnService genTableColumnService;
+
+    /**
+     * 查询代码生成列表
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:list')")
+    @GetMapping("/list")
+    public TableDataInfo genList(GenTable genTable) {
+        startPage();
+        List<GenTable> list = genTableService.selectGenTableList(genTable);
+        return getDataTable(list);
+    }
+
+    /**
+     * 修改代码生成业务
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:query')")
+    @GetMapping(value = "/{tableId}")
+    public AjaxResult getInfo(@PathVariable Long tableId) {
+        GenTable table = genTableService.selectGenTableById(tableId);
+        List<GenTable> tables = genTableService.selectGenTableAll();
+        List<GenTableColumn> list = genTableColumnService.selectGenTableColumnListByTableId(tableId);
+        Map<String, Object> map = new HashMap<String, Object>();
+        map.put("info", table);
+        map.put("rows", list);
+        map.put("tables", tables);
+        return success(map);
+    }
+
+    /**
+     * 查询数据库列表
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:list')")
+    @GetMapping("/db/list")
+    public TableDataInfo dataList(GenTable genTable) {
+        startPage();
+        List<GenTable> list = genTableService.selectDbTableList(genTable);
+        return getDataTable(list);
+    }
+
+    /**
+     * 查询数据表字段列表
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:list')")
+    @GetMapping(value = "/column/{tableId}")
+    public TableDataInfo columnList(Long tableId) {
+        TableDataInfo dataInfo = new TableDataInfo();
+        List<GenTableColumn> list = genTableColumnService.selectGenTableColumnListByTableId(tableId);
+        dataInfo.setRows(list);
+        dataInfo.setTotal(list.size());
+        return dataInfo;
+    }
+
+    /**
+     * 导入表结构（保存）
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:import')")
+    @Log(title = "代码生成", businessType = BusinessType.IMPORT)
+    @PostMapping("/importTable")
+    public AjaxResult importTableSave(String tables) {
+        String[] tableNames = Convert.toStrArray(tables);
+        // 查询表信息
+        List<GenTable> tableList = genTableService.selectDbTableListByNames(tableNames);
+        genTableService.importGenTable(tableList, SecurityUtils.getUsername());
+        return success();
+    }
+
+    /**
+     * 创建表结构（保存）
+     */
+    @PreAuthorize("@ss.hasRole('admin')")
+    @Log(title = "创建表", businessType = BusinessType.OTHER)
+    @PostMapping("/createTable")
+    public AjaxResult createTableSave(String sql) {
+        try {
+            SqlUtil.filterKeyword(sql);
+            List<SQLStatement> sqlStatements = SQLUtils.parseStatements(sql, DbType.mysql);
+            List<String> tableNames = new ArrayList<>();
+            for (SQLStatement sqlStatement : sqlStatements) {
+                if (sqlStatement instanceof MySqlCreateTableStatement) {
+                    MySqlCreateTableStatement createTableStatement = (MySqlCreateTableStatement)sqlStatement;
+                    if (genTableService.createTable(createTableStatement.toString())) {
+                        String tableName = createTableStatement.getTableName().replaceAll("`", "");
+                        tableNames.add(tableName);
+                    }
+                }
+            }
+            List<GenTable> tableList =
+                genTableService.selectDbTableListByNames(tableNames.toArray(new String[tableNames.size()]));
+            String operName = SecurityUtils.getUsername();
+            genTableService.importGenTable(tableList, operName);
+            return AjaxResult.success();
+        } catch (Exception e) {
+            logger.error(e.getMessage(), e);
+            return AjaxResult.error("创建表结构异常");
+        }
+    }
+
+    /**
+     * 修改保存代码生成业务
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:edit')")
+    @Log(title = "代码生成", businessType = BusinessType.UPDATE)
+    @PutMapping
+    public AjaxResult editSave(@Validated @RequestBody GenTable genTable) {
+        genTableService.validateEdit(genTable);
+        genTableService.updateGenTable(genTable);
+        return success();
+    }
+
+    /**
+     * 删除代码生成
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:remove')")
+    @Log(title = "代码生成", businessType = BusinessType.DELETE)
+    @DeleteMapping("/{tableIds}")
+    public AjaxResult remove(@PathVariable Long[] tableIds) {
+        genTableService.deleteGenTableByIds(tableIds);
+        return success();
+    }
+
+    /**
+     * 预览代码
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:preview')")
+    @GetMapping("/preview/{tableId}")
+    public AjaxResult preview(@PathVariable("tableId") Long tableId) throws IOException {
+        Map<String, String> dataMap = genTableService.previewCode(tableId);
+        return success(dataMap);
+    }
+
+    /**
+     * 生成代码（下载方式）
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:code')")
+    @Log(title = "代码生成", businessType = BusinessType.GENCODE)
+    @GetMapping("/download/{tableName}")
+    public void download(HttpServletResponse response, @PathVariable("tableName") String tableName) throws IOException {
+        byte[] data = genTableService.downloadCode(tableName);
+        genCode(response, data);
+    }
+
+    /**
+     * 生成代码（自定义路径）
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:code')")
+    @Log(title = "代码生成", businessType = BusinessType.GENCODE)
+    @GetMapping("/genCode/{tableName}")
+    public AjaxResult genCode(@PathVariable("tableName") String tableName) {
+        genTableService.generatorCode(tableName);
+        return success();
+    }
+
+    /**
+     * 同步数据库
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:edit')")
+    @Log(title = "代码生成", businessType = BusinessType.UPDATE)
+    @GetMapping("/synchDb/{tableName}")
+    public AjaxResult synchDb(@PathVariable("tableName") String tableName) {
+        genTableService.synchDb(tableName);
+        return success();
+    }
+
+    /**
+     * 批量生成代码
+     */
+    @PreAuthorize("@ss.hasPermi('tool:gen:code')")
+    @Log(title = "代码生成", businessType = BusinessType.GENCODE)
+    @GetMapping("/batchGenCode")
+    public void batchGenCode(HttpServletResponse response, String tables) throws IOException {
+        String[] tableNames = Convert.toStrArray(tables);
+        byte[] data = genTableService.downloadCode(tableNames);
+        genCode(response, data);
+    }
+
+    /**
+     * 生成zip文件
+     */
+    private void genCode(HttpServletResponse response, byte[] data) throws IOException {
+        response.reset();
+        response.addHeader("Access-Control-Allow-Origin", "*");
+        response.addHeader("Access-Control-Expose-Headers", "Content-Disposition");
+        response.setHeader("Content-Disposition", "attachment; filename=\"core.zip\"");
+        response.addHeader("Content-Length", "" + data.length);
+        response.setContentType("application/octet-stream; charset=UTF-8");
+        IOUtils.write(data, response.getOutputStream());
+    }
+
+    /**
+     * 导入表设计
+     * 
+     * @param file
+     * @return
+     */
+    @PostMapping("/importTableDesign")
+    public AjaxResult importTableDesign(MultipartFile file) {
+        try {
+            // 读取文件
+            InputStream is = file.getInputStream();
+            Workbook wb = WorkbookFactory.create(is);
+            StringBuilder sb = new StringBuilder();
+
+            // 遍历每个sheet页（每个表）
+            for (int i = 0; i < wb.getNumberOfSheets(); i++) {
+                sb.append("-- ----------------------------------------------------------------------------------\n");
+                Sheet st = wb.getSheetAt(i);
+
+                // 从第一行读取表名表注释
+                Row row0 = st.getRow(0);// 表名
+                String tableName = row0.getCell(4).toString();// 表名
+                String tableComment = row0.getCell(1).toString();// 表注释
+
+                // 【开头】CREATE TABLE "public".表名 (
+                StringBuilder createTableSqlSb = new StringBuilder();
+                createTableSqlSb.append("CREATE TABLE \"public\".");
+                createTableSqlSb.append(tableName);
+                createTableSqlSb.append(" (");
+                StringBuilder columnCommentSqlSb = new StringBuilder();
+
+                // 遍历每行字段
+                for (int j = 3; j < st.getLastRowNum(); j++) {
+                    Row rowj = st.getRow(j);
+                    Cell columnNo = rowj.getCell(0);// 序号
+                    Cell columnComment = rowj.getCell(1);// 字段注释
+                    Cell columnName = rowj.getCell(2);// 字段名
+                    Cell columnType = rowj.getCell(3);// 类型
+                    Cell columnLength = rowj.getCell(4);// 长度
+                    Cell columnNullable = rowj.getCell(6);// NULL允许
+                    Cell columnDefaultValue = rowj.getCell(8);// 默认值
+                    if (columnNo == null || StringUtils.isEmpty(columnNo.toString())) {
+                        // 没有序号说明遍历完毕，终止循环
+                        break;
+                    }
+                    createTableSqlSb.append("\n \"");
+                    createTableSqlSb.append(columnName.toString());
+                    createTableSqlSb.append("\" ");
+
+                    // 主键行
+                    if (j == 3) {
+                        // int8 NOT NULL DEFAULT nextval('表名_id_seq'::regclass),
+                        createTableSqlSb.append("int8 NOT NULL DEFAULT nextval('");
+                        createTableSqlSb.append(tableName);
+                        createTableSqlSb.append("_id_seq'::regclass),");
+
+                        // 类型【bigint】
+                    } else if ("bigint".equals(columnType.toString())) {
+                        if (columnNullable == null || StringUtils.isEmpty(columnNullable.toString())) {
+                            createTableSqlSb.append("int8 NOT NULL ");
+                            if (columnDefaultValue == null || StringUtils.isEmpty(columnDefaultValue.toString())) {
+                                // 【不允许NULL】【没有默认值】int8 NOT NULL ,
+                                createTableSqlSb.append(",");
+                            } else {
+                                // 【不允许NULL】【有默认值】int8 NOT NULL DEFAULT 0,
+                                createTableSqlSb.append("DEFAULT 0,");
+                            }
+                        } else {
+                            // 【允许NULL】int8 NULL,
+                            createTableSqlSb.append("int8 NULL,");
+                        }
+
+                        // 类型【integer】
+                    } else if ("integer".equals(columnType.toString())) {
+                        if (columnNullable == null || StringUtils.isEmpty(columnNullable.toString())) {
+                            createTableSqlSb.append("int4 NOT NULL ");
+                            if (columnDefaultValue == null || StringUtils.isEmpty(columnDefaultValue.toString())) {
+                                // 【不允许NULL】【没有默认值】int4 NOT NULL ,
+                                createTableSqlSb.append(",");
+                            } else {
+                                // 【不允许NULL】【有默认值】int4 NOT NULL DEFAULT 0,
+                                createTableSqlSb.append("DEFAULT ");
+                                createTableSqlSb.append(columnDefaultValue);
+                                createTableSqlSb.append(",");
+                            }
+                        } else {
+                            // 【允许NULL】int4 NULL,
+                            createTableSqlSb.append("int4 NULL,");
+                        }
+
+                        // 类型【varchar】
+                    } else if ("varchar".equals(columnType.toString())) {
+                        createTableSqlSb.append("varchar(");
+                        createTableSqlSb.append(columnLength.toString().split("\\.")[0]);
+                        if (columnNullable == null || StringUtils.isEmpty(columnNullable.toString())) {
+                            createTableSqlSb.append(") NOT NULL ");
+                            if (columnDefaultValue == null) {
+                                // 【不允许NULL】【没有默认值】varchar(?) NOT NULL ,
+                                createTableSqlSb.append(",");
+                            } else {
+                                if (columnName.toString().contains("json")) {
+                                    // 【不允许NULL】【有默认值】【是JSON字段】varchar(?) NOT NULL DEFAULT '{}'::character varying,
+                                    createTableSqlSb.append("DEFAULT '{}'::character varying,");
+                                } else {
+                                    // 【不允许NULL】【有默认值】【不是JSON字段】varchar(?) NOT NULL DEFAULT ''::character varying,
+                                    createTableSqlSb.append("DEFAULT ''::character varying,");
+                                }
+                            }
+                        } else {
+                            // 【允许NULL】varchar(?) NULL,
+                            createTableSqlSb.append(") NULL,");
+                        }
+
+                        // 类型【char】
+                    } else if ("char".equals(columnType.toString())) {
+                        createTableSqlSb.append("char(");
+                        createTableSqlSb.append(columnLength.toString().split("\\.")[0]);
+                        if (columnNullable == null || StringUtils.isEmpty(columnNullable.toString())) {
+                            createTableSqlSb.append(") NOT NULL ");
+                            if (columnDefaultValue == null) {
+                                // 【不允许NULL】【没有默认值】char(?) NOT NULL ,
+                                createTableSqlSb.append(",");
+                            } else {
+                                // 【不允许NULL】【有默认值】char(?) NOT NULL DEFAULT ''::character varying,,
+                                createTableSqlSb.append("DEFAULT ''::character varying,");
+                            }
+                        } else {
+                            // 【允许NULL】char(?) NULL,
+                            createTableSqlSb.append(") NULL,");
+                        }
+
+                        // 类型【decimal】
+                    } else if ("decimal".equals(columnType.toString())) {
+                        if (columnNullable == null || StringUtils.isEmpty(columnNullable.toString())) {
+                            createTableSqlSb.append("numeric(20,6) NOT NULL ");
+                            if (columnDefaultValue == null) {
+                                // 【不允许NULL】【没有默认值】numeric(20,6) NOT NULL ,
+                                createTableSqlSb.append(",");
+                            } else {
+                                // 【不允许NULL】【有默认值】numeric(20,6) NOT NULL DEFAULT 0,
+                                createTableSqlSb.append("DEFAULT 0,");
+                            }
+                        } else {
+                            // 【允许NULL】numeric(20,6) NULL,
+                            createTableSqlSb.append("numeric(20,6) NULL,");
+                        }
+
+                        // 类型【timestamptz】
+                    } else if ("timestamptz".equals(columnType.toString())) {
+                        if (columnNullable == null || StringUtils.isEmpty(columnNullable.toString())) {
+                            // 【不允许NULL】timestamptz(6) NOT NULL,
+                            createTableSqlSb.append("timestamptz(6) NOT NULL,");
+                        } else {
+                            // 【允许NULL】timestamptz(6) NULL,
+                            createTableSqlSb.append("timestamptz(6) NULL,");
+                        }
+                    }
+
+                    // 各字段注释：COMMENT ON COLUMN "public"."表名"."字段名" IS '注释';
+                    columnCommentSqlSb.append("COMMENT ON COLUMN \"public\".\"");
+                    columnCommentSqlSb.append(tableName);
+                    columnCommentSqlSb.append("\".\"");
+                    columnCommentSqlSb.append(columnName);
+                    columnCommentSqlSb.append("\" IS '");
+                    columnCommentSqlSb.append(columnComment.toString());
+                    columnCommentSqlSb.append("';\n");
+                }
+
+                // 拼接Sequence文
+                String createSequenceSql = "create sequence public." + tableName
+                    + "_id_seq increment 1 start 200 minvalue 1 maxvalue 99999999 cache 1;\n";
+                // 拼接drop文
+                String dropTableSql = "DROP TABLE IF EXISTS \"public\".\"" + tableName + "\";\n";
+                // 拼接create文
+                createTableSqlSb.deleteCharAt(createTableSqlSb.length() - 1);
+                createTableSqlSb.append("\n);\n");
+                String createTableSql = createTableSqlSb.toString();
+                // 拼接Comment文
+                columnCommentSqlSb.append("COMMENT ON TABLE \"public\".\"");
+                columnCommentSqlSb.append(tableName);
+                columnCommentSqlSb.append("\" IS '");
+                columnCommentSqlSb.append(tableComment).append("';\n");
+                String columnCommentSql = columnCommentSqlSb.toString();
+                // 拼接primaryKey文
+                String primaryKeySql = "ALTER TABLE \"public\".\"" + tableName + "\" ADD CONSTRAINT \"" + tableName
+                    + "_pkey\" PRIMARY KEY (\"" + st.getRow(3).getCell(2).toString() + "\");\n";
+                // 拼接nextval文
+                String nextvalSql = "alter table public." + tableName + " alter column id set default nextval('public."
+                    + tableName + "_id_seq');\n";
+                // 全部拼在一起
+                sb.append(createSequenceSql).append("\n").append(dropTableSql).append("\n").append(createTableSql)
+                    .append("\n").append(columnCommentSql).append("\n").append(primaryKeySql).append("\n")
+                    .append(nextvalSql).append("\n");
+            }
+
+            // 将所有表的执行SQL打印到文件中
+            String str = sb.toString();
+            String filePath = "D:\\example.txt";
+            try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath))) {
+                writer.write(str);
+            } catch (IOException e) {
+                e.printStackTrace();
+            } finally {
+                is.close();
+            }
+            return success();
+        } catch (Exception e) {
+            return error();
+        }
+    }
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/domain/GenTable.java

@@ -0,0 +1,330 @@
+package com.core.generator.domain;
+
+import java.util.List;
+
+import javax.validation.Valid;
+import javax.validation.constraints.NotBlank;
+
+import org.apache.commons.lang3.ArrayUtils;
+
+import com.core.common.constant.GenConstants;
+import com.core.common.core.domain.BaseEntity;
+import com.core.common.utils.StringUtils;
+
+/**
+ * 业务表 gen_table
+ * 
+ * @author system
+ */
+public class GenTable extends BaseEntity {
+    private static final long serialVersionUID = 1L;
+
+    /** 编号 */
+    private Long tableId;
+
+    /** 表名称 */
+    @NotBlank(message = "表名称不能为空")
+    private String tableName;
+
+    /** 表描述 */
+    @NotBlank(message = "表描述不能为空")
+    private String tableComment;
+
+    /** 关联父表的表名 */
+    private String subTableName;
+
+    /** 本表关联父表的外键名 */
+    private String subTableFkName;
+
+    /** 实体类名称(首字母大写) */
+    @NotBlank(message = "实体类名称不能为空")
+    private String className;
+
+    /** 使用的模板（crud单表操作 tree树表操作 sub主子表操作） */
+    private String tplCategory;
+
+    /** 前端类型（element-ui模版 element-plus模版） */
+    private String tplWebType;
+
+    /** 生成包路径 */
+    @NotBlank(message = "生成包路径不能为空")
+    private String packageName;
+
+    /** 生成模块名 */
+    @NotBlank(message = "生成模块名不能为空")
+    private String moduleName;
+
+    /** 生成业务名 */
+    @NotBlank(message = "生成业务名不能为空")
+    private String businessName;
+
+    /** 生成功能名 */
+    @NotBlank(message = "生成功能名不能为空")
+    private String functionName;
+
+    /** 生成作者 */
+    @NotBlank(message = "作者不能为空")
+    private String functionAuthor;
+
+    /** 生成代码方式（0zip压缩包 1自定义路径） */
+    private String genType;
+
+    /** 生成路径（不填默认项目路径） */
+    private String genPath;
+
+    /** 主键信息 */
+    private GenTableColumn pkColumn;
+
+    /** 子表信息 */
+    private GenTable subTable;
+
+    /** 表列信息 */
+    @Valid
+    private List<GenTableColumn> columns;
+
+    /** 其它生成选项 */
+    private String options;
+
+    /** 树编码字段 */
+    private String treeCode;
+
+    /** 树父编码字段 */
+    private String treeParentCode;
+
+    /** 树名称字段 */
+    private String treeName;
+
+    /** 上级菜单ID字段 */
+    private Long parentMenuId;
+
+    /** 上级菜单名称字段 */
+    private String parentMenuName;
+
+    public static boolean isSub(String tplCategory) {
+        return tplCategory != null && StringUtils.equals(GenConstants.TPL_SUB, tplCategory);
+    }
+
+    public static boolean isTree(String tplCategory) {
+        return tplCategory != null && StringUtils.equals(GenConstants.TPL_TREE, tplCategory);
+    }
+
+    public static boolean isCrud(String tplCategory) {
+        return tplCategory != null && StringUtils.equals(GenConstants.TPL_CRUD, tplCategory);
+    }
+
+    public static boolean isSuperColumn(String tplCategory, String javaField) {
+        if (isTree(tplCategory)) {
+            return StringUtils.equalsAnyIgnoreCase(javaField,
+                ArrayUtils.addAll(GenConstants.TREE_ENTITY, GenConstants.BASE_ENTITY));
+        }
+        return StringUtils.equalsAnyIgnoreCase(javaField, GenConstants.BASE_ENTITY);
+    }
+
+    public Long getTableId() {
+        return tableId;
+    }
+
+    public void setTableId(Long tableId) {
+        this.tableId = tableId;
+    }
+
+    public String getTableName() {
+        return tableName;
+    }
+
+    public void setTableName(String tableName) {
+        this.tableName = tableName;
+    }
+
+    public String getTableComment() {
+        return tableComment;
+    }
+
+    public void setTableComment(String tableComment) {
+        this.tableComment = tableComment;
+    }
+
+    public String getSubTableName() {
+        return subTableName;
+    }
+
+    public void setSubTableName(String subTableName) {
+        this.subTableName = subTableName;
+    }
+
+    public String getSubTableFkName() {
+        return subTableFkName;
+    }
+
+    public void setSubTableFkName(String subTableFkName) {
+        this.subTableFkName = subTableFkName;
+    }
+
+    public String getClassName() {
+        return className;
+    }
+
+    public void setClassName(String className) {
+        this.className = className;
+    }
+
+    public String getTplCategory() {
+        return tplCategory;
+    }
+
+    public void setTplCategory(String tplCategory) {
+        this.tplCategory = tplCategory;
+    }
+
+    public String getTplWebType() {
+        return tplWebType;
+    }
+
+    public void setTplWebType(String tplWebType) {
+        this.tplWebType = tplWebType;
+    }
+
+    public String getPackageName() {
+        return packageName;
+    }
+
+    public void setPackageName(String packageName) {
+        this.packageName = packageName;
+    }
+
+    public String getModuleName() {
+        return moduleName;
+    }
+
+    public void setModuleName(String moduleName) {
+        this.moduleName = moduleName;
+    }
+
+    public String getBusinessName() {
+        return businessName;
+    }
+
+    public void setBusinessName(String businessName) {
+        this.businessName = businessName;
+    }
+
+    public String getFunctionName() {
+        return functionName;
+    }
+
+    public void setFunctionName(String functionName) {
+        this.functionName = functionName;
+    }
+
+    public String getFunctionAuthor() {
+        return functionAuthor;
+    }
+
+    public void setFunctionAuthor(String functionAuthor) {
+        this.functionAuthor = functionAuthor;
+    }
+
+    public String getGenType() {
+        return genType;
+    }
+
+    public void setGenType(String genType) {
+        this.genType = genType;
+    }
+
+    public String getGenPath() {
+        return genPath;
+    }
+
+    public void setGenPath(String genPath) {
+        this.genPath = genPath;
+    }
+
+    public GenTableColumn getPkColumn() {
+        return pkColumn;
+    }
+
+    public void setPkColumn(GenTableColumn pkColumn) {
+        this.pkColumn = pkColumn;
+    }
+
+    public GenTable getSubTable() {
+        return subTable;
+    }
+
+    public void setSubTable(GenTable subTable) {
+        this.subTable = subTable;
+    }
+
+    public List<GenTableColumn> getColumns() {
+        return columns;
+    }
+
+    public void setColumns(List<GenTableColumn> columns) {
+        this.columns = columns;
+    }
+
+    public String getOptions() {
+        return options;
+    }
+
+    public void setOptions(String options) {
+        this.options = options;
+    }
+
+    public String getTreeCode() {
+        return treeCode;
+    }
+
+    public void setTreeCode(String treeCode) {
+        this.treeCode = treeCode;
+    }
+
+    public String getTreeParentCode() {
+        return treeParentCode;
+    }
+
+    public void setTreeParentCode(String treeParentCode) {
+        this.treeParentCode = treeParentCode;
+    }
+
+    public String getTreeName() {
+        return treeName;
+    }
+
+    public void setTreeName(String treeName) {
+        this.treeName = treeName;
+    }
+
+    public Long getParentMenuId() {
+        return parentMenuId;
+    }
+
+    public void setParentMenuId(Long parentMenuId) {
+        this.parentMenuId = parentMenuId;
+    }
+
+    public String getParentMenuName() {
+        return parentMenuName;
+    }
+
+    public void setParentMenuName(String parentMenuName) {
+        this.parentMenuName = parentMenuName;
+    }
+
+    public boolean isSub() {
+        return isSub(this.tplCategory);
+    }
+
+    public boolean isTree() {
+        return isTree(this.tplCategory);
+    }
+
+    public boolean isCrud() {
+        return isCrud(this.tplCategory);
+    }
+
+    public boolean isSuperColumn(String javaField) {
+        return isSuperColumn(this.tplCategory, javaField);
+    }
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/domain/GenTableColumn.java

@@ -0,0 +1,312 @@
+package com.core.generator.domain;
+
+import javax.validation.constraints.NotBlank;
+
+import com.core.common.core.domain.BaseEntity;
+import com.core.common.utils.StringUtils;
+
+/**
+ * 代码生成业务字段表 gen_table_column
+ * 
+ * @author system
+ */
+public class GenTableColumn extends BaseEntity {
+    private static final long serialVersionUID = 1L;
+
+    /** 编号 */
+    private Long columnId;
+
+    /** 归属表编号 */
+    private Long tableId;
+
+    /** 列名称 */
+    private String columnName;
+
+    /** 列描述 */
+    private String columnComment;
+
+    /** 列类型 */
+    private String columnType;
+
+    /** JAVA类型 */
+    private String javaType;
+
+    /** JAVA字段名 */
+    @NotBlank(message = "Java属性不能为空")
+    private String javaField;
+
+    /** 是否主键（1是） */
+    private String isPk;
+
+    /** 是否自增（1是） */
+    private String isIncrement;
+
+    /** 是否必填（1是） */
+    private String isRequired;
+
+    /** 是否为插入字段（1是） */
+    private String isInsert;
+
+    /** 是否编辑字段（1是） */
+    private String isEdit;
+
+    /** 是否列表字段（1是） */
+    private String isList;
+
+    /** 是否查询字段（1是） */
+    private String isQuery;
+
+    /** 查询方式（EQ等于、NE不等于、GT大于、LT小于、LIKE模糊、BETWEEN范围） */
+    private String queryType;
+
+    /** 显示类型（input文本框、textarea文本域、select下拉框、checkbox复选框、radio单选框、datetime日期控件、image图片上传控件、upload文件上传控件、editor富文本控件） */
+    private String htmlType;
+
+    /** 字典类型 */
+    private String dictType;
+
+    /** 排序 */
+    private Integer sort;
+
+    public static boolean isSuperColumn(String javaField) {
+        return StringUtils.equalsAnyIgnoreCase(javaField,
+            // BaseEntity
+            "createBy", "createTime", "updateBy", "updateTime", "remark",
+            // TreeEntity
+            "parentName", "parentId", "orderNum", "ancestors");
+    }
+
+    public static boolean isUsableColumn(String javaField) {
+        // isSuperColumn()中的名单用于避免生成多余Domain属性，若某些属性在生成页面时需要用到不能忽略，则放在此处白名单
+        return StringUtils.equalsAnyIgnoreCase(javaField, "parentId", "orderNum", "remark");
+    }
+
+    public Long getColumnId() {
+        return columnId;
+    }
+
+    public void setColumnId(Long columnId) {
+        this.columnId = columnId;
+    }
+
+    public Long getTableId() {
+        return tableId;
+    }
+
+    public void setTableId(Long tableId) {
+        this.tableId = tableId;
+    }
+
+    public String getColumnName() {
+        return columnName;
+    }
+
+    public void setColumnName(String columnName) {
+        this.columnName = columnName;
+    }
+
+    public String getColumnComment() {
+        return columnComment;
+    }
+
+    public void setColumnComment(String columnComment) {
+        this.columnComment = columnComment;
+    }
+
+    public String getColumnType() {
+        return columnType;
+    }
+
+    public void setColumnType(String columnType) {
+        this.columnType = columnType;
+    }
+
+    public String getJavaType() {
+        return javaType;
+    }
+
+    public void setJavaType(String javaType) {
+        this.javaType = javaType;
+    }
+
+    public String getJavaField() {
+        return javaField;
+    }
+
+    public void setJavaField(String javaField) {
+        this.javaField = javaField;
+    }
+
+    public String getCapJavaField() {
+        return StringUtils.capitalize(javaField);
+    }
+
+    public String getIsPk() {
+        return isPk;
+    }
+
+    public void setIsPk(String isPk) {
+        this.isPk = isPk;
+    }
+
+    public boolean isPk() {
+        return isPk(this.isPk);
+    }
+
+    public boolean isPk(String isPk) {
+        return isPk != null && StringUtils.equals("1", isPk);
+    }
+
+    public String getIsIncrement() {
+        return isIncrement;
+    }
+
+    public void setIsIncrement(String isIncrement) {
+        this.isIncrement = isIncrement;
+    }
+
+    public boolean isIncrement() {
+        return isIncrement(this.isIncrement);
+    }
+
+    public boolean isIncrement(String isIncrement) {
+        return isIncrement != null && StringUtils.equals("1", isIncrement);
+    }
+
+    public String getIsRequired() {
+        return isRequired;
+    }
+
+    public void setIsRequired(String isRequired) {
+        this.isRequired = isRequired;
+    }
+
+    public boolean isRequired() {
+        return isRequired(this.isRequired);
+    }
+
+    public boolean isRequired(String isRequired) {
+        return isRequired != null && StringUtils.equals("1", isRequired);
+    }
+
+    public String getIsInsert() {
+        return isInsert;
+    }
+
+    public void setIsInsert(String isInsert) {
+        this.isInsert = isInsert;
+    }
+
+    public boolean isInsert() {
+        return isInsert(this.isInsert);
+    }
+
+    public boolean isInsert(String isInsert) {
+        return isInsert != null && StringUtils.equals("1", isInsert);
+    }
+
+    public String getIsEdit() {
+        return isEdit;
+    }
+
+    public void setIsEdit(String isEdit) {
+        this.isEdit = isEdit;
+    }
+
+    public boolean isEdit() {
+        return isInsert(this.isEdit);
+    }
+
+    public boolean isEdit(String isEdit) {
+        return isEdit != null && StringUtils.equals("1", isEdit);
+    }
+
+    public String getIsList() {
+        return isList;
+    }
+
+    public void setIsList(String isList) {
+        this.isList = isList;
+    }
+
+    public boolean isList() {
+        return isList(this.isList);
+    }
+
+    public boolean isList(String isList) {
+        return isList != null && StringUtils.equals("1", isList);
+    }
+
+    public String getIsQuery() {
+        return isQuery;
+    }
+
+    public void setIsQuery(String isQuery) {
+        this.isQuery = isQuery;
+    }
+
+    public boolean isQuery() {
+        return isQuery(this.isQuery);
+    }
+
+    public boolean isQuery(String isQuery) {
+        return isQuery != null && StringUtils.equals("1", isQuery);
+    }
+
+    public String getQueryType() {
+        return queryType;
+    }
+
+    public void setQueryType(String queryType) {
+        this.queryType = queryType;
+    }
+
+    public String getHtmlType() {
+        return htmlType;
+    }
+
+    public void setHtmlType(String htmlType) {
+        this.htmlType = htmlType;
+    }
+
+    public String getDictType() {
+        return dictType;
+    }
+
+    public void setDictType(String dictType) {
+        this.dictType = dictType;
+    }
+
+    public Integer getSort() {
+        return sort;
+    }
+
+    public void setSort(Integer sort) {
+        this.sort = sort;
+    }
+
+    public boolean isSuperColumn() {
+        return isSuperColumn(this.javaField);
+    }
+
+    public boolean isUsableColumn() {
+        return isUsableColumn(javaField);
+    }
+
+    public String readConverterExp() {
+        String remarks = StringUtils.substringBetween(this.columnComment, "（", "）");
+        StringBuffer sb = new StringBuffer();
+        if (StringUtils.isNotEmpty(remarks)) {
+            for (String value : remarks.split(" ")) {
+                if (StringUtils.isNotEmpty(value)) {
+                    Object startStr = value.subSequence(0, 1);
+                    String endStr = value.substring(1);
+                    sb.append("").append(startStr).append("=").append(endStr).append(",");
+                }
+            }
+            return sb.deleteCharAt(sb.length() - 1).toString();
+        } else {
+            return this.columnComment;
+        }
+    }
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/mapper/GenTableColumnMapper.java

@@ -0,0 +1,60 @@
+package com.core.generator.mapper;
+
+import java.util.List;
+
+import com.core.generator.domain.GenTableColumn;
+
+/**
+ * 业务字段 数据层
+ * 
+ * @author system
+ */
+public interface GenTableColumnMapper {
+    /**
+     * 根据表名称查询列信息
+     * 
+     * @param tableName 表名称
+     * @return 列信息
+     */
+    public List<GenTableColumn> selectDbTableColumnsByName(String tableName);
+
+    /**
+     * 查询业务字段列表
+     * 
+     * @param tableId 业务字段编号
+     * @return 业务字段集合
+     */
+    public List<GenTableColumn> selectGenTableColumnListByTableId(Long tableId);
+
+    /**
+     * 新增业务字段
+     * 
+     * @param genTableColumn 业务字段信息
+     * @return 结果
+     */
+    public int insertGenTableColumn(GenTableColumn genTableColumn);
+
+    /**
+     * 修改业务字段
+     * 
+     * @param genTableColumn 业务字段信息
+     * @return 结果
+     */
+    public int updateGenTableColumn(GenTableColumn genTableColumn);
+
+    /**
+     * 删除业务字段
+     * 
+     * @param genTableColumns 列数据
+     * @return 结果
+     */
+    public int deleteGenTableColumns(List<GenTableColumn> genTableColumns);
+
+    /**
+     * 批量删除业务字段
+     * 
+     * @param ids 需要删除的数据ID
+     * @return 结果
+     */
+    public int deleteGenTableColumnByIds(Long[] ids);
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/mapper/GenTableMapper.java

@@ -0,0 +1,91 @@
+package com.core.generator.mapper;
+
+import java.util.List;
+
+import com.core.generator.domain.GenTable;
+
+/**
+ * 业务 数据层
+ * 
+ * @author system
+ */
+public interface GenTableMapper {
+    /**
+     * 查询业务列表
+     * 
+     * @param genTable 业务信息
+     * @return 业务集合
+     */
+    public List<GenTable> selectGenTableList(GenTable genTable);
+
+    /**
+     * 查询据库列表
+     * 
+     * @param genTable 业务信息
+     * @return 数据库表集合
+     */
+    public List<GenTable> selectDbTableList(GenTable genTable);
+
+    /**
+     * 查询据库列表
+     * 
+     * @param tableNames 表名称组
+     * @return 数据库表集合
+     */
+    public List<GenTable> selectDbTableListByNames(String[] tableNames);
+
+    /**
+     * 查询所有表信息
+     * 
+     * @return 表信息集合
+     */
+    public List<GenTable> selectGenTableAll();
+
+    /**
+     * 查询表ID业务信息
+     * 
+     * @param id 业务ID
+     * @return 业务信息
+     */
+    public GenTable selectGenTableById(Long id);
+
+    /**
+     * 查询表名称业务信息
+     * 
+     * @param tableName 表名称
+     * @return 业务信息
+     */
+    public GenTable selectGenTableByName(String tableName);
+
+    /**
+     * 新增业务
+     * 
+     * @param genTable 业务信息
+     * @return 结果
+     */
+    public int insertGenTable(GenTable genTable);
+
+    /**
+     * 修改业务
+     * 
+     * @param genTable 业务信息
+     * @return 结果
+     */
+    public int updateGenTable(GenTable genTable);
+
+    /**
+     * 批量删除业务
+     * 
+     * @param ids 需要删除的数据ID
+     * @return 结果
+     */
+    public int deleteGenTableByIds(Long[] ids);
+
+    /**
+     * 创建表
+     *
+     * @param sql 表结构
+     * @return 结果
+     */
+    public int createTable(String sql);
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/service/GenTableColumnServiceImpl.java

@@ -0,0 +1,65 @@
+package com.core.generator.service;
+
+import java.util.List;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import com.core.common.core.text.Convert;
+import com.core.generator.domain.GenTableColumn;
+import com.core.generator.mapper.GenTableColumnMapper;
+
+/**
+ * 业务字段 服务层实现
+ * 
+ * @author system
+ */
+@Service
+public class GenTableColumnServiceImpl implements IGenTableColumnService {
+    @Autowired
+    private GenTableColumnMapper genTableColumnMapper;
+
+    /**
+     * 查询业务字段列表
+     * 
+     * @param tableId 业务字段编号
+     * @return 业务字段集合
+     */
+    @Override
+    public List<GenTableColumn> selectGenTableColumnListByTableId(Long tableId) {
+        return genTableColumnMapper.selectGenTableColumnListByTableId(tableId);
+    }
+
+    /**
+     * 新增业务字段
+     * 
+     * @param genTableColumn 业务字段信息
+     * @return 结果
+     */
+    @Override
+    public int insertGenTableColumn(GenTableColumn genTableColumn) {
+        return genTableColumnMapper.insertGenTableColumn(genTableColumn);
+    }
+
+    /**
+     * 修改业务字段
+     * 
+     * @param genTableColumn 业务字段信息
+     * @return 结果
+     */
+    @Override
+    public int updateGenTableColumn(GenTableColumn genTableColumn) {
+        return genTableColumnMapper.updateGenTableColumn(genTableColumn);
+    }
+
+    /**
+     * 删除业务字段对象
+     * 
+     * @param ids 需要删除的数据ID
+     * @return 结果
+     */
+    @Override
+    public int deleteGenTableColumnByIds(String ids) {
+        return genTableColumnMapper.deleteGenTableColumnByIds(Convert.toLongArray(ids));
+    }
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/service/GenTableServiceImpl.java

@@ -0,0 +1,469 @@
+package com.core.generator.service;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.IOUtils;
+import org.apache.velocity.Template;
+import org.apache.velocity.VelocityContext;
+import org.apache.velocity.app.Velocity;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONObject;
+import com.core.common.constant.Constants;
+import com.core.common.constant.GenConstants;
+import com.core.common.core.text.CharsetKit;
+import com.core.common.exception.ServiceException;
+import com.core.common.utils.StringUtils;
+import com.core.generator.domain.GenTable;
+import com.core.generator.domain.GenTableColumn;
+import com.core.generator.mapper.GenTableColumnMapper;
+import com.core.generator.mapper.GenTableMapper;
+import com.core.generator.util.GenUtils;
+import com.core.generator.util.VelocityInitializer;
+import com.core.generator.util.VelocityUtils;
+
+/**
+ * 业务 服务层实现
+ * 
+ * @author system
+ */
+@Service
+public class GenTableServiceImpl implements IGenTableService {
+    private static final Logger log = LoggerFactory.getLogger(GenTableServiceImpl.class);
+
+    @Autowired
+    private GenTableMapper genTableMapper;
+
+    @Autowired
+    private GenTableColumnMapper genTableColumnMapper;
+
+    /**
+     * 获取代码生成地址
+     *
+     * @param table 业务表信息
+     * @param template 模板文件路径
+     * @return 生成地址
+     */
+    public static String getGenPath(GenTable table, String template) {
+        String genPath = table.getGenPath();
+        if (StringUtils.equals(genPath, "/")) {
+            return System.getProperty("user.dir") + File.separator + "src" + File.separator
+                + VelocityUtils.getFileName(template, table);
+        }
+        return genPath + File.separator + VelocityUtils.getFileName(template, table);
+    }
+
+    /**
+     * 查询业务信息
+     *
+     * @param id 业务ID
+     * @return 业务信息
+     */
+    @Override
+    public GenTable selectGenTableById(Long id) {
+        GenTable genTable = genTableMapper.selectGenTableById(id);
+        setTableFromOptions(genTable);
+        return genTable;
+    }
+
+    /**
+     * 查询业务列表
+     *
+     * @param genTable 业务信息
+     * @return 业务集合
+     */
+    @Override
+    public List<GenTable> selectGenTableList(GenTable genTable) {
+        return genTableMapper.selectGenTableList(genTable);
+    }
+
+    /**
+     * 查询据库列表
+     *
+     * @param genTable 业务信息
+     * @return 数据库表集合
+     */
+    @Override
+    public List<GenTable> selectDbTableList(GenTable genTable) {
+        return genTableMapper.selectDbTableList(genTable);
+    }
+
+    /**
+     * 查询据库列表
+     *
+     * @param tableNames 表名称组
+     * @return 数据库表集合
+     */
+    @Override
+    public List<GenTable> selectDbTableListByNames(String[] tableNames) {
+        return genTableMapper.selectDbTableListByNames(tableNames);
+    }
+
+    /**
+     * 查询所有表信息
+     *
+     * @return 表信息集合
+     */
+    @Override
+    public List<GenTable> selectGenTableAll() {
+        return genTableMapper.selectGenTableAll();
+    }
+
+    /**
+     * 修改业务
+     *
+     * @param genTable 业务信息
+     * @return 结果
+     */
+    @Override
+    @Transactional
+    public void updateGenTable(GenTable genTable) {
+        String options = JSON.toJSONString(genTable.getParams());
+        genTable.setOptions(options);
+        int row = genTableMapper.updateGenTable(genTable);
+        if (row > 0) {
+            for (GenTableColumn cenTableColumn : genTable.getColumns()) {
+                genTableColumnMapper.updateGenTableColumn(cenTableColumn);
+            }
+        }
+    }
+
+    /**
+     * 删除业务对象
+     *
+     * @param tableIds 需要删除的数据ID
+     * @return 结果
+     */
+    @Override
+    @Transactional
+    public void deleteGenTableByIds(Long[] tableIds) {
+        genTableMapper.deleteGenTableByIds(tableIds);
+        genTableColumnMapper.deleteGenTableColumnByIds(tableIds);
+    }
+
+    /**
+     * 创建表
+     *
+     * @param sql 创建表语句
+     * @return 结果
+     */
+    @Override
+    public boolean createTable(String sql) {
+        return genTableMapper.createTable(sql) == 0;
+    }
+
+    /**
+     * 导入表结构
+     *
+     * @param tableList 导入表列表
+     */
+    @Override
+    @Transactional
+    public void importGenTable(List<GenTable> tableList, String operName) {
+        try {
+            for (GenTable table : tableList) {
+                String tableName = table.getTableName();
+                GenUtils.initTable(table, operName);
+                int row = genTableMapper.insertGenTable(table);
+                if (row > 0) {
+                    // 保存列信息
+                    List<GenTableColumn> genTableColumns = genTableColumnMapper.selectDbTableColumnsByName(tableName);
+                    for (GenTableColumn column : genTableColumns) {
+                        GenUtils.initColumnField(column, table);
+                        genTableColumnMapper.insertGenTableColumn(column);
+                    }
+                }
+            }
+        } catch (Exception e) {
+            throw new ServiceException("导入失败：" + e.getMessage());
+        }
+    }
+
+    /**
+     * 预览代码
+     *
+     * @param tableId 表编号
+     * @return 预览数据列表
+     */
+    @Override
+    public Map<String, String> previewCode(Long tableId) {
+        Map<String, String> dataMap = new LinkedHashMap<>();
+        // 查询表信息
+        GenTable table = genTableMapper.selectGenTableById(tableId);
+        // 设置主子表信息
+        setSubTable(table);
+        // 设置主键列信息
+        setPkColumn(table);
+        VelocityInitializer.initVelocity();
+
+        VelocityContext context = VelocityUtils.prepareContext(table);
+
+        // 获取模板列表
+        List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory(), table.getTplWebType());
+        for (String template : templates) {
+            // 渲染模板
+            StringWriter sw = new StringWriter();
+            Template tpl = Velocity.getTemplate(template, Constants.UTF8);
+            tpl.merge(context, sw);
+            dataMap.put(template, sw.toString());
+        }
+        return dataMap;
+    }
+
+    /**
+     * 生成代码（下载方式）
+     *
+     * @param tableName 表名称
+     * @return 数据
+     */
+    @Override
+    public byte[] downloadCode(String tableName) {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        ZipOutputStream zip = new ZipOutputStream(outputStream);
+        generatorCode(tableName, zip);
+        IOUtils.closeQuietly(zip);
+        return outputStream.toByteArray();
+    }
+
+    /**
+     * 生成代码（自定义路径）
+     *
+     * @param tableName 表名称
+     */
+    @Override
+    public void generatorCode(String tableName) {
+        // 查询表信息
+        GenTable table = genTableMapper.selectGenTableByName(tableName);
+        // 设置主子表信息
+        setSubTable(table);
+        // 设置主键列信息
+        setPkColumn(table);
+
+        VelocityInitializer.initVelocity();
+
+        VelocityContext context = VelocityUtils.prepareContext(table);
+
+        // 获取模板列表
+        List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory(), table.getTplWebType());
+        for (String template : templates) {
+            if (!StringUtils.containsAny(template, "sql.vm", "api.js.vm", "index.vue.vm", "index-tree.vue.vm")) {
+                // 渲染模板
+                StringWriter sw = new StringWriter();
+                Template tpl = Velocity.getTemplate(template, Constants.UTF8);
+                tpl.merge(context, sw);
+                try {
+                    String path = getGenPath(table, template);
+                    FileUtils.writeStringToFile(new File(path), sw.toString(), CharsetKit.UTF_8);
+                } catch (IOException e) {
+                    throw new ServiceException("渲染模板失败，表名：" + table.getTableName());
+                }
+            }
+        }
+    }
+
+    /**
+     * 同步数据库
+     *
+     * @param tableName 表名称
+     */
+    @Override
+    @Transactional
+    public void synchDb(String tableName) {
+        GenTable table = genTableMapper.selectGenTableByName(tableName);
+        List<GenTableColumn> tableColumns = table.getColumns();
+        Map<String, GenTableColumn> tableColumnMap =
+            tableColumns.stream().collect(Collectors.toMap(GenTableColumn::getColumnName, Function.identity()));
+
+        List<GenTableColumn> dbTableColumns = genTableColumnMapper.selectDbTableColumnsByName(tableName);
+        if (StringUtils.isEmpty(dbTableColumns)) {
+            throw new ServiceException("同步数据失败，原表结构不存在");
+        }
+        List<String> dbTableColumnNames =
+            dbTableColumns.stream().map(GenTableColumn::getColumnName).collect(Collectors.toList());
+
+        dbTableColumns.forEach(column -> {
+            GenUtils.initColumnField(column, table);
+            if (tableColumnMap.containsKey(column.getColumnName())) {
+                GenTableColumn prevColumn = tableColumnMap.get(column.getColumnName());
+                column.setColumnId(prevColumn.getColumnId());
+                if (column.isList()) {
+                    // 如果是列表，继续保留查询方式/字典类型选项
+                    column.setDictType(prevColumn.getDictType());
+                    column.setQueryType(prevColumn.getQueryType());
+                }
+                if (StringUtils.isNotEmpty(prevColumn.getIsRequired()) && !column.isPk()
+                    && (column.isInsert() || column.isEdit())
+                    && ((column.isUsableColumn()) || (!column.isSuperColumn()))) {
+                    // 如果是(新增/修改&非主键/非忽略及父属性)，继续保留必填/显示类型选项
+                    column.setIsRequired(prevColumn.getIsRequired());
+                    column.setHtmlType(prevColumn.getHtmlType());
+                }
+                genTableColumnMapper.updateGenTableColumn(column);
+            } else {
+                genTableColumnMapper.insertGenTableColumn(column);
+            }
+        });
+
+        List<GenTableColumn> delColumns = tableColumns.stream()
+            .filter(column -> !dbTableColumnNames.contains(column.getColumnName())).collect(Collectors.toList());
+        if (StringUtils.isNotEmpty(delColumns)) {
+            genTableColumnMapper.deleteGenTableColumns(delColumns);
+        }
+    }
+
+    /**
+     * 批量生成代码（下载方式）
+     *
+     * @param tableNames 表数组
+     * @return 数据
+     */
+    @Override
+    public byte[] downloadCode(String[] tableNames) {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        ZipOutputStream zip = new ZipOutputStream(outputStream);
+        for (String tableName : tableNames) {
+            generatorCode(tableName, zip);
+        }
+        IOUtils.closeQuietly(zip);
+        return outputStream.toByteArray();
+    }
+
+    /**
+     * 查询表信息并生成代码
+     */
+    private void generatorCode(String tableName, ZipOutputStream zip) {
+        // 查询表信息
+        GenTable table = genTableMapper.selectGenTableByName(tableName);
+        // 设置主子表信息
+        setSubTable(table);
+        // 设置主键列信息
+        setPkColumn(table);
+
+        VelocityInitializer.initVelocity();
+
+        VelocityContext context = VelocityUtils.prepareContext(table);
+
+        // 获取模板列表
+        List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory(), table.getTplWebType());
+        for (String template : templates) {
+            // 渲染模板
+            StringWriter sw = new StringWriter();
+            Template tpl = Velocity.getTemplate(template, Constants.UTF8);
+            tpl.merge(context, sw);
+            try {
+                // 添加到zip
+                zip.putNextEntry(new ZipEntry(VelocityUtils.getFileName(template, table)));
+                IOUtils.write(sw.toString(), zip, Constants.UTF8);
+                IOUtils.closeQuietly(sw);
+                zip.flush();
+                zip.closeEntry();
+            } catch (IOException e) {
+                log.error("渲染模板失败，表名：" + table.getTableName(), e);
+            }
+        }
+    }
+
+    /**
+     * 修改保存参数校验
+     *
+     * @param genTable 业务信息
+     */
+    @Override
+    public void validateEdit(GenTable genTable) {
+        if (GenConstants.TPL_TREE.equals(genTable.getTplCategory())) {
+            String options = JSON.toJSONString(genTable.getParams());
+            JSONObject paramsObj = JSON.parseObject(options);
+            if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_CODE))) {
+                throw new ServiceException("树编码字段不能为空");
+            } else if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_PARENT_CODE))) {
+                throw new ServiceException("树父编码字段不能为空");
+            } else if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_NAME))) {
+                throw new ServiceException("树名称字段不能为空");
+            } else if (GenConstants.TPL_SUB.equals(genTable.getTplCategory())) {
+                if (StringUtils.isEmpty(genTable.getSubTableName())) {
+                    throw new ServiceException("关联子表的表名不能为空");
+                } else if (StringUtils.isEmpty(genTable.getSubTableFkName())) {
+                    throw new ServiceException("子表关联的外键名不能为空");
+                }
+            }
+        }
+    }
+
+    /**
+     * 设置主键列信息
+     *
+     * @param table 业务表信息
+     */
+    public void setPkColumn(GenTable table) {
+        for (GenTableColumn column : table.getColumns()) {
+            if (column.isPk()) {
+                table.setPkColumn(column);
+                break;
+            }
+        }
+        if (StringUtils.isNull(table.getPkColumn())) {
+            table.setPkColumn(table.getColumns().get(0));
+        }
+        if (GenConstants.TPL_SUB.equals(table.getTplCategory())) {
+            for (GenTableColumn column : table.getSubTable().getColumns()) {
+                if (column.isPk()) {
+                    table.getSubTable().setPkColumn(column);
+                    break;
+                }
+            }
+            if (StringUtils.isNull(table.getSubTable().getPkColumn())) {
+                table.getSubTable().setPkColumn(table.getSubTable().getColumns().get(0));
+            }
+        }
+    }
+
+    /**
+     * 设置主子表信息
+     *
+     * @param table 业务表信息
+     */
+    public void setSubTable(GenTable table) {
+        String subTableName = table.getSubTableName();
+        if (StringUtils.isNotEmpty(subTableName)) {
+            table.setSubTable(genTableMapper.selectGenTableByName(subTableName));
+        }
+    }
+
+    /**
+     * 设置代码生成其他选项值
+     *
+     * @param genTable 设置后的生成对象
+     */
+    public void setTableFromOptions(GenTable genTable) {
+        JSONObject paramsObj = JSON.parseObject(genTable.getOptions());
+        if (StringUtils.isNotNull(paramsObj)) {
+            String treeCode = paramsObj.getString(GenConstants.TREE_CODE);
+            String treeParentCode = paramsObj.getString(GenConstants.TREE_PARENT_CODE);
+            String treeName = paramsObj.getString(GenConstants.TREE_NAME);
+            Long parentMenuId = paramsObj.getLongValue(GenConstants.PARENT_MENU_ID);
+            String parentMenuName = paramsObj.getString(GenConstants.PARENT_MENU_NAME);
+
+            genTable.setTreeCode(treeCode);
+            genTable.setTreeParentCode(treeParentCode);
+            genTable.setTreeName(treeName);
+            genTable.setParentMenuId(parentMenuId);
+            genTable.setParentMenuName(parentMenuName);
+        }
+    }
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/service/IGenTableColumnService.java

@@ -0,0 +1,44 @@
+package com.core.generator.service;
+
+import java.util.List;
+
+import com.core.generator.domain.GenTableColumn;
+
+/**
+ * 业务字段 服务层
+ * 
+ * @author system
+ */
+public interface IGenTableColumnService {
+    /**
+     * 查询业务字段列表
+     * 
+     * @param tableId 业务字段编号
+     * @return 业务字段集合
+     */
+    public List<GenTableColumn> selectGenTableColumnListByTableId(Long tableId);
+
+    /**
+     * 新增业务字段
+     * 
+     * @param genTableColumn 业务字段信息
+     * @return 结果
+     */
+    public int insertGenTableColumn(GenTableColumn genTableColumn);
+
+    /**
+     * 修改业务字段
+     * 
+     * @param genTableColumn 业务字段信息
+     * @return 结果
+     */
+    public int updateGenTableColumn(GenTableColumn genTableColumn);
+
+    /**
+     * 删除业务字段信息
+     * 
+     * @param ids 需要删除的数据ID
+     * @return 结果
+     */
+    public int deleteGenTableColumnByIds(String ids);
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/service/IGenTableService.java

@@ -0,0 +1,130 @@
+package com.core.generator.service;
+
+import java.util.List;
+import java.util.Map;
+
+import com.core.generator.domain.GenTable;
+
+/**
+ * 业务 服务层
+ * 
+ * @author system
+ */
+public interface IGenTableService {
+    /**
+     * 查询业务列表
+     * 
+     * @param genTable 业务信息
+     * @return 业务集合
+     */
+    public List<GenTable> selectGenTableList(GenTable genTable);
+
+    /**
+     * 查询据库列表
+     * 
+     * @param genTable 业务信息
+     * @return 数据库表集合
+     */
+    public List<GenTable> selectDbTableList(GenTable genTable);
+
+    /**
+     * 查询据库列表
+     * 
+     * @param tableNames 表名称组
+     * @return 数据库表集合
+     */
+    public List<GenTable> selectDbTableListByNames(String[] tableNames);
+
+    /**
+     * 查询所有表信息
+     * 
+     * @return 表信息集合
+     */
+    public List<GenTable> selectGenTableAll();
+
+    /**
+     * 查询业务信息
+     * 
+     * @param id 业务ID
+     * @return 业务信息
+     */
+    public GenTable selectGenTableById(Long id);
+
+    /**
+     * 修改业务
+     * 
+     * @param genTable 业务信息
+     * @return 结果
+     */
+    public void updateGenTable(GenTable genTable);
+
+    /**
+     * 删除业务信息
+     * 
+     * @param tableIds 需要删除的表数据ID
+     * @return 结果
+     */
+    public void deleteGenTableByIds(Long[] tableIds);
+
+    /**
+     * 创建表
+     *
+     * @param sql 创建表语句
+     * @return 结果
+     */
+    public boolean createTable(String sql);
+
+    /**
+     * 导入表结构
+     *
+     * @param tableList 导入表列表
+     * @param operName 操作人员
+     */
+    public void importGenTable(List<GenTable> tableList, String operName);
+
+    /**
+     * 预览代码
+     * 
+     * @param tableId 表编号
+     * @return 预览数据列表
+     */
+    public Map<String, String> previewCode(Long tableId);
+
+    /**
+     * 生成代码（下载方式）
+     * 
+     * @param tableName 表名称
+     * @return 数据
+     */
+    public byte[] downloadCode(String tableName);
+
+    /**
+     * 生成代码（自定义路径）
+     * 
+     * @param tableName 表名称
+     * @return 数据
+     */
+    public void generatorCode(String tableName);
+
+    /**
+     * 同步数据库
+     * 
+     * @param tableName 表名称
+     */
+    public void synchDb(String tableName);
+
+    /**
+     * 批量生成代码（下载方式）
+     * 
+     * @param tableNames 表数组
+     * @return 数据
+     */
+    public byte[] downloadCode(String[] tableNames);
+
+    /**
+     * 修改保存参数校验
+     * 
+     * @param genTable 业务信息
+     */
+    public void validateEdit(GenTable genTable);
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/util/GenUtils.java

@@ -0,0 +1,202 @@
+package com.core.generator.util;
+
+import java.util.Arrays;
+
+import org.apache.commons.lang3.RegExUtils;
+
+import com.core.common.constant.GenConstants;
+import com.core.common.utils.StringUtils;
+import com.core.generator.config.GenConfig;
+import com.core.generator.domain.GenTable;
+import com.core.generator.domain.GenTableColumn;
+
+/**
+ * 代码生成器 工具类
+ * 
+ * @author system
+ */
+public class GenUtils {
+    /**
+     * 初始化表信息
+     */
+    public static void initTable(GenTable genTable, String operName) {
+        String tablePrefix = genTable.getTableName().split("_")[0];
+        switch (tablePrefix) {
+            case "cod":
+                genTable.setPackageName(GenConfig.getPackageName() + ".code");
+                break;
+            case "adm":
+                genTable.setPackageName(GenConfig.getPackageName() + ".administration");
+                break;
+            case "cli":
+                genTable.setPackageName(GenConfig.getPackageName() + ".clinical");
+                break;
+            case "dia":
+                genTable.setPackageName(GenConfig.getPackageName() + ".diagnostic");
+                break;
+            case "med":
+                genTable.setPackageName(GenConfig.getPackageName() + ".medication");
+                break;
+            case "wor":
+                genTable.setPackageName(GenConfig.getPackageName() + ".workflow");
+                break;
+            case "fin":
+                genTable.setPackageName(GenConfig.getPackageName() + ".financial");
+                break;
+            case "def":
+                genTable.setPackageName(GenConfig.getPackageName() + ".definition");
+                break;
+            case "doc":
+                genTable.setPackageName(GenConfig.getPackageName() + ".document");
+                break;
+            case "yb":
+                genTable.setPackageName(GenConfig.getPackageName() + ".ybcatalog");
+                break;
+            default:
+                genTable.setPackageName(GenConfig.getPackageName() + ".errortable");
+        }
+        genTable.setClassName(convertClassName(genTable.getTableName()));
+        genTable.setModuleName(getModuleName(GenConfig.getPackageName()));
+        genTable.setBusinessName(getBusinessName(genTable.getTableName()));
+        genTable.setFunctionName(replaceText(genTable.getTableComment()));
+        genTable.setFunctionAuthor(GenConfig.getAuthor());
+        genTable.setCreateBy(operName);
+    }
+
+    /**
+     * 初始化列属性字段
+     */
+    public static void initColumnField(GenTableColumn column, GenTable table) {
+        String dataType = column.getColumnType();// getDbType(column.getColumnType());
+        String columnName = column.getColumnName();
+        column.setTableId(table.getTableId());
+        column.setCreateBy(table.getCreateBy());
+        // 设置java字段名
+        column.setJavaField(StringUtils.toCamelCase(columnName));
+        // 设置默认类型
+        column.setJavaType(GenConstants.TYPE_STRING);
+        column.setQueryType(GenConstants.QUERY_EQ);
+
+        if ("int8".equals(dataType)) {
+            column.setJavaType(GenConstants.TYPE_LONG);
+        } else if ("int4".equals(dataType)) {
+            column.setJavaType(GenConstants.TYPE_INTEGER);
+        } else if ("timestamptz".equals(dataType)) {
+            column.setJavaType(GenConstants.TYPE_DATE);
+        } else if ("numeric".equals(dataType)) {
+            column.setJavaType(GenConstants.TYPE_BIGDECIMAL);
+        } else if ("timestamp".equals(dataType)) {
+            column.setJavaType(GenConstants.TYPE_DATE);
+        }
+        // 插入字段（默认所有字段都需要插入）
+        column.setIsInsert(GenConstants.REQUIRE);
+    }
+
+    /**
+     * 校验数组是否包含指定值
+     * 
+     * @param arr 数组
+     * @param targetValue 值
+     * @return 是否包含
+     */
+    public static boolean arraysContains(String[] arr, String targetValue) {
+        return Arrays.asList(arr).contains(targetValue);
+    }
+
+    /**
+     * 获取模块名
+     * 
+     * @param packageName 包名
+     * @return 模块名
+     */
+    public static String getModuleName(String packageName) {
+        int lastIndex = packageName.lastIndexOf(".");
+        int nameLength = packageName.length();
+        return StringUtils.substring(packageName, lastIndex + 1, nameLength);
+    }
+
+    /**
+     * 获取业务名
+     * 
+     * @param tableName 表名
+     * @return 业务名
+     */
+    public static String getBusinessName(String tableName) {
+        int lastIndex = tableName.lastIndexOf("_");
+        int nameLength = tableName.length();
+        return StringUtils.substring(tableName, lastIndex + 1, nameLength);
+    }
+
+    /**
+     * 表名转换成Java类名
+     * 
+     * @param tableName 表名称
+     * @return 类名
+     */
+    public static String convertClassName(String tableName) {
+        boolean autoRemovePre = GenConfig.getAutoRemovePre();
+        String tablePrefix = GenConfig.getTablePrefix();
+        if (autoRemovePre && StringUtils.isNotEmpty(tablePrefix)) {
+            String[] searchList = StringUtils.split(tablePrefix, ",");
+            tableName = replaceFirst(tableName, searchList);
+        }
+        return StringUtils.convertToCamelCase(tableName);
+    }
+
+    /**
+     * 批量替换前缀
+     * 
+     * @param replacementm 替换值
+     * @param searchList 替换列表
+     * @return
+     */
+    public static String replaceFirst(String replacementm, String[] searchList) {
+        String text = replacementm;
+        for (String searchString : searchList) {
+            if (replacementm.startsWith(searchString)) {
+                text = replacementm.replaceFirst(searchString, "");
+                break;
+            }
+        }
+        return text;
+    }
+
+    /**
+     * 关键字替换
+     * 
+     * @param text 需要被替换的名字
+     * @return 替换后的名字
+     */
+    public static String replaceText(String text) {
+        return RegExUtils.replaceAll(text, "(?:表|源)", "");
+    }
+
+    /**
+     * 获取数据库类型字段
+     * 
+     * @param columnType 列类型
+     * @return 截取后的列类型
+     */
+    public static String getDbType(String columnType) {
+        if (StringUtils.indexOf(columnType, "(") > 0) {
+            return StringUtils.substringBefore(columnType, "(");
+        } else {
+            return columnType;
+        }
+    }
+
+    /**
+     * 获取字段长度
+     * 
+     * @param columnType 列类型
+     * @return 截取后的列类型
+     */
+    public static Integer getColumnLength(String columnType) {
+        if (StringUtils.indexOf(columnType, "(") > 0) {
+            String length = StringUtils.substringBetween(columnType, "(", ")");
+            return Integer.valueOf(length);
+        } else {
+            return 0;
+        }
+    }
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/util/VelocityInitializer.java

@@ -0,0 +1,32 @@
+package com.core.generator.util;
+
+import java.util.Properties;
+
+import org.apache.velocity.app.Velocity;
+
+import com.core.common.constant.Constants;
+
+/**
+ * VelocityEngine工厂
+ * 
+ * @author system
+ */
+public class VelocityInitializer {
+    /**
+     * 初始化vm方法
+     */
+    public static void initVelocity() {
+        Properties p = new Properties();
+        try {
+            // 加载classpath目录下的vm文件
+            p.setProperty("resource.loader.file.class",
+                "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
+            // 定义字符集
+            p.setProperty(Velocity.INPUT_ENCODING, Constants.UTF8);
+            // 初始化Velocity引擎，指定配置Properties
+            Velocity.init(p);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

openhis-server-new/core-generator/src/main/java/com/core/generator/util/VelocityUtils.java

@@ -0,0 +1,320 @@
+package com.core.generator.util;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.velocity.VelocityContext;
+
+import com.alibaba.fastjson2.JSON;
+import com.alibaba.fastjson2.JSONObject;
+import com.core.common.constant.GenConstants;
+import com.core.common.utils.DateUtils;
+import com.core.common.utils.StringUtils;
+import com.core.generator.domain.GenTable;
+import com.core.generator.domain.GenTableColumn;
+
+/**
+ * 模板处理工具类
+ * 
+ * @author system
+ */
+public class VelocityUtils {
+    /** 项目空间路径 */
+    private static final String PROJECT_PATH = "main/java";
+
+    /** mybatis空间路径 */
+    private static final String MYBATIS_PATH = "main/resources/mapper";
+
+    /** 默认上级菜单，系统工具 */
+    private static final String DEFAULT_PARENT_MENU_ID = "3";
+
+    /**
+     * 设置模板变量信息
+     *
+     * @return 模板列表
+     */
+    public static VelocityContext prepareContext(GenTable genTable) {
+        String moduleName = genTable.getModuleName();
+        String businessName = genTable.getBusinessName();
+        String packageName = genTable.getPackageName();
+        String tplCategory = genTable.getTplCategory();
+        String functionName = genTable.getFunctionName();
+
+        VelocityContext velocityContext = new VelocityContext();
+        velocityContext.put("tplCategory", genTable.getTplCategory());
+        velocityContext.put("tableName", genTable.getTableName());
+        velocityContext.put("functionName", StringUtils.isNotEmpty(functionName) ? functionName : "【请填写功能名称】");
+        velocityContext.put("ClassName", genTable.getClassName());
+        velocityContext.put("className", StringUtils.uncapitalize(genTable.getClassName()));
+        velocityContext.put("moduleName", genTable.getModuleName());
+        velocityContext.put("BusinessName", StringUtils.capitalize(genTable.getBusinessName()));
+        velocityContext.put("businessName", genTable.getBusinessName());
+        velocityContext.put("basePackage", getPackagePrefix(packageName));
+        velocityContext.put("packageName", packageName);
+        velocityContext.put("author", genTable.getFunctionAuthor());
+        velocityContext.put("datetime", DateUtils.getDate());
+        velocityContext.put("pkColumn", genTable.getPkColumn());
+        velocityContext.put("importList", getImportList(genTable));
+        velocityContext.put("permissionPrefix", getPermissionPrefix(moduleName, businessName));
+        velocityContext.put("columns", genTable.getColumns());
+        velocityContext.put("table", genTable);
+        velocityContext.put("dicts", getDicts(genTable));
+        setMenuVelocityContext(velocityContext, genTable);
+        if (GenConstants.TPL_TREE.equals(tplCategory)) {
+            setTreeVelocityContext(velocityContext, genTable);
+        }
+        if (GenConstants.TPL_SUB.equals(tplCategory)) {
+            setSubVelocityContext(velocityContext, genTable);
+        }
+        return velocityContext;
+    }
+
+    public static void setMenuVelocityContext(VelocityContext context, GenTable genTable) {
+        String options = genTable.getOptions();
+        JSONObject paramsObj = JSON.parseObject(options);
+        String parentMenuId = getParentMenuId(paramsObj);
+        context.put("parentMenuId", parentMenuId);
+    }
+
+    public static void setTreeVelocityContext(VelocityContext context, GenTable genTable) {
+        String options = genTable.getOptions();
+        JSONObject paramsObj = JSON.parseObject(options);
+        String treeCode = getTreecode(paramsObj);
+        String treeParentCode = getTreeParentCode(paramsObj);
+        String treeName = getTreeName(paramsObj);
+
+        context.put("treeCode", treeCode);
+        context.put("treeParentCode", treeParentCode);
+        context.put("treeName", treeName);
+        context.put("expandColumn", getExpandColumn(genTable));
+        if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE)) {
+            context.put("tree_parent_code", paramsObj.getString(GenConstants.TREE_PARENT_CODE));
+        }
+        if (paramsObj.containsKey(GenConstants.TREE_NAME)) {
+            context.put("tree_name", paramsObj.getString(GenConstants.TREE_NAME));
+        }
+    }
+
+    public static void setSubVelocityContext(VelocityContext context, GenTable genTable) {
+        GenTable subTable = genTable.getSubTable();
+        String subTableName = genTable.getSubTableName();
+        String subTableFkName = genTable.getSubTableFkName();
+        String subClassName = genTable.getSubTable().getClassName();
+        String subTableFkClassName = StringUtils.convertToCamelCase(subTableFkName);
+
+        context.put("subTable", subTable);
+        context.put("subTableName", subTableName);
+        context.put("subTableFkName", subTableFkName);
+        context.put("subTableFkClassName", subTableFkClassName);
+        context.put("subTableFkclassName", StringUtils.uncapitalize(subTableFkClassName));
+        context.put("subClassName", subClassName);
+        context.put("subclassName", StringUtils.uncapitalize(subClassName));
+        context.put("subImportList", getImportList(genTable.getSubTable()));
+    }
+
+    /**
+     * 获取模板信息
+     * 
+     * @param tplCategory 生成的模板
+     * @param tplWebType 前端类型
+     * @return 模板列表
+     */
+    public static List<String> getTemplateList(String tplCategory, String tplWebType) {
+        List<String> templates = new ArrayList<String>();
+        templates.add("vm/java/domain.java.vm");
+        templates.add("vm/java/mapper.java.vm");
+        templates.add("vm/java/service.java.vm");
+        templates.add("vm/java/serviceImpl.java.vm");
+        templates.add("vm/xml/mapper.xml.vm");
+        return templates;
+    }
+
+    /**
+     * 获取文件名
+     */
+    public static String getFileName(String template, GenTable genTable) {
+        // 文件名称
+        String fileName = "";
+        // 包路径
+        String packageName = genTable.getPackageName();
+        // 大写类名
+        String className = genTable.getClassName();
+        // 模块名
+        String[] packageStringArray = packageName.split("\\.");
+        String moduleName = packageStringArray[packageStringArray.length - 1];
+
+        String javaPath = PROJECT_PATH + "/" + StringUtils.replace(packageName, ".", "/");
+        String mybatisPath = MYBATIS_PATH + "/" + moduleName;
+
+        if (template.contains("domain.java.vm")) {
+            fileName = StringUtils.format("{}/domain/{}.java", javaPath, className);
+        }
+        if (template.contains("mapper.java.vm")) {
+            fileName = StringUtils.format("{}/mapper/{}Mapper.java", javaPath, className);
+        } else if (template.contains("service.java.vm")) {
+            fileName = StringUtils.format("{}/service/I{}Service.java", javaPath, className);
+        } else if (template.contains("serviceImpl.java.vm")) {
+            fileName = StringUtils.format("{}/service/impl/{}ServiceImpl.java", javaPath, className);
+        } else if (template.contains("mapper.xml.vm")) {
+            fileName = StringUtils.format("{}/{}Mapper.xml", mybatisPath, className);
+        }
+        return fileName;
+    }
+
+    /**
+     * 获取包前缀
+     *
+     * @param packageName 包名称
+     * @return 包前缀名称
+     */
+    public static String getPackagePrefix(String packageName) {
+        int lastIndex = packageName.lastIndexOf(".");
+        return StringUtils.substring(packageName, 0, lastIndex);
+    }
+
+    /**
+     * 根据列类型获取导入包
+     * 
+     * @param genTable 业务表对象
+     * @return 返回需要导入的包列表
+     */
+    public static HashSet<String> getImportList(GenTable genTable) {
+        List<GenTableColumn> columns = genTable.getColumns();
+        GenTable subGenTable = genTable.getSubTable();
+        HashSet<String> importList = new HashSet<String>();
+        if (StringUtils.isNotNull(subGenTable)) {
+            importList.add("java.util.List");
+        }
+        for (GenTableColumn column : columns) {
+            if (!column.isSuperColumn() && GenConstants.TYPE_DATE.equals(column.getJavaType())) {
+                importList.add("java.util.Date");
+                importList.add("com.fasterxml.jackson.annotation.JsonFormat");
+            } else if (!column.isSuperColumn() && GenConstants.TYPE_BIGDECIMAL.equals(column.getJavaType())) {
+                importList.add("java.math.BigDecimal");
+            }
+        }
+        return importList;
+    }
+
+    /**
+     * 根据列类型获取字典组
+     * 
+     * @param genTable 业务表对象
+     * @return 返回字典组
+     */
+    public static String getDicts(GenTable genTable) {
+        List<GenTableColumn> columns = genTable.getColumns();
+        Set<String> dicts = new HashSet<String>();
+        addDicts(dicts, columns);
+        if (StringUtils.isNotNull(genTable.getSubTable())) {
+            List<GenTableColumn> subColumns = genTable.getSubTable().getColumns();
+            addDicts(dicts, subColumns);
+        }
+        return StringUtils.join(dicts, ", ");
+    }
+
+    /**
+     * 添加字典列表
+     * 
+     * @param dicts 字典列表
+     * @param columns 列集合
+     */
+    public static void addDicts(Set<String> dicts, List<GenTableColumn> columns) {
+        for (GenTableColumn column : columns) {
+            if (!column.isSuperColumn() && StringUtils.isNotEmpty(column.getDictType())
+                && StringUtils.equalsAny(column.getHtmlType(),
+                    new String[] {GenConstants.HTML_SELECT, GenConstants.HTML_RADIO, GenConstants.HTML_CHECKBOX})) {
+                dicts.add("'" + column.getDictType() + "'");
+            }
+        }
+    }
+
+    /**
+     * 获取权限前缀
+     *
+     * @param moduleName 模块名称
+     * @param businessName 业务名称
+     * @return 返回权限前缀
+     */
+    public static String getPermissionPrefix(String moduleName, String businessName) {
+        return StringUtils.format("{}:{}", moduleName, businessName);
+    }
+
+    /**
+     * 获取上级菜单ID字段
+     *
+     * @param paramsObj 生成其他选项
+     * @return 上级菜单ID字段
+     */
+    public static String getParentMenuId(JSONObject paramsObj) {
+        if (StringUtils.isNotEmpty(paramsObj) && paramsObj.containsKey(GenConstants.PARENT_MENU_ID)
+            && StringUtils.isNotEmpty(paramsObj.getString(GenConstants.PARENT_MENU_ID))) {
+            return paramsObj.getString(GenConstants.PARENT_MENU_ID);
+        }
+        return DEFAULT_PARENT_MENU_ID;
+    }
+
+    /**
+     * 获取树编码
+     *
+     * @param paramsObj 生成其他选项
+     * @return 树编码
+     */
+    public static String getTreecode(JSONObject paramsObj) {
+        if (paramsObj.containsKey(GenConstants.TREE_CODE)) {
+            return StringUtils.toCamelCase(paramsObj.getString(GenConstants.TREE_CODE));
+        }
+        return StringUtils.EMPTY;
+    }
+
+    /**
+     * 获取树父编码
+     *
+     * @param paramsObj 生成其他选项
+     * @return 树父编码
+     */
+    public static String getTreeParentCode(JSONObject paramsObj) {
+        if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE)) {
+            return StringUtils.toCamelCase(paramsObj.getString(GenConstants.TREE_PARENT_CODE));
+        }
+        return StringUtils.EMPTY;
+    }
+
+    /**
+     * 获取树名称
+     *
+     * @param paramsObj 生成其他选项
+     * @return 树名称
+     */
+    public static String getTreeName(JSONObject paramsObj) {
+        if (paramsObj.containsKey(GenConstants.TREE_NAME)) {
+            return StringUtils.toCamelCase(paramsObj.getString(GenConstants.TREE_NAME));
+        }
+        return StringUtils.EMPTY;
+    }
+
+    /**
+     * 获取需要在哪一列上面显示展开按钮
+     *
+     * @param genTable 业务表对象
+     * @return 展开按钮列序号
+     */
+    public static int getExpandColumn(GenTable genTable) {
+        String options = genTable.getOptions();
+        JSONObject paramsObj = JSON.parseObject(options);
+        String treeName = paramsObj.getString(GenConstants.TREE_NAME);
+        int num = 0;
+        for (GenTableColumn column : genTable.getColumns()) {
+            if (column.isList()) {
+                num++;
+                String columnName = column.getColumnName();
+                if (columnName.equals(treeName)) {
+                    break;
+                }
+            }
+        }
+        return num;
+    }
+}

openhis-server-new/core-generator/src/main/resources/generator.yml

@@ -0,0 +1,10 @@
+# 代码生成
+gen:
+  # 作者
+  author: system
+  # 默认生成包路径 system 需改成自己的模块名称 如 system monitor tool
+  packageName: com.openhis
+  # 自动去除表前缀，默认是false
+  autoRemovePre: true
+  # 表前缀（生成类名不会包含表前缀，多个用逗号分隔）
+  tablePrefix: cod_,adm_,cli_,dia_,med_,wor_,fin_,def_,doc_,yb_

openhis-server-new/core-generator/src/main/resources/mapper/generator/GenTableColumnMapper.xml

@@ -0,0 +1,167 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.core.generator.mapper.GenTableColumnMapper">
+
+    <resultMap type="GenTableColumn" id="GenTableColumnResult">
+        <id property="columnId" column="column_id"/>
+        <result property="tableId" column="table_id"/>
+        <result property="columnName" column="column_name"/>
+        <result property="columnComment" column="column_comment"/>
+        <result property="columnType" column="column_type"/>
+        <result property="javaType" column="java_type"/>
+        <result property="javaField" column="java_field"/>
+        <result property="isPk" column="is_pk"/>
+        <result property="isIncrement" column="is_increment"/>
+        <result property="isRequired" column="is_required"/>
+        <result property="isInsert" column="is_insert"/>
+        <result property="isEdit" column="is_edit"/>
+        <result property="isList" column="is_list"/>
+        <result property="isQuery" column="is_query"/>
+        <result property="queryType" column="query_type"/>
+        <result property="htmlType" column="html_type"/>
+        <result property="dictType" column="dict_type"/>
+        <result property="sort" column="sort"/>
+        <result property="createBy" column="create_by"/>
+        <result property="createTime" column="create_time"/>
+        <result property="updateBy" column="update_by"/>
+        <result property="updateTime" column="update_time"/>
+    </resultMap>
+
+    <sql id="selectGenTableColumnVo">
+        select column_id,
+               table_id,
+               column_name,
+               column_comment,
+               column_type,
+               java_type,
+               java_field,
+               is_pk,
+               is_increment,
+               is_required,
+               is_insert,
+               is_edit,
+               is_list,
+               is_query,
+               query_type,
+               html_type,
+               dict_type,
+               sort,
+               create_by,
+               create_time,
+               update_by,
+               update_time
+        from gen_table_column
+    </sql>
+
+    <select id="selectGenTableColumnListByTableId" parameterType="Long" resultMap="GenTableColumnResult">
+        <include refid="selectGenTableColumnVo"/>
+        where table_id = #{tableId}
+        order by sort
+    </select>
+
+    <select id="selectDbTableColumnsByName" parameterType="String" resultMap="GenTableColumnResult">
+        SELECT T1.column_name,
+               CASE WHEN T1.is_nullable = 'NO' THEN '1' ELSE '0' END   AS is_required,
+               CASE WHEN T1.ordinal_position = 1 THEN '1' ELSE '0' END AS is_pk,
+               T2.description                                          AS column_comment,
+               '0'                                                     AS is_increment,
+               T1.ordinal_position                                     AS sort,
+               T1.udt_name                                             AS column_type
+        FROM information_schema.columns T1
+                 LEFT JOIN pg_description T2
+                           ON T2.objsubid = T1.ordinal_position
+                               AND T2.objoid = T1.table_name::regclass::oid
+        WHERE T1.table_name = #{tableName}
+          AND T1.column_name NOT IN ('create_by'
+            , 'create_time'
+            , 'update_by'
+            , 'update_time'
+            , 'remark'
+            , 'tenant_id'
+            , 'del_flag'
+            , 'test_flag')
+        ORDER BY T1.ordinal_position
+    </select>
+
+    <insert id="insertGenTableColumn" parameterType="GenTableColumn" useGeneratedKeys="true" keyProperty="columnId">
+        insert into gen_table_column (
+        <if test="tableId != null and tableId != ''">table_id,</if>
+        <if test="columnName != null and columnName != ''">column_name,</if>
+        <if test="columnComment != null and columnComment != ''">column_comment,</if>
+        <if test="columnType != null and columnType != ''">column_type,</if>
+        <if test="javaType != null and javaType != ''">java_type,</if>
+        <if test="javaField != null  and javaField != ''">java_field,</if>
+        <if test="isPk != null and isPk != ''">is_pk,</if>
+        <if test="isIncrement != null and isIncrement != ''">is_increment,</if>
+        <if test="isRequired != null and isRequired != ''">is_required,</if>
+        <if test="isInsert != null and isInsert != ''">is_insert,</if>
+        <if test="isEdit != null and isEdit != ''">is_edit,</if>
+        <if test="isList != null and isList != ''">is_list,</if>
+        <if test="isQuery != null and isQuery != ''">is_query,</if>
+        <if test="queryType != null and queryType != ''">query_type,</if>
+        <if test="htmlType != null and htmlType != ''">html_type,</if>
+        <if test="dictType != null and dictType != ''">dict_type,</if>
+        <if test="sort != null">sort,</if>
+        <if test="createBy != null and createBy != ''">create_by,</if>
+        create_time
+        )values(
+        <if test="tableId != null and tableId != ''">#{tableId},</if>
+        <if test="columnName != null and columnName != ''">#{columnName},</if>
+        <if test="columnComment != null and columnComment != ''">#{columnComment},</if>
+        <if test="columnType != null and columnType != ''">#{columnType},</if>
+        <if test="javaType != null and javaType != ''">#{javaType},</if>
+        <if test="javaField != null and javaField != ''">#{javaField},</if>
+        <if test="isPk != null and isPk != ''">#{isPk},</if>
+        <if test="isIncrement != null and isIncrement != ''">#{isIncrement},</if>
+        <if test="isRequired != null and isRequired != ''">#{isRequired},</if>
+        <if test="isInsert != null and isInsert != ''">#{isInsert},</if>
+        <if test="isEdit != null and isEdit != ''">#{isEdit},</if>
+        <if test="isList != null and isList != ''">#{isList},</if>
+        <if test="isQuery != null and isQuery != ''">#{isQuery},</if>
+        <if test="queryType != null and queryType != ''">#{queryType},</if>
+        <if test="htmlType != null and htmlType != ''">#{htmlType},</if>
+        <if test="dictType != null and dictType != ''">#{dictType},</if>
+        <if test="sort != null">#{sort},</if>
+        <if test="createBy != null and createBy != ''">#{createBy},</if>
+        now()
+        )
+    </insert>
+
+    <update id="updateGenTableColumn" parameterType="GenTableColumn">
+        update gen_table_column
+        <set>
+            <if test="columnComment != null">column_comment = #{columnComment},</if>
+            <if test="javaType != null">java_type = #{javaType},</if>
+            <if test="javaField != null">java_field = #{javaField},</if>
+            <if test="isInsert != null">is_insert = #{isInsert},</if>
+            <if test="isEdit != null">is_edit = #{isEdit},</if>
+            <if test="isList != null">is_list = #{isList},</if>
+            <if test="isQuery != null">is_query = #{isQuery},</if>
+            <if test="isRequired != null">is_required = #{isRequired},</if>
+            <if test="queryType != null">query_type = #{queryType},</if>
+            <if test="htmlType != null">html_type = #{htmlType},</if>
+            <if test="dictType != null">dict_type = #{dictType},</if>
+            <if test="sort != null">sort = #{sort},</if>
+            <if test="updateBy != null">update_by = #{updateBy},</if>
+            update_time = now()
+        </set>
+        where column_id = #{columnId}
+    </update>
+
+    <delete id="deleteGenTableColumnByIds" parameterType="Long">
+        delete from gen_table_column where table_id in
+        <foreach collection="array" item="tableId" open="(" separator="," close=")">
+            #{tableId}
+        </foreach>
+    </delete>
+
+    <delete id="deleteGenTableColumns">
+        delete from gen_table_column where column_id in
+        <foreach collection="list" item="item" open="(" separator="," close=")">
+            #{item.columnId}
+        </foreach>
+    </delete>
+
+</mapper>

openhis-server-new/core-generator/src/main/resources/mapper/generator/GenTableMapper.xml

@@ -0,0 +1,346 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="com.core.generator.mapper.GenTableMapper">
+
+    <resultMap type="GenTable" id="GenTableResult">
+        <id property="tableId" column="table_id"/>
+        <result property="tableName" column="table_name"/>
+        <result property="tableComment" column="table_comment"/>
+        <result property="subTableName" column="sub_table_name"/>
+        <result property="subTableFkName" column="sub_table_fk_name"/>
+        <result property="className" column="class_name"/>
+        <result property="tplCategory" column="tpl_category"/>
+        <result property="tplWebType" column="tpl_web_type"/>
+        <result property="packageName" column="package_name"/>
+        <result property="moduleName" column="module_name"/>
+        <result property="businessName" column="business_name"/>
+        <result property="functionName" column="function_name"/>
+        <result property="functionAuthor" column="function_author"/>
+        <result property="genType" column="gen_type"/>
+        <result property="genPath" column="gen_path"/>
+        <result property="options" column="options"/>
+        <result property="createBy" column="create_by"/>
+        <result property="createTime" column="create_time"/>
+        <result property="updateBy" column="update_by"/>
+        <result property="updateTime" column="update_time"/>
+        <result property="remark" column="remark"/>
+        <collection property="columns" javaType="java.util.List" resultMap="GenTableColumnResult"/>
+    </resultMap>
+
+    <resultMap type="GenTableColumn" id="GenTableColumnResult">
+        <id property="columnId" column="column_id"/>
+        <result property="tableId" column="table_id"/>
+        <result property="columnName" column="column_name"/>
+        <result property="columnComment" column="column_comment"/>
+        <result property="columnType" column="column_type"/>
+        <result property="javaType" column="java_type"/>
+        <result property="javaField" column="java_field"/>
+        <result property="isPk" column="is_pk"/>
+        <result property="isIncrement" column="is_increment"/>
+        <result property="isRequired" column="is_required"/>
+        <result property="isInsert" column="is_insert"/>
+        <result property="isEdit" column="is_edit"/>
+        <result property="isList" column="is_list"/>
+        <result property="isQuery" column="is_query"/>
+        <result property="queryType" column="query_type"/>
+        <result property="htmlType" column="html_type"/>
+        <result property="dictType" column="dict_type"/>
+        <result property="sort" column="sort"/>
+        <result property="createBy" column="create_by"/>
+        <result property="createTime" column="create_time"/>
+        <result property="updateBy" column="update_by"/>
+        <result property="updateTime" column="update_time"/>
+    </resultMap>
+
+    <sql id="selectGenTableVo">
+        select table_id,
+               table_name,
+               table_comment,
+               sub_table_name,
+               sub_table_fk_name,
+               class_name,
+               tpl_category,
+               tpl_web_type,
+               package_name,
+               module_name,
+               business_name,
+               function_name,
+               function_author,
+               gen_type,
+               gen_path,
+               options,
+               create_by,
+               create_time,
+               update_by,
+               update_time,
+               remark
+        from gen_table
+    </sql>
+
+    <select id="selectGenTableList" parameterType="GenTable" resultMap="GenTableResult">
+        <include refid="selectGenTableVo"/>
+        <where>
+            <if test="tableName != null and tableName != ''">
+                AND lower(table_name) like lower(concat('%', #{tableName}, '%'))
+            </if>
+            <if test="tableComment != null and tableComment != ''">
+                AND lower(table_comment) like lower(concat('%', #{tableComment}, '%'))
+            </if>
+            <if test="params.beginTime != null and params.beginTime != ''"><!-- 开始时间检索 -->
+                AND date_format(create_time,'%Y%m%d') &gt;= date_format(#{params.beginTime},'%Y%m%d')
+            </if>
+            <if test="params.endTime != null and params.endTime != ''"><!-- 结束时间检索 -->
+                AND date_format(create_time,'%Y%m%d') &lt;= date_format(#{params.endTime},'%Y%m%d')
+            </if>
+        </where>
+    </select>
+
+    <select id="selectDbTableList" parameterType="map" resultMap="GenTableResult">
+        SELECT
+        T1.table_name,
+        T2.description AS table_comment
+        -- 移除 create_time，因为它在 information_schema.tables 中通常不存在
+        -- 移除 update_time，因为它在 information_schema.tables 中通常不存在
+        FROM information_schema.tables T1
+        LEFT JOIN pg_description T2
+        ON T2.objsubid = 0
+        AND T2.objoid = T1.table_name::regclass::oid
+        WHERE table_schema = current_schema()
+        AND table_name NOT LIKE 'qrtz\_%'
+        AND table_name NOT LIKE 'gen\_%'
+        AND table_name NOT LIKE 'act\_%'
+        AND table_name NOT LIKE 'flw\_%'
+        AND table_name NOT LIKE 'sys\_%'
+        AND table_name NOT IN (SELECT table_name FROM gen_table)
+        <if test="tableName != null and tableName != ''">
+            AND lower(table_name) LIKE lower(concat('%', #{tableName}, '%'))
+        </if>
+        <!-- 移除对 table_comment 的引用 -->
+        <!-- 移除对 create_time 的引用 -->
+    </select>
+
+    <select id="selectDbTableListByNames" resultMap="GenTableResult">
+        SELECT
+        T1.table_name,
+        T2.description AS table_comment
+        -- 移除 create_time，因为它在 information_schema.tables 中通常不存在
+        -- 移除 update_time，因为它在 information_schema.tables 中通常不存在
+        FROM information_schema.tables T1
+        LEFT JOIN pg_description T2
+        ON T2.objsubid = 0
+        AND T2.objoid = T1.table_name::regclass::oid
+        WHERE table_schema = current_schema()
+        AND table_name NOT LIKE 'qrtz\_%'
+        AND table_name NOT LIKE 'gen\_%'
+        AND table_name NOT LIKE 'act\_%'
+        AND table_name NOT LIKE 'flw\_%'
+        AND table_name NOT LIKE 'sys\_%'
+        AND table_name IN
+        <foreach collection="array" item="name" open="(" separator="," close=")">
+            #{name}
+        </foreach>
+    </select>
+
+    <select id="selectTableByName" parameterType="String" resultMap="GenTableResult">
+        select table_name, table_comment, create_time, update_time
+        from information_schema.tables
+        where table_comment <![CDATA[ <> ]]> ''
+          and table_schema = (select database())
+          and table_name = #{tableName}
+    </select>
+
+    <select id="selectGenTableById" parameterType="Long" resultMap="GenTableResult">
+        SELECT t.table_id,
+               t.table_name,
+               t.table_comment,
+               t.sub_table_name,
+               t.sub_table_fk_name,
+               t.class_name,
+               t.tpl_category,
+               t.tpl_web_type,
+               t.package_name,
+               t.module_name,
+               t.business_name,
+               t.function_name,
+               t.function_author,
+               t.gen_type,
+               t.gen_path,
+               t.options,
+               t.remark,
+               c.column_id,
+               c.column_name,
+               c.column_comment,
+               c.column_type,
+               c.java_type,
+               c.java_field,
+               c.is_pk,
+               c.is_increment,
+               c.is_required,
+               c.is_insert,
+               c.is_edit,
+               c.is_list,
+               c.is_query,
+               c.query_type,
+               c.html_type,
+               c.dict_type,
+               c.sort
+        FROM gen_table t
+                 LEFT JOIN gen_table_column c ON t.table_id = c.table_id
+        where t.table_id = #{tableId}
+        order by c.sort
+    </select>
+
+    <select id="selectGenTableByName" parameterType="String" resultMap="GenTableResult">
+        SELECT t.table_id,
+               t.table_name,
+               t.table_comment,
+               t.sub_table_name,
+               t.sub_table_fk_name,
+               t.class_name,
+               t.tpl_category,
+               t.tpl_web_type,
+               t.package_name,
+               t.module_name,
+               t.business_name,
+               t.function_name,
+               t.function_author,
+               t.gen_type,
+               t.gen_path,
+               t.options,
+               t.remark,
+               c.column_id,
+               c.column_name,
+               c.column_comment,
+               c.column_type,
+               c.java_type,
+               c.java_field,
+               c.is_pk,
+               c.is_increment,
+               c.is_required,
+               c.is_insert,
+               c.is_edit,
+               c.is_list,
+               c.is_query,
+               c.query_type,
+               c.html_type,
+               c.dict_type,
+               c.sort
+        FROM gen_table t
+                 LEFT JOIN gen_table_column c ON t.table_id = c.table_id
+        where t.table_name = #{tableName}
+        order by c.sort
+    </select>
+
+    <select id="selectGenTableAll" parameterType="String" resultMap="GenTableResult">
+        SELECT t.table_id,
+               t.table_name,
+               t.table_comment,
+               t.sub_table_name,
+               t.sub_table_fk_name,
+               t.class_name,
+               t.tpl_category,
+               t.tpl_web_type,
+               t.package_name,
+               t.module_name,
+               t.business_name,
+               t.function_name,
+               t.function_author,
+               t.options,
+               t.remark,
+               c.column_id,
+               c.column_name,
+               c.column_comment,
+               c.column_type,
+               c.java_type,
+               c.java_field,
+               c.is_pk,
+               c.is_increment,
+               c.is_required,
+               c.is_insert,
+               c.is_edit,
+               c.is_list,
+               c.is_query,
+               c.query_type,
+               c.html_type,
+               c.dict_type,
+               c.sort
+        FROM gen_table t
+                 LEFT JOIN gen_table_column c ON t.table_id = c.table_id
+        order by c.sort
+    </select>
+
+    <insert id="insertGenTable" parameterType="GenTable" useGeneratedKeys="true" keyProperty="tableId">
+        insert into gen_table (
+        <if test="tableName != null">table_name,</if>
+        <if test="tableComment != null and tableComment != ''">table_comment,</if>
+        <if test="className != null and className != ''">class_name,</if>
+        <if test="tplCategory != null and tplCategory != ''">tpl_category,</if>
+        <if test="tplWebType != null and tplWebType != ''">tpl_web_type,</if>
+        <if test="packageName != null and packageName != ''">package_name,</if>
+        <if test="moduleName != null and moduleName != ''">module_name,</if>
+        <if test="businessName != null and businessName != ''">business_name,</if>
+        <if test="functionName != null and functionName != ''">function_name,</if>
+        <if test="functionAuthor != null and functionAuthor != ''">function_author,</if>
+        <if test="genType != null and genType != ''">gen_type,</if>
+        <if test="genPath != null and genPath != ''">gen_path,</if>
+        <if test="remark != null and remark != ''">remark,</if>
+        <if test="createBy != null and createBy != ''">create_by,</if>
+        create_time
+        )values(
+        <if test="tableName != null">#{tableName},</if>
+        <if test="tableComment != null and tableComment != ''">#{tableComment},</if>
+        <if test="className != null and className != ''">#{className},</if>
+        <if test="tplCategory != null and tplCategory != ''">#{tplCategory},</if>
+        <if test="tplWebType != null and tplWebType != ''">#{tplWebType},</if>
+        <if test="packageName != null and packageName != ''">#{packageName},</if>
+        <if test="moduleName != null and moduleName != ''">#{moduleName},</if>
+        <if test="businessName != null and businessName != ''">#{businessName},</if>
+        <if test="functionName != null and functionName != ''">#{functionName},</if>
+        <if test="functionAuthor != null and functionAuthor != ''">#{functionAuthor},</if>
+        <if test="genType != null and genType != ''">#{genType},</if>
+        <if test="genPath != null and genPath != ''">#{genPath},</if>
+        <if test="remark != null and remark != ''">#{remark},</if>
+        <if test="createBy != null and createBy != ''">#{createBy},</if>
+        now()
+        )
+    </insert>
+
+    <update id="createTable">
+        ${sql}
+    </update>
+
+    <update id="updateGenTable" parameterType="GenTable">
+        update gen_table
+        <set>
+            <if test="tableName != null">table_name = #{tableName},</if>
+            <if test="tableComment != null and tableComment != ''">table_comment = #{tableComment},</if>
+            <if test="subTableName != null">sub_table_name = #{subTableName},</if>
+            <if test="subTableFkName != null">sub_table_fk_name = #{subTableFkName},</if>
+            <if test="className != null and className != ''">class_name = #{className},</if>
+            <if test="functionAuthor != null and functionAuthor != ''">function_author = #{functionAuthor},</if>
+            <if test="genType != null and genType != ''">gen_type = #{genType},</if>
+            <if test="genPath != null and genPath != ''">gen_path = #{genPath},</if>
+            <if test="tplCategory != null and tplCategory != ''">tpl_category = #{tplCategory},</if>
+            <if test="tplWebType != null and tplWebType != ''">tpl_web_type = #{tplWebType},</if>
+            <if test="packageName != null and packageName != ''">package_name = #{packageName},</if>
+            <if test="moduleName != null and moduleName != ''">module_name = #{moduleName},</if>
+            <if test="businessName != null and businessName != ''">business_name = #{businessName},</if>
+            <if test="functionName != null and functionName != ''">function_name = #{functionName},</if>
+            <if test="options != null and options != ''">options = #{options},</if>
+            <if test="updateBy != null and updateBy != ''">update_by = #{updateBy},</if>
+            <if test="remark != null">remark = #{remark},</if>
+            update_time = now()
+        </set>
+        where table_id = #{tableId}
+    </update>
+
+    <delete id="deleteGenTableByIds" parameterType="Long">
+        delete from gen_table where table_id in
+        <foreach collection="array" item="tableId" open="(" separator="," close=")">
+            #{tableId}
+        </foreach>
+    </delete>
+
+</mapper>

openhis-server-new/core-generator/src/main/resources/vm/java/domain.java.vm

@@ -0,0 +1,35 @@
+package ${packageName}.domain;
+
+import java.math.BigDecimal;
+import java.util.Date;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+
+import com.core.common.core.domain.HisBaseEntity;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.Accessors;
+
+/**
+ * ${functionName}Entity实体
+ *
+ * @author ${author}
+ * @date ${datetime}
+ */
+@Data
+@TableName("${tableName}")
+@Accessors(chain = true)
+@EqualsAndHashCode(callSuper = false)
+public class ${ClassName} extends HisBaseEntity {
+
+#foreach ($column in $columns)
+    /** $column.columnComment */
+    #if(1==$column.sort)
+    @TableId(type = IdType.ASSIGN_ID)
+    #end
+    private $column.javaType $column.javaField;
+
+#end
+}

openhis-server-new/core-generator/src/main/resources/vm/java/mapper.java.vm

@@ -0,0 +1,17 @@
+package ${packageName}.mapper;
+
+import org.springframework.stereotype.Repository;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import ${packageName}.domain.${ClassName};
+
+/**
+ * ${functionName}Mapper接口
+ *
+ * @author ${author}
+ * @date ${datetime}
+ */
+@Repository
+public interface ${ClassName}Mapper extends BaseMapper<${ClassName}> {
+
+}

openhis-server-new/core-generator/src/main/resources/vm/java/service.java.vm

@@ -0,0 +1,14 @@
+package ${packageName}.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import ${packageName}.domain.${ClassName};
+
+/**
+ * ${functionName}Service接口
+ *
+ * @author ${author}
+ * @date ${datetime}
+ */
+public interface I${ClassName}Service extends IService<${ClassName}> {
+
+}

openhis-server-new/core-generator/src/main/resources/vm/java/serviceImpl.java.vm

@@ -0,0 +1,19 @@
+package ${packageName}.service.impl;
+
+import org.springframework.stereotype.Service;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import ${packageName}.domain.${ClassName};
+import ${packageName}.mapper.${ClassName}Mapper;
+import ${packageName}.service.I${ClassName}Service;
+
+/**
+ * ${functionName}Service业务层处理
+ *
+ * @author ${author}
+ * @date ${datetime}
+ */
+@Service
+public class ${ClassName}ServiceImpl extends ServiceImpl<${ClassName}Mapper, ${ClassName}> implements I${ClassName}Service {
+
+}

openhis-server-new/core-generator/src/main/resources/vm/xml/mapper.xml.vm

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper
+        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
+        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="${packageName}.mapper.${ClassName}Mapper">
+
+</mapper>