irving/peipei-backend
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
starrySky
2024-03-20 09:28:04 +08:00
commit 989f0210f2
286 changed files with 25129 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

73
play-generator/src/main/java/com/starry/generator/config/GenConfig.java Normal file
View File

@@ -0,0 +1,73 @@
package com.starry.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 admin
* 读取代码生成相关配置
* @since 2022/7/15
*/
@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;
}
}

186
play-generator/src/main/java/com/starry/generator/constant/GenConstants.java Normal file
View File

@@ -0,0 +1,186 @@
package com.starry.generator.constant;
/**
* @author admin
* 代码生成通用常量
*/
public class GenConstants {
/**
* 单表（增删改查）
*/
public static final String TPL_CRUD = "crud";
/**
* 树表（增删改查）
*/
public static final String TPL_TREE = "tree";
/**
* 主子表（增删改查）
*/
public static final String TPL_SUB = "sub";
/**
* 树编码字段
*/
public static final String TREE_CODE = "treeCode";
/**
* 树父编码字段
*/
public static final String TREE_PARENT_CODE = "treeParentCode";
/**
* 树名称字段
*/
public static final String TREE_NAME = "treeName";
/**
* 上级菜单ID字段
*/
public static final String PARENT_MENU_ID = "parentMenuId";
/**
* 上级菜单名称字段
*/
public static final String PARENT_MENU_NAME = "parentMenuName";
/**
* 数据库字符串类型
*/
public static final String[] COLUMN_TYPE_STR = {"char", "varchar", "nvarchar", "varchar2"};
/**
* 数据库文本类型
*/
public static final String[] COLUMN_TYPE_TEXT = {"tinytext", "text", "mediumtext", "longtext"};
/**
* 数据库时间类型
*/
public static final String[] COLUMN_TYPE_TIME = {"datetime", "time", "date", "timestamp"};
/**
* 数据库数字类型
*/
public static final String[] COLUMNTYPE_NUMBER = {"tinyint", "smallint", "mediumint", "int", "number", "integer",
"bit", "bigint", "float", "double", "decimal"};
/**
* 页面不需要编辑字段
*/
public static final String[] COLUMN_NAME_NOT_EDIT = {"id", "create_by", "create_time", "del_flag"};
/**
* 页面不需要显示的列表字段
*/
public static final String[] COLUMN_NAME_NOT_LIST = {"id", "create_by", "create_time", "del_flag", "update_by",
"update_time"};
/**
* 页面不需要查询字段
*/
public static final String[] COLUMN_NAME_NOT_QUERY = {"id", "create_by", "create_time", "del_flag", "update_by",
"update_time", "remark"};
/**
* Entity基类字段
*/
public static final String[] BASE_ENTITY = {"createBy", "createTime", "updateBy", "updateTime", "remark"};
/**
* Tree基类字段
*/
public static final String[] TREE_ENTITY = {"parentName", "parentId", "orderNum", "ancestors", "children"};
/**
* 文本框
*/
public static final String HTML_INPUT = "input";
/**
* 文本域
*/
public static final String HTML_TEXTAREA = "textarea";
/**
* 下拉框
*/
public static final String HTML_SELECT = "select";
/**
* 单选框
*/
public static final String HTML_RADIO = "radio";
/**
* 复选框
*/
public static final String HTML_CHECKBOX = "checkbox";
/**
* 日期控件
*/
public static final String HTML_DATETIME = "datetime";
/**
* 图片上传控件
*/
public static final String HTML_IMAGE_UPLOAD = "imageUpload";
/**
* 文件上传控件
*/
public static final String HTML_FILE_UPLOAD = "fileUpload";
/**
* 富文本控件
*/
public static final String HTML_EDITOR = "editor";
/**
* 字符串类型
*/
public static final String TYPE_STRING = "String";
/**
* 整型
*/
public static final String TYPE_INTEGER = "Integer";
/**
* 长整型
*/
public static final String TYPE_LONG = "Long";
/**
* 浮点型
*/
public static final String TYPE_DOUBLE = "Double";
/**
* 高精度计算类型
*/
public static final String TYPE_BIGDECIMAL = "BigDecimal";
/**
* 时间类型
*/
public static final String TYPE_DATE = "Date";
/**
* 模糊查询
*/
public static final String QUERY_LIKE = "LIKE";
/**
* 相等查询
*/
public static final String QUERY_EQ = "EQ";
/**
* 需要
*/
public static final String REQUIRE = "1";
}

96
play-generator/src/main/java/com/starry/generator/controller/GenController.java Normal file
View File

@@ -0,0 +1,96 @@
package com.starry.generator.controller;
import cn.hutool.core.convert.Convert;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.starry.common.annotation.Log;
import com.starry.common.enums.BusinessType;
import com.starry.common.result.R;
import com.starry.generator.entity.GenTableEntity;
import com.starry.generator.entity.vo.GenTableVo;
import com.starry.generator.service.GenTableService;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.io.IOUtils;
import org.springframework.web.bind.annotation.*;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.List;
import java.util.Map;
/**
* @author admin
* @since 2022/7/14
*/
@RestController
@RequestMapping("/tool/gen")
public class GenController {
@Resource
private GenTableService genTableService;
@ApiOperation(value = "查询数据库列表")
@GetMapping("/db/list")
public R dataList(GenTableEntity genTableEntity) {
IPage<GenTableEntity> list = genTableService.selectDbTableList(genTableEntity);
return R.ok(list);
}
@ApiOperation(value = "保存表结构")
@PostMapping("/importTable")
public R importTableSave(String tables) {
String[] tableNames = Convert.toStrArray(tables);
// 查询表信息
List<GenTableEntity> tableList = genTableService.selectDbTableListByNames(tableNames);
genTableService.importGenTable(tableList);
return R.ok();
}
@ApiOperation(value = "查询生成表列表")
@GetMapping("/list")
public R genList(GenTableVo vo) {
return R.ok(genTableService.selectGenTableList(vo));
}
@ApiOperation(value = "预览代码")
@GetMapping("/preview/{tableId}")
public R preview(@PathVariable("tableId") Long tableId) {
Map<String, String> dataMap = genTableService.previewCode(tableId);
return R.ok(dataMap);
}
@ApiOperation(value = "生成代码（下载方式）")
@GetMapping("/download/{tableName}")
public void download(HttpServletResponse response, @PathVariable("tableName") String tableName) throws IOException {
byte[] data = genTableService.downloadCode(tableName);
genCode(response, data);
}
@Log(title = "代码生成", businessType = BusinessType.GENCODE)
@ApiOperation(value = "批量生成代码")
@GetMapping("/download/batch")
public void batchGenCode(HttpServletResponse response, String tables) throws IOException {
String[] tableNames = Convert.toStrArray(tables);
byte[] data = genTableService.downloadCode(tableNames);
genCode(response, data);
}
@ApiOperation(value = "删除代码生成")
@DeleteMapping("/{tableIds}")
public R remove(@PathVariable Long[] tableIds) {
genTableService.deleteGenTableByIds(tableIds);
return R.ok();
}
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=\"admin.zip\"");
response.addHeader("Content-Length", "" + data.length);
response.setContentType("application/octet-stream; charset=UTF-8");
IOUtils.write(data, response.getOutputStream());
}
}

137
play-generator/src/main/java/com/starry/generator/entity/GenTableColumnEntity.java Normal file
View File

@@ -0,0 +1,137 @@
package com.starry.generator.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.starry.common.domain.BaseEntity;
import com.starry.common.utils.StringUtils;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;
import javax.validation.constraints.NotBlank;
import java.io.Serializable;
/**
* @author admin
* 代码生成业务字段表 gen_table_column
* @since 2022/7/14
*/
@Getter
@Setter
@TableName("gen_table_column")
@ApiModel(value = "GenTableColumn对象", description = "代码生成业务表字段")
public class GenTableColumnEntity extends BaseEntity<GenTableEntity> implements Serializable {
/**
* 编号
*/
@ApiModelProperty("主键ID")
@TableId(value = "table_id", type = IdType.AUTO)
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
"createdBy", "createdTime", "updatedBy", "updatedTime", "deleted",
// TreeEntity
"parentName", "parentId", "orderNum", "ancestors");
}
public boolean isSuperColumn() {
return isSuperColumn(this.javaField);
}
public String getCapJavaField() {
return StringUtils.capitalize(javaField);
}
}

175
play-generator/src/main/java/com/starry/generator/entity/GenTableEntity.java Normal file
View File

@@ -0,0 +1,175 @@
package com.starry.generator.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import com.starry.common.domain.BaseEntity;
import com.starry.common.utils.StringUtils;
import com.starry.generator.constant.GenConstants;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Getter;
import lombok.Setter;
import javax.validation.constraints.NotBlank;
import java.util.List;
/**
* @author admin
* 业务表 gen_table
* @since 2022/7/14
*/
@Getter
@Setter
@TableName("gen_table")
@ApiModel(value = "GenTable对象", description = "代码生成业务表")
public class GenTableEntity extends BaseEntity<GenTableEntity> {
@ApiModelProperty("主键ID")
@TableId(value = "table_id", type = IdType.AUTO)
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;
/**
* 生成包路径
*/
@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;
/**
* 主键信息
*/
@TableField(exist = false)
private GenTableColumnEntity pkColumn;
/**
* 子表信息
*/
@TableField(exist = false)
private GenTableEntity subTable;
/**
* 表列信息
*/
@TableField(exist = false)
private List<GenTableColumnEntity> columns;
/**
* 其它生成选项
*/
private String options;
/**
* 树编码字段
*/
@TableField(exist = false)
private String treeCode;
/**
* 树父编码字段
*/
@TableField(exist = false)
private String treeParentCode;
/**
* 树名称字段
*/
@TableField(exist = false)
private String treeName;
/**
* 上级菜单ID字段
*/
@TableField(exist = false)
private String parentMenuId;
/**
* 上级菜单名称字段
*/
@TableField(exist = false)
private String parentMenuName;
public static boolean isCrud(String tplCategory) {
return tplCategory != null && StringUtils.equals(GenConstants.TPL_CRUD, tplCategory);
}
public static boolean isTree(String tplCategory) {
return tplCategory != null && StringUtils.equals(GenConstants.TPL_TREE, tplCategory);
}
public boolean isCrud() {
return isCrud(this.tplCategory);
}
public boolean isTree() {
return isTree(this.tplCategory);
}
}

155
play-generator/src/main/java/com/starry/generator/entity/vo/GenTableVo.java Normal file
View File

@@ -0,0 +1,155 @@
package com.starry.generator.entity.vo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.starry.common.domain.BasePageEntity;
import com.starry.generator.entity.GenTableColumnEntity;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
import javax.validation.constraints.NotBlank;
import java.util.List;
/**
* @author admin
* 业务表 gen_table
* @since 2022/7/14
*/
@EqualsAndHashCode(callSuper = true)
@Data
public class GenTableVo extends BasePageEntity {
@ApiModelProperty("主键ID")
@TableId(value = "table_id", type = IdType.AUTO)
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;
/**
* 生成包路径
*/
@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;
/**
* 主键信息
*/
@TableField(exist = false)
private GenTableColumnEntity pkColumn;
/**
* 子表信息
*/
@TableField(exist = false)
private GenTableVo subTable;
/**
* 表列信息
*/
@TableField(exist = false)
private List<GenTableColumnEntity> columns;
/**
* 其它生成选项
*/
private String options;
/**
* 树编码字段
*/
@TableField(exist = false)
private String treeCode;
/**
* 树父编码字段
*/
@TableField(exist = false)
private String treeParentCode;
/**
* 树名称字段
*/
@TableField(exist = false)
private String treeName;
/**
* 上级菜单ID字段
*/
@TableField(exist = false)
private String parentMenuId;
/**
* 上级菜单名称字段
*/
@TableField(exist = false)
private String parentMenuName;
}

28
play-generator/src/main/java/com/starry/generator/mapper/GenTableColumnMapper.java Normal file
View File

@@ -0,0 +1,28 @@
package com.starry.generator.mapper;
import com.baomidou.mybatisplus.annotation.InterceptorIgnore;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.starry.generator.entity.GenTableColumnEntity;
import java.util.List;
/**
* <p>
* 代码生成业务表字段 Mapper 接口
* </p>
*
* @author admin
* @since 2022-07-15
*/
public interface GenTableColumnMapper extends BaseMapper<GenTableColumnEntity> {
/**
* 根据表名称查询列信息
*
* @param tableName 表名称
* @return 列信息
*/
@InterceptorIgnore(tenantLine = "1")
List<GenTableColumnEntity> selectDbTableColumnsByName(String tableName);
}

64
play-generator/src/main/java/com/starry/generator/mapper/GenTableMapper.java Normal file
View File

@@ -0,0 +1,64 @@
package com.starry.generator.mapper;
import com.baomidou.mybatisplus.annotation.InterceptorIgnore;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.starry.generator.entity.GenTableEntity;
import com.starry.generator.entity.vo.GenTableVo;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* @author admin
* 业务 数据层
* @since 2022/7/14
*/
public interface GenTableMapper extends BaseMapper<GenTableEntity> {
/**
* 查询业务列表
*
* @param genTableEntity 业务信息
* @return 业务集合
*/
IPage<GenTableEntity> selectGenTableList(Page<GenTableEntity> page, @Param(value = "genTableEntity") GenTableVo genTableEntity);
@InterceptorIgnore(tenantLine = "1")
IPage<GenTableEntity> selectDbTableList(Page page, @Param("genTableEntity") GenTableEntity genTableEntity);
/**
* 查询数据库列表
*
* @param tableNames 表名称组
* @return 数据库表集合
*/
@InterceptorIgnore(tenantLine = "1")
List<GenTableEntity> selectDbTableListByNames(String[] tableNames);
/**
* 查询所有表信息
*
* @return 表信息集合
*/
List<GenTableEntity> selectGenTableAll();
/**
* 查询表ID业务信息
*
* @param id 业务ID
* @return 业务信息
*/
GenTableEntity selectGenTableById(Long id);
/**
* 查询表名称业务信息
*
* @param tableName 表名称
* @return 业务信息
*/
GenTableEntity selectGenTableByName(String tableName);
}

80
play-generator/src/main/java/com/starry/generator/service/GenTableService.java Normal file
View File

@@ -0,0 +1,80 @@
package com.starry.generator.service;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.service.IService;
import com.starry.generator.entity.GenTableEntity;
import com.starry.generator.entity.vo.GenTableVo;
import java.util.List;
import java.util.Map;
/**
* @author admin
* @since 2022/7/14
*/
public interface GenTableService extends IService<GenTableEntity> {
/**
* 查询数据库列表
*
* @param genTableEntity 业务信息
* @return 数据库表集合
*/
/*List<GenTableEntity> selectDbTableList(GenTableEntity genTableEntity);*/
IPage<GenTableEntity> selectDbTableList(GenTableEntity genTableEntity);
/**
* 查询据库列表
*
* @param tableNames 表名称组
* @return 数据库表集合
*/
List<GenTableEntity> selectDbTableListByNames(String[] tableNames);
/**
* 导入表结构
*
* @param tableList 导入表列表
*/
void importGenTable(List<GenTableEntity> tableList);
/**
* 查询业务列表
*
* @param genTableEntity 业务信息
* @return 业务集合
*/
IPage<GenTableEntity> selectGenTableList(GenTableVo genTableEntity);
/**
* 预览代码
*
* @param tableId 表编号
* @return 预览数据列表
*/
Map<String, String> previewCode(Long tableId);
/**
* 生成代码（下载方式）
*
* @param tableName 表名称
* @return 数据
*/
byte[] downloadCode(String tableName);
/**
* 批量生成代码（下载方式）
*
* @param tableNames 表数组
* @return 数据
*/
byte[] downloadCode(String[] tableNames);
/**
* 删除业务信息
*
* @param tableIds 需要删除的表数据ID
*/
void deleteGenTableByIds(Long[] tableIds);
}

212
play-generator/src/main/java/com/starry/generator/service/GenTableServiceImpl.java Normal file
View File

@@ -0,0 +1,212 @@
package com.starry.generator.service;
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.convert.Convert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.starry.common.utils.ServletUtils;
import com.starry.common.utils.StringUtils;
import com.starry.generator.constant.GenConstants;
import com.starry.generator.entity.GenTableColumnEntity;
import com.starry.generator.entity.GenTableEntity;
import com.starry.generator.entity.vo.GenTableVo;
import com.starry.generator.mapper.GenTableColumnMapper;
import com.starry.generator.mapper.GenTableMapper;
import com.starry.generator.utils.GenUtils;
import com.starry.generator.utils.VelocityInitializer;
import com.starry.generator.utils.VelocityUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.velocity.Template;
import org.apache.velocity.VelocityContext;
import org.apache.velocity.app.Velocity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import javax.annotation.Resource;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
/**
* @author admin
* @since 2022/7/14
*/
@Slf4j
@Service
public class GenTableServiceImpl extends ServiceImpl<GenTableMapper, GenTableEntity> implements GenTableService {
@Resource
private GenTableColumnMapper genTableColumnMapper;
/*@Override
public List<GenTableEntity> selectDbTableList(GenTableEntity genTableEntity) {
return baseMapper.selectDbTableList(genTableEntity);
}*/
@Override
public IPage<GenTableEntity> selectDbTableList(GenTableEntity genTableEntity) {
Page mpPage = new Page(Convert.toLong(ServletUtils.getParameterToInt("pageNum"), 1L), Convert.toLong(ServletUtils.getParameterToInt("pageSize"), 10L));
return baseMapper.selectDbTableList(mpPage, genTableEntity);
}
@Override
public List<GenTableEntity> selectDbTableListByNames(String[] tableNames) {
return baseMapper.selectDbTableListByNames(tableNames);
}
@Transactional(rollbackFor = Exception.class)
@Override
public void importGenTable(List<GenTableEntity> tableList) {
if (CollectionUtil.isNotEmpty(tableList)) {
for (GenTableEntity table : tableList) {
String tableName = table.getTableName();
GenUtils.initTable(table);
// 保存生成表数据
int row = baseMapper.insert(table);
if (row > 0) {
// 查询数据库表列信息
List<GenTableColumnEntity> genTableColumnEntities = genTableColumnMapper.selectDbTableColumnsByName(tableName);
if (CollectionUtil.isNotEmpty(genTableColumnEntities)) {
for (GenTableColumnEntity column : genTableColumnEntities) {
GenUtils.initColumnField(column, table);
// 保存生成表字段数据
genTableColumnMapper.insert(column);
}
}
}
}
}
}
@Override
public IPage<GenTableEntity> selectGenTableList(GenTableVo vo) {
return baseMapper.selectGenTableList(new Page<>(vo.getPageNum(), vo.getPageSize()), vo);
}
@Override
public Map<String, String> previewCode(Long tableId) {
Map<String, String> dataMap = new LinkedHashMap<>();
// 查询表信息
GenTableEntity table = baseMapper.selectGenTableById(tableId);
// 设置主子表信息
setSubTable(table);
// 设置主键列信息
setPkColumn(table);
// 初始化
VelocityInitializer.initVelocity();
// 设置模板变量信息
VelocityContext context = VelocityUtils.prepareContext(table);
// 获取模版列表
List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory());
for (String template : templates) {
// 渲染模板
StringWriter sw = new StringWriter();
Template tpl = Velocity.getTemplate(template, "UTF-8");
tpl.merge(context, sw);
dataMap.put(template, sw.toString());
}
return dataMap;
}
@Override
public byte[] downloadCode(String tableName) {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ZipOutputStream zip = new ZipOutputStream(outputStream);
generatorCode(tableName, zip);
IOUtils.closeQuietly(zip);
return outputStream.toByteArray();
}
@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();
}
@Transactional(rollbackFor = Exception.class)
@Override
public void deleteGenTableByIds(Long[] tableIds) {
baseMapper.deleteBatchIds(Arrays.asList(tableIds));
List<GenTableColumnEntity> genTableColumnEntities = genTableColumnMapper.selectList(new LambdaQueryWrapper<GenTableColumnEntity>().in(GenTableColumnEntity::getTableId, Arrays.asList(tableIds)));
genTableColumnMapper.deleteBatchIds(genTableColumnEntities);
}
private void generatorCode(String tableName, ZipOutputStream zip) {
// 查询表信息
GenTableEntity table = baseMapper.selectGenTableByName(tableName);
// 设置主子表信息
setSubTable(table);
// 设置主键列信息
setPkColumn(table);
// 初始化
VelocityInitializer.initVelocity();
// 设置模板变量信息
VelocityContext context = VelocityUtils.prepareContext(table);
// 获取模版列表
List<String> templates = VelocityUtils.getTemplateList(table.getTplCategory());
for (String template : templates) {
// 渲染模板
StringWriter sw = new StringWriter();
Template tpl = Velocity.getTemplate(template, "UTF-8");
tpl.merge(context, sw);
try {
// 添加到zip
zip.putNextEntry(new ZipEntry(VelocityUtils.getFileName(template, table)));
IOUtils.write(sw.toString(), zip, "UTF-8");
IOUtils.closeQuietly(sw);
zip.flush();
zip.closeEntry();
} catch (IOException e) {
log.error("渲染模板失败，表名：" + table.getTableName(), e);
}
}
}
public void setSubTable(GenTableEntity table) {
String subTableName = table.getSubTableName();
if (StringUtils.isNotBlank(subTableName)) {
}
}
/**
* 设置主键列信息
*
* @param table 业务表信息
*/
public void setPkColumn(GenTableEntity table) {
for (GenTableColumnEntity column : table.getColumns()) {
if ("1".equals(column.getIsPk())) {
table.setPkColumn(column);
break;
}
if (StringUtils.isNull(table.getPkColumn())) {
table.setPkColumn(table.getColumns().get(0));
}
if (GenConstants.TPL_SUB.equals(table.getTplCategory())) {
for (GenTableColumnEntity columnSub : table.getSubTable().getColumns()) {
if ("1".equals(columnSub.getIsPk())) {
table.getSubTable().setPkColumn(columnSub);
break;
}
if (StringUtils.isNull(table.getSubTable().getPkColumn())) {
table.getSubTable().setPkColumn(table.getSubTable().getColumns().get(0));
}
}
}
}
}
}

265
play-generator/src/main/java/com/starry/generator/utils/GenUtils.java Normal file
View File

@@ -0,0 +1,265 @@
package com.starry.generator.utils;
import com.starry.generator.config.GenConfig;
import com.starry.generator.constant.GenConstants;
import com.starry.generator.entity.GenTableColumnEntity;
import com.starry.generator.entity.GenTableEntity;
import org.apache.commons.lang3.StringUtils;
import java.util.Arrays;
/**
* @author admin
* 代码生成器 工具类
* @since 2022/7/15
*/
public class GenUtils {
/**
* 初始化表信息
*/
public static void initTable(GenTableEntity genTableEntity) {
genTableEntity.setClassName(convertClassName(genTableEntity.getTableName()));
genTableEntity.setPackageName(GenConfig.getPackageName());
genTableEntity.setModuleName(getModuleName(GenConfig.getPackageName()));
genTableEntity.setBusinessName(getBusinessName(genTableEntity.getTableName()));
genTableEntity.setFunctionName(genTableEntity.getTableComment());
genTableEntity.setFunctionAuthor(GenConfig.getAuthor());
}
/**
* 表名转换成Java类名
*
* @param tableName 表名称
* @return 类名
*/
public static String convertClassName(String tableName) {
// 获取是否自动去除表前缀
boolean autoRemovePre = GenConfig.getAutoRemovePre();
// 获取表前缀
String tablePrefix = GenConfig.getTablePrefix();
if (autoRemovePre && StringUtils.isNotBlank(tablePrefix)) {
String[] searchList = StringUtils.split(tablePrefix, ",");
tableName = replaceFirst(tableName, searchList);
}
return convertToCamelCase(tableName);
}
/**
* 批量替换前缀
*
* @param replacement 替换值
* @param searchList 替换列表
* @return
*/
public static String replaceFirst(String replacement, String[] searchList) {
String text = replacement;
for (String searchString : searchList) {
if (replacement.startsWith(searchString)) {
text = replacement.replaceFirst(searchString, "");
break;
}
}
return text;
}
/**
* 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。
* 例如：HELLO_WORLD -> HelloWorld
*
* @param name 转换前的下划线大写方式命名的字符串
* @return 转换后的驼峰式命名的字符串
*/
public static String convertToCamelCase(String name) {
StringBuilder result = new StringBuilder();
if (StringUtils.isBlank(name)) {
return "";
} else if (!name.contains("_")) {
// 不含下划线，仅将首字母大写
return name.substring(0, 1).toUpperCase() + name.substring(1);
}
String[] camels = name.split("_");
for (String camel : camels) {
// 跳过原始字符串中开头、结尾的下换线或双重下划线
if (camel.isEmpty()) {
continue;
}
// 首字母大写
result.append(camel.substring(0, 1).toUpperCase());
result.append(camel.substring(1).toLowerCase());
}
return result.toString();
}
/**
* 获取模块名
*
* @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);
}
/**
* 初始化列属性字段
*/
public static void initColumnField(GenTableColumnEntity column, GenTableEntity table) {
String dataType = getDbType(column.getColumnType());
String columnName = column.getColumnName();
column.setTableId(table.getTableId());
// 设置java字段名
column.setJavaField(toCamelCase(columnName));
// 设置默认类型
column.setJavaType(GenConstants.TYPE_STRING);
column.setQueryType(GenConstants.QUERY_EQ);
if (arraysContains(GenConstants.COLUMN_TYPE_STR, dataType) || arraysContains(GenConstants.COLUMN_TYPE_TEXT, dataType)) {
// 字符串长度超过500设置为文本域
Integer columnLength = getColumnLength(column.getColumnType());
String htmlType = columnLength >= 500 || arraysContains(GenConstants.COLUMN_TYPE_TEXT, dataType) ? GenConstants.HTML_TEXTAREA : GenConstants.HTML_INPUT;
column.setHtmlType(htmlType);
} else if (arraysContains(GenConstants.COLUMN_TYPE_TIME, dataType)) {
// 时间类型
column.setJavaType(GenConstants.TYPE_DATE);
column.setHtmlType(GenConstants.HTML_DATETIME);
} else if (arraysContains(GenConstants.COLUMNTYPE_NUMBER, dataType)) {
// 数字类型
column.setHtmlType(GenConstants.HTML_INPUT);
// 如果是浮点型 统一用BigDecimal
String[] str = StringUtils.split(StringUtils.substringBetween(column.getColumnType(), "(", ")"), ",");
if (str != null && str.length == 2 && Integer.parseInt(str[1]) > 0) {
column.setJavaType(GenConstants.TYPE_BIGDECIMAL);
} else if (str != null && str.length == 1 && Integer.parseInt(str[0]) <= 10) {
// 如果是整形
column.setJavaType(GenConstants.TYPE_INTEGER);
} else {
// 长整形
column.setJavaType(GenConstants.TYPE_LONG);
}
}
// 插入字段（默认所有字段都需要插入）
column.setIsInsert(GenConstants.REQUIRE);
// 编辑字段
if (!arraysContains(GenConstants.COLUMN_NAME_NOT_EDIT, columnName) && !"1".equals(column.getIsPk())) {
column.setIsEdit(GenConstants.REQUIRE);
}
// 列表字段
if (!arraysContains(GenConstants.COLUMN_NAME_NOT_LIST, columnName) && !"1".equals(column.getIsPk())) {
column.setIsList(GenConstants.REQUIRE);
}
// 查询字段
if (!arraysContains(GenConstants.COLUMN_NAME_NOT_QUERY, columnName) && !"1".equals(column.getIsPk())) {
column.setIsQuery(GenConstants.REQUIRE);
}
// 查询字段类型
if (StringUtils.endsWithIgnoreCase(columnName, "name")) {
column.setQueryType(GenConstants.QUERY_LIKE);
}
// 状态字段设置单选框
if (StringUtils.endsWithIgnoreCase(columnName, "status")) {
column.setHtmlType(GenConstants.HTML_RADIO);
}
// 类型&性别字段设置下拉框
else if (StringUtils.endsWithIgnoreCase(columnName, "type")
|| StringUtils.endsWithIgnoreCase(columnName, "sex")) {
column.setHtmlType(GenConstants.HTML_SELECT);
}
// 图片字段设置图片上传控件
else if (StringUtils.endsWithIgnoreCase(columnName, "image")) {
column.setHtmlType(GenConstants.HTML_IMAGE_UPLOAD);
}
// 文件字段设置文件上传控件
else if (StringUtils.endsWithIgnoreCase(columnName, "file")) {
column.setHtmlType(GenConstants.HTML_FILE_UPLOAD);
}
// 内容字段设置富文本控件
else if (StringUtils.endsWithIgnoreCase(columnName, "content")) {
column.setHtmlType(GenConstants.HTML_EDITOR);
}
}
/**
* 获取数据库类型字段
* 例如： bigint 、varchar(64)
*
* @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;
}
}
/**
* 驼峰式命名法 例如：user_name->userName
*/
public static String toCamelCase(String s) {
if (StringUtils.isNotBlank(s)) {
// 小写
s = s.toLowerCase();
StringBuilder sb = new StringBuilder(s.length());
// 大写
boolean upperCase = false;
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
if (c == '_') {
upperCase = true;
} else if (upperCase) {
sb.append(Character.toUpperCase(c));
upperCase = false;
} else {
sb.append(c);
}
}
return sb.toString();
}
return s;
}
/**
* 校验数组是否包含指定值
*
* @param arr 数组
* @param targetValue 值
* @return 是否包含
*/
public static boolean arraysContains(String[] arr, String targetValue) {
return Arrays.asList(arr).contains(targetValue);
}
}

22
play-generator/src/main/java/com/starry/generator/utils/VelocityInitializer.java Normal file
View File

@@ -0,0 +1,22 @@
package com.starry.generator.utils;
import org.apache.velocity.app.Velocity;
import java.util.Properties;
/**
* @author VelocityEngine工厂
* @since 2022/7/19
*/
public class VelocityInitializer {
public static void initVelocity() {
Properties p = new Properties();
// 加载classpath目录下的vm文件
p.setProperty("resource.loader.file.class", "org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader");
// 定义字符集
p.setProperty(Velocity.INPUT_ENCODING, "UTF-8");
// 初始化Velocity引擎，指定配置Properties
Velocity.init(p);
}
}

345
play-generator/src/main/java/com/starry/generator/utils/VelocityUtils.java Normal file
View File

@@ -0,0 +1,345 @@
package com.starry.generator.utils;
import cn.hutool.core.date.DateUtil;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;
import com.starry.common.utils.StringUtils;
import com.starry.generator.constant.GenConstants;
import com.starry.generator.entity.GenTableColumnEntity;
import com.starry.generator.entity.GenTableEntity;
import org.apache.velocity.VelocityContext;
import java.util.*;
/**
* @author admin
* 模板处理工具类
* @since 2022/7/19
*/
public class VelocityUtils {
/**
* 默认上级菜单，系统工具
*/
private static final String DEFAULT_PARENT_MENU_ID = "3";
/**
* 项目空间路径
*/
private static final String PROJECT_PATH = "main/java";
/**
* mybatis空间路径
*/
private static final String MYBATIS_PATH = "main/resources/mapper";
/**
* 设置模板变量信息
*
* @return 模板列表
*/
public static VelocityContext prepareContext(GenTableEntity genTableEntity) {
String moduleName = genTableEntity.getModuleName();
String businessName = genTableEntity.getBusinessName();
String packageName = genTableEntity.getPackageName();
String tplCategory = genTableEntity.getTplCategory();
String functionName = genTableEntity.getFunctionName();
VelocityContext velocityContext = new VelocityContext();
velocityContext.put("tplCategory", genTableEntity.getTplCategory());
velocityContext.put("tableName", genTableEntity.getTableName());
velocityContext.put("functionName", StringUtils.isNotEmpty(functionName) ? functionName : "【请填写功能名称】");
velocityContext.put("ClassName", genTableEntity.getClassName());
// 首字母小写
velocityContext.put("className", StringUtils.uncapitalize(genTableEntity.getClassName()));
velocityContext.put("moduleName", genTableEntity.getModuleName());
// 首字母大写
velocityContext.put("BusinessName", StringUtils.capitalize(genTableEntity.getBusinessName()));
velocityContext.put("businessName", genTableEntity.getBusinessName());
velocityContext.put("basePackage", getPackagePrefix(packageName));
velocityContext.put("packageName", packageName);
velocityContext.put("author", genTableEntity.getFunctionAuthor());
velocityContext.put("datetime", DateUtil.format(new Date(), "yyyy-MM-dd"));
velocityContext.put("pkColumn", genTableEntity.getPkColumn());
velocityContext.put("importList", getImportList(genTableEntity));
velocityContext.put("permissionPrefix", getPermissionPrefix(moduleName, businessName));
velocityContext.put("columns", genTableEntity.getColumns());
velocityContext.put("table", genTableEntity);
velocityContext.put("dicts", getDicts(genTableEntity));
setMenuVelocityContext(velocityContext, genTableEntity);
if (GenConstants.TPL_TREE.equals(tplCategory)) {
setTreeVelocityContext(velocityContext, genTableEntity);
}
if (GenConstants.TPL_SUB.equals(tplCategory)) {
setSubVelocityContext(velocityContext, genTableEntity);
}
return velocityContext;
}
/**
* 获取包前缀
*
* @param packageName 包名称
* @return 包前缀名称
*/
public static String getPackagePrefix(String packageName) {
int lastIndex = packageName.lastIndexOf(".");
return StringUtils.substring(packageName, 0, lastIndex);
}
/**
* 根据列类型获取导入包
*
* @param genTableEntity 业务表对象
* @return 返回需要导入的包列表
*/
public static HashSet<String> getImportList(GenTableEntity genTableEntity) {
List<GenTableColumnEntity> columns = genTableEntity.getColumns();
GenTableEntity subGenTableEntity = genTableEntity.getSubTable();
HashSet<String> importList = new HashSet<>();
if (StringUtils.isNotNull(subGenTableEntity)) {
importList.add("java.util.List");
}
for (GenTableColumnEntity 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 moduleName 模块名称
* @param businessName 业务名称
* @return 返回权限前缀
*/
public static String getPermissionPrefix(String moduleName, String businessName) {
return StringUtils.format("{}:{}", moduleName, businessName);
}
/**
* 根据列类型获取字典组
*
* @param genTableEntity 业务表对象
* @return 返回字典组
*/
public static String getDicts(GenTableEntity genTableEntity) {
List<GenTableColumnEntity> columns = genTableEntity.getColumns();
Set<String> dicts = new HashSet<>();
addDicts(dicts, columns);
if (StringUtils.isNotNull(genTableEntity.getSubTable())) {
List<GenTableColumnEntity> subColumns = genTableEntity.getSubTable().getColumns();
addDicts(dicts, subColumns);
}
return StringUtils.join(dicts, ", ");
}
/**
* 添加字典列表
*
* @param dicts 字典列表
* @param columns 列集合
*/
public static void addDicts(Set<String> dicts, List<GenTableColumnEntity> columns) {
for (GenTableColumnEntity 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() + "'");
}
}
}
public static void setMenuVelocityContext(VelocityContext context, GenTableEntity genTableEntity) {
String options = genTableEntity.getOptions();
JSONObject paramsObj = JSON.parseObject(options);
String parentMenuId = getParentMenuId(paramsObj);
context.put("parentMenuId", parentMenuId);
}
public static void setTreeVelocityContext(VelocityContext context, GenTableEntity genTableEntity) {
String options = genTableEntity.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(genTableEntity));
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, GenTableEntity genTableEntity) {
GenTableEntity subTable = genTableEntity.getSubTable();
String subTableName = genTableEntity.getSubTableName();
String subTableFkName = genTableEntity.getSubTableFkName();
String subClassName = genTableEntity.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(genTableEntity.getSubTable()));
}
/**
* 获取上级菜单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;
}
public static int getExpandColumn(GenTableEntity genTableEntity) {
String options = genTableEntity.getOptions();
JSONObject paramsObj = JSON.parseObject(options);
String treeName = paramsObj.getString(GenConstants.TREE_NAME);
int num = 0;
for (GenTableColumnEntity column : genTableEntity.getColumns()) {
if ("1".equals(column.getIsList())) {
num++;
String columnName = column.getColumnName();
if (columnName.equals(treeName)) {
break;
}
}
}
return num;
}
/**
* 获取模板信息
*
* @return 模板列表
*/
public static List<String> getTemplateList(String tplCategory) {
List<String> templates = new ArrayList<>();
templates.add("vm/java/entity.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/java/controller.java.vm");
templates.add("vm/xml/mapper.xml.vm");
templates.add("vm/sql/sql.vm");
templates.add("vm/js/api.js.vm");
if (GenConstants.TPL_CRUD.equals(tplCategory)) {
templates.add("vm/vue/index.vue.vm");
} else if (GenConstants.TPL_TREE.equals(tplCategory)) {
templates.add("vm/vue/index-tree.vue.vm");
} else if (GenConstants.TPL_SUB.equals(tplCategory)) {
templates.add("vm/vue/index.vue.vm");
templates.add("vm/java/sub-domain.java.vm");
}
return templates;
}
/**
* 获取文件名
*
* @return 文件名称
*/
public static String getFileName(String template, GenTableEntity genTableEntity) {
// 文件名称
String fileName = "";
// 包路径
String packageName = genTableEntity.getPackageName();
// 模块名
String moduleName = genTableEntity.getModuleName();
// 大写类名
String className = genTableEntity.getClassName();
// 业务名称
String businessName = genTableEntity.getBusinessName();
// 相关生成文件目录
String javaPath = PROJECT_PATH + "/" + StringUtils.replace(packageName, ".", "/");
String mybatisPath = MYBATIS_PATH + "/" + moduleName;
String vuePath = "vue";
if (template.contains("domain.java.vm")) {
fileName = StringUtils.format("{}/domain/{}.java", javaPath, className);
} else if (template.contains("sub-domain.java.vm") && StringUtils.equals(GenConstants.TPL_SUB, genTableEntity.getTplCategory())) {
fileName = StringUtils.format("{}/domain/{}.java", javaPath, genTableEntity.getSubTable().getClassName());
} else 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("controller.java.vm")) {
fileName = StringUtils.format("{}/controller/{}Controller.java", javaPath, className);
} else if (template.contains("mapper.xml.vm")) {
fileName = StringUtils.format("{}/{}Mapper.xml", mybatisPath, className);
} else if (template.contains("sql.vm")) {
fileName = businessName + "Menu.sql";
} else if (template.contains("api.js.vm")) {
fileName = StringUtils.format("{}/api/{}/{}.js", vuePath, moduleName, businessName);
} else if (template.contains("index.vue.vm")) {
fileName = StringUtils.format("{}/views/{}/{}/index.vue", vuePath, moduleName, businessName);
} else if (template.contains("index-tree.vue.vm")) {
fileName = StringUtils.format("{}/views/{}/{}/index.vue", vuePath, moduleName, businessName);
}
return fileName;
}
}