xins
/
hwmom
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'ruoyi-cloud/master'

Browse Source 
# Conflicts:
#	ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/constant/Constants.java
#	ruoyi-modules/ruoyi-gen/src/main/java/com/ruoyi/gen/service/GenTableServiceImpl.java
#	ruoyi-modules/ruoyi-job/src/main/java/com/ruoyi/job/controller/SysJobController.java
#	ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictTypeServiceImpl.java
#	sql/ry_config_20220114.sql
2.X
疯狂的狮子li 3 years ago
parent 384a52e3e9 6b4d03cb8d
commit c28d9c208e
5 changed files with 769 additions and 756 deletions
Show Stats Download Patch File Download Diff File

240
ruoyi-common/ruoyi-common-core/src/main/java/com/ruoyi/common/core/constant/Constants.java
Unescape Escape View File

@ -1,120 +1,120 @@
package com.ruoyi.common.core.constant; package com.ruoyi.common.core.constant;
/** /**
* 通用常量信息 * 通用常量信息
* *
* @author Lion Li * @author Lion Li
*/ */
public interface Constants { public interface Constants {
/** /**
* UTF-8 字符集 * UTF-8 字符集
*/ */
String UTF8 = "UTF-8"; String UTF8 = "UTF-8";
/** /**
* GBK 字符集 * GBK 字符集
*/ */
String GBK = "GBK"; String GBK = "GBK";
/** /**
* RMI 远程方法调用 * RMI 远程方法调用
*/ */
String LOOKUP_RMI = "rmi:"; String LOOKUP_RMI = "rmi:";
/** /**
* LDAP 远程方法调用 * LDAP 远程方法调用
*/ */
String LOOKUP_LDAP = "ldap:"; String LOOKUP_LDAP = "ldap:";
/** /**
* LDAPS 远程方法调用 * LDAPS 远程方法调用
*/ */
String LOOKUP_LDAPS = "ldaps:"; String LOOKUP_LDAPS = "ldaps:";
/** /**
* http请求 * http请求
*/ */
String HTTP = "http://"; String HTTP = "http://";
/** /**
* https请求 * https请求
*/ */
String HTTPS = "https://"; String HTTPS = "https://";
/** /**
* 成功标记 * 成功标记
*/ */
Integer SUCCESS = 200; Integer SUCCESS = 200;
/** /**
* 失败标记 * 失败标记
*/ */
Integer FAIL = 500; Integer FAIL = 500;
/** /**
* 登录成功 * 登录成功
*/ */
String LOGIN_SUCCESS = "Success"; String LOGIN_SUCCESS = "Success";
/** /**
* 注销 * 注销
*/ */
String LOGOUT = "Logout"; String LOGOUT = "Logout";
/** /**
* 注册 * 注册
*/ */
String REGISTER = "Register"; String REGISTER = "Register";
/** /**
* 登录失败 * 登录失败
*/ */
String LOGIN_FAIL = "Error"; String LOGIN_FAIL = "Error";
/** /**
* 当前记录起始索引 * 当前记录起始索引
*/ */
String PAGE_NUM = "pageNum"; String PAGE_NUM = "pageNum";
/** /**
* 每页显示记录数 * 每页显示记录数
*/ */
String PAGE_SIZE = "pageSize"; String PAGE_SIZE = "pageSize";
/** /**
* 排序列 * 排序列
*/ */
String ORDER_BY_COLUMN = "orderByColumn"; String ORDER_BY_COLUMN = "orderByColumn";
/** /**
* 排序的方向 "desc" 或者 "asc". * 排序的方向 "desc" 或者 "asc".
*/ */
String IS_ASC = "isAsc"; String IS_ASC = "isAsc";
/** /**
* 验证码 redis key * 验证码 redis key
*/ */
String CAPTCHA_CODE_KEY = "captcha_codes:"; String CAPTCHA_CODE_KEY = "captcha_codes:";
/** /**
* 验证码有效期（分钟） * 验证码有效期（分钟）
*/ */
long CAPTCHA_EXPIRATION = 2; long CAPTCHA_EXPIRATION = 2;
/** /**
* 参数管理 cache key * 参数管理 cache key
*/ */
String SYS_CONFIG_KEY = "sys_config:"; String SYS_CONFIG_KEY = "sys_config:";
/** /**
* 字典管理 cache key * 字典管理 cache key
*/ */
String SYS_DICT_KEY = "sys_dict:"; String SYS_DICT_KEY = "sys_dict:";
/** /**
* 资源映射路径 前缀 * 资源映射路径 前缀
*/ */
String RESOURCE_PREFIX = "/profile"; String RESOURCE_PREFIX = "/profile";
} }

879
ruoyi-modules/ruoyi-gen/src/main/java/com/ruoyi/gen/service/GenTableServiceImpl.java
Unescape Escape View File

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

402
ruoyi-modules/ruoyi-system/src/main/java/com/ruoyi/system/service/impl/SysDictTypeServiceImpl.java
Unescape Escape View File

@ -1,199 +1,203 @@
package com.ruoyi.system.service.impl; package com.ruoyi.system.service.impl;
import com.ruoyi.common.core.constant.UserConstants; import com.ruoyi.common.core.constant.UserConstants;
import com.ruoyi.common.core.exception.ServiceException; import com.ruoyi.common.core.exception.ServiceException;
import com.ruoyi.common.core.utils.StringUtils; import com.ruoyi.common.core.utils.StringUtils;
import com.ruoyi.common.dict.utils.DictUtils; import com.ruoyi.common.dict.utils.DictUtils;
import com.ruoyi.system.api.domain.SysDictData; import com.ruoyi.system.api.domain.SysDictData;
import com.ruoyi.system.api.domain.SysDictType; import com.ruoyi.system.api.domain.SysDictType;
import com.ruoyi.system.mapper.SysDictDataMapper; import com.ruoyi.system.mapper.SysDictDataMapper;
import com.ruoyi.system.mapper.SysDictTypeMapper; import com.ruoyi.system.mapper.SysDictTypeMapper;
import com.ruoyi.system.service.ISysDictTypeService; import com.ruoyi.system.service.ISysDictTypeService;
import lombok.RequiredArgsConstructor; import lombok.RequiredArgsConstructor;
import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import javax.annotation.PostConstruct; import javax.annotation.PostConstruct;
import java.util.List; import java.util.List;
import java.util.Comparator;
/** import java.util.Map;
* 字典 业务层处理 import java.util.stream.Collectors;
*
* @author ruoyi /**
*/ * 字典 业务层处理
@RequiredArgsConstructor(onConstructor_ = @Autowired) *
@Service * @author ruoyi
public class SysDictTypeServiceImpl implements ISysDictTypeService { */
@RequiredArgsConstructor(onConstructor_ = @Autowired)
private final SysDictTypeMapper dictTypeMapper; @Service
private final SysDictDataMapper dictDataMapper; public class SysDictTypeServiceImpl implements ISysDictTypeService {
/** private final SysDictTypeMapper dictTypeMapper;
* 项目启动时，初始化字典到缓存 private final SysDictDataMapper dictDataMapper;
*/
@PostConstruct /**
public void init() { * 项目启动时，初始化字典到缓存
loadingDictCache(); */
} @PostConstruct
public void init() {
/** loadingDictCache();
* 根据条件分页查询字典类型 }
*
* @param dictType 字典类型信息 /**
* @return 字典类型集合信息 * 根据条件分页查询字典类型
*/ *
@Override * @param dictType 字典类型信息
public List<SysDictType> selectDictTypeList(SysDictType dictType) { * @return 字典类型集合信息
return dictTypeMapper.selectDictTypeList(dictType); */
} @Override
public List<SysDictType> selectDictTypeList(SysDictType dictType) {
/** return dictTypeMapper.selectDictTypeList(dictType);
* 根据所有字典类型 }
*
* @return 字典类型集合信息 /**
*/ * 根据所有字典类型
@Override *
public List<SysDictType> selectDictTypeAll() { * @return 字典类型集合信息
return dictTypeMapper.selectDictTypeAll(); */
} @Override
public List<SysDictType> selectDictTypeAll() {
/** return dictTypeMapper.selectDictTypeAll();
* 根据字典类型查询字典数据 }
*
* @param dictType 字典类型 /**
* @return 字典数据集合信息 * 根据字典类型查询字典数据
*/ *
@Override * @param dictType 字典类型
public List<SysDictData> selectDictDataByType(String dictType) { * @return 字典数据集合信息
List<SysDictData> dictDatas = DictUtils.getDictCache(dictType); */
if (StringUtils.isNotEmpty(dictDatas)) { @Override
return dictDatas; public List<SysDictData> selectDictDataByType(String dictType) {
} List<SysDictData> dictDatas = DictUtils.getDictCache(dictType);
dictDatas = dictDataMapper.selectDictDataByType(dictType); if (StringUtils.isNotEmpty(dictDatas)) {
if (StringUtils.isNotEmpty(dictDatas)) { return dictDatas;
DictUtils.setDictCache(dictType, dictDatas); }
return dictDatas; dictDatas = dictDataMapper.selectDictDataByType(dictType);
} if (StringUtils.isNotEmpty(dictDatas)) {
return null; DictUtils.setDictCache(dictType, dictDatas);
} return dictDatas;
}
/** return null;
* 根据字典类型ID查询信息 }
*
* @param dictId 字典类型ID /**
* @return 字典类型 * 根据字典类型ID查询信息
*/ *
@Override * @param dictId 字典类型ID
public SysDictType selectDictTypeById(Long dictId) { * @return 字典类型
return dictTypeMapper.selectDictTypeById(dictId); */
} @Override
public SysDictType selectDictTypeById(Long dictId) {
/** return dictTypeMapper.selectDictTypeById(dictId);
* 根据字典类型查询信息 }
*
* @param dictType 字典类型 /**
* @return 字典类型 * 根据字典类型查询信息
*/ *
@Override * @param dictType 字典类型
public SysDictType selectDictTypeByType(String dictType) { * @return 字典类型
return dictTypeMapper.selectDictTypeByType(dictType); */
} @Override
public SysDictType selectDictTypeByType(String dictType) {
/** return dictTypeMapper.selectDictTypeByType(dictType);
* 批量删除字典类型信息 }
*
* @param dictIds 需要删除的字典ID /**
* @return 结果 * 批量删除字典类型信息
*/ *
@Override * @param dictIds 需要删除的字典ID
public void deleteDictTypeByIds(Long[] dictIds) { * @return 结果
for (Long dictId : dictIds) { */
SysDictType dictType = selectDictTypeById(dictId); @Override
if (dictDataMapper.countDictDataByType(dictType.getDictType()) > 0) { public void deleteDictTypeByIds(Long[] dictIds) {
throw new ServiceException(String.format("%1$s已分配,不能删除", dictType.getDictName())); for (Long dictId : dictIds) {
} SysDictType dictType = selectDictTypeById(dictId);
dictTypeMapper.deleteDictTypeById(dictId); if (dictDataMapper.countDictDataByType(dictType.getDictType()) > 0) {
DictUtils.removeDictCache(dictType.getDictType()); throw new ServiceException(String.format("%1$s已分配,不能删除", dictType.getDictName()));
} }
} dictTypeMapper.deleteDictTypeById(dictId);
DictUtils.removeDictCache(dictType.getDictType());
/** }
* 加载字典缓存数据 }
*/
@Override /**
public void loadingDictCache() { * 加载字典缓存数据
List<SysDictType> dictTypeList = dictTypeMapper.selectDictTypeAll(); */
for (SysDictType dictType : dictTypeList) { @Override
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dictType.getDictType()); public void loadingDictCache() {
DictUtils.setDictCache(dictType.getDictType(), dictDatas); SysDictData dictData = new SysDictData();
} dictData.setStatus("0");
} Map<String, List<SysDictData>> dictDataMap = dictDataMapper.selectDictDataList(dictData).stream().collect(Collectors.groupingBy(SysDictData::getDictType));
for (Map.Entry<String, List<SysDictData>> entry : dictDataMap.entrySet()) {
/** DictUtils.setDictCache(entry.getKey(), entry.getValue().stream().sorted(Comparator.comparing(SysDictData::getDictSort)).collect(Collectors.toList()));
* 清空字典缓存数据 }
*/ }
@Override
public void clearDictCache() { /**
DictUtils.clearDictCache(); * 清空字典缓存数据
} */
@Override
/** public void clearDictCache() {
* 重置字典缓存数据 DictUtils.clearDictCache();
*/ }
@Override
public void resetDictCache() { /**
clearDictCache(); * 重置字典缓存数据
loadingDictCache(); */
} @Override
public void resetDictCache() {
/** clearDictCache();
* 新增保存字典类型信息 loadingDictCache();
* }
* @param dict 字典类型信息
* @return 结果 /**
*/ * 新增保存字典类型信息
@Override *
public int insertDictType(SysDictType dict) { * @param dict 字典类型信息
int row = dictTypeMapper.insertDictType(dict); * @return 结果
if (row > 0) { */
DictUtils.setDictCache(dict.getDictType(), null); @Override
} public int insertDictType(SysDictType dict) {
return row; int row = dictTypeMapper.insertDictType(dict);
} if (row > 0) {
DictUtils.setDictCache(dict.getDictType(), null);
/** }
* 修改保存字典类型信息 return row;
* }
* @param dict 字典类型信息
* @return 结果 /**
*/ * 修改保存字典类型信息
@Override *
@Transactional * @param dict 字典类型信息
public int updateDictType(SysDictType dict) { * @return 结果
SysDictType oldDict = dictTypeMapper.selectDictTypeById(dict.getDictId()); */
dictDataMapper.updateDictDataType(oldDict.getDictType(), dict.getDictType()); @Override
int row = dictTypeMapper.updateDictType(dict); @Transactional
if (row > 0) { public int updateDictType(SysDictType dict) {
List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType()); SysDictType oldDict = dictTypeMapper.selectDictTypeById(dict.getDictId());
DictUtils.setDictCache(dict.getDictType(), dictDatas); dictDataMapper.updateDictDataType(oldDict.getDictType(), dict.getDictType());
} int row = dictTypeMapper.updateDictType(dict);
return row; if (row > 0) {
} List<SysDictData> dictDatas = dictDataMapper.selectDictDataByType(dict.getDictType());
DictUtils.setDictCache(dict.getDictType(), dictDatas);
/** }
* 校验字典类型称是否唯一 return row;
* }
* @param dict 字典类型
* @return 结果 /**
*/ * 校验字典类型称是否唯一
@Override *
public String checkDictTypeUnique(SysDictType dict) { * @param dict 字典类型
Long dictId = StringUtils.isNull(dict.getDictId()) ? -1L : dict.getDictId(); * @return 结果
SysDictType dictType = dictTypeMapper.checkDictTypeUnique(dict.getDictType()); */
if (StringUtils.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) { @Override
return UserConstants.NOT_UNIQUE; public String checkDictTypeUnique(SysDictType dict) {
} Long dictId = StringUtils.isNull(dict.getDictId()) ? -1L : dict.getDictId();
return UserConstants.UNIQUE; SysDictType dictType = dictTypeMapper.checkDictTypeUnique(dict.getDictType());
} if (StringUtils.isNotNull(dictType) && dictType.getDictId().longValue() != dictId.longValue()) {
} return UserConstants.NOT_UNIQUE;
}
return UserConstants.UNIQUE;
}
}

2
ruoyi-ui/src/views/login.vue
Unescape Escape View File

@ -56,7 +56,7 @@
</el-form> </el-form>
<!-- 底部 --> <!-- 底部 -->
<div class="el-login-footer"> <div class="el-login-footer">
<span>Copyright © 2018-2021 ruoyi.vip All Rights Reserved.</span> <span>Copyright © 2018-2022 ruoyi.vip All Rights Reserved.</span>
</div> </div>
</div> </div>
</template> </template>

2
ruoyi-ui/src/views/register.vue
Unescape Escape View File

@ -61,7 +61,7 @@
</el-form> </el-form>
<!-- 底部 --> <!-- 底部 -->
<div class="el-register-footer"> <div class="el-register-footer">
<span>Copyright © 2018-2021 ruoyi.vip All Rights Reserved.</span> <span>Copyright © 2018-2022 ruoyi.vip All Rights Reserved.</span>
</div> </div>
</div> </div>
</template> </template>

Write Preview
Loading…
Cancel
Save