Skip to content

G
government-platform
Commit be4fe6cf authored by 赵啸非's avatar 赵啸非
Browse files
Options

编写系统代码生成模块

parent 33bf55da
Hide whitespace changes
Inline Side-by-side
Showing with 11493 additions and 255 deletions
db/government-platform.sql
View file @ be4fe6cf
......@@ -309,6 +309,63 @@ CREATE TABLE `mortals_xhx_valid_code` (
SET FOREIGN_KEY_CHECKS = 1;
-- ----------------------------
-- 代码生成业务表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_xhx_gentable`;
CREATE TABLE `mortals_xhx_gentable` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID，主键，自增长',
`tableName` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT '' COMMENT '表名称',
`tableComment` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT '' COMMENT '表描述',
`subTableName` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '关联子表的表名',
`subTableFkName` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '子表关联的外键名',
`className` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT '' COMMENT '实体类名称',
`tplCategory` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT 'crud' COMMENT '使用的模板（crud单表操作 tree树表操作）',
`packageName` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '生成包路径',
`moduleName` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '生成模块名',
`businessName` varchar(30) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '生成业务名',
`functionName` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '生成功能名',
`functionAuthor` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '生成功能作者',
`genType` tinyint(1) DEFAULT '0' COMMENT '生成代码方式（0.zip压缩包 1.自定义路径）',
`genPath` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT '/' COMMENT '生成路径（不填默认项目路径）',
`options` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '其它生成选项',
`remark` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '备注',
`updateTime` datetime(0) DEFAULT NULL COMMENT '变更时间',
`updateUser` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '变更用户loginName',
`createTime` datetime(0) NOT NULL COMMENT '创建时间',
`createUser` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '创建用户loginName',
PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='代码生成业务表';
-- ----------------------------
-- 代码生成业务表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_xhx_gentable_column`;
CREATE TABLE `mortals_xhx_gentable_column` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT 'ID，主键，自增长',
`tableId` bigint(20) NOT NULL COMMENT '所属表编号',
`columnName` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '列名称',
`columnComment` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '列描述',
`columnType` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '列类型',
`javaType` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT 'JAVA类型',
`javaField` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT 'JAVA字段名',
`isPrimaryKey` tinyint(2) DEFAULT '0' COMMENT '是否pk（0否，1 是）',
`isIncrement` tinyint(2) DEFAULT '0' COMMENT '是否自增（0否，1 是）',
`isRequired` tinyint(2) DEFAULT '0' COMMENT '是否必填（0否，1 是）',
`isInsert` tinyint(2) DEFAULT '0' COMMENT '是否为插入字段（0否，1 是）',
`isEdit` tinyint(2) DEFAULT '0' COMMENT '是否编辑字段（0否，1 是）',
`isList` tinyint(2) DEFAULT '0' COMMENT '是否列表字段（0否，1 是）',
`isQuery` tinyint(2) DEFAULT '0' COMMENT '是否查询字段（0否，1 是）',
`htmlType` tinyint(2) DEFAULT '1' COMMENT '显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）',
`sort` int(11) DEFAULT NULL COMMENT '排序',
`updateTime` datetime(0) DEFAULT NULL COMMENT '变更时间',
`updateUser` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '变更用户loginName',
`createTime` datetime(0) NOT NULL COMMENT '创建时间',
`createUser` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '创建用户loginName',
PRIMARY KEY (`id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='代码生成业务表字段';
INSERT INTO `mortals_xhx_param` VALUES (1000, '材料形式', 'materialProperty', NULL, '0', '纸质', 1, 4, 0, NULL, NULL, NULL, NULL);
......
government-manage-ui/admin/src/router.js
View file @ be4fe6cf
......@@ -28,7 +28,9 @@ const router = new Router({
...restBuilder('param', 'system/param'), // 系统管理--参数管理
...restBuilder('task', 'system/task'), // 系统管理--任务管理
...restBuilder('area', 'system/area'), // 系统管理-区域管理
...restBuilder('gentable', 'system/gentable'), // 系统管理-代码生成
...restBuilder('gentable/column', 'system/gentable/column'), // 系统管理-代码生成-列信息
builder('gen/edit', 'system/gentable/editTable'),//站点
builder('site/list', 'system/site/index'),//站点
//工作流业务模块
...restBuilder('flowable/definition', 'flowable/definition'), // 流程定义类
......
government-manage-ui/admin/src/views/flowable/definition/list.vue
View file @ be4fe6cf
......@@ -4,48 +4,6 @@
<LayoutTable :data="tableData" :config="tableConfig" notAdd notDel>
</LayoutTable>
<!-- bpmn20.xml导入对话框 -->
<el-dialog
:title="upload.title"
:visible.sync="upload.open"
width="400px"
append-to-body
>
<el-upload
ref="upload"
:limit="1"
accept=".xml"
:headers="upload.headers"
:action="
upload.url + '?name=' + upload.name + '&category=' + upload.category
"
:disabled="upload.isUploading"
:on-progress="handleFileUploadProgress"
:on-success="handleFileSuccess"
:auto-upload="false"
drag
>
<i class="el-icon-upload"></i>
<div class="el-upload__text">
将文件拖到此处，或
<em>点击上传</em>
</div>
<div class="el-upload__tip" slot="tip">
流程名称：<el-input v-model="upload.name" /> 流程分类：<el-input
v-model="upload.category"
/>
</div>
<div class="el-upload__tip" style="color: red" slot="tip">
提示：仅允许导入“bpmn20.xml”格式文件！
</div>
</el-upload>
<div slot="footer" class="dialog-footer">
<el-button type="primary" @click="submitFileForm">确 定</el-button>
<el-button @click="upload.open = false">取 消</el-button>
</div>
</el-dialog>
<el-dialog
append-to-body
:title="taskDialog.title"
......@@ -76,10 +34,46 @@
</div>
</el-dialog>
<el-dialog
append-to-body
:title="siteDialog.title"
:visible.sync="siteDialog.visible"
>
<el-form label-width="120px">
<el-form-item label="选择站点">
<treeselect
v-model="siteId"
:options="siteOptions"
placeholder="请选择站点"
/>
</el-form-item>
<el-form-item label="选择角色">
<el-select
v-model="roleId"
:multiple="siteDialog.multiple"
placeholder="请选择"
>
<el-option
v-for="item in roleList"
:key="item.id"
:label="item.name"
:value="item.id"
>
</el-option>
</el-select>
</el-form-item>
</el-form>
<div slot="footer" class="dialog-footer">
<el-button type="primary" @click="siteConfirm">确 定</el-button>
<el-button @click="siteDialog.visible = false">取 消</el-button>
</div>
</el-dialog>
<el-dialog
:title="configDialog.title"
:visible.sync="configDialog.visible"
width="70%"
width="90%"
append-to-body
>
<!-- 动态创建对应关系 表格 -->
......@@ -94,13 +88,31 @@
>
<el-table-column prop="name" label="任务名称"> </el-table-column>
<el-table-column prop="el" label="EL变量表达式"> </el-table-column>
<el-table-column prop="assignee" label="审批人员"> </el-table-column>
<el-table-column prop="candidateUsers" label="审批候选人">
</el-table-column>
<el-table-column prop="candidateGroups" label="审批候选组">
</el-table-column>
<el-table-column prop="multiple" label="是否并行"> </el-table-column>
<!-- <el-table-column prop="el" label="EL变量表达式"> </el-table-column> -->
<el-table-column
prop="multiple"
label="是否并行"
:formatter="formatter"
>
</el-table-column>
<el-table-column prop="assigneeName" label="对应人员">
</el-table-column>
<el-table-column prop="candidateUsersName" label="对应候选人员">
</el-table-column>
<el-table-column prop="candidateGroupsName" label="对应站点与角色">
</el-table-column>
<el-table-column label="操作" align="center">
<template slot-scope="scope">
<el-form-item label-width="0">
......@@ -108,8 +120,24 @@
size="mini"
type="text"
icon="el-icon-user"
@click="handTableSelect(scope.$index, scope.row)"
>选择人员</el-button
@click="handSelectUser(scope.$index, scope.row)"
>选择审批人员</el-button
>
<el-button
size="mini"
type="text"
icon="el-icon-user"
@click="handSelectCandidateUsers(scope.$index, scope.row)"
>选择候选人员</el-button
>
<el-button
size="mini"
type="text"
icon="el-icon-user"
@click="handSelectSiteAndRole(scope.$index, scope.row)"
>选择站点角色</el-button
>
</el-form-item>
</template>
......@@ -130,65 +158,28 @@
width="70%"
append-to-body
>
<!-- <el-image :src="readImage.src"></el-image> -->
<flow :xmlData="xmlData" />
</el-dialog>
<!--表单配置详情-->
<el-dialog
:title="formTitle"
:visible.sync="formConfOpen"
width="50%"
append-to-body
>
<div class="test-form">
<parser :key="new Date().getTime()" :form-conf="formConf" />
</div>
</el-dialog>
<!--挂载表单-->
<el-dialog
:title="formDeployTitle"
:visible.sync="formDeployOpen"
width="30%"
append-to-body
>
<el-select v-model="formDeployParam.formId" placeholder="请选择表单">
<el-option
v-for="form in formList"
:key="form.id"
:label="form.formName"
:value="form.id"
/>
</el-select>
<el-button type="primary" @click="submitFormDeploy">确 定</el-button>
</el-dialog>
</div>
</template>
<script>
import { treeCache } from "@/assets/utils/tree";
import {
listDefinition,
updateState,
delDeployment,
addDeployment,
updateDeployment,
exportDeployment,
definitionStart,
readXml,
userList,
} from "@/api/flowable/definition";
import { getForm, addForm, addDeployForm, listForm } from "@/api/flowable/form";
import table from "@/assets/mixins/table";
import Parser from "@/components/parser/Parser";
import flow from "@/views/flowable/task/record/flow";
import Treeselect from "@riophae/vue-treeselect";
import "@riophae/vue-treeselect/dist/vue-treeselect.css";
export default {
name: "Definition",
components: {
Parser,
flow,
Treeselect,
},
mixins: [table],
......@@ -200,22 +191,51 @@ export default {
this.userDict[item.loginName] = item.realName;
}
});
this.getTreeselect();
this.getRoleList();
},
methods: {
/** 查询部门下拉树结构 */
getTreeselect() {
this.loading = true;
this.$post("/site/treeselect", {})
.then((res) => {
if (res && res.code && res.code == 1) {
this.siteOptions = res.data.result;
this.loading = false;
}
})
.catch((error) => {
this.$message.error(error.message);
});
},
getRoleList() {
this.loading = true;
this.$post("/role/list", {"query.roleType":2, "pageInfo.prePageResult": "-1" })
.then((res) => {
if (res && res.code && res.code == 1) {
this.roleList = res.data.result;
this.loading = false;
}
})
.catch((error) => {
this.$message.error(error.message);
});
},
submitConfigForm() {
let params = {};
params[this.configDialog.key] = JSON.stringify(this.dataList);
params[this.configDialog.key] = JSON.stringify(this.dataList);
this.$post("/flowable/definition/setVars", params).then(({ data }) => {
this.configDialog.visible=false;
this.configDialog.visible = false;
//弹出框配置对应关系
});
},
taskConfirm() {
console.log(this.assignee);
if (this.taskDialog.multiple == 0) {
this.dataList[this.taskDialog.index].assignee = this.assignee;
this.dataList[this.taskDialog.index].assigneeName =
......@@ -237,26 +257,49 @@ export default {
this.taskDialog.visible = false;
},
siteConfirm() {
if (this.siteDialog.multiple == 0) {
//组合选择的站点与角色 站点[角色] 目前都为单选
let siteName="";
let roleName="";
//查找站点
this.siteOptions.map(item=>{
if(item.id===this.siteId){
siteName=item.label;
}
})
this.roleList.map(item=>{
if(item.id===this.roleId){
roleName=item.name;
}
})
this.dataList[this.siteDialog.index].candidateGroupsIds = this.siteId+"and"+this.roleId;
this.dataList[this.siteDialog.index].candidateGroupsName =siteName+"["+roleName+"]";
} else {
let temp = "";
for (let item of this.assignee) {
temp += this.userDict[item] + ",";
}
this.dataList[this.siteDialog.index].assigneeName = temp;
this.dataList[this.siteDialog.index].assigneeList = this.assignee;
}
this.siteDialog.visible = false;
},
handleCheckChange(val) {
if (val instanceof Array) {
console.log(1111, val);
// this.taskForm.values = {
// approval: val.join(","),
// };
} else {
console.log(222222, val);
// this.taskForm.values = {
// approval: val,
// };
}
},
handTableSelect(index, row) {
console.log("人员选择", index, row);
this.assignee=null
this.assigneeName=""
handSelectUser(index, row) {
console.log("审批人员选择，单选", index, row);
this.assignee = null;
this.assigneeName = "";
this.taskDialog.index = index;
......@@ -268,22 +311,36 @@ export default {
this.taskDialog.visible = true;
},
/** 新增按钮操作 */
handleAdd() {
console.log("新增按钮操作");
this.reset();
this.open = true;
this.title = "添加流程定义";
handSelectCandidateUsers(index, row) {
console.log("审批候选人员选择，多选", index, row);
this.assignee = null;
this.assigneeName = "";
this.taskDialog.index = index;
if (row.multiple == 0) {
this.taskDialog.multiple = false;
} else {
this.taskDialog.multiple = true;
}
this.taskDialog.visible = true;
},
/** 跳转到流程设计页面 */
handleLoadXml(row) {
console.log("跳转到流程设计页面");
this.$router.push({
path: "/flowable/definition/model",
query: { deployId: row.deploymentId },
});
handSelectSiteAndRole(index, row) {
console.log("审批候选组选择，多选", index, row);
this.assignee = null;
this.assigneeName = "";
this.siteDialog.index = index;
if (row.multiple == 0) {
this.siteDialog.multiple = false;
} else {
this.siteDialog.multiple = true;
}
this.siteDialog.visible = true;
},
/** 流程图查看 */
handleReadImage(row) {
console.log("流程图查看");
......@@ -296,48 +353,13 @@ export default {
this.xmlData = res.data;
});
},
/** 表单查看 */
handleForm(formId) {
console.log("formId:" + formId);
getForm(formId).then((res) => {
this.formTitle = "表单详情";
this.formConfOpen = true;
this.formConf = JSON.parse(res.data.entity.formContent);
});
},
readXml(row) {
definitionStart(row.id).then((res) => {
this.msgSuccess(res.msg);
});
},
/** 挂载表单弹框 */
handleAddForm(row) {
console.log("挂载表单！");
this.formDeployParam.deployId = row.deploymentId;
const pageInfo = {
prePageResult: 100,
};
listForm({}, pageInfo).then((res) => {
this.formList = res.data.result;
this.formDeployOpen = true;
this.formDeployTitle = "挂载表单";
});
},
/** 挂载表单 */
submitFormDeploy() {
//提交表单
addForm();
console.log("提交表单!");
console.log(this.formDeployParam);
addDeployForm(this.formDeployParam).then((res) => {
console.log(res);
this.$message.success("表单关联成功！");
this.formDeployOpen = false;
this.getData();
});
},
/** 挂起/激活流程 */
handleUpdateSuspensionState(row) {
console.log("挂起/激活流程!");
......@@ -368,36 +390,11 @@ export default {
this.dataList = data;
this.configDialog.visible = true;
this.configDialog.key=row.key;
//弹出框配置对应关系
this.configDialog.key = row.key;
}
);
//查询所有el表达式
},
/** 导入bpmn.xml文件 */
handleImport() {
this.upload.title = "bpmn20.xml文件导入";
this.upload.open = true;
},
// 文件上传中处理
handleFileUploadProgress(event, file, fileList) {
this.upload.isUploading = true;
},
// 文件上传成功处理
handleFileSuccess(response, file, fileList) {
this.upload.open = false;
this.upload.isUploading = false;
this.$refs.upload.clearFiles();
this.$message.success(response.msg);
this.getData();
},
// 提交上传文件
submitFileForm() {
console.log("上传附件");
this.$refs.upload.submit();
},
},
data() {
return {
......@@ -408,13 +405,24 @@ export default {
index: 0,
type: "",
},
siteDialog: {
visible: false,
title: "选择站点角色",
multiple: false,
index: 0,
type: "",
},
configDialog: {
visible: false,
title: "流程人员配置",
index: 0,
},
siteOptions: [],
roleList: [],
userDataList: [], // 流程候选人
userDict: {},
siteId: null,
roleId: null,
assignee: null,
dataList: [],
// 遮罩层
......@@ -445,21 +453,7 @@ export default {
open: false,
src: "",
},
// bpmn.xml 导入
upload: {
// 是否显示弹出层（xml导入）
open: false,
// 弹出层标题（xml导入）
title: "",
// 是否禁用上传
isUploading: false,
name: null,
category: null,
// 设置上传的请求头部
// headers: { Authorization: "Bearer " + getToken() },
// 上传的地址
url: "/m/flowable/definition/upload",
},
// 查询参数
queryParams: {
pageNum: 1,
......@@ -493,11 +487,6 @@ export default {
},
],
columns: [
{
type: "selection",
width: 60,
},
{
prop: "deploymentId",
label: "流程编号",
......@@ -530,28 +519,6 @@ export default {
label: "流程分类",
},
{
prop: "formName",
label: "挂载表单",
formatter: (row) => {
return (
<el-button
type="text"
onClick={() => {
this.handleForm(row.formId);
}}
>
{row.formName}
</el-button>
);
},
},
{
prop: "version",
label: "流程版本",
},
{
prop: "suspensionState",
label: "状态",
......@@ -582,23 +549,6 @@ export default {
配置
</el-button>
<span> </span>
{row && row.formId == null ? (
<el-button
size="mini"
type="text"
icon="el-icon-connection"
v-if="row.formId != null"
onClick={() => {
this.handleAddForm(row);
}}
>
配置表单
</el-button>
) : (
""
)}
<span> </span>
{row && row.suspensionState === 1 ? (
<el-button
......@@ -624,23 +574,6 @@ export default {
激活
</el-button>
)}
<span> </span>
{row && row.formId != null ? (
<el-button
size="mini"
type="text"
icon="el-icon-view"
onClick={() => {
this.handleForm(row.formId);
}}
>
查看表单
</el-button>
) : (
""
)}
</el-row>
);
},
......
government-manager/src/main/java/com/mortals/xhx/base/framework/config/GenConfig.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.framework.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: zxfei
* @date: 2021/9/28 15:45
*/
@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;
}
}
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/dao/GentableColumnDao.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.base.system.gentable.model.GentableColumnEntity;
import java.util.List;
/**
* <p>Title: 代码生成业务表字段</p>
* <p>Description: GentableColumnDao DAO接口 </p>
* @author
* @version 1.0.0
*/
public interface GentableColumnDao extends ICRUDDao<GentableColumnEntity,Long> {
/**
* 根据表名称查询列信息
*
* @param tableName 表名称
* @return 列信息
*/
List<GentableColumnEntity> selectDbTableColumnsByName(String tableName);
}
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/dao/GentableDao.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.framework.model.ParamDto;
import com.mortals.xhx.base.system.gentable.model.GentableEntity;
import java.util.List;
/**
* <p>Title: 代码生成业务表</p>
* <p>Description: GentableDao DAO接口 </p>
* @author
* @version 1.0.0
*/
public interface GentableDao extends ICRUDDao<GentableEntity,Long> {
/**
* 查询数据库表
* @param paramDto
* @return
*/
List<GentableEntity> selectDbTableList(ParamDto paramDto);
/**
* 查询所有表信息
*
* @return 表信息集合
*/
List<GentableEntity> selectGenTableAll();
/**
* 查询数据库表
* @param tableNames
* @return
*/
List<GentableEntity> selectDbTableListByNames(String[] tableNames);
}
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/dao/ibatis/GentableColumnDaoImpl.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.gentable.dao.GentableColumnDao;
import com.mortals.xhx.base.system.gentable.model.GentableColumnEntity;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* <p>Title: 代码生成业务表字段</p>
* <p>Description: GentableColumnDaoImpl DAO接口 </p>
* @author
* @version 1.0.0
*/
@Repository("gentableColumnDao")
public class GentableColumnDaoImpl extends BaseCRUDDaoMybatis<GentableColumnEntity,Long> implements GentableColumnDao {
@Override
public List<GentableColumnEntity> selectDbTableColumnsByName(String tableName) {
return getSqlSession().selectList(getSqlId("selectDbTableColumnsByName"), tableName);
}
}
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/dao/ibatis/GentableDaoImpl.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.framework.model.ParamDto;
import com.mortals.xhx.base.system.gentable.dao.GentableDao;
import com.mortals.xhx.base.system.gentable.model.GentableEntity;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* <p>Title: 代码生成业务表</p>
* <p>Description: GentableDaoImpl DAO接口 </p>
* @author
* @version 1.0.0
*/
@Repository("gentableDao")
public class GentableDaoImpl extends BaseCRUDDaoMybatis<GentableEntity,Long> implements GentableDao {
@Override
public List<GentableEntity> selectDbTableList(ParamDto paramDto) {
return getSqlSession().selectList(getSqlId("selectDbTableList"), paramDto);
}
@Override
public List<GentableEntity> selectGenTableAll() {
return getSqlSession().selectList(getSqlId("selectGenTableAll"));
}
@Override
public List<GentableEntity> selectDbTableListByNames(String[] tableNames) {
return getSqlSession().selectList(getSqlId("selectDbTableListByNames"), tableNames);
}
}
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/model/GentableColumnEntity.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.model;
import java.util.Date;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.common.utils.StringUtils;
/**
* Description:GentableColumn
* date: 2021-9-28 10:10:15
*/
public class GentableColumnEntity extends BaseEntityLong {
private static final long serialVersionUID = 1632795015375L;
/**
* 所属表编号
*/
private Long tableId;
/**
* 列名称
*/
private String columnName;
/**
* 列描述
*/
private String columnComment;
/**
* 列类型
*/
private String columnType;
/**
* JAVA类型
*/
private String javaType;
/**
* JAVA字段名
*/
private String javaField;
/**
* 是否primaryKey（0否，1 是）
*/
private Integer isPrimaryKey;
/**
* 是否自增（0否，1 是）
*/
private Integer isIncrement;
/**
* 是否必填（0否，1 是）
*/
private Integer isRequired;
/**
* 是否为插入字段（0否，1 是）
*/
private Integer isInsert;
/**
* 是否编辑字段（0否，1 是）
*/
private Integer isEdit;
/**
* 是否列表字段（0否，1 是）
*/
private Integer isList;
/**
* 是否查询字段（0否，1 是）
*/
private Integer isQuery;
/**
* 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
*/
private Integer htmlType;
/**
* 排序
*/
private Integer sort;
/**
* 变更时间
*/
private Date updateTime;
/**
* 变更用户loginName
*/
private String updateUser;
/**
* 创建时间
*/
private Date createTime;
/**
* 创建用户loginName
*/
private String createUser;
public GentableColumnEntity() {
}
/**
* 获取 所属表编号
*
* @return tableId
*/
public Long getTableId() {
return this.tableId;
}
/**
* 设置 所属表编号
*
* @param tableId
*/
public void setTableId(Long tableId) {
this.tableId = tableId;
}
/**
* 获取 列名称
*
* @return columnName
*/
public String getColumnName() {
return this.columnName;
}
/**
* 设置 列名称
*
* @param columnName
*/
public void setColumnName(String columnName) {
this.columnName = columnName;
}
/**
* 获取 列描述
*
* @return columnComment
*/
public String getColumnComment() {
return this.columnComment;
}
/**
* 设置 列描述
*
* @param columnComment
*/
public void setColumnComment(String columnComment) {
this.columnComment = columnComment;
}
/**
* 获取 列类型
*
* @return columnType
*/
public String getColumnType() {
return this.columnType;
}
/**
* 设置 列类型
*
* @param columnType
*/
public void setColumnType(String columnType) {
this.columnType = columnType;
}
/**
* 获取 JAVA类型
*
* @return javaType
*/
public String getJavaType() {
return this.javaType;
}
/**
* 设置 JAVA类型
*
* @param javaType
*/
public void setJavaType(String javaType) {
this.javaType = javaType;
}
/**
* 获取 JAVA字段名
*
* @return javaField
*/
public String getJavaField() {
return this.javaField;
}
/**
* 设置 JAVA字段名
*
* @param javaField
*/
public void setJavaField(String javaField) {
this.javaField = javaField;
}
/**
* 获取 是否primaryKey（0否，1 是）
*
* @return isPrimaryKey
*/
public Integer getIsPrimaryKey() {
return this.isPrimaryKey;
}
/**
* 设置 是否primaryKey（0否，1 是）
*
* @param isPrimaryKey
*/
public void setIsPrimaryKey(Integer isPrimaryKey) {
this.isPrimaryKey = isPrimaryKey;
}
/**
* 获取 是否自增（0否，1 是）
*
* @return isIncrement
*/
public Integer getIsIncrement() {
return this.isIncrement;
}
/**
* 设置 是否自增（0否，1 是）
*
* @param isIncrement
*/
public void setIsIncrement(Integer isIncrement) {
this.isIncrement = isIncrement;
}
/**
* 获取 是否必填（0否，1 是）
*
* @return isRequired
*/
public Integer getIsRequired() {
return this.isRequired;
}
/**
* 设置 是否必填（0否，1 是）
*
* @param isRequired
*/
public void setIsRequired(Integer isRequired) {
this.isRequired = isRequired;
}
/**
* 获取 是否为插入字段（0否，1 是）
*
* @return isInsert
*/
public Integer getIsInsert() {
return this.isInsert;
}
/**
* 设置 是否为插入字段（0否，1 是）
*
* @param isInsert
*/
public void setIsInsert(Integer isInsert) {
this.isInsert = isInsert;
}
/**
* 获取 是否编辑字段（0否，1 是）
*
* @return isEdit
*/
public Integer getIsEdit() {
return this.isEdit;
}
/**
* 设置 是否编辑字段（0否，1 是）
*
* @param isEdit
*/
public void setIsEdit(Integer isEdit) {
this.isEdit = isEdit;
}
/**
* 获取 是否列表字段（0否，1 是）
*
* @return isList
*/
public Integer getIsList() {
return this.isList;
}
/**
* 设置 是否列表字段（0否，1 是）
*
* @param isList
*/
public void setIsList(Integer isList) {
this.isList = isList;
}
/**
* 获取 是否查询字段（0否，1 是）
*
* @return isQuery
*/
public Integer getIsQuery() {
return this.isQuery;
}
/**
* 设置 是否查询字段（0否，1 是）
*
* @param isQuery
*/
public void setIsQuery(Integer isQuery) {
this.isQuery = isQuery;
}
/**
* 获取 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
*
* @return htmlType
*/
public Integer getHtmlType() {
return this.htmlType;
}
/**
* 设置 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
*
* @param htmlType
*/
public void setHtmlType(Integer htmlType) {
this.htmlType = htmlType;
}
/**
* 获取 排序
*
* @return sort
*/
public Integer getSort() {
return this.sort;
}
/**
* 设置 排序
*
* @param sort
*/
public void setSort(Integer sort) {
this.sort = sort;
}
/**
* 获取 变更时间
*
* @return updateTime
*/
public Date getUpdateTime() {
return this.updateTime;
}
/**
* 设置 变更时间
*
* @param updateTime
*/
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
/**
* 获取 变更用户loginName
*
* @return updateUser
*/
public String getUpdateUser() {
return this.updateUser;
}
/**
* 设置 变更用户loginName
*
* @param updateUser
*/
public void setUpdateUser(String updateUser) {
this.updateUser = updateUser;
}
/**
* 获取 创建时间
*
* @return createTime
*/
public Date getCreateTime() {
return this.createTime;
}
/**
* 设置 创建时间
*
* @param createTime
*/
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
/**
* 获取 创建用户loginName
*
* @return createUser
*/
public String getCreateUser() {
return this.createUser;
}
/**
* 设置 创建用户loginName
*
* @param createUser
*/
public void setCreateUser(String createUser) {
this.createUser = createUser;
}
public boolean isSuperColumn() {
return isSuperColumn(this.javaField);
}
public static boolean isSuperColumn(String javaField) {
return StringUtils.equalsAnyIgnoreCase(javaField,
// BaseEntity
"createUser", "createTime", "updateUser", "updateTime","createUserId","updateUserId",
// TreeEntity
"parentName", "parentId", "orderNum", "ancestors");
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null)
return false;
if (obj instanceof GentableColumnEntity) {
GentableColumnEntity tmp = (GentableColumnEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
public String toString() {
StringBuilder sb = new StringBuilder("");
sb
.append(",id:").append(getId())
.append(",tableId:").append(getTableId())
.append(",columnName:").append(getColumnName())
.append(",columnComment:").append(getColumnComment())
.append(",columnType:").append(getColumnType())
.append(",javaType:").append(getJavaType())
.append(",javaField:").append(getJavaField())
.append(",isPrimaryKey:").append(getIsPrimaryKey())
.append(",isIncrement:").append(getIsIncrement())
.append(",isRequired:").append(getIsRequired())
.append(",isInsert:").append(getIsInsert())
.append(",isEdit:").append(getIsEdit())
.append(",isList:").append(getIsList())
.append(",isQuery:").append(getIsQuery())
.append(",htmlType:").append(getHtmlType())
.append(",sort:").append(getSort())
.append(",updateTime:").append(getUpdateTime())
.append(",updateUser:").append(getUpdateUser())
.append(",createTime:").append(getCreateTime())
.append(",createUser:").append(getCreateUser())
;
return sb.toString();
}
public void initAttrValue() {
this.tableId = null;
this.columnName = null;
this.columnComment = null;
this.columnType = null;
this.javaType = null;
this.javaField = null;
this.isPrimaryKey = null;
this.isIncrement = null;
this.isRequired = null;
this.isInsert = null;
this.isEdit = null;
this.isList = null;
this.isQuery = null;
this.htmlType = null;
this.sort = null;
this.updateTime = null;
this.updateUser = null;
this.createTime = null;
this.createUser = null;
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/model/GentableColumnQuery.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.model;
import java.util.List;
import java.util.Date;
/**
*
* Description:GentableColumn
* date: 2021-9-28 10:10:15
*/
public class GentableColumnQuery extends GentableColumnEntity{
private static final long serialVersionUID = 1632795015378L;
/** 开始 ID，主键，自增长 */
private Long idStart;
/** 结束 ID，主键，自增长 */
private Long idEnd;
/** 增加 ID，主键，自增长 */
private Long idIncrement;
/** ID，主键，自增长 */
private List <Long> idList;
/** 开始 所属表编号 */
private Long tableIdStart;
/** 结束 所属表编号 */
private Long tableIdEnd;
/** 增加 所属表编号 */
private Long tableIdIncrement;
/** 所属表编号 */
private List <Long> tableIdList;
/** 列名称 */
private List<String> columnNameList;
/** 列描述 */
private List<String> columnCommentList;
/** 列类型 */
private List<String> columnTypeList;
/** JAVA类型 */
private List<String> javaTypeList;
/** JAVA字段名 */
private List<String> javaFieldList;
/** 开始 是否primaryKey（0否，1 是） */
private Integer isPrimaryKeyStart;
/** 结束 是否primaryKey（0否，1 是） */
private Integer isPrimaryKeyEnd;
/** 增加 是否primaryKey（0否，1 是） */
private Integer isPrimaryKeyIncrement;
/** 是否primaryKey（0否，1 是） */
private List <Integer> isPrimaryKeyList;
/** 开始 是否自增（0否，1 是） */
private Integer isIncrementStart;
/** 结束 是否自增（0否，1 是） */
private Integer isIncrementEnd;
/** 增加 是否自增（0否，1 是） */
private Integer isIncrementIncrement;
/** 是否自增（0否，1 是） */
private List <Integer> isIncrementList;
/** 开始 是否必填（0否，1 是） */
private Integer isRequiredStart;
/** 结束 是否必填（0否，1 是） */
private Integer isRequiredEnd;
/** 增加 是否必填（0否，1 是） */
private Integer isRequiredIncrement;
/** 是否必填（0否，1 是） */
private List <Integer> isRequiredList;
/** 开始 是否为插入字段（0否，1 是） */
private Integer isInsertStart;
/** 结束 是否为插入字段（0否，1 是） */
private Integer isInsertEnd;
/** 增加 是否为插入字段（0否，1 是） */
private Integer isInsertIncrement;
/** 是否为插入字段（0否，1 是） */
private List <Integer> isInsertList;
/** 开始 是否编辑字段（0否，1 是） */
private Integer isEditStart;
/** 结束 是否编辑字段（0否，1 是） */
private Integer isEditEnd;
/** 增加 是否编辑字段（0否，1 是） */
private Integer isEditIncrement;
/** 是否编辑字段（0否，1 是） */
private List <Integer> isEditList;
/** 开始 是否列表字段（0否，1 是） */
private Integer isListStart;
/** 结束 是否列表字段（0否，1 是） */
private Integer isListEnd;
/** 增加 是否列表字段（0否，1 是） */
private Integer isListIncrement;
/** 是否列表字段（0否，1 是） */
private List <Integer> isListList;
/** 开始 是否查询字段（0否，1 是） */
private Integer isQueryStart;
/** 结束 是否查询字段（0否，1 是） */
private Integer isQueryEnd;
/** 增加 是否查询字段（0否，1 是） */
private Integer isQueryIncrement;
/** 是否查询字段（0否，1 是） */
private List <Integer> isQueryList;
/** 开始 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件） */
private Integer htmlTypeStart;
/** 结束 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件） */
private Integer htmlTypeEnd;
/** 增加 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件） */
private Integer htmlTypeIncrement;
/** 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件） */
private List <Integer> htmlTypeList;
/** 开始 排序 */
private Integer sortStart;
/** 结束 排序 */
private Integer sortEnd;
/** 增加 排序 */
private Integer sortIncrement;
/** 排序 */
private List <Integer> sortList;
/** 开始 变更时间 */
private String updateTimeStart;
/** 结束 变更时间 */
private String updateTimeEnd;
/** 变更用户loginName */
private List<String> updateUserList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 创建用户loginName */
private List<String> createUserList;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<GentableColumnQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<GentableColumnQuery> andConditionList;
public GentableColumnQuery(){
}
/**
* 获取 开始 ID，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 ID，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 ID，主键，自增长
* @return idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 ID，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 ID，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 ID，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 ID，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 ID，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 开始 所属表编号
* @return tableIdStart
*/
public Long getTableIdStart(){
return this.tableIdStart;
}
/**
* 设置 开始 所属表编号
* @param tableIdStart
*/
public void setTableIdStart(Long tableIdStart){
this.tableIdStart = tableIdStart;
}
/**
* 获取 结束 所属表编号
* @return tableIdEnd
*/
public Long getTableIdEnd(){
return this.tableIdEnd;
}
/**
* 设置 结束 所属表编号
* @param tableIdEnd
*/
public void setTableIdEnd(Long tableIdEnd){
this.tableIdEnd = tableIdEnd;
}
/**
* 获取 增加 所属表编号
* @return tableIdIncrement
*/
public Long getTableIdIncrement(){
return this.tableIdIncrement;
}
/**
* 设置 增加 所属表编号
* @param tableIdIncrement
*/
public void setTableIdIncrement(Long tableIdIncrement){
this.tableIdIncrement = tableIdIncrement;
}
/**
* 获取 所属表编号
* @return tableIdList
*/
public List<Long> getTableIdList(){
return this.tableIdList;
}
/**
* 设置 所属表编号
* @param tableIdList
*/
public void setTableIdList(List<Long> tableIdList){
this.tableIdList = tableIdList;
}
/**
* 获取 列名称
* @return columnNameList
*/
public List<String> getColumnNameList(){
return this.columnNameList;
}
/**
* 设置 列名称
* @param columnNameList
*/
public void setColumnNameList(List<String> columnNameList){
this.columnNameList = columnNameList;
}
/**
* 获取 列描述
* @return columnCommentList
*/
public List<String> getColumnCommentList(){
return this.columnCommentList;
}
/**
* 设置 列描述
* @param columnCommentList
*/
public void setColumnCommentList(List<String> columnCommentList){
this.columnCommentList = columnCommentList;
}
/**
* 获取 列类型
* @return columnTypeList
*/
public List<String> getColumnTypeList(){
return this.columnTypeList;
}
/**
* 设置 列类型
* @param columnTypeList
*/
public void setColumnTypeList(List<String> columnTypeList){
this.columnTypeList = columnTypeList;
}
/**
* 获取 JAVA类型
* @return javaTypeList
*/
public List<String> getJavaTypeList(){
return this.javaTypeList;
}
/**
* 设置 JAVA类型
* @param javaTypeList
*/
public void setJavaTypeList(List<String> javaTypeList){
this.javaTypeList = javaTypeList;
}
/**
* 获取 JAVA字段名
* @return javaFieldList
*/
public List<String> getJavaFieldList(){
return this.javaFieldList;
}
/**
* 设置 JAVA字段名
* @param javaFieldList
*/
public void setJavaFieldList(List<String> javaFieldList){
this.javaFieldList = javaFieldList;
}
/**
* 获取 开始 是否primaryKey（0否，1 是）
* @return isPrimaryKeyStart
*/
public Integer getIsPrimaryKeyStart(){
return this.isPrimaryKeyStart;
}
/**
* 设置 开始 是否primaryKey（0否，1 是）
* @param isPrimaryKeyStart
*/
public void setIsPrimaryKeyStart(Integer isPrimaryKeyStart){
this.isPrimaryKeyStart = isPrimaryKeyStart;
}
/**
* 获取 结束 是否primaryKey（0否，1 是）
* @return isPrimaryKeyEnd
*/
public Integer getIsPrimaryKeyEnd(){
return this.isPrimaryKeyEnd;
}
/**
* 设置 结束 是否primaryKey（0否，1 是）
* @param isPrimaryKeyEnd
*/
public void setIsPrimaryKeyEnd(Integer isPrimaryKeyEnd){
this.isPrimaryKeyEnd = isPrimaryKeyEnd;
}
/**
* 获取 增加 是否primaryKey（0否，1 是）
* @return isPrimaryKeyIncrement
*/
public Integer getIsPrimaryKeyIncrement(){
return this.isPrimaryKeyIncrement;
}
/**
* 设置 增加 是否primaryKey（0否，1 是）
* @param isPrimaryKeyIncrement
*/
public void setIsPrimaryKeyIncrement(Integer isPrimaryKeyIncrement){
this.isPrimaryKeyIncrement = isPrimaryKeyIncrement;
}
/**
* 获取 是否primaryKey（0否，1 是）
* @return isPrimaryKeyList
*/
public List<Integer> getIsPrimaryKeyList(){
return this.isPrimaryKeyList;
}
/**
* 设置 是否primaryKey（0否，1 是）
* @param isPrimaryKeyList
*/
public void setIsPrimaryKeyList(List<Integer> isPrimaryKeyList){
this.isPrimaryKeyList = isPrimaryKeyList;
}
/**
* 获取 开始 是否自增（0否，1 是）
* @return isIncrementStart
*/
public Integer getIsIncrementStart(){
return this.isIncrementStart;
}
/**
* 设置 开始 是否自增（0否，1 是）
* @param isIncrementStart
*/
public void setIsIncrementStart(Integer isIncrementStart){
this.isIncrementStart = isIncrementStart;
}
/**
* 获取 结束 是否自增（0否，1 是）
* @return isIncrementEnd
*/
public Integer getIsIncrementEnd(){
return this.isIncrementEnd;
}
/**
* 设置 结束 是否自增（0否，1 是）
* @param isIncrementEnd
*/
public void setIsIncrementEnd(Integer isIncrementEnd){
this.isIncrementEnd = isIncrementEnd;
}
/**
* 获取 增加 是否自增（0否，1 是）
* @return isIncrementIncrement
*/
public Integer getIsIncrementIncrement(){
return this.isIncrementIncrement;
}
/**
* 设置 增加 是否自增（0否，1 是）
* @param isIncrementIncrement
*/
public void setIsIncrementIncrement(Integer isIncrementIncrement){
this.isIncrementIncrement = isIncrementIncrement;
}
/**
* 获取 是否自增（0否，1 是）
* @return isIncrementList
*/
public List<Integer> getIsIncrementList(){
return this.isIncrementList;
}
/**
* 设置 是否自增（0否，1 是）
* @param isIncrementList
*/
public void setIsIncrementList(List<Integer> isIncrementList){
this.isIncrementList = isIncrementList;
}
/**
* 获取 开始 是否必填（0否，1 是）
* @return isRequiredStart
*/
public Integer getIsRequiredStart(){
return this.isRequiredStart;
}
/**
* 设置 开始 是否必填（0否，1 是）
* @param isRequiredStart
*/
public void setIsRequiredStart(Integer isRequiredStart){
this.isRequiredStart = isRequiredStart;
}
/**
* 获取 结束 是否必填（0否，1 是）
* @return isRequiredEnd
*/
public Integer getIsRequiredEnd(){
return this.isRequiredEnd;
}
/**
* 设置 结束 是否必填（0否，1 是）
* @param isRequiredEnd
*/
public void setIsRequiredEnd(Integer isRequiredEnd){
this.isRequiredEnd = isRequiredEnd;
}
/**
* 获取 增加 是否必填（0否，1 是）
* @return isRequiredIncrement
*/
public Integer getIsRequiredIncrement(){
return this.isRequiredIncrement;
}
/**
* 设置 增加 是否必填（0否，1 是）
* @param isRequiredIncrement
*/
public void setIsRequiredIncrement(Integer isRequiredIncrement){
this.isRequiredIncrement = isRequiredIncrement;
}
/**
* 获取 是否必填（0否，1 是）
* @return isRequiredList
*/
public List<Integer> getIsRequiredList(){
return this.isRequiredList;
}
/**
* 设置 是否必填（0否，1 是）
* @param isRequiredList
*/
public void setIsRequiredList(List<Integer> isRequiredList){
this.isRequiredList = isRequiredList;
}
/**
* 获取 开始 是否为插入字段（0否，1 是）
* @return isInsertStart
*/
public Integer getIsInsertStart(){
return this.isInsertStart;
}
/**
* 设置 开始 是否为插入字段（0否，1 是）
* @param isInsertStart
*/
public void setIsInsertStart(Integer isInsertStart){
this.isInsertStart = isInsertStart;
}
/**
* 获取 结束 是否为插入字段（0否，1 是）
* @return isInsertEnd
*/
public Integer getIsInsertEnd(){
return this.isInsertEnd;
}
/**
* 设置 结束 是否为插入字段（0否，1 是）
* @param isInsertEnd
*/
public void setIsInsertEnd(Integer isInsertEnd){
this.isInsertEnd = isInsertEnd;
}
/**
* 获取 增加 是否为插入字段（0否，1 是）
* @return isInsertIncrement
*/
public Integer getIsInsertIncrement(){
return this.isInsertIncrement;
}
/**
* 设置 增加 是否为插入字段（0否，1 是）
* @param isInsertIncrement
*/
public void setIsInsertIncrement(Integer isInsertIncrement){
this.isInsertIncrement = isInsertIncrement;
}
/**
* 获取 是否为插入字段（0否，1 是）
* @return isInsertList
*/
public List<Integer> getIsInsertList(){
return this.isInsertList;
}
/**
* 设置 是否为插入字段（0否，1 是）
* @param isInsertList
*/
public void setIsInsertList(List<Integer> isInsertList){
this.isInsertList = isInsertList;
}
/**
* 获取 开始 是否编辑字段（0否，1 是）
* @return isEditStart
*/
public Integer getIsEditStart(){
return this.isEditStart;
}
/**
* 设置 开始 是否编辑字段（0否，1 是）
* @param isEditStart
*/
public void setIsEditStart(Integer isEditStart){
this.isEditStart = isEditStart;
}
/**
* 获取 结束 是否编辑字段（0否，1 是）
* @return isEditEnd
*/
public Integer getIsEditEnd(){
return this.isEditEnd;
}
/**
* 设置 结束 是否编辑字段（0否，1 是）
* @param isEditEnd
*/
public void setIsEditEnd(Integer isEditEnd){
this.isEditEnd = isEditEnd;
}
/**
* 获取 增加 是否编辑字段（0否，1 是）
* @return isEditIncrement
*/
public Integer getIsEditIncrement(){
return this.isEditIncrement;
}
/**
* 设置 增加 是否编辑字段（0否，1 是）
* @param isEditIncrement
*/
public void setIsEditIncrement(Integer isEditIncrement){
this.isEditIncrement = isEditIncrement;
}
/**
* 获取 是否编辑字段（0否，1 是）
* @return isEditList
*/
public List<Integer> getIsEditList(){
return this.isEditList;
}
/**
* 设置 是否编辑字段（0否，1 是）
* @param isEditList
*/
public void setIsEditList(List<Integer> isEditList){
this.isEditList = isEditList;
}
/**
* 获取 开始 是否列表字段（0否，1 是）
* @return isListStart
*/
public Integer getIsListStart(){
return this.isListStart;
}
/**
* 设置 开始 是否列表字段（0否，1 是）
* @param isListStart
*/
public void setIsListStart(Integer isListStart){
this.isListStart = isListStart;
}
/**
* 获取 结束 是否列表字段（0否，1 是）
* @return isListEnd
*/
public Integer getIsListEnd(){
return this.isListEnd;
}
/**
* 设置 结束 是否列表字段（0否，1 是）
* @param isListEnd
*/
public void setIsListEnd(Integer isListEnd){
this.isListEnd = isListEnd;
}
/**
* 获取 增加 是否列表字段（0否，1 是）
* @return isListIncrement
*/
public Integer getIsListIncrement(){
return this.isListIncrement;
}
/**
* 设置 增加 是否列表字段（0否，1 是）
* @param isListIncrement
*/
public void setIsListIncrement(Integer isListIncrement){
this.isListIncrement = isListIncrement;
}
/**
* 获取 是否列表字段（0否，1 是）
* @return isListList
*/
public List<Integer> getIsListList(){
return this.isListList;
}
/**
* 设置 是否列表字段（0否，1 是）
* @param isListList
*/
public void setIsListList(List<Integer> isListList){
this.isListList = isListList;
}
/**
* 获取 开始 是否查询字段（0否，1 是）
* @return isQueryStart
*/
public Integer getIsQueryStart(){
return this.isQueryStart;
}
/**
* 设置 开始 是否查询字段（0否，1 是）
* @param isQueryStart
*/
public void setIsQueryStart(Integer isQueryStart){
this.isQueryStart = isQueryStart;
}
/**
* 获取 结束 是否查询字段（0否，1 是）
* @return isQueryEnd
*/
public Integer getIsQueryEnd(){
return this.isQueryEnd;
}
/**
* 设置 结束 是否查询字段（0否，1 是）
* @param isQueryEnd
*/
public void setIsQueryEnd(Integer isQueryEnd){
this.isQueryEnd = isQueryEnd;
}
/**
* 获取 增加 是否查询字段（0否，1 是）
* @return isQueryIncrement
*/
public Integer getIsQueryIncrement(){
return this.isQueryIncrement;
}
/**
* 设置 增加 是否查询字段（0否，1 是）
* @param isQueryIncrement
*/
public void setIsQueryIncrement(Integer isQueryIncrement){
this.isQueryIncrement = isQueryIncrement;
}
/**
* 获取 是否查询字段（0否，1 是）
* @return isQueryList
*/
public List<Integer> getIsQueryList(){
return this.isQueryList;
}
/**
* 设置 是否查询字段（0否，1 是）
* @param isQueryList
*/
public void setIsQueryList(List<Integer> isQueryList){
this.isQueryList = isQueryList;
}
/**
* 获取 开始 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @return htmlTypeStart
*/
public Integer getHtmlTypeStart(){
return this.htmlTypeStart;
}
/**
* 设置 开始 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @param htmlTypeStart
*/
public void setHtmlTypeStart(Integer htmlTypeStart){
this.htmlTypeStart = htmlTypeStart;
}
/**
* 获取 结束 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @return htmlTypeEnd
*/
public Integer getHtmlTypeEnd(){
return this.htmlTypeEnd;
}
/**
* 设置 结束 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @param htmlTypeEnd
*/
public void setHtmlTypeEnd(Integer htmlTypeEnd){
this.htmlTypeEnd = htmlTypeEnd;
}
/**
* 获取 增加 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @return htmlTypeIncrement
*/
public Integer getHtmlTypeIncrement(){
return this.htmlTypeIncrement;
}
/**
* 设置 增加 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @param htmlTypeIncrement
*/
public void setHtmlTypeIncrement(Integer htmlTypeIncrement){
this.htmlTypeIncrement = htmlTypeIncrement;
}
/**
* 获取 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @return htmlTypeList
*/
public List<Integer> getHtmlTypeList(){
return this.htmlTypeList;
}
/**
* 设置 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @param htmlTypeList
*/
public void setHtmlTypeList(List<Integer> htmlTypeList){
this.htmlTypeList = htmlTypeList;
}
/**
* 获取 开始 排序
* @return sortStart
*/
public Integer getSortStart(){
return this.sortStart;
}
/**
* 设置 开始 排序
* @param sortStart
*/
public void setSortStart(Integer sortStart){
this.sortStart = sortStart;
}
/**
* 获取 结束 排序
* @return sortEnd
*/
public Integer getSortEnd(){
return this.sortEnd;
}
/**
* 设置 结束 排序
* @param sortEnd
*/
public void setSortEnd(Integer sortEnd){
this.sortEnd = sortEnd;
}
/**
* 获取 增加 排序
* @return sortIncrement
*/
public Integer getSortIncrement(){
return this.sortIncrement;
}
/**
* 设置 增加 排序
* @param sortIncrement
*/
public void setSortIncrement(Integer sortIncrement){
this.sortIncrement = sortIncrement;
}
/**
* 获取 排序
* @return sortList
*/
public List<Integer> getSortList(){
return this.sortList;
}
/**
* 设置 排序
* @param sortList
*/
public void setSortList(List<Integer> sortList){
this.sortList = sortList;
}
/**
* 获取 开始 变更时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 变更时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 变更时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 变更时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 获取 变更用户loginName
* @return updateUserList
*/
public List<String> getUpdateUserList(){
return this.updateUserList;
}
/**
* 设置 变更用户loginName
* @param updateUserList
*/
public void setUpdateUserList(List<String> updateUserList){
this.updateUserList = updateUserList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 创建用户loginName
* @return createUserList
*/
public List<String> getCreateUserList(){
return this.createUserList;
}
/**
* 设置 创建用户loginName
* @param createUserList
*/
public void setCreateUserList(List<String> createUserList){
this.createUserList = createUserList;
}
/**
* 设置 ID，主键，自增长
* @param id
*/
public GentableColumnQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 ID，主键，自增长
* @param idStart
*/
public GentableColumnQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 ID，主键，自增长
* @param idEnd
*/
public GentableColumnQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 ID，主键，自增长
* @param idIncrement
*/
public GentableColumnQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 ID，主键，自增长
* @param idList
*/
public GentableColumnQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 所属表编号
* @param tableId
*/
public GentableColumnQuery tableId(Long tableId){
setTableId(tableId);
return this;
}
/**
* 设置 开始 所属表编号
* @param tableIdStart
*/
public GentableColumnQuery tableIdStart(Long tableIdStart){
this.tableIdStart = tableIdStart;
return this;
}
/**
* 设置 结束 所属表编号
* @param tableIdEnd
*/
public GentableColumnQuery tableIdEnd(Long tableIdEnd){
this.tableIdEnd = tableIdEnd;
return this;
}
/**
* 设置 增加 所属表编号
* @param tableIdIncrement
*/
public GentableColumnQuery tableIdIncrement(Long tableIdIncrement){
this.tableIdIncrement = tableIdIncrement;
return this;
}
/**
* 设置 所属表编号
* @param tableIdList
*/
public GentableColumnQuery tableIdList(List<Long> tableIdList){
this.tableIdList = tableIdList;
return this;
}
/**
* 设置 列名称
* @param columnName
*/
public GentableColumnQuery columnName(String columnName){
setColumnName(columnName);
return this;
}
/**
* 设置 列名称
* @param columnNameList
*/
public GentableColumnQuery columnNameList(List<String> columnNameList){
this.columnNameList = columnNameList;
return this;
}
/**
* 设置 列描述
* @param columnComment
*/
public GentableColumnQuery columnComment(String columnComment){
setColumnComment(columnComment);
return this;
}
/**
* 设置 列描述
* @param columnCommentList
*/
public GentableColumnQuery columnCommentList(List<String> columnCommentList){
this.columnCommentList = columnCommentList;
return this;
}
/**
* 设置 列类型
* @param columnType
*/
public GentableColumnQuery columnType(String columnType){
setColumnType(columnType);
return this;
}
/**
* 设置 列类型
* @param columnTypeList
*/
public GentableColumnQuery columnTypeList(List<String> columnTypeList){
this.columnTypeList = columnTypeList;
return this;
}
/**
* 设置 JAVA类型
* @param javaType
*/
public GentableColumnQuery javaType(String javaType){
setJavaType(javaType);
return this;
}
/**
* 设置 JAVA类型
* @param javaTypeList
*/
public GentableColumnQuery javaTypeList(List<String> javaTypeList){
this.javaTypeList = javaTypeList;
return this;
}
/**
* 设置 JAVA字段名
* @param javaField
*/
public GentableColumnQuery javaField(String javaField){
setJavaField(javaField);
return this;
}
/**
* 设置 JAVA字段名
* @param javaFieldList
*/
public GentableColumnQuery javaFieldList(List<String> javaFieldList){
this.javaFieldList = javaFieldList;
return this;
}
/**
* 设置 是否primaryKey（0否，1 是）
* @param isPrimaryKey
*/
public GentableColumnQuery isPrimaryKey(Integer isPrimaryKey){
setIsPrimaryKey(isPrimaryKey);
return this;
}
/**
* 设置 开始 是否primaryKey（0否，1 是）
* @param isPrimaryKeyStart
*/
public GentableColumnQuery isPrimaryKeyStart(Integer isPrimaryKeyStart){
this.isPrimaryKeyStart = isPrimaryKeyStart;
return this;
}
/**
* 设置 结束 是否primaryKey（0否，1 是）
* @param isPrimaryKeyEnd
*/
public GentableColumnQuery isPrimaryKeyEnd(Integer isPrimaryKeyEnd){
this.isPrimaryKeyEnd = isPrimaryKeyEnd;
return this;
}
/**
* 设置 增加 是否primaryKey（0否，1 是）
* @param isPrimaryKeyIncrement
*/
public GentableColumnQuery isPrimaryKeyIncrement(Integer isPrimaryKeyIncrement){
this.isPrimaryKeyIncrement = isPrimaryKeyIncrement;
return this;
}
/**
* 设置 是否primaryKey（0否，1 是）
* @param isPrimaryKeyList
*/
public GentableColumnQuery isPrimaryKeyList(List<Integer> isPrimaryKeyList){
this.isPrimaryKeyList = isPrimaryKeyList;
return this;
}
/**
* 设置 是否自增（0否，1 是）
* @param isIncrement
*/
public GentableColumnQuery isIncrement(Integer isIncrement){
setIsIncrement(isIncrement);
return this;
}
/**
* 设置 开始 是否自增（0否，1 是）
* @param isIncrementStart
*/
public GentableColumnQuery isIncrementStart(Integer isIncrementStart){
this.isIncrementStart = isIncrementStart;
return this;
}
/**
* 设置 结束 是否自增（0否，1 是）
* @param isIncrementEnd
*/
public GentableColumnQuery isIncrementEnd(Integer isIncrementEnd){
this.isIncrementEnd = isIncrementEnd;
return this;
}
/**
* 设置 增加 是否自增（0否，1 是）
* @param isIncrementIncrement
*/
public GentableColumnQuery isIncrementIncrement(Integer isIncrementIncrement){
this.isIncrementIncrement = isIncrementIncrement;
return this;
}
/**
* 设置 是否自增（0否，1 是）
* @param isIncrementList
*/
public GentableColumnQuery isIncrementList(List<Integer> isIncrementList){
this.isIncrementList = isIncrementList;
return this;
}
/**
* 设置 是否必填（0否，1 是）
* @param isRequired
*/
public GentableColumnQuery isRequired(Integer isRequired){
setIsRequired(isRequired);
return this;
}
/**
* 设置 开始 是否必填（0否，1 是）
* @param isRequiredStart
*/
public GentableColumnQuery isRequiredStart(Integer isRequiredStart){
this.isRequiredStart = isRequiredStart;
return this;
}
/**
* 设置 结束 是否必填（0否，1 是）
* @param isRequiredEnd
*/
public GentableColumnQuery isRequiredEnd(Integer isRequiredEnd){
this.isRequiredEnd = isRequiredEnd;
return this;
}
/**
* 设置 增加 是否必填（0否，1 是）
* @param isRequiredIncrement
*/
public GentableColumnQuery isRequiredIncrement(Integer isRequiredIncrement){
this.isRequiredIncrement = isRequiredIncrement;
return this;
}
/**
* 设置 是否必填（0否，1 是）
* @param isRequiredList
*/
public GentableColumnQuery isRequiredList(List<Integer> isRequiredList){
this.isRequiredList = isRequiredList;
return this;
}
/**
* 设置 是否为插入字段（0否，1 是）
* @param isInsert
*/
public GentableColumnQuery isInsert(Integer isInsert){
setIsInsert(isInsert);
return this;
}
/**
* 设置 开始 是否为插入字段（0否，1 是）
* @param isInsertStart
*/
public GentableColumnQuery isInsertStart(Integer isInsertStart){
this.isInsertStart = isInsertStart;
return this;
}
/**
* 设置 结束 是否为插入字段（0否，1 是）
* @param isInsertEnd
*/
public GentableColumnQuery isInsertEnd(Integer isInsertEnd){
this.isInsertEnd = isInsertEnd;
return this;
}
/**
* 设置 增加 是否为插入字段（0否，1 是）
* @param isInsertIncrement
*/
public GentableColumnQuery isInsertIncrement(Integer isInsertIncrement){
this.isInsertIncrement = isInsertIncrement;
return this;
}
/**
* 设置 是否为插入字段（0否，1 是）
* @param isInsertList
*/
public GentableColumnQuery isInsertList(List<Integer> isInsertList){
this.isInsertList = isInsertList;
return this;
}
/**
* 设置 是否编辑字段（0否，1 是）
* @param isEdit
*/
public GentableColumnQuery isEdit(Integer isEdit){
setIsEdit(isEdit);
return this;
}
/**
* 设置 开始 是否编辑字段（0否，1 是）
* @param isEditStart
*/
public GentableColumnQuery isEditStart(Integer isEditStart){
this.isEditStart = isEditStart;
return this;
}
/**
* 设置 结束 是否编辑字段（0否，1 是）
* @param isEditEnd
*/
public GentableColumnQuery isEditEnd(Integer isEditEnd){
this.isEditEnd = isEditEnd;
return this;
}
/**
* 设置 增加 是否编辑字段（0否，1 是）
* @param isEditIncrement
*/
public GentableColumnQuery isEditIncrement(Integer isEditIncrement){
this.isEditIncrement = isEditIncrement;
return this;
}
/**
* 设置 是否编辑字段（0否，1 是）
* @param isEditList
*/
public GentableColumnQuery isEditList(List<Integer> isEditList){
this.isEditList = isEditList;
return this;
}
/**
* 设置 是否列表字段（0否，1 是）
* @param isList
*/
public GentableColumnQuery isList(Integer isList){
setIsList(isList);
return this;
}
/**
* 设置 开始 是否列表字段（0否，1 是）
* @param isListStart
*/
public GentableColumnQuery isListStart(Integer isListStart){
this.isListStart = isListStart;
return this;
}
/**
* 设置 结束 是否列表字段（0否，1 是）
* @param isListEnd
*/
public GentableColumnQuery isListEnd(Integer isListEnd){
this.isListEnd = isListEnd;
return this;
}
/**
* 设置 增加 是否列表字段（0否，1 是）
* @param isListIncrement
*/
public GentableColumnQuery isListIncrement(Integer isListIncrement){
this.isListIncrement = isListIncrement;
return this;
}
/**
* 设置 是否列表字段（0否，1 是）
* @param isListList
*/
public GentableColumnQuery isListList(List<Integer> isListList){
this.isListList = isListList;
return this;
}
/**
* 设置 是否查询字段（0否，1 是）
* @param isQuery
*/
public GentableColumnQuery isQuery(Integer isQuery){
setIsQuery(isQuery);
return this;
}
/**
* 设置 开始 是否查询字段（0否，1 是）
* @param isQueryStart
*/
public GentableColumnQuery isQueryStart(Integer isQueryStart){
this.isQueryStart = isQueryStart;
return this;
}
/**
* 设置 结束 是否查询字段（0否，1 是）
* @param isQueryEnd
*/
public GentableColumnQuery isQueryEnd(Integer isQueryEnd){
this.isQueryEnd = isQueryEnd;
return this;
}
/**
* 设置 增加 是否查询字段（0否，1 是）
* @param isQueryIncrement
*/
public GentableColumnQuery isQueryIncrement(Integer isQueryIncrement){
this.isQueryIncrement = isQueryIncrement;
return this;
}
/**
* 设置 是否查询字段（0否，1 是）
* @param isQueryList
*/
public GentableColumnQuery isQueryList(List<Integer> isQueryList){
this.isQueryList = isQueryList;
return this;
}
/**
* 设置 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @param htmlType
*/
public GentableColumnQuery htmlType(Integer htmlType){
setHtmlType(htmlType);
return this;
}
/**
* 设置 开始 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @param htmlTypeStart
*/
public GentableColumnQuery htmlTypeStart(Integer htmlTypeStart){
this.htmlTypeStart = htmlTypeStart;
return this;
}
/**
* 设置 结束 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @param htmlTypeEnd
*/
public GentableColumnQuery htmlTypeEnd(Integer htmlTypeEnd){
this.htmlTypeEnd = htmlTypeEnd;
return this;
}
/**
* 设置 增加 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @param htmlTypeIncrement
*/
public GentableColumnQuery htmlTypeIncrement(Integer htmlTypeIncrement){
this.htmlTypeIncrement = htmlTypeIncrement;
return this;
}
/**
* 设置 显示类型（1.文本框、2.文本域、3.下拉框、4.复选框、5.单选框、6.日期控件）
* @param htmlTypeList
*/
public GentableColumnQuery htmlTypeList(List<Integer> htmlTypeList){
this.htmlTypeList = htmlTypeList;
return this;
}
/**
* 设置 排序
* @param sort
*/
public GentableColumnQuery sort(Integer sort){
setSort(sort);
return this;
}
/**
* 设置 开始 排序
* @param sortStart
*/
public GentableColumnQuery sortStart(Integer sortStart){
this.sortStart = sortStart;
return this;
}
/**
* 设置 结束 排序
* @param sortEnd
*/
public GentableColumnQuery sortEnd(Integer sortEnd){
this.sortEnd = sortEnd;
return this;
}
/**
* 设置 增加 排序
* @param sortIncrement
*/
public GentableColumnQuery sortIncrement(Integer sortIncrement){
this.sortIncrement = sortIncrement;
return this;
}
/**
* 设置 排序
* @param sortList
*/
public GentableColumnQuery sortList(List<Integer> sortList){
this.sortList = sortList;
return this;
}
/**
* 设置 开始 变更时间
* @param updateTimeStart
*/
public GentableColumnQuery updateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
return this;
}
/**
* 设置 结束 变更时间
* @param updateTimeEnd
*/
public GentableColumnQuery updateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
return this;
}
/**
* 设置 变更用户loginName
* @param updateUser
*/
public GentableColumnQuery updateUser(String updateUser){
setUpdateUser(updateUser);
return this;
}
/**
* 设置 变更用户loginName
* @param updateUserList
*/
public GentableColumnQuery updateUserList(List<String> updateUserList){
this.updateUserList = updateUserList;
return this;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public GentableColumnQuery createTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
return this;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public GentableColumnQuery createTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
return this;
}
/**
* 设置 创建用户loginName
* @param createUser
*/
public GentableColumnQuery createUser(String createUser){
setCreateUser(createUser);
return this;
}
/**
* 设置 创建用户loginName
* @param createUserList
*/
public GentableColumnQuery createUserList(List<String> createUserList){
this.createUserList = createUserList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<GentableColumnQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<GentableColumnQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<GentableColumnQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<GentableColumnQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/model/GentableEntity.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.model;
import java.util.Date;
import java.util.List;
import com.mortals.framework.model.BaseEntityLong;
/**
*
* Description:Gentable
* date: 2021-9-29 9:35:30
*/
public class GentableEntity extends GentableEntityExt{
private static final long serialVersionUID = 1632879330094L;
/**
* 表名称
*/
private String tableName;
/**
* 表描述
*/
private String tableComment;
/**
* 关联子表的表名
*/
private String subTableName;
/**
* 子表关联的外键名
*/
private String subTableFkName;
/**
* 实体类名称
*/
private String className;
/**
* 使用的模板（crud单表操作 tree树表操作）
*/
private String tplCategory;
/**
* 生成包路径
*/
private String packageName;
/**
* 生成模块名
*/
private String moduleName;
/**
* 生成业务名
*/
private String businessName;
/**
* 生成功能名
*/
private String functionName;
/**
* 生成功能作者
*/
private String functionAuthor;
/**
* 缓存服务方式（0,无，1.静态实体缓存，2.动态实体缓存）
*/
private Integer cacheServiceType;
/**
* 生成代码方式（0.zip压缩包 1.自定义路径）
*/
private Integer genType;
/**
* 分表方式（0.无，1.年，2.月，3.日，4.hash取余）
*/
private Integer dividedTableType;
/**
* 生成路径（不填默认项目路径）
*/
private String genPath;
/**
* 其它生成选项
*/
private String options;
/**
* 备注
*/
private String remark;
/**
* 变更时间
*/
private Date updateTime;
/**
* 变更用户loginName
*/
private String updateUser;
/**
* 创建时间
*/
private Date createTime;
/**
* 创建用户loginName
*/
private String createUser;
public GentableEntity(){
}
/**
* 获取 表名称
* @return tableName
*/
public String getTableName() {
return this.tableName;
}
/**
* 设置 表名称
* @param tableName
*/
public void setTableName(String tableName) {
this.tableName = tableName;
}
/**
* 获取 表描述
* @return tableComment
*/
public String getTableComment() {
return this.tableComment;
}
/**
* 设置 表描述
* @param tableComment
*/
public void setTableComment(String tableComment) {
this.tableComment = tableComment;
}
/**
* 获取 关联子表的表名
* @return subTableName
*/
public String getSubTableName() {
return this.subTableName;
}
/**
* 设置 关联子表的表名
* @param subTableName
*/
public void setSubTableName(String subTableName) {
this.subTableName = subTableName;
}
/**
* 获取 子表关联的外键名
* @return subTableFkName
*/
public String getSubTableFkName() {
return this.subTableFkName;
}
/**
* 设置 子表关联的外键名
* @param subTableFkName
*/
public void setSubTableFkName(String subTableFkName) {
this.subTableFkName = subTableFkName;
}
/**
* 获取 实体类名称
* @return className
*/
public String getClassName() {
return this.className;
}
/**
* 设置 实体类名称
* @param className
*/
public void setClassName(String className) {
this.className = className;
}
/**
* 获取 使用的模板（crud单表操作 tree树表操作）
* @return tplCategory
*/
public String getTplCategory() {
return this.tplCategory;
}
/**
* 设置 使用的模板（crud单表操作 tree树表操作）
* @param tplCategory
*/
public void setTplCategory(String tplCategory) {
this.tplCategory = tplCategory;
}
/**
* 获取 生成包路径
* @return packageName
*/
public String getPackageName() {
return this.packageName;
}
/**
* 设置 生成包路径
* @param packageName
*/
public void setPackageName(String packageName) {
this.packageName = packageName;
}
/**
* 获取 生成模块名
* @return moduleName
*/
public String getModuleName() {
return this.moduleName;
}
/**
* 设置 生成模块名
* @param moduleName
*/
public void setModuleName(String moduleName) {
this.moduleName = moduleName;
}
/**
* 获取 生成业务名
* @return businessName
*/
public String getBusinessName() {
return this.businessName;
}
/**
* 设置 生成业务名
* @param businessName
*/
public void setBusinessName(String businessName) {
this.businessName = businessName;
}
/**
* 获取 生成功能名
* @return functionName
*/
public String getFunctionName() {
return this.functionName;
}
/**
* 设置 生成功能名
* @param functionName
*/
public void setFunctionName(String functionName) {
this.functionName = functionName;
}
/**
* 获取 生成功能作者
* @return functionAuthor
*/
public String getFunctionAuthor() {
return this.functionAuthor;
}
/**
* 设置 生成功能作者
* @param functionAuthor
*/
public void setFunctionAuthor(String functionAuthor) {
this.functionAuthor = functionAuthor;
}
/**
* 获取 缓存服务方式（0,无，1.静态实体缓存，2.动态实体缓存）
* @return cacheServiceType
*/
public Integer getCacheServiceType() {
return this.cacheServiceType;
}
/**
* 设置 缓存服务方式（0,无，1.静态实体缓存，2.动态实体缓存）
* @param cacheServiceType
*/
public void setCacheServiceType(Integer cacheServiceType) {
this.cacheServiceType = cacheServiceType;
}
/**
* 获取 生成代码方式（0.zip压缩包 1.自定义路径）
* @return genType
*/
public Integer getGenType() {
return this.genType;
}
/**
* 设置 生成代码方式（0.zip压缩包 1.自定义路径）
* @param genType
*/
public void setGenType(Integer genType) {
this.genType = genType;
}
/**
* 获取 分表方式（0.无，1.年，2.月，3.日，4.hash取余）
* @return dividedTableType
*/
public Integer getDividedTableType() {
return this.dividedTableType;
}
/**
* 设置 分表方式（0.无，1.年，2.月，3.日，4.hash取余）
* @param dividedTableType
*/
public void setDividedTableType(Integer dividedTableType) {
this.dividedTableType = dividedTableType;
}
/**
* 获取 生成路径（不填默认项目路径）
* @return genPath
*/
public String getGenPath() {
return this.genPath;
}
/**
* 设置 生成路径（不填默认项目路径）
* @param genPath
*/
public void setGenPath(String genPath) {
this.genPath = genPath;
}
/**
* 获取 其它生成选项
* @return options
*/
public String getOptions() {
return this.options;
}
/**
* 设置 其它生成选项
* @param options
*/
public void setOptions(String options) {
this.options = options;
}
/**
* 获取 备注
* @return remark
*/
public String getRemark() {
return this.remark;
}
/**
* 设置 备注
* @param remark
*/
public void setRemark(String remark) {
this.remark = remark;
}
/**
* 获取 变更时间
* @return updateTime
*/
public Date getUpdateTime() {
return this.updateTime;
}
/**
* 设置 变更时间
* @param updateTime
*/
public void setUpdateTime(Date updateTime) {
this.updateTime = updateTime;
}
/**
* 获取 变更用户loginName
* @return updateUser
*/
public String getUpdateUser() {
return this.updateUser;
}
/**
* 设置 变更用户loginName
* @param updateUser
*/
public void setUpdateUser(String updateUser) {
this.updateUser = updateUser;
}
/**
* 获取 创建时间
* @return createTime
*/
public Date getCreateTime() {
return this.createTime;
}
/**
* 设置 创建时间
* @param createTime
*/
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
/**
* 获取 创建用户loginName
* @return createUser
*/
public String getCreateUser() {
return this.createUser;
}
/**
* 设置 创建用户loginName
* @param createUser
*/
public void setCreateUser(String createUser) {
this.createUser = createUser;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null)
return false;
if (obj instanceof GentableEntity) {
GentableEntity tmp = (GentableEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb
.append(",id:").append(getId())
.append(",tableName:").append(getTableName())
.append(",tableComment:").append(getTableComment())
.append(",subTableName:").append(getSubTableName())
.append(",subTableFkName:").append(getSubTableFkName())
.append(",className:").append(getClassName())
.append(",tplCategory:").append(getTplCategory())
.append(",packageName:").append(getPackageName())
.append(",moduleName:").append(getModuleName())
.append(",businessName:").append(getBusinessName())
.append(",functionName:").append(getFunctionName())
.append(",functionAuthor:").append(getFunctionAuthor())
.append(",cacheServiceType:").append(getCacheServiceType())
.append(",genType:").append(getGenType())
.append(",dividedTableType:").append(getDividedTableType())
.append(",genPath:").append(getGenPath())
.append(",options:").append(getOptions())
.append(",remark:").append(getRemark())
.append(",updateTime:").append(getUpdateTime())
.append(",updateUser:").append(getUpdateUser())
.append(",createTime:").append(getCreateTime())
.append(",createUser:").append(getCreateUser())
;
return sb.toString();
}
public void initAttrValue(){
this.tableName = null;
this.tableComment = null;
this.subTableName = null;
this.subTableFkName = null;
this.className = null;
this.tplCategory = null;
this.packageName = null;
this.moduleName = null;
this.businessName = null;
this.functionName = null;
this.functionAuthor = null;
this.cacheServiceType = null;
this.genType = null;
this.dividedTableType = null;
this.genPath = null;
this.options = null;
this.remark = null;
this.updateTime = null;
this.updateUser = null;
this.createTime = null;
this.createUser = null;
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/model/GentableEntityExt.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.model;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.common.utils.StringUtils;
import lombok.Data;
import java.util.Date;
import java.util.List;
/**
* Description:Gentable
* date: 2021-9-29 9:35:30
*/
@Data
public class GentableEntityExt extends BaseEntityLong {
/**
* 主键信息
*/
private GentableColumnEntity pkColumn;
/**
* 子表信息
*/
private GentableEntity subTable;
/**
* 表列信息
*/
private List<GentableColumnEntity> columns;
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/model/GentableQuery.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.model;
import java.util.List;
import java.util.Date;
/**
*
* Description:Gentable
* date: 2021-9-28 10:10:15
*/
public class GentableQuery extends GentableEntity{
private static final long serialVersionUID = 1632795015394L;
/** 开始 ID，主键，自增长 */
private Long idStart;
/** 结束 ID，主键，自增长 */
private Long idEnd;
/** 增加 ID，主键，自增长 */
private Long idIncrement;
/** ID，主键，自增长 */
private List <Long> idList;
/** 表名称 */
private List<String> tableNameList;
/** 表描述 */
private List<String> tableCommentList;
/** 关联子表的表名 */
private List<String> subTableNameList;
/** 子表关联的外键名 */
private List<String> subTableFkNameList;
/** 实体类名称 */
private List<String> classNameList;
/** 使用的模板（crud单表操作 tree树表操作） */
private List<String> tplCategoryList;
/** 生成包路径 */
private List<String> packageNameList;
/** 生成模块名 */
private List<String> moduleNameList;
/** 生成业务名 */
private List<String> businessNameList;
/** 生成功能名 */
private List<String> functionNameList;
/** 生成功能作者 */
private List<String> functionAuthorList;
/** 开始 生成代码方式（0.zip压缩包 1.自定义路径） */
private Integer genTypeStart;
/** 结束 生成代码方式（0.zip压缩包 1.自定义路径） */
private Integer genTypeEnd;
/** 增加 生成代码方式（0.zip压缩包 1.自定义路径） */
private Integer genTypeIncrement;
/** 生成代码方式（0.zip压缩包 1.自定义路径） */
private List <Integer> genTypeList;
/** 生成路径（不填默认项目路径） */
private List<String> genPathList;
/** 其它生成选项 */
private List<String> optionsList;
/** 备注 */
private List<String> remarkList;
/** 开始 变更时间 */
private String updateTimeStart;
/** 结束 变更时间 */
private String updateTimeEnd;
/** 变更用户loginName */
private List<String> updateUserList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 创建用户loginName */
private List<String> createUserList;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<GentableQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<GentableQuery> andConditionList;
public GentableQuery(){
}
/**
* 获取 开始 ID，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 ID，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 ID，主键，自增长
* @return idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 ID，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 ID，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 ID，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 ID，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 ID，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 表名称
* @return tableNameList
*/
public List<String> getTableNameList(){
return this.tableNameList;
}
/**
* 设置 表名称
* @param tableNameList
*/
public void setTableNameList(List<String> tableNameList){
this.tableNameList = tableNameList;
}
/**
* 获取 表描述
* @return tableCommentList
*/
public List<String> getTableCommentList(){
return this.tableCommentList;
}
/**
* 设置 表描述
* @param tableCommentList
*/
public void setTableCommentList(List<String> tableCommentList){
this.tableCommentList = tableCommentList;
}
/**
* 获取 关联子表的表名
* @return subTableNameList
*/
public List<String> getSubTableNameList(){
return this.subTableNameList;
}
/**
* 设置 关联子表的表名
* @param subTableNameList
*/
public void setSubTableNameList(List<String> subTableNameList){
this.subTableNameList = subTableNameList;
}
/**
* 获取 子表关联的外键名
* @return subTableFkNameList
*/
public List<String> getSubTableFkNameList(){
return this.subTableFkNameList;
}
/**
* 设置 子表关联的外键名
* @param subTableFkNameList
*/
public void setSubTableFkNameList(List<String> subTableFkNameList){
this.subTableFkNameList = subTableFkNameList;
}
/**
* 获取 实体类名称
* @return classNameList
*/
public List<String> getClassNameList(){
return this.classNameList;
}
/**
* 设置 实体类名称
* @param classNameList
*/
public void setClassNameList(List<String> classNameList){
this.classNameList = classNameList;
}
/**
* 获取 使用的模板（crud单表操作 tree树表操作）
* @return tplCategoryList
*/
public List<String> getTplCategoryList(){
return this.tplCategoryList;
}
/**
* 设置 使用的模板（crud单表操作 tree树表操作）
* @param tplCategoryList
*/
public void setTplCategoryList(List<String> tplCategoryList){
this.tplCategoryList = tplCategoryList;
}
/**
* 获取 生成包路径
* @return packageNameList
*/
public List<String> getPackageNameList(){
return this.packageNameList;
}
/**
* 设置 生成包路径
* @param packageNameList
*/
public void setPackageNameList(List<String> packageNameList){
this.packageNameList = packageNameList;
}
/**
* 获取 生成模块名
* @return moduleNameList
*/
public List<String> getModuleNameList(){
return this.moduleNameList;
}
/**
* 设置 生成模块名
* @param moduleNameList
*/
public void setModuleNameList(List<String> moduleNameList){
this.moduleNameList = moduleNameList;
}
/**
* 获取 生成业务名
* @return businessNameList
*/
public List<String> getBusinessNameList(){
return this.businessNameList;
}
/**
* 设置 生成业务名
* @param businessNameList
*/
public void setBusinessNameList(List<String> businessNameList){
this.businessNameList = businessNameList;
}
/**
* 获取 生成功能名
* @return functionNameList
*/
public List<String> getFunctionNameList(){
return this.functionNameList;
}
/**
* 设置 生成功能名
* @param functionNameList
*/
public void setFunctionNameList(List<String> functionNameList){
this.functionNameList = functionNameList;
}
/**
* 获取 生成功能作者
* @return functionAuthorList
*/
public List<String> getFunctionAuthorList(){
return this.functionAuthorList;
}
/**
* 设置 生成功能作者
* @param functionAuthorList
*/
public void setFunctionAuthorList(List<String> functionAuthorList){
this.functionAuthorList = functionAuthorList;
}
/**
* 获取 开始 生成代码方式（0.zip压缩包 1.自定义路径）
* @return genTypeStart
*/
public Integer getGenTypeStart(){
return this.genTypeStart;
}
/**
* 设置 开始 生成代码方式（0.zip压缩包 1.自定义路径）
* @param genTypeStart
*/
public void setGenTypeStart(Integer genTypeStart){
this.genTypeStart = genTypeStart;
}
/**
* 获取 结束 生成代码方式（0.zip压缩包 1.自定义路径）
* @return genTypeEnd
*/
public Integer getGenTypeEnd(){
return this.genTypeEnd;
}
/**
* 设置 结束 生成代码方式（0.zip压缩包 1.自定义路径）
* @param genTypeEnd
*/
public void setGenTypeEnd(Integer genTypeEnd){
this.genTypeEnd = genTypeEnd;
}
/**
* 获取 增加 生成代码方式（0.zip压缩包 1.自定义路径）
* @return genTypeIncrement
*/
public Integer getGenTypeIncrement(){
return this.genTypeIncrement;
}
/**
* 设置 增加 生成代码方式（0.zip压缩包 1.自定义路径）
* @param genTypeIncrement
*/
public void setGenTypeIncrement(Integer genTypeIncrement){
this.genTypeIncrement = genTypeIncrement;
}
/**
* 获取 生成代码方式（0.zip压缩包 1.自定义路径）
* @return genTypeList
*/
public List<Integer> getGenTypeList(){
return this.genTypeList;
}
/**
* 设置 生成代码方式（0.zip压缩包 1.自定义路径）
* @param genTypeList
*/
public void setGenTypeList(List<Integer> genTypeList){
this.genTypeList = genTypeList;
}
/**
* 获取 生成路径（不填默认项目路径）
* @return genPathList
*/
public List<String> getGenPathList(){
return this.genPathList;
}
/**
* 设置 生成路径（不填默认项目路径）
* @param genPathList
*/
public void setGenPathList(List<String> genPathList){
this.genPathList = genPathList;
}
/**
* 获取 其它生成选项
* @return optionsList
*/
public List<String> getOptionsList(){
return this.optionsList;
}
/**
* 设置 其它生成选项
* @param optionsList
*/
public void setOptionsList(List<String> optionsList){
this.optionsList = optionsList;
}
/**
* 获取 备注
* @return remarkList
*/
public List<String> getRemarkList(){
return this.remarkList;
}
/**
* 设置 备注
* @param remarkList
*/
public void setRemarkList(List<String> remarkList){
this.remarkList = remarkList;
}
/**
* 获取 开始 变更时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 变更时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 变更时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 变更时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 获取 变更用户loginName
* @return updateUserList
*/
public List<String> getUpdateUserList(){
return this.updateUserList;
}
/**
* 设置 变更用户loginName
* @param updateUserList
*/
public void setUpdateUserList(List<String> updateUserList){
this.updateUserList = updateUserList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 创建用户loginName
* @return createUserList
*/
public List<String> getCreateUserList(){
return this.createUserList;
}
/**
* 设置 创建用户loginName
* @param createUserList
*/
public void setCreateUserList(List<String> createUserList){
this.createUserList = createUserList;
}
/**
* 设置 ID，主键，自增长
* @param id
*/
public GentableQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 ID，主键，自增长
* @param idStart
*/
public GentableQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 ID，主键，自增长
* @param idEnd
*/
public GentableQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 ID，主键，自增长
* @param idIncrement
*/
public GentableQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 ID，主键，自增长
* @param idList
*/
public GentableQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 表名称
* @param tableName
*/
public GentableQuery tableName(String tableName){
setTableName(tableName);
return this;
}
/**
* 设置 表名称
* @param tableNameList
*/
public GentableQuery tableNameList(List<String> tableNameList){
this.tableNameList = tableNameList;
return this;
}
/**
* 设置 表描述
* @param tableComment
*/
public GentableQuery tableComment(String tableComment){
setTableComment(tableComment);
return this;
}
/**
* 设置 表描述
* @param tableCommentList
*/
public GentableQuery tableCommentList(List<String> tableCommentList){
this.tableCommentList = tableCommentList;
return this;
}
/**
* 设置 关联子表的表名
* @param subTableName
*/
public GentableQuery subTableName(String subTableName){
setSubTableName(subTableName);
return this;
}
/**
* 设置 关联子表的表名
* @param subTableNameList
*/
public GentableQuery subTableNameList(List<String> subTableNameList){
this.subTableNameList = subTableNameList;
return this;
}
/**
* 设置 子表关联的外键名
* @param subTableFkName
*/
public GentableQuery subTableFkName(String subTableFkName){
setSubTableFkName(subTableFkName);
return this;
}
/**
* 设置 子表关联的外键名
* @param subTableFkNameList
*/
public GentableQuery subTableFkNameList(List<String> subTableFkNameList){
this.subTableFkNameList = subTableFkNameList;
return this;
}
/**
* 设置 实体类名称
* @param className
*/
public GentableQuery className(String className){
setClassName(className);
return this;
}
/**
* 设置 实体类名称
* @param classNameList
*/
public GentableQuery classNameList(List<String> classNameList){
this.classNameList = classNameList;
return this;
}
/**
* 设置 使用的模板（crud单表操作 tree树表操作）
* @param tplCategory
*/
public GentableQuery tplCategory(String tplCategory){
setTplCategory(tplCategory);
return this;
}
/**
* 设置 使用的模板（crud单表操作 tree树表操作）
* @param tplCategoryList
*/
public GentableQuery tplCategoryList(List<String> tplCategoryList){
this.tplCategoryList = tplCategoryList;
return this;
}
/**
* 设置 生成包路径
* @param packageName
*/
public GentableQuery packageName(String packageName){
setPackageName(packageName);
return this;
}
/**
* 设置 生成包路径
* @param packageNameList
*/
public GentableQuery packageNameList(List<String> packageNameList){
this.packageNameList = packageNameList;
return this;
}
/**
* 设置 生成模块名
* @param moduleName
*/
public GentableQuery moduleName(String moduleName){
setModuleName(moduleName);
return this;
}
/**
* 设置 生成模块名
* @param moduleNameList
*/
public GentableQuery moduleNameList(List<String> moduleNameList){
this.moduleNameList = moduleNameList;
return this;
}
/**
* 设置 生成业务名
* @param businessName
*/
public GentableQuery businessName(String businessName){
setBusinessName(businessName);
return this;
}
/**
* 设置 生成业务名
* @param businessNameList
*/
public GentableQuery businessNameList(List<String> businessNameList){
this.businessNameList = businessNameList;
return this;
}
/**
* 设置 生成功能名
* @param functionName
*/
public GentableQuery functionName(String functionName){
setFunctionName(functionName);
return this;
}
/**
* 设置 生成功能名
* @param functionNameList
*/
public GentableQuery functionNameList(List<String> functionNameList){
this.functionNameList = functionNameList;
return this;
}
/**
* 设置 生成功能作者
* @param functionAuthor
*/
public GentableQuery functionAuthor(String functionAuthor){
setFunctionAuthor(functionAuthor);
return this;
}
/**
* 设置 生成功能作者
* @param functionAuthorList
*/
public GentableQuery functionAuthorList(List<String> functionAuthorList){
this.functionAuthorList = functionAuthorList;
return this;
}
/**
* 设置 生成代码方式（0.zip压缩包 1.自定义路径）
* @param genType
*/
public GentableQuery genType(Integer genType){
setGenType(genType);
return this;
}
/**
* 设置 开始 生成代码方式（0.zip压缩包 1.自定义路径）
* @param genTypeStart
*/
public GentableQuery genTypeStart(Integer genTypeStart){
this.genTypeStart = genTypeStart;
return this;
}
/**
* 设置 结束 生成代码方式（0.zip压缩包 1.自定义路径）
* @param genTypeEnd
*/
public GentableQuery genTypeEnd(Integer genTypeEnd){
this.genTypeEnd = genTypeEnd;
return this;
}
/**
* 设置 增加 生成代码方式（0.zip压缩包 1.自定义路径）
* @param genTypeIncrement
*/
public GentableQuery genTypeIncrement(Integer genTypeIncrement){
this.genTypeIncrement = genTypeIncrement;
return this;
}
/**
* 设置 生成代码方式（0.zip压缩包 1.自定义路径）
* @param genTypeList
*/
public GentableQuery genTypeList(List<Integer> genTypeList){
this.genTypeList = genTypeList;
return this;
}
/**
* 设置 生成路径（不填默认项目路径）
* @param genPath
*/
public GentableQuery genPath(String genPath){
setGenPath(genPath);
return this;
}
/**
* 设置 生成路径（不填默认项目路径）
* @param genPathList
*/
public GentableQuery genPathList(List<String> genPathList){
this.genPathList = genPathList;
return this;
}
/**
* 设置 其它生成选项
* @param options
*/
public GentableQuery options(String options){
setOptions(options);
return this;
}
/**
* 设置 其它生成选项
* @param optionsList
*/
public GentableQuery optionsList(List<String> optionsList){
this.optionsList = optionsList;
return this;
}
/**
* 设置 备注
* @param remark
*/
public GentableQuery remark(String remark){
setRemark(remark);
return this;
}
/**
* 设置 备注
* @param remarkList
*/
public GentableQuery remarkList(List<String> remarkList){
this.remarkList = remarkList;
return this;
}
/**
* 设置 开始 变更时间
* @param updateTimeStart
*/
public GentableQuery updateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
return this;
}
/**
* 设置 结束 变更时间
* @param updateTimeEnd
*/
public GentableQuery updateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
return this;
}
/**
* 设置 变更用户loginName
* @param updateUser
*/
public GentableQuery updateUser(String updateUser){
setUpdateUser(updateUser);
return this;
}
/**
* 设置 变更用户loginName
* @param updateUserList
*/
public GentableQuery updateUserList(List<String> updateUserList){
this.updateUserList = updateUserList;
return this;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public GentableQuery createTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
return this;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public GentableQuery createTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
return this;
}
/**
* 设置 创建用户loginName
* @param createUser
*/
public GentableQuery createUser(String createUser){
setCreateUser(createUser);
return this;
}
/**
* 设置 创建用户loginName
* @param createUserList
*/
public GentableQuery createUserList(List<String> createUserList){
this.createUserList = createUserList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<GentableQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<GentableQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<GentableQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<GentableQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/service/GentableColumnService.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.service;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.base.system.gentable.model.GentableColumnEntity;
import java.util.List;
/**
* <p>Title: 代码生成业务表字段</p>
* <p>Description: GentableColumnService service接口 </p>
* <p>Copyright: Copyright &reg; </p>
* @version 1.0.0
*/
public interface GentableColumnService extends ICRUDService<GentableColumnEntity,Long> {
/**
* 根据表名称查询列信息
*
* @param tableName 表名称
* @return 列信息
*/
List<GentableColumnEntity> selectDbTableColumnsByName(String tableName);
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/service/GentableService.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.service;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.base.system.gentable.model.GentableEntity;
import com.mortals.xhx.base.system.gentable.model.GentableQuery;
import java.util.List;
/**
* <p>Title: 代码生成业务表</p>
* <p>Description: GentableService service接口 </p>
* <p>Copyright: Copyright &reg; </p>
* @version 1.0.0
*/
public interface GentableService extends ICRUDService<GentableEntity,Long> {
/**
* 查询据库列表
*
* @param query 业务信息
* @return 数据库表集合
*/
List<GentableEntity> selectDbTableList(GentableQuery query);
/**
* 查询据库列表
*
* @param tableNames 表名称组
* @return 数据库表集合
*/
List<GentableEntity> selectDbTableListByNames(String[] tableNames);
/**
* 查询所有表信息
*
* @return 表信息集合
*/
List<GentableEntity> selectGenTableAll();
/**
* 导入表结构
*
* @param tableList 导入表列表
*/
void importGenTable(List<GentableEntity> tableList, Context context);
/**
* 修改保存参数校验
*
* @param genTable 业务信息
*/
void validateEdit(GentableEntity genTable);
/**
* 生成代码（单表生成下载方式）
*
* @param tableName 表名称
* @return 数据
*/
byte[] downloadCode(String tableName);
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/service/impl/GentableColumnServiceImpl.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.service.impl;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.xhx.base.system.gentable.dao.GentableColumnDao;
import com.mortals.xhx.base.system.gentable.model.GentableColumnEntity;
import com.mortals.xhx.base.system.gentable.service.GentableColumnService;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>Title: 代码生成业务表字段</p>
* <p>Description: GentableColumnService service接口 </p>
* <p>Copyright: Copyright &reg; </p>
*
* @version 1.0.0
*/
@Service("gentableColumnService")
public class GentableColumnServiceImpl extends AbstractCRUDServiceImpl<GentableColumnDao, GentableColumnEntity, Long> implements GentableColumnService {
@Override
public List<GentableColumnEntity> selectDbTableColumnsByName(String tableName) {
return this.dao.selectDbTableColumnsByName(tableName);
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/service/impl/GentableServiceImpl.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.service.impl;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.framework.model.ParamDto;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.util.EntityUtil;
import com.mortals.xhx.base.system.gentable.dao.GentableDao;
import com.mortals.xhx.base.system.gentable.model.GentableColumnEntity;
import com.mortals.xhx.base.system.gentable.model.GentableColumnQuery;
import com.mortals.xhx.base.system.gentable.model.GentableEntity;
import com.mortals.xhx.base.system.gentable.model.GentableQuery;
import com.mortals.xhx.base.system.gentable.service.GentableColumnService;
import com.mortals.xhx.base.system.gentable.service.GentableService;
import com.mortals.xhx.common.code.CacheServiceTypeEnum;
import com.mortals.xhx.common.code.DividedTableTypeEnum;
import com.mortals.xhx.common.code.YesNoEnum;
import com.mortals.xhx.common.key.GenConstants;
import com.mortals.xhx.common.utils.GenUtils;
import com.mortals.xhx.common.utils.StringUtils;
import org.apache.commons.io.IOUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
/**
* <p>Title: 代码生成业务表</p>
* <p>Description: GentableService service接口 </p>
* <p>Copyright: Copyright &reg; </p>
*
* @version 1.0.0
*/
@Service("gentableService")
public class GentableServiceImpl extends AbstractCRUDServiceImpl<GentableDao, GentableEntity, Long> implements GentableService {
@Autowired
private GentableColumnService gentableColumnService;
@Override
public List<GentableEntity> selectDbTableList(GentableQuery query) {
//query to dao
ParamDto paramDto = new ParamDto();
Map map = new HashMap();
EntityUtil.entityToMap(query, map);
paramDto.setCondition(map);
return this.dao.selectDbTableList(paramDto);
}
@Override
public List<GentableEntity> selectDbTableListByNames(String[] tableNames) {
return this.getDao().selectDbTableListByNames(tableNames);
}
@Override
public List<GentableEntity> selectGenTableAll() {
return this.getDao().selectGenTableAll();
}
@Override
public void importGenTable(List<GentableEntity> tableList, Context context) {
String operName = context.getUser().getLoginName();
try {
for (GentableEntity table : tableList) {
String tableName = table.getTableName();
GenUtils.initTable(table, operName);
table.setGenType(0);
table.setGenPath("/");
table.setTplCategory("crud");
table.setCacheServiceType(CacheServiceTypeEnum.NORMAL_SERVICE.getValue());
table.setDividedTableType(DividedTableTypeEnum.DIVIED_NO.getValue());
//保存表
this.save(table);
//保存列
List<GentableColumnEntity> genTableColumns = gentableColumnService.selectDbTableColumnsByName(tableName);
for (GentableColumnEntity column : genTableColumns) {
GenUtils.initColumnField(column, table);
gentableColumnService.save(column);
}
}
} catch (Exception e) {
throw new AppException("导入失败：" + e.getMessage());
}
}
@Override
public void validateEdit(GentableEntity genTable) {
if (GenConstants.TPL_TREE.equals(genTable.getTplCategory())) {
String options = JSON.toJSONString(genTable.getOptions());
JSONObject paramsObj = JSONObject.parseObject(options);
if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_CODE))) {
throw new AppException("树编码字段不能为空");
} else if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_PARENT_CODE))) {
throw new AppException("树父编码字段不能为空");
} else if (StringUtils.isEmpty(paramsObj.getString(GenConstants.TREE_NAME))) {
throw new AppException("树名称字段不能为空");
} else if (GenConstants.TPL_SUB.equals(genTable.getTplCategory())) {
if (StringUtils.isEmpty(genTable.getSubTableName())) {
throw new AppException("关联子表的表名不能为空");
} else if (StringUtils.isEmpty(genTable.getSubTableFkName())) {
throw new AppException("子表关联的外键名不能为空");
}
}
}
}
@Override
protected void updateAfter(GentableEntity entity, Context context) throws AppException {
if (!ObjectUtils.isEmpty(entity.getColumns())) {
gentableColumnService.update(entity.getColumns());
}
super.updateAfter(entity, context);
}
@Override
public byte[] downloadCode(String tableName) {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
ZipOutputStream zip = new ZipOutputStream(outputStream);
generatorCode(tableName, zip);
IOUtils.closeQuietly(zip);
return outputStream.toByteArray();
}
/**
* 查询表信息并生成代码
*/
private void generatorCode(String tableName, ZipOutputStream zip) {
GentableEntity gentableEntity = this.selectOne(new GentableQuery().tableName(tableName));
if (!ObjectUtils.isEmpty(gentableEntity)) {
// 设置主子表信息
setSubTable(gentableEntity);
// 设置主键列信息
setPkColumn(gentableEntity);
//通过模板生成不同的业务类
// 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, 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 table 业务表信息
*/
public void setPkColumn(GentableEntity table) {
for (GentableColumnEntity column : table.getColumns()) {
if (column.getIsPrimaryKey() == YesNoEnum.YES.getValue()) {
//是主键 设置主键列
table.setPkColumn(column);
break;
}
}
if (StringUtils.isNull(table.getPkColumn())) {
table.setPkColumn(table.getColumns().get(0));
}
if (GenConstants.TPL_SUB.equals(table.getTplCategory())) {
for (GentableColumnEntity column : table.getSubTable().getColumns()) {
if (column.getIsPrimaryKey() == YesNoEnum.YES.getValue()) {
table.getSubTable().setPkColumn(column);
break;
}
}
if (StringUtils.isNull(table.getSubTable().getPkColumn())) {
table.getSubTable().setPkColumn(table.getSubTable().getColumns().get(0));
}
}
}
/**
* 设置主子表信息
*
* @param table 业务表信息
*/
public void setSubTable(GentableEntity table) {
String subTableName = table.getSubTableName();
if (StringUtils.isNotEmpty(subTableName)) {
GentableEntity gentableEntity = this.selectOne(new GentableQuery().tableName(subTableName));
if (!ObjectUtils.isEmpty(gentableEntity)) {
table.setSubTable(gentableEntity);
}
}
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/web/GentableColumnController.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.web;
import com.mortals.framework.web.BaseCRUDJsonMappingController;
import com.mortals.xhx.base.system.gentable.model.GentableColumnEntity;
import com.mortals.xhx.base.system.gentable.service.GentableColumnService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* <p>Title: 代码生成业务表字段</p>
* <p>Description: GentableColumnController </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author zxfei
* @version 1.0.0
*/
@RestController
@RequestMapping("gentable/column")
public class GentableColumnController extends BaseCRUDJsonMappingController<GentableColumnService,GentableColumnForm, GentableColumnEntity,Long> {
public GentableColumnController(){
super.setFormClass(GentableColumnForm.class);
super.setModuleDesc("代码生成业务表字段");
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/web/GentableColumnForm.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.web;
import com.mortals.framework.web.BaseCRUDFormLong;
import com.mortals.xhx.base.system.gentable.model.GentableColumnEntity;
import com.mortals.xhx.base.system.gentable.model.GentableColumnQuery;
/**
* <p>Title: 代码生成业务表字段</p>
* <p>Description: GentableColumnForm </p>
* @author
* @version 1.0.0
*/
public class GentableColumnForm extends BaseCRUDFormLong<GentableColumnEntity> {
private GentableColumnEntity entity = new GentableColumnEntity();
private GentableColumnQuery query = new GentableColumnQuery();
public GentableColumnForm(){
}
@Override
public GentableColumnEntity getEntity() {
return entity;
}
public void setGentableColumn(GentableColumnEntity entity) {
this.entity = entity;
}
@Override
public GentableColumnQuery getQuery() {
return query;
}
public void setQuery(GentableColumnQuery query) {
this.query = query;
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/web/GentableController.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.web;
import cn.hutool.core.convert.Convert;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.model.Context;
import com.mortals.framework.web.BaseCRUDJsonMappingController;
import com.mortals.xhx.base.system.gentable.model.GentableColumnEntity;
import com.mortals.xhx.base.system.gentable.model.GentableColumnQuery;
import com.mortals.xhx.base.system.gentable.model.GentableEntity;
import com.mortals.xhx.base.system.gentable.service.GentableColumnService;
import com.mortals.xhx.base.system.gentable.service.GentableService;
import com.mortals.xhx.common.code.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* <p>Title: 代码生成业务表</p>
* <p>Description: GentableController </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
*
* @author zxfei
* @version 1.0.0
*/
@RestController
@RequestMapping("gentable")
public class GentableController extends BaseCRUDJsonMappingController<GentableService, GentableForm, GentableEntity, Long> {
@Autowired
private GentableColumnService gentableColumnService;
public GentableController() {
super.setFormClass(GentableForm.class);
super.setModuleDesc("代码生成业务表");
}
@Override
protected void init(HttpServletRequest request, HttpServletResponse response, GentableForm form, Map<String, Object> model, Context context) {
this.addDict(model, "dividedTableType", DividedTableTypeEnum.getEnumMap());
this.addDict(model, "cacheServiceType", CacheServiceTypeEnum.getEnumMap());
this.addDict(model, "genType", GenTypeEnum.getEnumMap());
this.addDict(model, "htmlType", HtmlTypeEnum.getEnumMap());
super.init(request, response, form, model, context);
}
@PostMapping("/db/list")
public String dblist(GentableForm form) {
Map<String, Object> model = new HashMap<>();
JSONObject ret = new JSONObject();
String busiDesc = "查询数据库表";
int code = VALUE_RESULT_SUCCESS;
try {
List<GentableEntity> list = this.service.selectDbTableList(form.getQuery());
model.put("result", list);
recordSysLog(request, busiDesc + " 【成功】");
} catch (Exception e) {
code = VALUE_RESULT_FAILURE;
this.doException(request, busiDesc, model, e);
}
ret.put(KEY_RESULT_CODE, code);
ret.put(KEY_RESULT_QUERY, form.getQuery());
ret.put(KEY_RESULT_DATA, model);
return ret.toJSONString();
}
@PostMapping("/importTable")
public String importTable(@RequestParam(value = "tables") String tables) {
Map<String, Object> model = new HashMap<>();
JSONObject ret = new JSONObject();
String busiDesc = "查询数据库表";
int code = VALUE_RESULT_SUCCESS;
try {
String[] tableNames = Convert.toStrArray(tables);
//查询
List<GentableEntity> list = this.service.selectDbTableListByNames(tableNames);
//导入
this.service.importGenTable(list, getContext());
recordSysLog(request, busiDesc + " 【成功】");
} catch (Exception e) {
code = VALUE_RESULT_FAILURE;
this.doException(request, busiDesc, model, e);
}
ret.put(KEY_RESULT_CODE, code);
ret.put(KEY_RESULT_DATA, model);
return ret.toJSONString();
}
@PostMapping("/info")
public String getInfo(@RequestParam(value = "tableId") Long tableId) {
Map<String, Object> model = new HashMap<>();
JSONObject ret = new JSONObject();
String busiDesc = "查询数据库表";
int code = VALUE_RESULT_SUCCESS;
try {
//查询单表信息
GentableEntity gentableEntity = this.service.get(tableId);
//关联查询表与列信息
List<GentableEntity> allList = this.service.selectGenTableAll();
//查询列信息
List<GentableColumnEntity> columnEntities = gentableColumnService.find(new GentableColumnQuery().tableId(tableId));
model.put("info", gentableEntity);
model.put("rows", columnEntities);
model.put("tables", allList);
recordSysLog(request, busiDesc + " 【成功】");
} catch (Exception e) {
code = VALUE_RESULT_FAILURE;
this.doException(request, busiDesc, model, e);
}
this.init(this.request, this.response, null, model, getContext());
ret.put(KEY_RESULT_CODE, code);
ret.put(KEY_RESULT_DATA, model);
return ret.toJSONString();
}
/**
* 通过表名生成代码
* @param tableName
* @return
*/
@PostMapping("/genCode")
public String genCode(@RequestParam(value = "tableName") String tableName) {
Map<String, Object> model = new HashMap<>();
JSONObject ret = new JSONObject();
String busiDesc = "生成单表代码";
int code = VALUE_RESULT_SUCCESS;
try {
recordSysLog(request, busiDesc + " 【成功】");
} catch (Exception e) {
code = VALUE_RESULT_FAILURE;
this.doException(request, busiDesc, model, e);
}
ret.put(KEY_RESULT_CODE, code);
ret.put(KEY_RESULT_DATA, model);
return ret.toJSONString();
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/base/system/gentable/web/GentableForm.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.base.system.gentable.web;
import com.mortals.framework.web.BaseCRUDFormLong;
import com.mortals.xhx.base.system.gentable.model.GentableEntity;
import com.mortals.xhx.base.system.gentable.model.GentableQuery;
/**
* <p>Title: 代码生成业务表</p>
* <p>Description: GentableForm </p>
* @author
* @version 1.0.0
*/
public class GentableForm extends BaseCRUDFormLong<GentableEntity> {
private GentableEntity entity = new GentableEntity();
private GentableQuery query = new GentableQuery();
public GentableForm(){
}
@Override
public GentableEntity getEntity() {
return entity;
}
public void setGentable(GentableEntity entity) {
this.entity = entity;
}
@Override
public GentableQuery getQuery() {
return query;
}
public void setQuery(GentableQuery query) {
this.query = query;
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/common/code/CacheServiceTypeEnum.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author: finegirl
* @date: 2021/7/16 11:50
* @description: 缓存服务方式
**/
public enum CacheServiceTypeEnum {
NORMAL_SERVICE(0, "无"),
CACHE_SERVICE(1, "静态缓存服务"),
CACHE_DYNAMIC_SERVICE(2, "动态缓存服务");
private int value;
private String desc;
private CacheServiceTypeEnum(int value, String desc) {
this.value = value;
this.desc = desc;
}
public int getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static CacheServiceTypeEnum getByValue(int value) {
CacheServiceTypeEnum[] var1 = values();
int var2 = var1.length;
for(int var3 = 0; var3 < var2; ++var3) {
CacheServiceTypeEnum examStatus = var1[var3];
if (examStatus.getValue() == value) {
return examStatus;
}
}
return null;
}
public static Map<String, String> getEnumMap(int... eItem) {
Map<String, String> resultMap = new LinkedHashMap();
CacheServiceTypeEnum[] var2 = values();
int var3 = var2.length;
for(int var4 = 0; var4 < var3; ++var4) {
CacheServiceTypeEnum item = var2[var4];
try {
boolean hasE = false;
int[] var7 = eItem;
int var8 = eItem.length;
for(int var9 = 0; var9 < var8; ++var9) {
int e = var7[var9];
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception var11) {
}
}
return resultMap;
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/common/code/DividedTableTypeEnum.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author: finegirl
* @date: 2021/7/16 11:50
* @description: 分表方式
**/
public enum DividedTableTypeEnum {
DIVIED_NO(0, "无"),
DIVIED_BY_DAY(1, "日"),
DIVIED_BY_WEEK(2, "周"),
DIVIED_BY_MONTH(3, "月"),
DIVIED_BY_MOD(4, "HASH取余");
private int value;
private String desc;
private DividedTableTypeEnum(int value, String desc) {
this.value = value;
this.desc = desc;
}
public int getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static DividedTableTypeEnum getByValue(int value) {
DividedTableTypeEnum[] var1 = values();
int var2 = var1.length;
for (int var3 = 0; var3 < var2; ++var3) {
DividedTableTypeEnum examStatus = var1[var3];
if (examStatus.getValue() == value) {
return examStatus;
}
}
return null;
}
public static Map<String, String> getEnumMap(int... eItem) {
Map<String, String> resultMap = new LinkedHashMap();
DividedTableTypeEnum[] var2 = values();
int var3 = var2.length;
for (int var4 = 0; var4 < var3; ++var4) {
DividedTableTypeEnum item = var2[var4];
try {
boolean hasE = false;
int[] var7 = eItem;
int var8 = eItem.length;
for (int var9 = 0; var9 < var8; ++var9) {
int e = var7[var9];
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception var11) {
}
}
return resultMap;
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/common/code/GenTypeEnum.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author: finegirl
* @date: 2021/7/16 11:50
* @description: //TODO 请完善注释信息
**/
public enum GenTypeEnum {
ZIP(0, "zip压缩包"),
CUSTOM(1, "自定义路径");
private int value;
private String desc;
private GenTypeEnum(int value, String desc) {
this.value = value;
this.desc = desc;
}
public int getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static GenTypeEnum getByValue(int value) {
GenTypeEnum[] var1 = values();
int var2 = var1.length;
for(int var3 = 0; var3 < var2; ++var3) {
GenTypeEnum examStatus = var1[var3];
if (examStatus.getValue() == value) {
return examStatus;
}
}
return null;
}
public static Map<String, String> getEnumMap(int... eItem) {
Map<String, String> resultMap = new LinkedHashMap();
GenTypeEnum[] var2 = values();
int var3 = var2.length;
for(int var4 = 0; var4 < var3; ++var4) {
GenTypeEnum item = var2[var4];
try {
boolean hasE = false;
int[] var7 = eItem;
int var8 = eItem.length;
for(int var9 = 0; var9 < var8; ++var9) {
int e = var7[var9];
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception var11) {
}
}
return resultMap;
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/common/code/HtmlTypeEnum.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* @author: finegirl
* @date: 2021/7/16 11:50
* @description: //TODO 请完善注释信息
**/
public enum HtmlTypeEnum {
HTML_INPUT(1, "文本框"),
HTML_TEXTAREA(2, "文本域"),
HTML_SELECT(3, "下拉框"),
HTML_RADIO(4, "单选框"),
HTML_CHECKBOX(5, "复选框"),
HTML_DATETIME(6, "日期控件"),
HTML_IMAGE_UPLOAD(7, "图片上传控件"),
HTML_FILE_UPLOAD(8, "文件上传控件"),
HTML_EDITOR(9, "富文本控件");
private int value;
private String desc;
private HtmlTypeEnum(int value, String desc) {
this.value = value;
this.desc = desc;
}
public int getValue() {
return this.value;
}
public String getDesc() {
return this.desc;
}
public static HtmlTypeEnum getByValue(int value) {
HtmlTypeEnum[] var1 = values();
int var2 = var1.length;
for(int var3 = 0; var3 < var2; ++var3) {
HtmlTypeEnum examStatus = var1[var3];
if (examStatus.getValue() == value) {
return examStatus;
}
}
return null;
}
public static Map<String, String> getEnumMap(int... eItem) {
Map<String, String> resultMap = new LinkedHashMap();
HtmlTypeEnum[] var2 = values();
int var3 = var2.length;
for(int var4 = 0; var4 < var3; ++var4) {
HtmlTypeEnum item = var2[var4];
try {
boolean hasE = false;
int[] var7 = eItem;
int var8 = eItem.length;
for(int var9 = 0; var9 < var8; ++var9) {
int e = var7[var9];
if (item.getValue() == e) {
hasE = true;
break;
}
}
if (!hasE) {
resultMap.put(item.getValue() + "", item.getDesc());
}
} catch (Exception var11) {
}
}
return resultMap;
}
}
\ No newline at end of file
government-manager/src/main/java/com/mortals/xhx/common/key/GenConstants.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.key;
/**
* 代码生成通用常量
*
* @author: zxfei
* @date: 2021/9/28 15:43
*/
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[] COLUMNTYPE_STR = { "char", "varchar", "nvarchar", "varchar2" };
/** 数据库文本类型 */
public static final String[] COLUMNTYPE_TEXT = { "tinytext", "text", "mediumtext", "longtext" };
/** 数据库时间类型 */
public static final String[] COLUMNTYPE_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[] COLUMNNAME_NOT_EDIT = { "id", "create_by", "create_time", "del_flag" };
/** 页面不需要显示的列表字段 */
public static final String[] COLUMNNAME_NOT_LIST = { "id", "create_by", "create_time", "del_flag", "update_by",
"update_time" };
/** 页面不需要查询字段 */
public static final String[] COLUMNNAME_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 Integer REQUIRE = 1;
}
government-manager/src/main/java/com/mortals/xhx/common/utils/CharsetKit.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.utils;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
/**
* 字符集工具类
*
* @author: zxfei
* @date: 2021/9/28 15:54
*/
public class CharsetKit {
/**
* ISO-8859-1
*/
public static final String ISO_8859_1 = "ISO-8859-1";
/**
* UTF-8
*/
public static final String UTF_8 = "UTF-8";
/**
* GBK
*/
public static final String GBK = "GBK";
/**
* ISO-8859-1
*/
public static final Charset CHARSET_ISO_8859_1 = Charset.forName(ISO_8859_1);
/**
* UTF-8
*/
public static final Charset CHARSET_UTF_8 = Charset.forName(UTF_8);
/**
* GBK
*/
public static final Charset CHARSET_GBK = Charset.forName(GBK);
/**
* 转换为Charset对象
*
* @param charset 字符集，为空则返回默认字符集
* @return Charset
*/
public static Charset charset(String charset) {
return StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset);
}
/**
* 转换字符串的字符集编码
*
* @param source 字符串
* @param srcCharset 源字符集，默认ISO-8859-1
* @param destCharset 目标字符集，默认UTF-8
* @return 转换后的字符集
*/
public static String convert(String source, String srcCharset, String destCharset) {
return convert(source, Charset.forName(srcCharset), Charset.forName(destCharset));
}
/**
* 转换字符串的字符集编码
*
* @param source 字符串
* @param srcCharset 源字符集，默认ISO-8859-1
* @param destCharset 目标字符集，默认UTF-8
* @return 转换后的字符集
*/
public static String convert(String source, Charset srcCharset, Charset destCharset) {
if (null == srcCharset) {
srcCharset = StandardCharsets.ISO_8859_1;
}
if (null == destCharset) {
destCharset = StandardCharsets.UTF_8;
}
if (StringUtils.isEmpty(source) || srcCharset.equals(destCharset)) {
return source;
}
return new String(source.getBytes(srcCharset), destCharset);
}
/**
* @return 系统字符集编码
*/
public static String systemCharset() {
return Charset.defaultCharset().name();
}
}
government-manager/src/main/java/com/mortals/xhx/common/utils/Convert.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.utils;
import org.apache.commons.lang3.ArrayUtils;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.text.NumberFormat;
import java.util.Set;
/**
* 类型转换器
*
* @author ruoyi
*/
public class Convert
{
/**
* 转换为字符串<br>
* 如果给定的值为null，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static String toStr(Object value, String defaultValue)
{
if (null == value)
{
return defaultValue;
}
if (value instanceof String)
{
return (String) value;
}
return value.toString();
}
/**
* 转换为字符串<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static String toStr(Object value)
{
return toStr(value, null);
}
/**
* 转换为字符<br>
* 如果给定的值为null，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Character toChar(Object value, Character defaultValue)
{
if (null == value)
{
return defaultValue;
}
if (value instanceof Character)
{
return (Character) value;
}
final String valueStr = toStr(value, null);
return StringUtils.isEmpty(valueStr) ? defaultValue : valueStr.charAt(0);
}
/**
* 转换为字符<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Character toChar(Object value)
{
return toChar(value, null);
}
/**
* 转换为byte<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Byte toByte(Object value, Byte defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Byte)
{
return (Byte) value;
}
if (value instanceof Number)
{
return ((Number) value).byteValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Byte.parseByte(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为byte<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Byte toByte(Object value)
{
return toByte(value, null);
}
/**
* 转换为Short<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Short toShort(Object value, Short defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Short)
{
return (Short) value;
}
if (value instanceof Number)
{
return ((Number) value).shortValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Short.parseShort(valueStr.trim());
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为Short<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Short toShort(Object value)
{
return toShort(value, null);
}
/**
* 转换为Number<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Number toNumber(Object value, Number defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Number)
{
return (Number) value;
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return NumberFormat.getInstance().parse(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为Number<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Number toNumber(Object value)
{
return toNumber(value, null);
}
/**
* 转换为int<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Integer toInt(Object value, Integer defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Integer)
{
return (Integer) value;
}
if (value instanceof Number)
{
return ((Number) value).intValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Integer.parseInt(valueStr.trim());
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为int<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Integer toInt(Object value)
{
return toInt(value, null);
}
/**
* 转换为Integer数组<br>
*
* @param str 被转换的值
* @return 结果
*/
public static Integer[] toIntArray(String str)
{
return toIntArray(",", str);
}
/**
* 转换为Long数组<br>
*
* @param str 被转换的值
* @return 结果
*/
public static Long[] toLongArray(String str)
{
return toLongArray(",", str);
}
/**
* 转换为Integer数组<br>
*
* @param split 分隔符
* @param split 被转换的值
* @return 结果
*/
public static Integer[] toIntArray(String split, String str)
{
if (StringUtils.isEmpty(str))
{
return new Integer[] {};
}
String[] arr = str.split(split);
final Integer[] ints = new Integer[arr.length];
for (int i = 0; i < arr.length; i++)
{
final Integer v = toInt(arr[i], 0);
ints[i] = v;
}
return ints;
}
/**
* 转换为Long数组<br>
*
* @param split 分隔符
* @param str 被转换的值
* @return 结果
*/
public static Long[] toLongArray(String split, String str)
{
if (StringUtils.isEmpty(str))
{
return new Long[] {};
}
String[] arr = str.split(split);
final Long[] longs = new Long[arr.length];
for (int i = 0; i < arr.length; i++)
{
final Long v = toLong(arr[i], null);
longs[i] = v;
}
return longs;
}
/**
* 转换为String数组<br>
*
* @param str 被转换的值
* @return 结果
*/
public static String[] toStrArray(String str)
{
return toStrArray(",", str);
}
/**
* 转换为String数组<br>
*
* @param split 分隔符
* @param split 被转换的值
* @return 结果
*/
public static String[] toStrArray(String split, String str)
{
return str.split(split);
}
/**
* 转换为long<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Long toLong(Object value, Long defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Long)
{
return (Long) value;
}
if (value instanceof Number)
{
return ((Number) value).longValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
// 支持科学计数法
return new BigDecimal(valueStr.trim()).longValue();
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为long<br>
* 如果给定的值为<code>null</code>，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Long toLong(Object value)
{
return toLong(value, null);
}
/**
* 转换为double<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Double toDouble(Object value, Double defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Double)
{
return (Double) value;
}
if (value instanceof Number)
{
return ((Number) value).doubleValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
// 支持科学计数法
return new BigDecimal(valueStr.trim()).doubleValue();
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为double<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Double toDouble(Object value)
{
return toDouble(value, null);
}
/**
* 转换为Float<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Float toFloat(Object value, Float defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Float)
{
return (Float) value;
}
if (value instanceof Number)
{
return ((Number) value).floatValue();
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Float.parseFloat(valueStr.trim());
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为Float<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Float toFloat(Object value)
{
return toFloat(value, null);
}
/**
* 转换为boolean<br>
* String支持的值为：true、false、yes、ok、no，1,0 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static Boolean toBool(Object value, Boolean defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof Boolean)
{
return (Boolean) value;
}
String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
valueStr = valueStr.trim().toLowerCase();
switch (valueStr)
{
case "true":
return true;
case "false":
return false;
case "yes":
return true;
case "ok":
return true;
case "no":
return false;
case "1":
return true;
case "0":
return false;
default:
return defaultValue;
}
}
/**
* 转换为boolean<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static Boolean toBool(Object value)
{
return toBool(value, null);
}
/**
* 转换为Enum对象<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
*
* @param clazz Enum的Class
* @param value 值
* @param defaultValue 默认值
* @return Enum
*/
public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value, E defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (clazz.isAssignableFrom(value.getClass()))
{
@SuppressWarnings("unchecked")
E myE = (E) value;
return myE;
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return Enum.valueOf(clazz, valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为Enum对象<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
*
* @param clazz Enum的Class
* @param value 值
* @return Enum
*/
public static <E extends Enum<E>> E toEnum(Class<E> clazz, Object value)
{
return toEnum(clazz, value, null);
}
/**
* 转换为BigInteger<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static BigInteger toBigInteger(Object value, BigInteger defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof BigInteger)
{
return (BigInteger) value;
}
if (value instanceof Long)
{
return BigInteger.valueOf((Long) value);
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return new BigInteger(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为BigInteger<br>
* 如果给定的值为空，或者转换失败，返回默认值<code>null</code><br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static BigInteger toBigInteger(Object value)
{
return toBigInteger(value, null);
}
/**
* 转换为BigDecimal<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @param defaultValue 转换错误时的默认值
* @return 结果
*/
public static BigDecimal toBigDecimal(Object value, BigDecimal defaultValue)
{
if (value == null)
{
return defaultValue;
}
if (value instanceof BigDecimal)
{
return (BigDecimal) value;
}
if (value instanceof Long)
{
return new BigDecimal((Long) value);
}
if (value instanceof Double)
{
return new BigDecimal((Double) value);
}
if (value instanceof Integer)
{
return new BigDecimal((Integer) value);
}
final String valueStr = toStr(value, null);
if (StringUtils.isEmpty(valueStr))
{
return defaultValue;
}
try
{
return new BigDecimal(valueStr);
}
catch (Exception e)
{
return defaultValue;
}
}
/**
* 转换为BigDecimal<br>
* 如果给定的值为空，或者转换失败，返回默认值<br>
* 转换失败不会报错
*
* @param value 被转换的值
* @return 结果
*/
public static BigDecimal toBigDecimal(Object value)
{
return toBigDecimal(value, null);
}
/**
* 将对象转为字符串<br>
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
*
* @param obj 对象
* @return 字符串
*/
public static String utf8Str(Object obj)
{
return str(obj, CharsetKit.CHARSET_UTF_8);
}
/**
* 将对象转为字符串<br>
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
*
* @param obj 对象
* @param charsetName 字符集
* @return 字符串
*/
public static String str(Object obj, String charsetName)
{
return str(obj, Charset.forName(charsetName));
}
/**
* 将对象转为字符串<br>
* 1、Byte数组和ByteBuffer会被转换为对应字符串的数组 2、对象数组会调用Arrays.toString方法
*
* @param obj 对象
* @param charset 字符集
* @return 字符串
*/
public static String str(Object obj, Charset charset)
{
if (null == obj)
{
return null;
}
if (obj instanceof String)
{
return (String) obj;
}
else if (obj instanceof byte[])
{
return str((byte[]) obj, charset);
}
else if (obj instanceof Byte[])
{
byte[] bytes = ArrayUtils.toPrimitive((Byte[]) obj);
return str(bytes, charset);
}
else if (obj instanceof ByteBuffer)
{
return str((ByteBuffer) obj, charset);
}
return obj.toString();
}
/**
* 将byte数组转为字符串
*
* @param bytes byte数组
* @param charset 字符集
* @return 字符串
*/
public static String str(byte[] bytes, String charset)
{
return str(bytes, StringUtils.isEmpty(charset) ? Charset.defaultCharset() : Charset.forName(charset));
}
/**
* 解码字节码
*
* @param data 字符串
* @param charset 字符集，如果此字段为空，则解码的结果取决于平台
* @return 解码后的字符串
*/
public static String str(byte[] data, Charset charset)
{
if (data == null)
{
return null;
}
if (null == charset)
{
return new String(data);
}
return new String(data, charset);
}
/**
* 将编码的byteBuffer数据转换为字符串
*
* @param data 数据
* @param charset 字符集，如果为空使用当前系统字符集
* @return 字符串
*/
public static String str(ByteBuffer data, String charset)
{
if (data == null)
{
return null;
}
return str(data, Charset.forName(charset));
}
/**
* 将编码的byteBuffer数据转换为字符串
*
* @param data 数据
* @param charset 字符集，如果为空使用当前系统字符集
* @return 字符串
*/
public static String str(ByteBuffer data, Charset charset)
{
if (null == charset)
{
charset = Charset.defaultCharset();
}
return charset.decode(data).toString();
}
// ----------------------------------------------------------------------- 全角半角转换
/**
* 半角转全角
*
* @param input String.
* @return 全角字符串.
*/
public static String toSBC(String input)
{
return toSBC(input, null);
}
/**
* 半角转全角
*
* @param input String
* @param notConvertSet 不替换的字符集合
* @return 全角字符串.
*/
public static String toSBC(String input, Set<Character> notConvertSet)
{
char c[] = input.toCharArray();
for (int i = 0; i < c.length; i++)
{
if (null != notConvertSet && notConvertSet.contains(c[i]))
{
// 跳过不替换的字符
continue;
}
if (c[i] == ' ')
{
c[i] = '\u3000';
}
else if (c[i] < '\177')
{
c[i] = (char) (c[i] + 65248);
}
}
return new String(c);
}
/**
* 全角转半角
*
* @param input String.
* @return 半角字符串
*/
public static String toDBC(String input)
{
return toDBC(input, null);
}
/**
* 替换全角为半角
*
* @param text 文本
* @param notConvertSet 不替换的字符集合
* @return 替换后的字符
*/
public static String toDBC(String text, Set<Character> notConvertSet)
{
char c[] = text.toCharArray();
for (int i = 0; i < c.length; i++)
{
if (null != notConvertSet && notConvertSet.contains(c[i]))
{
// 跳过不替换的字符
continue;
}
if (c[i] == '\u3000')
{
c[i] = ' ';
}
else if (c[i] > '\uFF00' && c[i] < '\uFF5F')
{
c[i] = (char) (c[i] - 65248);
}
}
String returnString = new String(c);
return returnString;
}
/**
* 数字金额大写转换 先写个完整的然后将如零拾替换成零
*
* @param n 数字
* @return 中文大写数字
*/
public static String digitUppercase(double n)
{
String[] fraction = { "角", "分" };
String[] digit = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
String[][] unit = { { "元", "万", "亿" }, { "", "拾", "佰", "仟" } };
String head = n < 0 ? "负" : "";
n = Math.abs(n);
String s = "";
for (int i = 0; i < fraction.length; i++)
{
s += (digit[(int) (Math.floor(n * 10 * Math.pow(10, i)) % 10)] + fraction[i]).replaceAll("(零.)+", "");
}
if (s.length() < 1)
{
s = "整";
}
int integerPart = (int) Math.floor(n);
for (int i = 0; i < unit[0].length && integerPart > 0; i++)
{
String p = "";
for (int j = 0; j < unit[1].length && n > 0; j++)
{
p = digit[integerPart % 10] + unit[1][j] + p;
integerPart = integerPart / 10;
}
s = p.replaceAll("(零.)*零$", "").replaceAll("^$", "零") + unit[0][i] + s;
}
return head + s.replaceAll("(零.)*零元", "元").replaceFirst("(零.)+", "").replaceAll("(零.)+", "零").replaceAll("^整$", "零元整");
}
}
government-manager/src/main/java/com/mortals/xhx/common/utils/FreeMarkerUtils.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.utils;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.util.DateUtils;
import com.mortals.xhx.base.system.gentable.model.GentableColumnEntity;
import com.mortals.xhx.base.system.gentable.model.GentableEntity;
import com.mortals.xhx.common.code.YesNoEnum;
import com.mortals.xhx.common.key.GenConstants;
import freemarker.template.Configuration;
import freemarker.template.Template;
import freemarker.template.TemplateException;
import freemarker.template.TemplateExceptionHandler;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
public class FreeMarkerUtils {
/**
* 项目空间路径
*/
private static final String PROJECT_PATH = "main/java";
/**
* mybatis空间路径
*/
private static final String MYBATIS_PATH = "main/resources/sqlmap";
/**
* 默认上级菜单，系统工具
*/
private static final String DEFAULT_PARENT_MENU_ID = "3";
public static Configuration cfg = null;
/**
* 初始化freeMaker方法
*/
public static void initFreeMarker() {
//初始化模板引擎
cfg = new Configuration(Configuration.VERSION_2_3_29);
//指定模板文件存放的地方
cfg.setClassLoaderForTemplateLoading(FreeMarkerUtils.class.getClassLoader(), "/template/java");
cfg.setClassLoaderForTemplateLoading(FreeMarkerUtils.class.getClassLoader(), "/template/sql");
cfg.setClassLoaderForTemplateLoading(FreeMarkerUtils.class.getClassLoader(), "/template/vue");
cfg.setClassLoaderForTemplateLoading(FreeMarkerUtils.class.getClassLoader(), "/template/xml");
//设置字符编码集
cfg.setDefaultEncoding("UTF-8");
//设置异常的处理方式
cfg.setTemplateExceptionHandler(TemplateExceptionHandler.RETHROW_HANDLER);
//设置输出时间格式
cfg.setDateFormat("yyyy-MM-dd HH:mm:ss");
}
// 获取模板对象
public static Template getTemplate(String templateName) {
try {
return cfg.getTemplate(templateName);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
/**
* 设置模板变量信息
*
* @return 模板列表
*/
public static Map prepareSetFreeMarkerData(GentableEntity genTable) {
Map data = new HashMap();
String moduleName = genTable.getModuleName();
String businessName = genTable.getBusinessName();
String packageName = genTable.getPackageName();
String tplCategory = genTable.getTplCategory();
String functionName = genTable.getFunctionName();
data.put("tplCategory", genTable.getTplCategory());
data.put("tableName", genTable.getTableName());
data.put("functionName", StringUtils.isNotEmpty(functionName) ? functionName : "【请填写功能名称】");
data.put("ClassName", genTable.getClassName());
data.put("className", StringUtils.uncapitalize(genTable.getClassName()));
data.put("moduleName", genTable.getModuleName());
data.put("BusinessName", StringUtils.capitalize(genTable.getBusinessName()));
data.put("businessName", genTable.getBusinessName());
data.put("basePackage", getPackagePrefix(packageName));
data.put("packageName", packageName);
data.put("author", genTable.getFunctionAuthor());
data.put("datetime", DateUtils.getCurrStrDate());
data.put("pkColumn", genTable.getPkColumn());
data.put("importList", getImportList(genTable));
data.put("columns", genTable.getColumns());
if (GenConstants.TPL_TREE.equals(tplCategory)) {
setTreeFreeMarkerData(data, genTable);
}
if (GenConstants.TPL_SUB.equals(tplCategory)) {
setSubFreeMarkerData(data, genTable);
}
return data;
}
public static void setTreeFreeMarkerData(Map data, GentableEntity genTable) {
String options = genTable.getOptions();
JSONObject paramsObj = JSONObject.parseObject(options);
String treeCode = getTreecode(paramsObj);
String treeParentCode = getTreeParentCode(paramsObj);
String treeName = getTreeName(paramsObj);
data.put("treeCode", treeCode);
data.put("treeParentCode", treeParentCode);
data.put("treeName", treeName);
data.put("expandColumn", getExpandColumn(genTable));
if (paramsObj.containsKey(GenConstants.TREE_PARENT_CODE)) {
data.put("tree_parent_code", paramsObj.getString(GenConstants.TREE_PARENT_CODE));
}
if (paramsObj.containsKey(GenConstants.TREE_NAME)) {
data.put("tree_name", paramsObj.getString(GenConstants.TREE_NAME));
}
}
/**
* 获取树编码
*
* @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 getTreeName(JSONObject paramsObj) {
if (paramsObj.containsKey(GenConstants.TREE_NAME)) {
return StringUtils.toCamelCase(paramsObj.getString(GenConstants.TREE_NAME));
}
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 genTable 业务表对象
* @return 展开按钮列序号
*/
public static int getExpandColumn(GentableEntity genTable) {
String options = genTable.getOptions();
JSONObject paramsObj = JSONObject.parseObject(options);
String treeName = paramsObj.getString(GenConstants.TREE_NAME);
int num = 0;
for (GentableColumnEntity column : genTable.getColumns()) {
if (column.getIsList() == YesNoEnum.YES.getValue()) {
num++;
String columnName = column.getColumnName();
if (columnName.equals(treeName)) {
break;
}
}
}
return num;
}
public static void setSubFreeMarkerData(Map data, GentableEntity genTable) {
GentableEntity subTable = genTable.getSubTable();
String subTableName = genTable.getSubTableName();
String subTableFkName = genTable.getSubTableFkName();
String subClassName = genTable.getSubTable().getClassName();
String subTableFkClassName = StringUtils.convertToCamelCase(subTableFkName);
data.put("subTable", subTable);
data.put("subTableName", subTableName);
data.put("subTableFkName", subTableFkName);
data.put("subTableFkClassName", subTableFkClassName);
data.put("subTableFkclassName", StringUtils.uncapitalize(subTableFkClassName));
data.put("subClassName", subClassName);
data.put("subclassName", StringUtils.uncapitalize(subClassName));
data.put("subImportList", getImportList(genTable.getSubTable()));
}
/**
* 获取包前缀
*
* @param packageName 包名称
* @return 包前缀名称
*/
public static String getPackagePrefix(String packageName) {
int lastIndex = packageName.lastIndexOf(".");
String basePackage = StringUtils.substring(packageName, 0, lastIndex);
return basePackage;
}
/**
* 根据列类型获取导入包
*
* @param genTable 业务表对象
* @return 返回需要导入的包列表
*/
public static HashSet<String> getImportList(GentableEntity genTable) {
List<GentableColumnEntity> columns = genTable.getColumns();
GentableEntity subGenTable = genTable.getSubTable();
HashSet<String> importList = new HashSet<>();
if (StringUtils.isNotNull(subGenTable)) {
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;
}
/**
* 获取文件名
*/
public static String getFileName(String template, GentableEntity genTable) {
// 文件名称
String fileName = "";
// 包路径
String packageName = genTable.getPackageName();
// 模块名
String moduleName = genTable.getModuleName();
// 大写类名
String className = genTable.getClassName();
// 业务名称
String businessName = StringUtils.replace(genTable.getBusinessName(), ".", "/");
// main/java+ packageName(com.mortals.xhx.modules)
String javaPath = PROJECT_PATH + "/" + StringUtils.replace(packageName, ".", "/");
String mybatisPath = MYBATIS_PATH + "/" + moduleName;
String vuePath = "vue";
//实体类输出路径
if (template.contains("entity.ftl")) {
fileName = StringUtils.format("{}/{}/model/{}Entity.java", javaPath, businessName, className);
}
//todo
// if (template.contains("sub-domain.java.vm") && StringUtils.equals(GenConstants.TPL_SUB, genTable.getTplCategory())) {
// fileName = StringUtils.format("{}/domain/{}.java", javaPath, genTable.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;
}
/**
* 提供模板文件，输出到控制台
*
* @param templateName 模板对象
* @param dataModel 数据模型
*/
public static void printConsole(String templateName, Map dataModel) {
Template template = getTemplate(templateName);
try {
template.process(dataModel, new PrintWriter(System.out));
} catch (TemplateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 提供模板文件名称，输出到文件中
*
* @param templateName 模板对象
* @param dataModel 数据模型
* @param destFile 目标文件地址
*/
public static String printFile(String templateName, Map dataModel, String destFile) {
System.out.println(destFile);
Template template = getTemplate(templateName);
try {
template.process(dataModel, new FileWriter(new File(destFile)));
} catch (TemplateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return destFile;
}
public static String printFile(String templateName, List<Map> dataModel, String destFile) {
Template template = getTemplate(templateName);
try {
template.process(dataModel, new FileWriter(new File(destFile)));
} catch (TemplateException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return destFile;
}
public static void main(String[] args) {
FreeMarkerUtils.initFreeMarker();
Template template = FreeMarkerUtils.getTemplate("sqlMap.ftl");
System.out.println(template.getName());
GentableEntity gentableEntity = new GentableEntity();
gentableEntity.setPackageName("com.mortals.xhx.module");
gentableEntity.setBusinessName("matter");
gentableEntity.setClassName("MortalsXhxMatter");
gentableEntity.setModuleName("moduleName");
String fileName = FreeMarkerUtils.getFileName("entity.ftl", gentableEntity);
System.out.println("fileName:" + fileName);
}
}
government-manager/src/main/java/com/mortals/xhx/common/utils/GenUtils.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.utils;
import com.mortals.xhx.base.framework.config.GenConfig;
import com.mortals.xhx.base.system.gentable.model.GentableColumnEntity;
import com.mortals.xhx.base.system.gentable.model.GentableEntity;
import com.mortals.xhx.common.code.HtmlTypeEnum;
import com.mortals.xhx.common.code.YesNoEnum;
import com.mortals.xhx.common.key.GenConstants;
import org.apache.commons.lang3.RegExUtils;
import java.util.Arrays;
import java.util.Date;
/**
* 代码生成器 工具类
*
* @author: zxfei
* @date: 2021/9/28 15:35
*/
public class GenUtils {
/**
* 初始化表信息
*/
public static void initTable(GentableEntity genTable, String operName) {
genTable.setClassName(convertClassName(genTable.getTableName()));
genTable.setPackageName(GenConfig.getPackageName());
genTable.setModuleName(getModuleName(GenConfig.getPackageName()));
genTable.setBusinessName(getBusinessName(genTable.getTableName()));
genTable.setFunctionName(replaceText(genTable.getTableComment()));
genTable.setFunctionAuthor(GenConfig.getAuthor());
genTable.setCreateUser(operName);
genTable.setCreateTime(new Date());
}
/**
* 初始化列属性字段
*/
public static void initColumnField(GentableColumnEntity column, GentableEntity table) {
String dataType = getDbType(column.getColumnType());
String columnName = column.getColumnName();
column.setTableId(table.getId());
column.setCreateUser(table.getCreateUser());
column.setCreateTime(new Date());
// 设置java字段名
column.setJavaField(StringUtils.toCamelCase(columnName));
// 设置默认类型
column.setJavaType(GenConstants.TYPE_STRING);
if (arraysContains(GenConstants.COLUMNTYPE_STR, dataType) || arraysContains(GenConstants.COLUMNTYPE_TEXT, dataType)) {
// 字符串长度超过500设置为文本域
Integer columnLength = getColumnLength(column.getColumnType());
Integer htmlType = columnLength >= 500 || arraysContains(GenConstants.COLUMNTYPE_TEXT, dataType) ? HtmlTypeEnum.HTML_TEXTAREA.getValue() : HtmlTypeEnum.HTML_INPUT.getValue();
column.setHtmlType(htmlType);
} else if (arraysContains(GenConstants.COLUMNTYPE_TIME, dataType)) {
column.setJavaType(GenConstants.TYPE_DATE);
column.setHtmlType(HtmlTypeEnum.HTML_DATETIME.getValue());
} else if (arraysContains(GenConstants.COLUMNTYPE_NUMBER, dataType)) {
column.setHtmlType(HtmlTypeEnum.HTML_INPUT.getValue());
// 如果是浮点型 统一用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.COLUMNNAME_NOT_EDIT, columnName) && column.getIsPrimaryKey()!= YesNoEnum.YES.getValue()) {
column.setIsEdit(GenConstants.REQUIRE);
}
// 列表字段
if (!arraysContains(GenConstants.COLUMNNAME_NOT_LIST, columnName) && column.getIsPrimaryKey()!= YesNoEnum.YES.getValue()) {
column.setIsList(GenConstants.REQUIRE);
}
// 查询字段
if (!arraysContains(GenConstants.COLUMNNAME_NOT_QUERY, columnName) && column.getIsPrimaryKey()!= YesNoEnum.YES.getValue()) {
column.setIsQuery(GenConstants.REQUIRE);
}
// 状态字段设置单选框
if (StringUtils.endsWithIgnoreCase(columnName, "status")) {
column.setHtmlType(HtmlTypeEnum.HTML_RADIO.getValue());
}
// 类型&性别字段设置下拉框
else if (StringUtils.endsWithIgnoreCase(columnName, "type")
|| StringUtils.endsWithIgnoreCase(columnName, "sex")) {
column.setHtmlType(HtmlTypeEnum.HTML_SELECT.getValue());
}
// 图片字段设置图片上传控件
else if (StringUtils.endsWithIgnoreCase(columnName, "image")) {
column.setHtmlType(HtmlTypeEnum.HTML_IMAGE_UPLOAD.getValue());
}
// 文件字段设置文件上传控件
else if (StringUtils.endsWithIgnoreCase(columnName, "file")) {
column.setHtmlType(HtmlTypeEnum.HTML_FILE_UPLOAD.getValue());
}
// 内容字段设置富文本控件
else if (StringUtils.endsWithIgnoreCase(columnName, "content")) {
column.setHtmlType(HtmlTypeEnum.HTML_EDITOR.getValue());
}
}
/**
* 校验数组是否包含指定值
*
* @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();
String moduleName = StringUtils.substring(packageName, lastIndex + 1, nameLength);
return moduleName;
}
/**
* 获取业务名
*
* @param tableName 表名
* @return 业务名
*/
public static String getBusinessName(String tableName) {
int lastIndex = tableName.lastIndexOf("_");
int nameLength = tableName.length();
String businessName = StringUtils.substring(tableName, lastIndex + 1, nameLength);
return businessName;
}
/**
* 表名转换成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;
}
}
}
government-manager/src/main/java/com/mortals/xhx/common/utils/StrFormatter.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.utils;
/**
* 字符串格式化
*
* @author: zxfei
* @date: 2021/9/28 15:52
*/
public class StrFormatter
{
public static final String EMPTY_JSON = "{}";
public static final char C_BACKSLASH = '\\';
public static final char C_DELIM_START = '{';
public static final char C_DELIM_END = '}';
/**
* 格式化字符串<br>
* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
* 例：<br>
* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
*
* @param strPattern 字符串模板
* @param argArray 参数列表
* @return 结果
*/
public static String format(final String strPattern, final Object... argArray)
{
if (StringUtils.isEmpty(strPattern) || StringUtils.isEmpty(argArray))
{
return strPattern;
}
final int strPatternLength = strPattern.length();
// 初始化定义好的长度以获得更好的性能
StringBuilder sbuf = new StringBuilder(strPatternLength + 50);
int handledPosition = 0;
int delimIndex;// 占位符所在位置
for (int argIndex = 0; argIndex < argArray.length; argIndex++)
{
delimIndex = strPattern.indexOf(EMPTY_JSON, handledPosition);
if (delimIndex == -1)
{
if (handledPosition == 0)
{
return strPattern;
}
else
{ // 字符串模板剩余部分不再包含占位符，加入剩余部分后返回结果
sbuf.append(strPattern, handledPosition, strPatternLength);
return sbuf.toString();
}
}
else
{
if (delimIndex > 0 && strPattern.charAt(delimIndex - 1) == C_BACKSLASH)
{
if (delimIndex > 1 && strPattern.charAt(delimIndex - 2) == C_BACKSLASH)
{
// 转义符之前还有一个转义符，占位符依旧有效
sbuf.append(strPattern, handledPosition, delimIndex - 1);
sbuf.append(Convert.utf8Str(argArray[argIndex]));
handledPosition = delimIndex + 2;
}
else
{
// 占位符被转义
argIndex--;
sbuf.append(strPattern, handledPosition, delimIndex - 1);
sbuf.append(C_DELIM_START);
handledPosition = delimIndex + 1;
}
}
else
{
// 正常占位符
sbuf.append(strPattern, handledPosition, delimIndex);
sbuf.append(Convert.utf8Str(argArray[argIndex]));
handledPosition = delimIndex + 2;
}
}
}
// 加入最后一个占位符后所有的字符
sbuf.append(strPattern, handledPosition, strPattern.length());
return sbuf.toString();
}
}
government-manager/src/main/java/com/mortals/xhx/common/utils/StringUtils.java 0 → 100644
View file @ be4fe6cf
package com.mortals.xhx.common.utils;
import java.util.*;
/**
* 字符串工具类
*
* @author: zxfei
* @date: 2021/9/28 15:51
*/
public class StringUtils extends org.apache.commons.lang3.StringUtils
{
/** 空字符串 */
private static final String NULLSTR = "";
/** 下划线 */
private static final char SEPARATOR = '_';
/**
* 获取参数不为空值
*
* @param value defaultValue 要判断的value
* @return value 返回值
*/
public static <T> T nvl(T value, T defaultValue)
{
return value != null ? value : defaultValue;
}
/**
* * 判断一个Collection是否为空， 包含List，Set，Queue
*
* @param coll 要判断的Collection
* @return true：为空 false：非空
*/
public static boolean isEmpty(Collection<?> coll)
{
return isNull(coll) || coll.isEmpty();
}
/**
* * 判断一个Collection是否非空，包含List，Set，Queue
*
* @param coll 要判断的Collection
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Collection<?> coll)
{
return !isEmpty(coll);
}
/**
* * 判断一个对象数组是否为空
*
* @param objects 要判断的对象数组
** @return true：为空 false：非空
*/
public static boolean isEmpty(Object[] objects)
{
return isNull(objects) || (objects.length == 0);
}
/**
* * 判断一个对象数组是否非空
*
* @param objects 要判断的对象数组
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Object[] objects)
{
return !isEmpty(objects);
}
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true：为空 false：非空
*/
public static boolean isEmpty(Map<?, ?> map)
{
return isNull(map) || map.isEmpty();
}
/**
* * 判断一个Map是否为空
*
* @param map 要判断的Map
* @return true：非空 false：空
*/
public static boolean isNotEmpty(Map<?, ?> map)
{
return !isEmpty(map);
}
/**
* * 判断一个字符串是否为空串
*
* @param str String
* @return true：为空 false：非空
*/
public static boolean isEmpty(String str)
{
return isNull(str) || NULLSTR.equals(str.trim());
}
/**
* * 判断一个字符串是否为非空串
*
* @param str String
* @return true：非空串 false：空串
*/
public static boolean isNotEmpty(String str)
{
return !isEmpty(str);
}
/**
* * 判断一个对象是否为空
*
* @param object Object
* @return true：为空 false：非空
*/
public static boolean isNull(Object object)
{
return object == null;
}
/**
* * 判断一个对象是否非空
*
* @param object Object
* @return true：非空 false：空
*/
public static boolean isNotNull(Object object)
{
return !isNull(object);
}
/**
* * 判断一个对象是否是数组类型（Java基本型别的数组）
*
* @param object 对象
* @return true：是数组 false：不是数组
*/
public static boolean isArray(Object object)
{
return isNotNull(object) && object.getClass().isArray();
}
/**
* 去空格
*/
public static String trim(String str)
{
return (str == null ? "" : str.trim());
}
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @return 结果
*/
public static String substring(final String str, int start)
{
if (str == null)
{
return NULLSTR;
}
if (start < 0)
{
start = str.length() + start;
}
if (start < 0)
{
start = 0;
}
if (start > str.length())
{
return NULLSTR;
}
return str.substring(start);
}
/**
* 截取字符串
*
* @param str 字符串
* @param start 开始
* @param end 结束
* @return 结果
*/
public static String substring(final String str, int start, int end)
{
if (str == null)
{
return NULLSTR;
}
if (end < 0)
{
end = str.length() + end;
}
if (start < 0)
{
start = str.length() + start;
}
if (end > str.length())
{
end = str.length();
}
if (start > end)
{
return NULLSTR;
}
if (start < 0)
{
start = 0;
}
if (end < 0)
{
end = 0;
}
return str.substring(start, end);
}
/**
* 格式化文本, {} 表示占位符<br>
* 此方法只是简单将占位符 {} 按照顺序替换为参数<br>
* 如果想输出 {} 使用 \\转义 { 即可，如果想输出 {} 之前的 \ 使用双转义符 \\\\ 即可<br>
* 例：<br>
* 通常使用：format("this is {} for {}", "a", "b") -> this is a for b<br>
* 转义{}： format("this is \\{} for {}", "a", "b") -> this is \{} for a<br>
* 转义\： format("this is \\\\{} for {}", "a", "b") -> this is \a for b<br>
*
* @param template 文本模板，被替换的部分用 {} 表示
* @param params 参数值
* @return 格式化后的文本
*/
public static String format(String template, Object... params)
{
if (isEmpty(params) || isEmpty(template))
{
return template;
}
return StrFormatter.format(template, params);
}
/**
* 字符串转set
*
* @param str 字符串
* @param sep 分隔符
* @return set集合
*/
public static final Set<String> str2Set(String str, String sep)
{
return new HashSet<String>(str2List(str, sep, true, false));
}
/**
* 字符串转list
*
* @param str 字符串
* @param sep 分隔符
* @param filterBlank 过滤纯空白
* @param trim 去掉首尾空白
* @return list集合
*/
public static final List<String> str2List(String str, String sep, boolean filterBlank, boolean trim)
{
List<String> list = new ArrayList<String>();
if (StringUtils.isEmpty(str))
{
return list;
}
// 过滤空白字符串
if (filterBlank && StringUtils.isBlank(str))
{
return list;
}
String[] split = str.split(sep);
for (String string : split)
{
if (filterBlank && StringUtils.isBlank(string))
{
continue;
}
if (trim)
{
string = string.trim();
}
list.add(string);
}
return list;
}
/**
* 下划线转驼峰命名
*/
public static String toUnderScoreCase(String str)
{
if (str == null)
{
return null;
}
StringBuilder sb = new StringBuilder();
// 前置字符是否大写
boolean preCharIsUpperCase = true;
// 当前字符是否大写
boolean curreCharIsUpperCase = true;
// 下一字符是否大写
boolean nexteCharIsUpperCase = true;
for (int i = 0; i < str.length(); i++)
{
char c = str.charAt(i);
if (i > 0)
{
preCharIsUpperCase = Character.isUpperCase(str.charAt(i - 1));
}
else
{
preCharIsUpperCase = false;
}
curreCharIsUpperCase = Character.isUpperCase(c);
if (i < (str.length() - 1))
{
nexteCharIsUpperCase = Character.isUpperCase(str.charAt(i + 1));
}
if (preCharIsUpperCase && curreCharIsUpperCase && !nexteCharIsUpperCase)
{
sb.append(SEPARATOR);
}
else if ((i != 0 && !preCharIsUpperCase) && curreCharIsUpperCase)
{
sb.append(SEPARATOR);
}
sb.append(Character.toLowerCase(c));
}
return sb.toString();
}
/**
* 是否包含字符串
*
* @param str 验证字符串
* @param strs 字符串组
* @return 包含返回true
*/
public static boolean inStringIgnoreCase(String str, String... strs)
{
if (str != null && strs != null)
{
for (String s : strs)
{
if (str.equalsIgnoreCase(trim(s)))
{
return true;
}
}
}
return false;
}
/**
* 将下划线大写方式命名的字符串转换为驼峰式。如果转换前的下划线大写方式命名的字符串为空，则返回空字符串。 例如：HELLO_WORLD->HelloWorld
*
* @param name 转换前的下划线大写方式命名的字符串
* @return 转换后的驼峰式命名的字符串
*/
public static String convertToCamelCase(String name)
{
StringBuilder result = new StringBuilder();
// 快速检查
if (name == null || name.isEmpty())
{
// 没必要转换
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();
}
/**
* 驼峰式命名法 例如：user_name->userName
*/
public static String toCamelCase(String s)
{
if (s == null)
{
return null;
}
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 == SEPARATOR)
{
upperCase = true;
}
else if (upperCase)
{
sb.append(Character.toUpperCase(c));
upperCase = false;
}
else
{
sb.append(c);
}
}
return sb.toString();
}
@SuppressWarnings("unchecked")
public static <T> T cast(Object obj)
{
return (T) obj;
}
}
\ No newline at end of file
government-manager/src/main/resources/generator.yml 0 → 100644
View file @ be4fe6cf
# 代码生成
gen:
# 作者
author: zxfei
# 默认生成包路径 module 需改成自己的模块名称 如 system monitor tool
packageName: com.mortals.xhx.module
# 自动去除表前缀，默认是false
autoRemovePre: false
# 表前缀（生成类名不会包含表前缀，多个用逗号分隔）
tablePrefix: sys_,mortals_xhx_,mortals_iot_
\ No newline at end of file
government-manager/src/main/resources/sqlmap/base/system/gentable.xml 0 → 100644
View file @ be4fe6cf
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.base.system.gentable.dao.ibatis.GentableDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="GentableEntity" id="GentableEntity-Map">
<result property="id" column="id" />
<result property="tableName" column="tableName" />
<result property="tableComment" column="tableComment" />
<result property="subTableName" column="subTableName" />
<result property="subTableFkName" column="subTableFkName" />
<result property="className" column="className" />
<result property="tplCategory" column="tplCategory" />
<result property="packageName" column="packageName" />
<result property="moduleName" column="moduleName" />
<result property="businessName" column="businessName" />
<result property="functionName" column="functionName" />
<result property="functionAuthor" column="functionAuthor" />
<result property="cacheServiceType" column="cacheServiceType" />
<result property="genType" column="genType" />
<result property="dividedTableType" column="dividedTableType" />
<result property="genPath" column="genPath" />
<result property="options" column="options" />
<result property="remark" column="remark" />
<result property="updateTime" column="updateTime" />
<result property="updateUser" column="updateUser" />
<result property="createTime" column="createTime" />
<result property="createUser" column="createUser" />
<collection property="columns" javaType="java.util.List" resultMap="GentableColumnEntity-Map" />
</resultMap>
<resultMap type="GentableColumnEntity" id="GentableColumnEntity-Map">
<result property="id" column="id" />
<result property="tableId" column="tableId" />
<result property="columnName" column="columnName" />
<result property="columnComment" column="columnComment" />
<result property="columnType" column="columnType" />
<result property="javaType" column="javaType" />
<result property="javaField" column="javaField" />
<result property="isPrimaryKey" column="isPrimaryKey" />
<result property="isIncrement" column="isIncrement" />
<result property="isRequired" column="isRequired" />
<result property="isInsert" column="isInsert" />
<result property="isEdit" column="isEdit" />
<result property="isList" column="isList" />
<result property="isQuery" column="isQuery" />
<result property="htmlType" column="htmlType" />
<result property="sort" column="sort" />
<result property="updateTime" column="updateTime" />
<result property="updateUser" column="updateUser" />
<result property="createTime" column="createTime" />
<result property="createUser" column="createUser" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id as id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('tableName') or colPickMode == 1 and data.containsKey('tableName')))">
a.tableName as tableName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('tableComment') or colPickMode == 1 and data.containsKey('tableComment')))">
a.tableComment as tableComment,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('subTableName') or colPickMode == 1 and data.containsKey('subTableName')))">
a.subTableName as subTableName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('subTableFkName') or colPickMode == 1 and data.containsKey('subTableFkName')))">
a.subTableFkName as subTableFkName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('className') or colPickMode == 1 and data.containsKey('className')))">
a.className as className,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('tplCategory') or colPickMode == 1 and data.containsKey('tplCategory')))">
a.tplCategory as tplCategory,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('packageName') or colPickMode == 1 and data.containsKey('packageName')))">
a.packageName as packageName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('moduleName') or colPickMode == 1 and data.containsKey('moduleName')))">
a.moduleName as moduleName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('businessName') or colPickMode == 1 and data.containsKey('businessName')))">
a.businessName as businessName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('functionName') or colPickMode == 1 and data.containsKey('functionName')))">
a.functionName as functionName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('functionAuthor') or colPickMode == 1 and data.containsKey('functionAuthor')))">
a.functionAuthor as functionAuthor,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('cacheServiceType') or colPickMode == 1 and data.containsKey('cacheServiceType')))">
a.cacheServiceType as cacheServiceType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('genType') or colPickMode == 1 and data.containsKey('genType')))">
a.genType as genType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('dividedTableType') or colPickMode == 1 and data.containsKey('dividedTableType')))">
a.dividedTableType as dividedTableType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('genPath') or colPickMode == 1 and data.containsKey('genPath')))">
a.genPath as genPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('options') or colPickMode == 1 and data.containsKey('options')))">
a.options as options,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark as remark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime as updateTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUser') or colPickMode == 1 and data.containsKey('updateUser')))">
a.updateUser as updateUser,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime as createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUser') or colPickMode == 1 and data.containsKey('createUser')))">
a.createUser as createUser,
</if>
</trim>
</sql>
<!-- 新增 -->
<insert id="insert" parameterType="GentableEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_gentable
(tableName,tableComment,subTableName,subTableFkName,className,tplCategory,packageName,moduleName,businessName,functionName,functionAuthor,cacheServiceType,genType,dividedTableType,genPath,options,remark,updateTime,updateUser,createTime,createUser)
VALUES
(#{tableName},#{tableComment},#{subTableName},#{subTableFkName},#{className},#{tplCategory},#{packageName},#{moduleName},#{businessName},#{functionName},#{functionAuthor},#{cacheServiceType},#{genType},#{dividedTableType},#{genPath},#{options},#{remark},#{updateTime},#{updateUser},#{createTime},#{createUser})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_gentable
(tableName,tableComment,subTableName,subTableFkName,className,tplCategory,packageName,moduleName,businessName,functionName,functionAuthor,cacheServiceType,genType,dividedTableType,genPath,options,remark,updateTime,updateUser,createTime,createUser)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.tableName},#{item.tableComment},#{item.subTableName},#{item.subTableFkName},#{item.className},#{item.tplCategory},#{item.packageName},#{item.moduleName},#{item.businessName},#{item.functionName},#{item.functionAuthor},#{item.cacheServiceType},#{item.genType},#{item.dividedTableType},#{item.genPath},#{item.options},#{item.remark},#{item.updateTime},#{item.updateUser},#{item.createTime},#{item.createUser})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_gentable as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('tableName')) or (colPickMode==1 and !data.containsKey('tableName'))">
a.tableName=#{data.tableName},
</if>
<if test="(colPickMode==0 and data.containsKey('tableComment')) or (colPickMode==1 and !data.containsKey('tableComment'))">
a.tableComment=#{data.tableComment},
</if>
<if test="(colPickMode==0 and data.containsKey('subTableName')) or (colPickMode==1 and !data.containsKey('subTableName'))">
a.subTableName=#{data.subTableName},
</if>
<if test="(colPickMode==0 and data.containsKey('subTableFkName')) or (colPickMode==1 and !data.containsKey('subTableFkName'))">
a.subTableFkName=#{data.subTableFkName},
</if>
<if test="(colPickMode==0 and data.containsKey('className')) or (colPickMode==1 and !data.containsKey('className'))">
a.className=#{data.className},
</if>
<if test="(colPickMode==0 and data.containsKey('tplCategory')) or (colPickMode==1 and !data.containsKey('tplCategory'))">
a.tplCategory=#{data.tplCategory},
</if>
<if test="(colPickMode==0 and data.containsKey('packageName')) or (colPickMode==1 and !data.containsKey('packageName'))">
a.packageName=#{data.packageName},
</if>
<if test="(colPickMode==0 and data.containsKey('moduleName')) or (colPickMode==1 and !data.containsKey('moduleName'))">
a.moduleName=#{data.moduleName},
</if>
<if test="(colPickMode==0 and data.containsKey('businessName')) or (colPickMode==1 and !data.containsKey('businessName'))">
a.businessName=#{data.businessName},
</if>
<if test="(colPickMode==0 and data.containsKey('functionName')) or (colPickMode==1 and !data.containsKey('functionName'))">
a.functionName=#{data.functionName},
</if>
<if test="(colPickMode==0 and data.containsKey('functionAuthor')) or (colPickMode==1 and !data.containsKey('functionAuthor'))">
a.functionAuthor=#{data.functionAuthor},
</if>
<if test="(colPickMode==0 and data.containsKey('cacheServiceType')) or (colPickMode==1 and !data.containsKey('cacheServiceType'))">
a.cacheServiceType=#{data.cacheServiceType},
</if>
<if test="(colPickMode==0 and data.containsKey('cacheServiceTypeIncrement')) or (colPickMode==1 and !data.containsKey('cacheServiceTypeIncrement'))">
a.cacheServiceType=ifnull(a.cacheServiceType,0) + #{data.cacheServiceTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('genType')) or (colPickMode==1 and !data.containsKey('genType'))">
a.genType=#{data.genType},
</if>
<if test="(colPickMode==0 and data.containsKey('genTypeIncrement')) or (colPickMode==1 and !data.containsKey('genTypeIncrement'))">
a.genType=ifnull(a.genType,0) + #{data.genTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('dividedTableType')) or (colPickMode==1 and !data.containsKey('dividedTableType'))">
a.dividedTableType=#{data.dividedTableType},
</if>
<if test="(colPickMode==0 and data.containsKey('dividedTableTypeIncrement')) or (colPickMode==1 and !data.containsKey('dividedTableTypeIncrement'))">
a.dividedTableType=ifnull(a.dividedTableType,0) + #{data.dividedTableTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('genPath')) or (colPickMode==1 and !data.containsKey('genPath'))">
a.genPath=#{data.genPath},
</if>
<if test="(colPickMode==0 and data.containsKey('options')) or (colPickMode==1 and !data.containsKey('options'))">
a.options=#{data.options},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUser')) or (colPickMode==1 and !data.containsKey('updateUser'))">
a.updateUser=#{data.updateUser},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUser')) or (colPickMode==1 and !data.containsKey('createUser'))">
a.createUser=#{data.createUser},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_gentable as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="tableName=(case" suffix="ELSE tableName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('tableName')) or (colPickMode==1 and !item.containsKey('tableName'))">
when a.id=#{item.id} then #{item.tableName}
</if>
</foreach>
</trim>
<trim prefix="tableComment=(case" suffix="ELSE tableComment end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('tableComment')) or (colPickMode==1 and !item.containsKey('tableComment'))">
when a.id=#{item.id} then #{item.tableComment}
</if>
</foreach>
</trim>
<trim prefix="subTableName=(case" suffix="ELSE subTableName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('subTableName')) or (colPickMode==1 and !item.containsKey('subTableName'))">
when a.id=#{item.id} then #{item.subTableName}
</if>
</foreach>
</trim>
<trim prefix="subTableFkName=(case" suffix="ELSE subTableFkName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('subTableFkName')) or (colPickMode==1 and !item.containsKey('subTableFkName'))">
when a.id=#{item.id} then #{item.subTableFkName}
</if>
</foreach>
</trim>
<trim prefix="className=(case" suffix="ELSE className end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('className')) or (colPickMode==1 and !item.containsKey('className'))">
when a.id=#{item.id} then #{item.className}
</if>
</foreach>
</trim>
<trim prefix="tplCategory=(case" suffix="ELSE tplCategory end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('tplCategory')) or (colPickMode==1 and !item.containsKey('tplCategory'))">
when a.id=#{item.id} then #{item.tplCategory}
</if>
</foreach>
</trim>
<trim prefix="packageName=(case" suffix="ELSE packageName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('packageName')) or (colPickMode==1 and !item.containsKey('packageName'))">
when a.id=#{item.id} then #{item.packageName}
</if>
</foreach>
</trim>
<trim prefix="moduleName=(case" suffix="ELSE moduleName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('moduleName')) or (colPickMode==1 and !item.containsKey('moduleName'))">
when a.id=#{item.id} then #{item.moduleName}
</if>
</foreach>
</trim>
<trim prefix="businessName=(case" suffix="ELSE businessName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('businessName')) or (colPickMode==1 and !item.containsKey('businessName'))">
when a.id=#{item.id} then #{item.businessName}
</if>
</foreach>
</trim>
<trim prefix="functionName=(case" suffix="ELSE functionName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('functionName')) or (colPickMode==1 and !item.containsKey('functionName'))">
when a.id=#{item.id} then #{item.functionName}
</if>
</foreach>
</trim>
<trim prefix="functionAuthor=(case" suffix="ELSE functionAuthor end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('functionAuthor')) or (colPickMode==1 and !item.containsKey('functionAuthor'))">
when a.id=#{item.id} then #{item.functionAuthor}
</if>
</foreach>
</trim>
<trim prefix="cacheServiceType=(case" suffix="ELSE cacheServiceType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('cacheServiceType')) or (colPickMode==1 and !item.containsKey('cacheServiceType'))">
when a.id=#{item.id} then #{item.cacheServiceType}
</when>
<when test="(colPickMode==0 and item.containsKey('cacheServiceTypeIncrement')) or (colPickMode==1 and !item.containsKey('cacheServiceTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.cacheServiceType,0) + #{item.cacheServiceTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="genType=(case" suffix="ELSE genType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('genType')) or (colPickMode==1 and !item.containsKey('genType'))">
when a.id=#{item.id} then #{item.genType}
</when>
<when test="(colPickMode==0 and item.containsKey('genTypeIncrement')) or (colPickMode==1 and !item.containsKey('genTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.genType,0) + #{item.genTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="dividedTableType=(case" suffix="ELSE dividedTableType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('dividedTableType')) or (colPickMode==1 and !item.containsKey('dividedTableType'))">
when a.id=#{item.id} then #{item.dividedTableType}
</when>
<when test="(colPickMode==0 and item.containsKey('dividedTableTypeIncrement')) or (colPickMode==1 and !item.containsKey('dividedTableTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.dividedTableType,0) + #{item.dividedTableTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="genPath=(case" suffix="ELSE genPath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('genPath')) or (colPickMode==1 and !item.containsKey('genPath'))">
when a.id=#{item.id} then #{item.genPath}
</if>
</foreach>
</trim>
<trim prefix="options=(case" suffix="ELSE options end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('options')) or (colPickMode==1 and !item.containsKey('options'))">
when a.id=#{item.id} then #{item.options}
</if>
</foreach>
</trim>
<trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark}
</if>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
<trim prefix="updateUser=(case" suffix="ELSE updateUser end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateUser')) or (colPickMode==1 and !item.containsKey('updateUser'))">
when a.id=#{item.id} then #{item.updateUser}
</if>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUser=(case" suffix="ELSE createUser end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createUser')) or (colPickMode==1 and !item.containsKey('createUser'))">
when a.id=#{item.id} then #{item.createUser}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="GentableEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_gentable as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_gentable as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_gentable where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_gentable as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="GentableEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_gentable as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_xhx_gentable as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('tableName')">
<if test="conditionParamRef.tableName != null and conditionParamRef.tableName != ''">
${_conditionType_} a.tableName like #{${_conditionParam_}.tableName}
</if>
<if test="conditionParamRef.tableName == null">
${_conditionType_} a.tableName is null
</if>
</if>
<if test="conditionParamRef.containsKey('tableNameList')">
${_conditionType_} a.tableName in
<foreach collection="conditionParamRef.tableNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('tableComment')">
<if test="conditionParamRef.tableComment != null and conditionParamRef.tableComment != ''">
${_conditionType_} a.tableComment like #{${_conditionParam_}.tableComment}
</if>
<if test="conditionParamRef.tableComment == null">
${_conditionType_} a.tableComment is null
</if>
</if>
<if test="conditionParamRef.containsKey('tableCommentList')">
${_conditionType_} a.tableComment in
<foreach collection="conditionParamRef.tableCommentList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('subTableName')">
<if test="conditionParamRef.subTableName != null and conditionParamRef.subTableName != ''">
${_conditionType_} a.subTableName like #{${_conditionParam_}.subTableName}
</if>
<if test="conditionParamRef.subTableName == null">
${_conditionType_} a.subTableName is null
</if>
</if>
<if test="conditionParamRef.containsKey('subTableNameList')">
${_conditionType_} a.subTableName in
<foreach collection="conditionParamRef.subTableNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('subTableFkName')">
<if test="conditionParamRef.subTableFkName != null and conditionParamRef.subTableFkName != ''">
${_conditionType_} a.subTableFkName like #{${_conditionParam_}.subTableFkName}
</if>
<if test="conditionParamRef.subTableFkName == null">
${_conditionType_} a.subTableFkName is null
</if>
</if>
<if test="conditionParamRef.containsKey('subTableFkNameList')">
${_conditionType_} a.subTableFkName in
<foreach collection="conditionParamRef.subTableFkNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('className')">
<if test="conditionParamRef.className != null and conditionParamRef.className != ''">
${_conditionType_} a.className like #{${_conditionParam_}.className}
</if>
<if test="conditionParamRef.className == null">
${_conditionType_} a.className is null
</if>
</if>
<if test="conditionParamRef.containsKey('classNameList')">
${_conditionType_} a.className in
<foreach collection="conditionParamRef.classNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('tplCategory')">
<if test="conditionParamRef.tplCategory != null and conditionParamRef.tplCategory != ''">
${_conditionType_} a.tplCategory like #{${_conditionParam_}.tplCategory}
</if>
<if test="conditionParamRef.tplCategory == null">
${_conditionType_} a.tplCategory is null
</if>
</if>
<if test="conditionParamRef.containsKey('tplCategoryList')">
${_conditionType_} a.tplCategory in
<foreach collection="conditionParamRef.tplCategoryList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('packageName')">
<if test="conditionParamRef.packageName != null and conditionParamRef.packageName != ''">
${_conditionType_} a.packageName like #{${_conditionParam_}.packageName}
</if>
<if test="conditionParamRef.packageName == null">
${_conditionType_} a.packageName is null
</if>
</if>
<if test="conditionParamRef.containsKey('packageNameList')">
${_conditionType_} a.packageName in
<foreach collection="conditionParamRef.packageNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('moduleName')">
<if test="conditionParamRef.moduleName != null and conditionParamRef.moduleName != ''">
${_conditionType_} a.moduleName like #{${_conditionParam_}.moduleName}
</if>
<if test="conditionParamRef.moduleName == null">
${_conditionType_} a.moduleName is null
</if>
</if>
<if test="conditionParamRef.containsKey('moduleNameList')">
${_conditionType_} a.moduleName in
<foreach collection="conditionParamRef.moduleNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('businessName')">
<if test="conditionParamRef.businessName != null and conditionParamRef.businessName != ''">
${_conditionType_} a.businessName like #{${_conditionParam_}.businessName}
</if>
<if test="conditionParamRef.businessName == null">
${_conditionType_} a.businessName is null
</if>
</if>
<if test="conditionParamRef.containsKey('businessNameList')">
${_conditionType_} a.businessName in
<foreach collection="conditionParamRef.businessNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('functionName')">
<if test="conditionParamRef.functionName != null and conditionParamRef.functionName != ''">
${_conditionType_} a.functionName like #{${_conditionParam_}.functionName}
</if>
<if test="conditionParamRef.functionName == null">
${_conditionType_} a.functionName is null
</if>
</if>
<if test="conditionParamRef.containsKey('functionNameList')">
${_conditionType_} a.functionName in
<foreach collection="conditionParamRef.functionNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('functionAuthor')">
<if test="conditionParamRef.functionAuthor != null and conditionParamRef.functionAuthor != ''">
${_conditionType_} a.functionAuthor like #{${_conditionParam_}.functionAuthor}
</if>
<if test="conditionParamRef.functionAuthor == null">
${_conditionType_} a.functionAuthor is null
</if>
</if>
<if test="conditionParamRef.containsKey('functionAuthorList')">
${_conditionType_} a.functionAuthor in
<foreach collection="conditionParamRef.functionAuthorList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('cacheServiceType')">
<if test="conditionParamRef.cacheServiceType != null ">
${_conditionType_} a.cacheServiceType = #{${_conditionParam_}.cacheServiceType}
</if>
<if test="conditionParamRef.cacheServiceType == null">
${_conditionType_} a.cacheServiceType is null
</if>
</if>
<if test="conditionParamRef.containsKey('cacheServiceTypeList')">
${_conditionType_} a.cacheServiceType in
<foreach collection="conditionParamRef.cacheServiceTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('cacheServiceTypeStart') and conditionParamRef.cacheServiceTypeStart != null">
${_conditionType_} a.cacheServiceType <![CDATA[ >= ]]> #{${_conditionParam_}.cacheServiceTypeStart}
</if>
<if test="conditionParamRef.containsKey('cacheServiceTypeEnd') and conditionParamRef.cacheServiceTypeEnd != null">
${_conditionType_} a.cacheServiceType <![CDATA[ <= ]]> #{${_conditionParam_}.cacheServiceTypeEnd}
</if>
<if test="conditionParamRef.containsKey('genType')">
<if test="conditionParamRef.genType != null ">
${_conditionType_} a.genType = #{${_conditionParam_}.genType}
</if>
<if test="conditionParamRef.genType == null">
${_conditionType_} a.genType is null
</if>
</if>
<if test="conditionParamRef.containsKey('genTypeList')">
${_conditionType_} a.genType in
<foreach collection="conditionParamRef.genTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('genTypeStart') and conditionParamRef.genTypeStart != null">
${_conditionType_} a.genType <![CDATA[ >= ]]> #{${_conditionParam_}.genTypeStart}
</if>
<if test="conditionParamRef.containsKey('genTypeEnd') and conditionParamRef.genTypeEnd != null">
${_conditionType_} a.genType <![CDATA[ <= ]]> #{${_conditionParam_}.genTypeEnd}
</if>
<if test="conditionParamRef.containsKey('dividedTableType')">
<if test="conditionParamRef.dividedTableType != null ">
${_conditionType_} a.dividedTableType = #{${_conditionParam_}.dividedTableType}
</if>
<if test="conditionParamRef.dividedTableType == null">
${_conditionType_} a.dividedTableType is null
</if>
</if>
<if test="conditionParamRef.containsKey('dividedTableTypeList')">
${_conditionType_} a.dividedTableType in
<foreach collection="conditionParamRef.dividedTableTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('dividedTableTypeStart') and conditionParamRef.dividedTableTypeStart != null">
${_conditionType_} a.dividedTableType <![CDATA[ >= ]]> #{${_conditionParam_}.dividedTableTypeStart}
</if>
<if test="conditionParamRef.containsKey('dividedTableTypeEnd') and conditionParamRef.dividedTableTypeEnd != null">
${_conditionType_} a.dividedTableType <![CDATA[ <= ]]> #{${_conditionParam_}.dividedTableTypeEnd}
</if>
<if test="conditionParamRef.containsKey('genPath')">
<if test="conditionParamRef.genPath != null and conditionParamRef.genPath != ''">
${_conditionType_} a.genPath like #{${_conditionParam_}.genPath}
</if>
<if test="conditionParamRef.genPath == null">
${_conditionType_} a.genPath is null
</if>
</if>
<if test="conditionParamRef.containsKey('genPathList')">
${_conditionType_} a.genPath in
<foreach collection="conditionParamRef.genPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('options')">
<if test="conditionParamRef.options != null and conditionParamRef.options != ''">
${_conditionType_} a.options like #{${_conditionParam_}.options}
</if>
<if test="conditionParamRef.options == null">
${_conditionType_} a.options is null
</if>
</if>
<if test="conditionParamRef.containsKey('optionsList')">
${_conditionType_} a.options in
<foreach collection="conditionParamRef.optionsList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList')">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUser')">
<if test="conditionParamRef.updateUser != null and conditionParamRef.updateUser != ''">
${_conditionType_} a.updateUser like #{${_conditionParam_}.updateUser}
</if>
<if test="conditionParamRef.updateUser == null">
${_conditionType_} a.updateUser is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserList')">
${_conditionType_} a.updateUser in
<foreach collection="conditionParamRef.updateUserList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUser')">
<if test="conditionParamRef.createUser != null and conditionParamRef.createUser != ''">
${_conditionType_} a.createUser like #{${_conditionParam_}.createUser}
</if>
<if test="conditionParamRef.createUser == null">
${_conditionType_} a.createUser is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserList')">
${_conditionType_} a.createUser in
<foreach collection="conditionParamRef.createUserList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('tableName')">
a.tableName
<if test='orderCol.tableName != null and "DESC".equalsIgnoreCase(orderCol.tableName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('tableComment')">
a.tableComment
<if test='orderCol.tableComment != null and "DESC".equalsIgnoreCase(orderCol.tableComment)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('subTableName')">
a.subTableName
<if test='orderCol.subTableName != null and "DESC".equalsIgnoreCase(orderCol.subTableName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('subTableFkName')">
a.subTableFkName
<if test='orderCol.subTableFkName != null and "DESC".equalsIgnoreCase(orderCol.subTableFkName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('className')">
a.className
<if test='orderCol.className != null and "DESC".equalsIgnoreCase(orderCol.className)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('tplCategory')">
a.tplCategory
<if test='orderCol.tplCategory != null and "DESC".equalsIgnoreCase(orderCol.tplCategory)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('packageName')">
a.packageName
<if test='orderCol.packageName != null and "DESC".equalsIgnoreCase(orderCol.packageName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('moduleName')">
a.moduleName
<if test='orderCol.moduleName != null and "DESC".equalsIgnoreCase(orderCol.moduleName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('businessName')">
a.businessName
<if test='orderCol.businessName != null and "DESC".equalsIgnoreCase(orderCol.businessName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('functionName')">
a.functionName
<if test='orderCol.functionName != null and "DESC".equalsIgnoreCase(orderCol.functionName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('functionAuthor')">
a.functionAuthor
<if test='orderCol.functionAuthor != null and "DESC".equalsIgnoreCase(orderCol.functionAuthor)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('cacheServiceType')">
a.cacheServiceType
<if test='orderCol.cacheServiceType != null and "DESC".equalsIgnoreCase(orderCol.cacheServiceType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('genType')">
a.genType
<if test='orderCol.genType != null and "DESC".equalsIgnoreCase(orderCol.genType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('dividedTableType')">
a.dividedTableType
<if test='orderCol.dividedTableType != null and "DESC".equalsIgnoreCase(orderCol.dividedTableType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('genPath')">
a.genPath
<if test='orderCol.genPath != null and "DESC".equalsIgnoreCase(orderCol.genPath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('options')">
a.options
<if test='orderCol.options != null and "DESC".equalsIgnoreCase(orderCol.options)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUser')">
a.updateUser
<if test='orderCol.updateUser != null and "DESC".equalsIgnoreCase(orderCol.updateUser)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUser')">
a.createUser
<if test='orderCol.createUser != null and "DESC".equalsIgnoreCase(orderCol.createUser)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
government-manager/src/main/resources/sqlmap/base/system/gentableColumn.xml 0 → 100644
View file @ be4fe6cf
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.base.system.gentable.dao.ibatis.GentableColumnDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="GentableColumnEntity" id="GentableColumnEntity-Map">
<result property="id" column="id" />
<result property="tableId" column="tableId" />
<result property="columnName" column="columnName" />
<result property="columnComment" column="columnComment" />
<result property="columnType" column="columnType" />
<result property="javaType" column="javaType" />
<result property="javaField" column="javaField" />
<result property="isPrimaryKey" column="isPrimaryKey" />
<result property="isIncrement" column="isIncrement" />
<result property="isRequired" column="isRequired" />
<result property="isInsert" column="isInsert" />
<result property="isEdit" column="isEdit" />
<result property="isList" column="isList" />
<result property="isQuery" column="isQuery" />
<result property="htmlType" column="htmlType" />
<result property="sort" column="sort" />
<result property="updateTime" column="updateTime" />
<result property="updateUser" column="updateUser" />
<result property="createTime" column="createTime" />
<result property="createUser" column="createUser" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id as id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('tableId') or colPickMode == 1 and data.containsKey('tableId')))">
a.tableId as tableId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('columnName') or colPickMode == 1 and data.containsKey('columnName')))">
a.columnName as columnName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('columnComment') or colPickMode == 1 and data.containsKey('columnComment')))">
a.columnComment as columnComment,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('columnType') or colPickMode == 1 and data.containsKey('columnType')))">
a.columnType as columnType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('javaType') or colPickMode == 1 and data.containsKey('javaType')))">
a.javaType as javaType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('javaField') or colPickMode == 1 and data.containsKey('javaField')))">
a.javaField as javaField,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isPrimaryKey') or colPickMode == 1 and data.containsKey('isPrimaryKey')))">
a.isPrimaryKey as isPrimaryKey,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isIncrement') or colPickMode == 1 and data.containsKey('isIncrement')))">
a.isIncrement as isIncrement,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isRequired') or colPickMode == 1 and data.containsKey('isRequired')))">
a.isRequired as isRequired,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isInsert') or colPickMode == 1 and data.containsKey('isInsert')))">
a.isInsert as isInsert,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isEdit') or colPickMode == 1 and data.containsKey('isEdit')))">
a.isEdit as isEdit,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isList') or colPickMode == 1 and data.containsKey('isList')))">
a.isList as isList,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isQuery') or colPickMode == 1 and data.containsKey('isQuery')))">
a.isQuery as isQuery,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('htmlType') or colPickMode == 1 and data.containsKey('htmlType')))">
a.htmlType as htmlType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sort') or colPickMode == 1 and data.containsKey('sort')))">
a.sort as sort,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime as updateTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUser') or colPickMode == 1 and data.containsKey('updateUser')))">
a.updateUser as updateUser,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime as createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUser') or colPickMode == 1 and data.containsKey('createUser')))">
a.createUser as createUser,
</if>
</trim>
</sql>
<!-- 新增 -->
<insert id="insert" parameterType="GentableColumnEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_gentable_column
(tableId,columnName,columnComment,columnType,javaType,javaField,isPrimaryKey,isIncrement,isRequired,isInsert,isEdit,isList,isQuery,htmlType,sort,updateTime,updateUser,createTime,createUser)
VALUES
(#{tableId},#{columnName},#{columnComment},#{columnType},#{javaType},#{javaField},#{isPrimaryKey},#{isIncrement},#{isRequired},#{isInsert},#{isEdit},#{isList},#{isQuery},#{htmlType},#{sort},#{updateTime},#{updateUser},#{createTime},#{createUser})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_gentable_column
(tableId,columnName,columnComment,columnType,javaType,javaField,isPrimaryKey,isIncrement,isRequired,isInsert,isEdit,isList,isQuery,htmlType,sort,updateTime,updateUser,createTime,createUser)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.tableId},#{item.columnName},#{item.columnComment},#{item.columnType},#{item.javaType},#{item.javaField},#{item.isPrimaryKey},#{item.isIncrement},#{item.isRequired},#{item.isInsert},#{item.isEdit},#{item.isList},#{item.isQuery},#{item.htmlType},#{item.sort},#{item.updateTime},#{item.updateUser},#{item.createTime},#{item.createUser})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_gentable_column as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('tableId')) or (colPickMode==1 and !data.containsKey('tableId'))">
a.tableId=#{data.tableId},
</if>
<if test="(colPickMode==0 and data.containsKey('tableIdIncrement')) or (colPickMode==1 and !data.containsKey('tableIdIncrement'))">
a.tableId=ifnull(a.tableId,0) + #{data.tableIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('columnName')) or (colPickMode==1 and !data.containsKey('columnName'))">
a.columnName=#{data.columnName},
</if>
<if test="(colPickMode==0 and data.containsKey('columnComment')) or (colPickMode==1 and !data.containsKey('columnComment'))">
a.columnComment=#{data.columnComment},
</if>
<if test="(colPickMode==0 and data.containsKey('columnType')) or (colPickMode==1 and !data.containsKey('columnType'))">
a.columnType=#{data.columnType},
</if>
<if test="(colPickMode==0 and data.containsKey('javaType')) or (colPickMode==1 and !data.containsKey('javaType'))">
a.javaType=#{data.javaType},
</if>
<if test="(colPickMode==0 and data.containsKey('javaField')) or (colPickMode==1 and !data.containsKey('javaField'))">
a.javaField=#{data.javaField},
</if>
<if test="(colPickMode==0 and data.containsKey('isPrimaryKey')) or (colPickMode==1 and !data.containsKey('isPrimaryKey'))">
a.isPrimaryKey=#{data.isPrimaryKey},
</if>
<if test="(colPickMode==0 and data.containsKey('isPrimaryKeyIncrement')) or (colPickMode==1 and !data.containsKey('isPrimaryKeyIncrement'))">
a.isPrimaryKey=ifnull(a.isPrimaryKey,0) + #{data.isPrimaryKeyIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('isIncrement')) or (colPickMode==1 and !data.containsKey('isIncrement'))">
a.isIncrement=#{data.isIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('isIncrementIncrement')) or (colPickMode==1 and !data.containsKey('isIncrementIncrement'))">
a.isIncrement=ifnull(a.isIncrement,0) + #{data.isIncrementIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('isRequired')) or (colPickMode==1 and !data.containsKey('isRequired'))">
a.isRequired=#{data.isRequired},
</if>
<if test="(colPickMode==0 and data.containsKey('isRequiredIncrement')) or (colPickMode==1 and !data.containsKey('isRequiredIncrement'))">
a.isRequired=ifnull(a.isRequired,0) + #{data.isRequiredIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('isInsert')) or (colPickMode==1 and !data.containsKey('isInsert'))">
a.isInsert=#{data.isInsert},
</if>
<if test="(colPickMode==0 and data.containsKey('isInsertIncrement')) or (colPickMode==1 and !data.containsKey('isInsertIncrement'))">
a.isInsert=ifnull(a.isInsert,0) + #{data.isInsertIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('isEdit')) or (colPickMode==1 and !data.containsKey('isEdit'))">
a.isEdit=#{data.isEdit},
</if>
<if test="(colPickMode==0 and data.containsKey('isEditIncrement')) or (colPickMode==1 and !data.containsKey('isEditIncrement'))">
a.isEdit=ifnull(a.isEdit,0) + #{data.isEditIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('isList')) or (colPickMode==1 and !data.containsKey('isList'))">
a.isList=#{data.isList},
</if>
<if test="(colPickMode==0 and data.containsKey('isListIncrement')) or (colPickMode==1 and !data.containsKey('isListIncrement'))">
a.isList=ifnull(a.isList,0) + #{data.isListIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('isQuery')) or (colPickMode==1 and !data.containsKey('isQuery'))">
a.isQuery=#{data.isQuery},
</if>
<if test="(colPickMode==0 and data.containsKey('isQueryIncrement')) or (colPickMode==1 and !data.containsKey('isQueryIncrement'))">
a.isQuery=ifnull(a.isQuery,0) + #{data.isQueryIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('htmlType')) or (colPickMode==1 and !data.containsKey('htmlType'))">
a.htmlType=#{data.htmlType},
</if>
<if test="(colPickMode==0 and data.containsKey('htmlTypeIncrement')) or (colPickMode==1 and !data.containsKey('htmlTypeIncrement'))">
a.htmlType=ifnull(a.htmlType,0) + #{data.htmlTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('sort')) or (colPickMode==1 and !data.containsKey('sort'))">
a.sort=#{data.sort},
</if>
<if test="(colPickMode==0 and data.containsKey('sortIncrement')) or (colPickMode==1 and !data.containsKey('sortIncrement'))">
a.sort=ifnull(a.sort,0) + #{data.sortIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUser')) or (colPickMode==1 and !data.containsKey('updateUser'))">
a.updateUser=#{data.updateUser},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUser')) or (colPickMode==1 and !data.containsKey('createUser'))">
a.createUser=#{data.createUser},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_gentable_column as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="tableId=(case" suffix="ELSE tableId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('tableId')) or (colPickMode==1 and !item.containsKey('tableId'))">
when a.id=#{item.id} then #{item.tableId}
</when>
<when test="(colPickMode==0 and item.containsKey('tableIdIncrement')) or (colPickMode==1 and !item.containsKey('tableIdIncrement'))">
when a.id=#{item.id} then ifnull(a.tableId,0) + #{item.tableIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="columnName=(case" suffix="ELSE columnName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('columnName')) or (colPickMode==1 and !item.containsKey('columnName'))">
when a.id=#{item.id} then #{item.columnName}
</if>
</foreach>
</trim>
<trim prefix="columnComment=(case" suffix="ELSE columnComment end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('columnComment')) or (colPickMode==1 and !item.containsKey('columnComment'))">
when a.id=#{item.id} then #{item.columnComment}
</if>
</foreach>
</trim>
<trim prefix="columnType=(case" suffix="ELSE columnType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('columnType')) or (colPickMode==1 and !item.containsKey('columnType'))">
when a.id=#{item.id} then #{item.columnType}
</if>
</foreach>
</trim>
<trim prefix="javaType=(case" suffix="ELSE javaType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('javaType')) or (colPickMode==1 and !item.containsKey('javaType'))">
when a.id=#{item.id} then #{item.javaType}
</if>
</foreach>
</trim>
<trim prefix="javaField=(case" suffix="ELSE javaField end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('javaField')) or (colPickMode==1 and !item.containsKey('javaField'))">
when a.id=#{item.id} then #{item.javaField}
</if>
</foreach>
</trim>
<trim prefix="isPrimaryKey=(case" suffix="ELSE isPrimaryKey end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('isPrimaryKey')) or (colPickMode==1 and !item.containsKey('isPrimaryKey'))">
when a.id=#{item.id} then #{item.isPrimaryKey}
</when>
<when test="(colPickMode==0 and item.containsKey('isPrimaryKeyIncrement')) or (colPickMode==1 and !item.containsKey('isPrimaryKeyIncrement'))">
when a.id=#{item.id} then ifnull(a.isPrimaryKey,0) + #{item.isPrimaryKeyIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="isIncrement=(case" suffix="ELSE isIncrement end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('isIncrement')) or (colPickMode==1 and !item.containsKey('isIncrement'))">
when a.id=#{item.id} then #{item.isIncrement}
</when>
<when test="(colPickMode==0 and item.containsKey('isIncrementIncrement')) or (colPickMode==1 and !item.containsKey('isIncrementIncrement'))">
when a.id=#{item.id} then ifnull(a.isIncrement,0) + #{item.isIncrementIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="isRequired=(case" suffix="ELSE isRequired end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('isRequired')) or (colPickMode==1 and !item.containsKey('isRequired'))">
when a.id=#{item.id} then #{item.isRequired}
</when>
<when test="(colPickMode==0 and item.containsKey('isRequiredIncrement')) or (colPickMode==1 and !item.containsKey('isRequiredIncrement'))">
when a.id=#{item.id} then ifnull(a.isRequired,0) + #{item.isRequiredIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="isInsert=(case" suffix="ELSE isInsert end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('isInsert')) or (colPickMode==1 and !item.containsKey('isInsert'))">
when a.id=#{item.id} then #{item.isInsert}
</when>
<when test="(colPickMode==0 and item.containsKey('isInsertIncrement')) or (colPickMode==1 and !item.containsKey('isInsertIncrement'))">
when a.id=#{item.id} then ifnull(a.isInsert,0) + #{item.isInsertIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="isEdit=(case" suffix="ELSE isEdit end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('isEdit')) or (colPickMode==1 and !item.containsKey('isEdit'))">
when a.id=#{item.id} then #{item.isEdit}
</when>
<when test="(colPickMode==0 and item.containsKey('isEditIncrement')) or (colPickMode==1 and !item.containsKey('isEditIncrement'))">
when a.id=#{item.id} then ifnull(a.isEdit,0) + #{item.isEditIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="isList=(case" suffix="ELSE isList end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('isList')) or (colPickMode==1 and !item.containsKey('isList'))">
when a.id=#{item.id} then #{item.isList}
</when>
<when test="(colPickMode==0 and item.containsKey('isListIncrement')) or (colPickMode==1 and !item.containsKey('isListIncrement'))">
when a.id=#{item.id} then ifnull(a.isList,0) + #{item.isListIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="isQuery=(case" suffix="ELSE isQuery end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('isQuery')) or (colPickMode==1 and !item.containsKey('isQuery'))">
when a.id=#{item.id} then #{item.isQuery}
</when>
<when test="(colPickMode==0 and item.containsKey('isQueryIncrement')) or (colPickMode==1 and !item.containsKey('isQueryIncrement'))">
when a.id=#{item.id} then ifnull(a.isQuery,0) + #{item.isQueryIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="htmlType=(case" suffix="ELSE htmlType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('htmlType')) or (colPickMode==1 and !item.containsKey('htmlType'))">
when a.id=#{item.id} then #{item.htmlType}
</when>
<when test="(colPickMode==0 and item.containsKey('htmlTypeIncrement')) or (colPickMode==1 and !item.containsKey('htmlTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.htmlType,0) + #{item.htmlTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="sort=(case" suffix="ELSE sort end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('sort')) or (colPickMode==1 and !item.containsKey('sort'))">
when a.id=#{item.id} then #{item.sort}
</when>
<when test="(colPickMode==0 and item.containsKey('sortIncrement')) or (colPickMode==1 and !item.containsKey('sortIncrement'))">
when a.id=#{item.id} then ifnull(a.sort,0) + #{item.sortIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
<trim prefix="updateUser=(case" suffix="ELSE updateUser end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateUser')) or (colPickMode==1 and !item.containsKey('updateUser'))">
when a.id=#{item.id} then #{item.updateUser}
</if>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUser=(case" suffix="ELSE createUser end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createUser')) or (colPickMode==1 and !item.containsKey('createUser'))">
when a.id=#{item.id} then #{item.createUser}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="GentableColumnEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_gentable_column as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_gentable_column as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_gentable_column where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_gentable_column as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="GentableColumnEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_gentable_column as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_xhx_gentable_column as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('tableId')">
<if test="conditionParamRef.tableId != null ">
${_conditionType_} a.tableId = #{${_conditionParam_}.tableId}
</if>
<if test="conditionParamRef.tableId == null">
${_conditionType_} a.tableId is null
</if>
</if>
<if test="conditionParamRef.containsKey('tableIdList')">
${_conditionType_} a.tableId in
<foreach collection="conditionParamRef.tableIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('tableIdStart') and conditionParamRef.tableIdStart != null">
${_conditionType_} a.tableId <![CDATA[ >= ]]> #{${_conditionParam_}.tableIdStart}
</if>
<if test="conditionParamRef.containsKey('tableIdEnd') and conditionParamRef.tableIdEnd != null">
${_conditionType_} a.tableId <![CDATA[ <= ]]> #{${_conditionParam_}.tableIdEnd}
</if>
<if test="conditionParamRef.containsKey('columnName')">
<if test="conditionParamRef.columnName != null and conditionParamRef.columnName != ''">
${_conditionType_} a.columnName like #{${_conditionParam_}.columnName}
</if>
<if test="conditionParamRef.columnName == null">
${_conditionType_} a.columnName is null
</if>
</if>
<if test="conditionParamRef.containsKey('columnNameList')">
${_conditionType_} a.columnName in
<foreach collection="conditionParamRef.columnNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('columnComment')">
<if test="conditionParamRef.columnComment != null and conditionParamRef.columnComment != ''">
${_conditionType_} a.columnComment like #{${_conditionParam_}.columnComment}
</if>
<if test="conditionParamRef.columnComment == null">
${_conditionType_} a.columnComment is null
</if>
</if>
<if test="conditionParamRef.containsKey('columnCommentList')">
${_conditionType_} a.columnComment in
<foreach collection="conditionParamRef.columnCommentList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('columnType')">
<if test="conditionParamRef.columnType != null and conditionParamRef.columnType != ''">
${_conditionType_} a.columnType like #{${_conditionParam_}.columnType}
</if>
<if test="conditionParamRef.columnType == null">
${_conditionType_} a.columnType is null
</if>
</if>
<if test="conditionParamRef.containsKey('columnTypeList')">
${_conditionType_} a.columnType in
<foreach collection="conditionParamRef.columnTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('javaType')">
<if test="conditionParamRef.javaType != null and conditionParamRef.javaType != ''">
${_conditionType_} a.javaType like #{${_conditionParam_}.javaType}
</if>
<if test="conditionParamRef.javaType == null">
${_conditionType_} a.javaType is null
</if>
</if>
<if test="conditionParamRef.containsKey('javaTypeList')">
${_conditionType_} a.javaType in
<foreach collection="conditionParamRef.javaTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('javaField')">
<if test="conditionParamRef.javaField != null and conditionParamRef.javaField != ''">
${_conditionType_} a.javaField like #{${_conditionParam_}.javaField}
</if>
<if test="conditionParamRef.javaField == null">
${_conditionType_} a.javaField is null
</if>
</if>
<if test="conditionParamRef.containsKey('javaFieldList')">
${_conditionType_} a.javaField in
<foreach collection="conditionParamRef.javaFieldList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isPrimaryKey')">
<if test="conditionParamRef.isPrimaryKey != null ">
${_conditionType_} a.isPrimaryKey = #{${_conditionParam_}.isPrimaryKey}
</if>
<if test="conditionParamRef.isPrimaryKey == null">
${_conditionType_} a.isPrimaryKey is null
</if>
</if>
<if test="conditionParamRef.containsKey('isPrimaryKeyList')">
${_conditionType_} a.isPrimaryKey in
<foreach collection="conditionParamRef.isPrimaryKeyList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isPrimaryKeyStart') and conditionParamRef.isPrimaryKeyStart != null">
${_conditionType_} a.isPrimaryKey <![CDATA[ >= ]]> #{${_conditionParam_}.isPrimaryKeyStart}
</if>
<if test="conditionParamRef.containsKey('isPrimaryKeyEnd') and conditionParamRef.isPrimaryKeyEnd != null">
${_conditionType_} a.isPrimaryKey <![CDATA[ <= ]]> #{${_conditionParam_}.isPrimaryKeyEnd}
</if>
<if test="conditionParamRef.containsKey('isIncrement')">
<if test="conditionParamRef.isIncrement != null ">
${_conditionType_} a.isIncrement = #{${_conditionParam_}.isIncrement}
</if>
<if test="conditionParamRef.isIncrement == null">
${_conditionType_} a.isIncrement is null
</if>
</if>
<if test="conditionParamRef.containsKey('isIncrementList')">
${_conditionType_} a.isIncrement in
<foreach collection="conditionParamRef.isIncrementList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isIncrementStart') and conditionParamRef.isIncrementStart != null">
${_conditionType_} a.isIncrement <![CDATA[ >= ]]> #{${_conditionParam_}.isIncrementStart}
</if>
<if test="conditionParamRef.containsKey('isIncrementEnd') and conditionParamRef.isIncrementEnd != null">
${_conditionType_} a.isIncrement <![CDATA[ <= ]]> #{${_conditionParam_}.isIncrementEnd}
</if>
<if test="conditionParamRef.containsKey('isRequired')">
<if test="conditionParamRef.isRequired != null ">
${_conditionType_} a.isRequired = #{${_conditionParam_}.isRequired}
</if>
<if test="conditionParamRef.isRequired == null">
${_conditionType_} a.isRequired is null
</if>
</if>
<if test="conditionParamRef.containsKey('isRequiredList')">
${_conditionType_} a.isRequired in
<foreach collection="conditionParamRef.isRequiredList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isRequiredStart') and conditionParamRef.isRequiredStart != null">
${_conditionType_} a.isRequired <![CDATA[ >= ]]> #{${_conditionParam_}.isRequiredStart}
</if>
<if test="conditionParamRef.containsKey('isRequiredEnd') and conditionParamRef.isRequiredEnd != null">
${_conditionType_} a.isRequired <![CDATA[ <= ]]> #{${_conditionParam_}.isRequiredEnd}
</if>
<if test="conditionParamRef.containsKey('isInsert')">
<if test="conditionParamRef.isInsert != null ">
${_conditionType_} a.isInsert = #{${_conditionParam_}.isInsert}
</if>
<if test="conditionParamRef.isInsert == null">
${_conditionType_} a.isInsert is null
</if>
</if>
<if test="conditionParamRef.containsKey('isInsertList')">
${_conditionType_} a.isInsert in
<foreach collection="conditionParamRef.isInsertList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isInsertStart') and conditionParamRef.isInsertStart != null">
${_conditionType_} a.isInsert <![CDATA[ >= ]]> #{${_conditionParam_}.isInsertStart}
</if>
<if test="conditionParamRef.containsKey('isInsertEnd') and conditionParamRef.isInsertEnd != null">
${_conditionType_} a.isInsert <![CDATA[ <= ]]> #{${_conditionParam_}.isInsertEnd}
</if>
<if test="conditionParamRef.containsKey('isEdit')">
<if test="conditionParamRef.isEdit != null ">
${_conditionType_} a.isEdit = #{${_conditionParam_}.isEdit}
</if>
<if test="conditionParamRef.isEdit == null">
${_conditionType_} a.isEdit is null
</if>
</if>
<if test="conditionParamRef.containsKey('isEditList')">
${_conditionType_} a.isEdit in
<foreach collection="conditionParamRef.isEditList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isEditStart') and conditionParamRef.isEditStart != null">
${_conditionType_} a.isEdit <![CDATA[ >= ]]> #{${_conditionParam_}.isEditStart}
</if>
<if test="conditionParamRef.containsKey('isEditEnd') and conditionParamRef.isEditEnd != null">
${_conditionType_} a.isEdit <![CDATA[ <= ]]> #{${_conditionParam_}.isEditEnd}
</if>
<if test="conditionParamRef.containsKey('isList')">
<if test="conditionParamRef.isList != null ">
${_conditionType_} a.isList = #{${_conditionParam_}.isList}
</if>
<if test="conditionParamRef.isList == null">
${_conditionType_} a.isList is null
</if>
</if>
<if test="conditionParamRef.containsKey('isListList')">
${_conditionType_} a.isList in
<foreach collection="conditionParamRef.isListList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isListStart') and conditionParamRef.isListStart != null">
${_conditionType_} a.isList <![CDATA[ >= ]]> #{${_conditionParam_}.isListStart}
</if>
<if test="conditionParamRef.containsKey('isListEnd') and conditionParamRef.isListEnd != null">
${_conditionType_} a.isList <![CDATA[ <= ]]> #{${_conditionParam_}.isListEnd}
</if>
<if test="conditionParamRef.containsKey('isQuery')">
<if test="conditionParamRef.isQuery != null ">
${_conditionType_} a.isQuery = #{${_conditionParam_}.isQuery}
</if>
<if test="conditionParamRef.isQuery == null">
${_conditionType_} a.isQuery is null
</if>
</if>
<if test="conditionParamRef.containsKey('isQueryList')">
${_conditionType_} a.isQuery in
<foreach collection="conditionParamRef.isQueryList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('isQueryStart') and conditionParamRef.isQueryStart != null">
${_conditionType_} a.isQuery <![CDATA[ >= ]]> #{${_conditionParam_}.isQueryStart}
</if>
<if test="conditionParamRef.containsKey('isQueryEnd') and conditionParamRef.isQueryEnd != null">
${_conditionType_} a.isQuery <![CDATA[ <= ]]> #{${_conditionParam_}.isQueryEnd}
</if>
<if test="conditionParamRef.containsKey('htmlType')">
<if test="conditionParamRef.htmlType != null ">
${_conditionType_} a.htmlType = #{${_conditionParam_}.htmlType}
</if>
<if test="conditionParamRef.htmlType == null">
${_conditionType_} a.htmlType is null
</if>
</if>
<if test="conditionParamRef.containsKey('htmlTypeList')">
${_conditionType_} a.htmlType in
<foreach collection="conditionParamRef.htmlTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('htmlTypeStart') and conditionParamRef.htmlTypeStart != null">
${_conditionType_} a.htmlType <![CDATA[ >= ]]> #{${_conditionParam_}.htmlTypeStart}
</if>
<if test="conditionParamRef.containsKey('htmlTypeEnd') and conditionParamRef.htmlTypeEnd != null">
${_conditionType_} a.htmlType <![CDATA[ <= ]]> #{${_conditionParam_}.htmlTypeEnd}
</if>
<if test="conditionParamRef.containsKey('sort')">
<if test="conditionParamRef.sort != null ">
${_conditionType_} a.sort = #{${_conditionParam_}.sort}
</if>
<if test="conditionParamRef.sort == null">
${_conditionType_} a.sort is null
</if>
</if>
<if test="conditionParamRef.containsKey('sortList')">
${_conditionType_} a.sort in
<foreach collection="conditionParamRef.sortList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sortStart') and conditionParamRef.sortStart != null">
${_conditionType_} a.sort <![CDATA[ >= ]]> #{${_conditionParam_}.sortStart}
</if>
<if test="conditionParamRef.containsKey('sortEnd') and conditionParamRef.sortEnd != null">
${_conditionType_} a.sort <![CDATA[ <= ]]> #{${_conditionParam_}.sortEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUser')">
<if test="conditionParamRef.updateUser != null and conditionParamRef.updateUser != ''">
${_conditionType_} a.updateUser like #{${_conditionParam_}.updateUser}
</if>
<if test="conditionParamRef.updateUser == null">
${_conditionType_} a.updateUser is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserList')">
${_conditionType_} a.updateUser in
<foreach collection="conditionParamRef.updateUserList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUser')">
<if test="conditionParamRef.createUser != null and conditionParamRef.createUser != ''">
${_conditionType_} a.createUser like #{${_conditionParam_}.createUser}
</if>
<if test="conditionParamRef.createUser == null">
${_conditionType_} a.createUser is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserList')">
${_conditionType_} a.createUser in
<foreach collection="conditionParamRef.createUserList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('tableId')">
a.tableId
<if test='orderCol.tableId != null and "DESC".equalsIgnoreCase(orderCol.tableId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('columnName')">
a.columnName
<if test='orderCol.columnName != null and "DESC".equalsIgnoreCase(orderCol.columnName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('columnComment')">
a.columnComment
<if test='orderCol.columnComment != null and "DESC".equalsIgnoreCase(orderCol.columnComment)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('columnType')">
a.columnType
<if test='orderCol.columnType != null and "DESC".equalsIgnoreCase(orderCol.columnType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('javaType')">
a.javaType
<if test='orderCol.javaType != null and "DESC".equalsIgnoreCase(orderCol.javaType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('javaField')">
a.javaField
<if test='orderCol.javaField != null and "DESC".equalsIgnoreCase(orderCol.javaField)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isPrimaryKey')">
a.isPrimaryKey
<if test='orderCol.isPrimaryKey != null and "DESC".equalsIgnoreCase(orderCol.isPrimaryKey)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isIncrement')">
a.isIncrement
<if test='orderCol.isIncrement != null and "DESC".equalsIgnoreCase(orderCol.isIncrement)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isRequired')">
a.isRequired
<if test='orderCol.isRequired != null and "DESC".equalsIgnoreCase(orderCol.isRequired)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isInsert')">
a.isInsert
<if test='orderCol.isInsert != null and "DESC".equalsIgnoreCase(orderCol.isInsert)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isEdit')">
a.isEdit
<if test='orderCol.isEdit != null and "DESC".equalsIgnoreCase(orderCol.isEdit)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isList')">
a.isList
<if test='orderCol.isList != null and "DESC".equalsIgnoreCase(orderCol.isList)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('isQuery')">
a.isQuery
<if test='orderCol.isQuery != null and "DESC".equalsIgnoreCase(orderCol.isQuery)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('htmlType')">
a.htmlType
<if test='orderCol.htmlType != null and "DESC".equalsIgnoreCase(orderCol.htmlType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('sort')">
a.sort
<if test='orderCol.sort != null and "DESC".equalsIgnoreCase(orderCol.sort)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUser')">
a.updateUser
<if test='orderCol.updateUser != null and "DESC".equalsIgnoreCase(orderCol.updateUser)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUser')">
a.createUser
<if test='orderCol.createUser != null and "DESC".equalsIgnoreCase(orderCol.createUser)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
government-manager/src/main/resources/sqlmap/base/system/gentableColumnExt.xml 0 → 100644
View file @ be4fe6cf
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.base.system.gentable.dao.ibatis.GentableColumnDaoImpl">
<select id="selectDbTableColumnsByName" parameterType="String" resultMap="GentableColumnEntity-Map">
SELECT
column_name as columnName,
( CASE WHEN ( is_nullable = 'no' <![CDATA[ && ]]> column_key != 'PRI' ) THEN '1' ELSE NULL END ) AS isRequired,
( CASE WHEN column_key = 'PRI' THEN '1' ELSE '0' END ) AS isPrimaryKey,
ordinal_position AS sort,
column_comment AS columnComment,
( CASE WHEN extra = 'auto_increment' THEN '1' ELSE '0' END ) AS isIncrement,
column_type AS columnType
FROM
information_schema.COLUMNS
WHERE
table_schema = ( SELECT DATABASE ( ) )
AND table_name = 'mortals_xhx_accept'
ORDER BY
ordinal_position
</select>
</mapper>
\ No newline at end of file
government-manager/src/main/resources/sqlmap/base/system/gentableExt.xml 0 → 100644
View file @ be4fe6cf
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.base.system.gentable.dao.ibatis.GentableDaoImpl">
<select id="selectDbTableList" parameterType="paramDto" resultMap="GentableEntity-Map">
select a.table_name As tableName, a.table_comment as tableComment, a.create_time as createTime, a.update_time as updateTime
from information_schema.tables a
<trim suffixOverrides="where" suffix="">
where table_schema = (select database())
AND table_name NOT LIKE 'act_%' AND table_name NOT LIKE 'mortals_xhx_gen%'
AND table_name NOT IN (select tableName from mortals_xhx_gentable)
<if test="condition.containsKey('tableName')">
<if test="condition.tableName != null and condition.tableName != ''">
and a.table_name like #{condition.tableName}
</if>
</if>
</trim>
</select>
<select id="selectDbTableListByNames" resultMap="GentableEntity-Map">
select table_name As tableName, table_comment as tableComment, create_time as createTime, update_time as updateTime
from information_schema.tables
where table_name NOT LIKE 'act_%' and table_name NOT LIKE 'mortals_xhx_gen%' and table_schema = (select database())
and table_name in
<foreach collection="array" item="name" open="(" separator="," close=")">
#{name}
</foreach>
</select>
<!--查询所有表关联数据 -->
<select id="selectGenTableAll" parameterType="String" resultMap="GentableEntity-Map">
SELECT
t.id,
t.tableName,
t.tableComment,
t.subTableName,
t.subTableFkName,
t.className,
t.tplCategory,
t.packageName,
t.moduleName,
t.businessName,
t.functionName,
t.functionAuthor,
t.cacheServiceType,
t.genType,
t.dividedTableType,
t.options,
t.remark,
c.id,
c.columnName,
c.columnComment,
c.columnType,
c.javaType,
c.javaField,
c.isPrimaryKey,
c.isIncrement,
c.isRequired,
c.isInsert,
c.isEdit,
c.isList,
c.isQuery,
c.htmlType,
c.sort
FROM mortals_xhx_gentable t
LEFT JOIN mortals_xhx_gentable_column c ON t.id = c.tableId
ORDER BY
c.sort
</select>
</mapper>
\ No newline at end of file
government-manager/src/main/resources/template/java/dao.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
import com.mortals.framework.dao.ICRUDDao;
import ${pack}.model.${entityClassName}Entity;
/**
* <p>Title: ${entityDesc}</p>
* <p>Description: ${entityClassName}Dao DAO接口 </p>
* @author
* @version 1.0.0
*/
public interface ${entityClassName}Dao extends ICRUDDao<${entityClassName}Entity,Long>{
}
government-manager/src/main/resources/template/java/daoImpl.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
import org.springframework.stereotype.Repository;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import ${pack}.dao.${entityClassName}Dao;
import ${pack}.model.${entityClassName}Entity;
/**
* <p>Title: ${entityDesc}</p>
* <p>Description: ${entityClassName}DaoImpl DAO接口 </p>
* @author
* @version 1.0.0
*/
@Repository("${entityClassName?uncap_first}Dao")
public class ${entityClassName}DaoImpl extends BaseCRUDDaoMybatis<${entityClassName}Entity,Long> implements ${entityClassName}Dao {
}
government-manager/src/main/resources/template/java/entity.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
<#list importPacks as pack>
<#if pack == "BigDecimal">
import java.math.${pack};
</#if>
<#if pack == "java.util.Date">
import ${pack};
</#if>
</#list>
import com.mortals.framework.model.BaseEntityLong;
/**
*
* Description:${entityClassName}
* date: ${date?datetime}
*/
public class ${entityClassName}Entity extends BaseEntityLong{
private static final long serialVersionUID = ${serialVersionUID?c}L;
<#list fields as field>
<#if (field.pk)??>
<#else>
<#if field.columnName!='id'>
/**
* ${field.remarks}
*/
private ${(field.typeName?split("."))?last} ${field.attName};
</#if>
</#if>
</#list>
public ${entityClassName}Entity(){
}
<#list fields as field>
<#if (field.pk)?? && field.columnName!='id'>
/**
* 获取 ${field.remarks}
* @return ${field.attName}
*/
public ${(field.typeName?split("."))?last} get${field.attName?cap_first}() {
return getId();
}
/**
* 设置 ${field.remarks}
* @param ${field.attName}
*/
public void set${field.attName?cap_first}(${(field.typeName?split("."))?last} ${field.attName}) {
setId(${field.attName});
}
<#else>
<#if field.columnName!='id'>
/**
* 获取 ${field.remarks}
* @return ${field.attName}
*/
public ${(field.typeName?split("."))?last} get${field.attName?cap_first}() {
return this.${field.attName};
}
/**
* 设置 ${field.remarks}
* @param ${field.attName}
*/
public void set${field.attName?cap_first}(${(field.typeName?split("."))?last} ${field.attName}) {
this.${field.attName} = ${field.attName};
}
</#if>
</#if>
<#-- <#if field.columnName != "id">
/**
* 获取 ${field.remarks}
* @return ${field.columnName}
*/
public ${(field.typeName?split("."))?last} get${field.columnName?cap_first}() {
return this.${field.columnName};
}
/**
* 设置 ${field.remarks}
* @param ${field.columnName}
*/
public void set${field.columnName?cap_first}(${(field.typeName?split("."))?last} ${field.columnName}) {
this.${field.columnName} = ${field.columnName};
}
</#if>-->
</#list>
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null)
return false;
if (obj instanceof ${entityClassName}Entity) {
${entityClassName}Entity tmp = (${entityClassName}Entity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb
<#list fields as field>
.append(",${field.attName}:").append(get${field.attName?cap_first}())
</#list>;
return sb.toString();
}
public void initAttrValue(){
<#list fields as field>
<#if field.columnName != "id">
this.${field.attName} = null;
</#if>
</#list>
}
}
\ No newline at end of file
government-manager/src/main/resources/template/java/entityQuery.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
import java.util.List;
<#list importPacks as pack>
<#if pack == "BigDecimal">
import java.math.${pack};
</#if>
<#if pack == "java.util.Date">
import ${pack};
</#if>
</#list>
/**
*
* Description:${entityClassName}
* date: ${date?datetime}
*/
public class ${entityClassName}Query extends ${entityClassName}Entity{
private static final long serialVersionUID = ${serialVersionUID?c}L;
<#list fields as field>
<#if field.typeName == "java.lang.Long">
/** 开始 ${field.remarks} */
private Long ${field.attName}Start;
/** 结束 ${field.remarks} */
private Long ${field.attName}End;
/** 增加 ${field.remarks} */
private Long ${field.attName}Increment;
/** ${field.remarks} */
private List <Long> ${field.attName}List;
<#elseif field.typeName == "String">
/** ${field.remarks} */
private List<String> ${field.attName}List;
<#elseif field.typeName == "java.lang.Integer">
/** 开始 ${field.remarks} */
private Integer ${field.attName}Start;
/** 结束 ${field.remarks} */
private Integer ${field.attName}End;
/** 增加 ${field.remarks} */
private Integer ${field.attName}Increment;
/** ${field.remarks} */
private List <Integer> ${field.attName}List;
<#elseif field.typeName == "java.util.Date">
/** 开始 ${field.remarks} */
private String ${field.attName}Start;
/** 结束 ${field.remarks} */
private String ${field.attName}End;
<#elseif field.typeName == "BigDecimal">
/** 开始 ${field.remarks} */
private BigDecimal ${field.attName}Start;
/** 结束 ${field.remarks} */
private BigDecimal ${field.attName}End;
/** 增加 ${field.remarks} */
private BigDecimal ${field.attName}Increment;
/** ${field.remarks} */
private List <BigDecimal> ${field.attName}List;
</#if>
</#list>
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<${entityClassName}Query> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<${entityClassName}Query> andConditionList;
public ${entityClassName}Query(){
}
<#list fields as field>
<#if field.typeName == "java.lang.Long">
/**
* 获取 开始 ${field.remarks}
* @return ${field.attName}Start
*/
public Long get${field.attName?cap_first}Start(){
return this.${field.attName}Start;
}
/**
* 设置 开始 ${field.remarks}
* @param ${field.attName}Start
*/
public void set${field.attName?cap_first}Start(Long ${field.attName}Start){
this.${field.attName}Start = ${field.attName}Start;
}
/**
* 获取 结束 ${field.remarks}
* @return ${field.attName}End
*/
public Long get${field.attName?cap_first}End(){
return this.${field.attName}End;
}
/**
* 设置 结束 ${field.remarks}
* @param ${field.attName}End
*/
public void set${field.attName?cap_first}End(Long ${field.attName}End){
this.${field.attName}End = ${field.attName}End;
}
/**
* 获取 增加 ${field.remarks}
* @return ${field.attName}Increment
*/
public Long get${field.attName?cap_first}Increment(){
return this.${field.attName}Increment;
}
/**
* 设置 增加 ${field.remarks}
* @param ${field.attName}Increment
*/
public void set${field.attName?cap_first}Increment(Long ${field.attName}Increment){
this.${field.attName}Increment = ${field.attName}Increment;
}
/**
* 获取 ${field.remarks}
* @return ${field.attName}List
*/
public List<Long> get${field.attName?cap_first}List(){
return this.${field.attName}List;
}
/**
* 设置 ${field.remarks}
* @param ${field.attName}List
*/
public void set${field.attName?cap_first}List(List<Long> ${field.attName}List){
this.${field.attName}List = ${field.attName}List;
}
</#if>
<#if field.typeName == "String">
/**
* 获取 ${field.remarks}
* @return ${field.attName}List
*/
public List<String> get${field.attName?cap_first}List(){
return this.${field.attName}List;
}
/**
* 设置 ${field.remarks}
* @param ${field.attName}List
*/
public void set${field.attName?cap_first}List(List<String> ${field.attName}List){
this.${field.attName}List = ${field.attName}List;
}
</#if>
<#if field.typeName == "java.lang.Integer">
/**
* 获取 开始 ${field.remarks}
* @return ${field.attName}Start
*/
public Integer get${field.attName?cap_first}Start(){
return this.${field.attName}Start;
}
/**
* 设置 开始 ${field.remarks}
* @param ${field.attName}Start
*/
public void set${field.attName?cap_first}Start(Integer ${field.attName}Start){
this.${field.attName}Start = ${field.attName}Start;
}
/**
* 获取 结束 ${field.remarks}
* @return ${field.attName}End
*/
public Integer get${field.attName?cap_first}End(){
return this.${field.attName}End;
}
/**
* 设置 结束 ${field.remarks}
* @param ${field.attName}End
*/
public void set${field.attName?cap_first}End(Integer ${field.attName}End){
this.${field.attName}End = ${field.attName}End;
}
/**
* 获取 增加 ${field.remarks}
* @return ${field.attName}Increment
*/
public Integer get${field.attName?cap_first}Increment(){
return this.${field.attName}Increment;
}
/**
* 设置 增加 ${field.remarks}
* @param ${field.attName}Increment
*/
public void set${field.attName?cap_first}Increment(Integer ${field.attName}Increment){
this.${field.attName}Increment = ${field.attName}Increment;
}
/**
* 获取 ${field.remarks}
* @return ${field.attName}List
*/
public List<Integer> get${field.attName?cap_first}List(){
return this.${field.attName}List;
}
/**
* 设置 ${field.remarks}
* @param ${field.attName}List
*/
public void set${field.attName?cap_first}List(List<Integer> ${field.attName}List){
this.${field.attName}List = ${field.attName}List;
}
</#if>
<#if field.typeName == "BigDecimal">
/**
* 获取 开始 ${field.remarks}
* @return ${field.attName}Start
*/
public BigDecimal get${field.attName?cap_first}Start(){
return this.${field.attName}Start;
}
/**
* 设置 开始 ${field.remarks}
* @param ${field.attName}Start
*/
public void set${field.attName?cap_first}Start(BigDecimal ${field.attName}Start){
this.${field.attName}Start = ${field.attName}Start;
}
/**
* 获取 结束 ${field.remarks}
* @return ${field.attName}End
*/
public BigDecimal get${field.attName?cap_first}End(){
return this.${field.attName}End;
}
/**
* 设置 结束 ${field.remarks}
* @param ${field.attName}End
*/
public void set${field.attName?cap_first}End(BigDecimal ${field.attName}End){
this.${field.attName}End = ${field.attName}End;
}
/**
* 获取 增加 ${field.remarks}
* @return ${field.attName}Increment
*/
public BigDecimal get${field.attName?cap_first}Increment(){
return this.${field.attName}Increment;
}
/**
* 设置 增加 ${field.remarks}
* @param ${field.attName}Increment
*/
public void set${field.attName?cap_first}Increment(BigDecimal ${field.attName}Increment){
this.${field.attName}Increment = ${field.attName}Increment;
}
/**
* 获取 ${field.remarks}
* @return ${field.attName}List
*/
public List<BigDecimal> get${field.attName?cap_first}List(){
return this.${field.attName}List;
}
/**
* 设置 ${field.remarks}
* @param ${field.attName}List
*/
public void set${field.attName?cap_first}List(List<BigDecimal> ${field.attName}List){
this.${field.attName}List = ${field.attName}List;
}
</#if>
<#if field.typeName == "java.util.Date">
/**
* 获取 开始 ${field.remarks}
* @return ${field.attName}Start
*/
public String get${field.attName?cap_first}Start(){
return this.${field.attName}Start;
}
/**
* 设置 开始 ${field.remarks}
* @param ${field.attName}Start
*/
public void set${field.attName?cap_first}Start(String ${field.attName}Start){
this.${field.attName}Start = ${field.attName}Start;
}
/**
* 获取 结束 ${field.remarks}
* @return ${field.attName}End
*/
public String get${field.attName?cap_first}End(){
return this.${field.attName}End;
}
/**
* 设置 结束 ${field.remarks}
* @param ${field.attName}End
*/
public void set${field.attName?cap_first}End(String ${field.attName}End){
this.${field.attName}End = ${field.attName}End;
}
</#if>
</#list>
<#list fields as field>
<#if field.typeName == "java.lang.Long">
/**
* 设置 ${field.remarks}
* @param ${field.attName}
*/
public ${entityClassName}Query ${field.attName}(Long ${field.attName}){
set${field.attName?cap_first}(${field.attName});
return this;
}
/**
* 设置 开始 ${field.remarks}
* @param ${field.attName}Start
*/
public ${entityClassName}Query ${field.attName}Start(Long ${field.attName}Start){
this.${field.attName}Start = ${field.attName}Start;
return this;
}
/**
* 设置 结束 ${field.remarks}
* @param ${field.attName}End
*/
public ${entityClassName}Query ${field.attName}End(Long ${field.attName}End){
this.${field.attName}End = ${field.attName}End;
return this;
}
/**
* 设置 增加 ${field.remarks}
* @param ${field.attName}Increment
*/
public ${entityClassName}Query ${field.attName}Increment(Long ${field.attName}Increment){
this.${field.attName}Increment = ${field.attName}Increment;
return this;
}
/**
* 设置 ${field.remarks}
* @param ${field.attName}List
*/
public ${entityClassName}Query ${field.attName}List(List<Long> ${field.attName}List){
this.${field.attName}List = ${field.attName}List;
return this;
}
</#if>
<#if field.typeName == "String">
/**
* 设置 ${field.remarks}
* @param ${field.attName}
*/
public ${entityClassName}Query ${field.attName}(String ${field.attName}){
set${field.attName?cap_first}(${field.attName});
return this;
}
/**
* 设置 ${field.remarks}
* @param ${field.attName}List
*/
public ${entityClassName}Query ${field.attName}List(List<String> ${field.attName}List){
this.${field.attName}List = ${field.attName}List;
return this;
}
</#if>
<#if field.typeName == "java.lang.Integer">
/**
* 设置 ${field.remarks}
* @param ${field.attName}
*/
public ${entityClassName}Query ${field.attName}(Integer ${field.attName}){
set${field.attName?cap_first}(${field.attName});
return this;
}
/**
* 设置 开始 ${field.remarks}
* @param ${field.attName}Start
*/
public ${entityClassName}Query ${field.attName}Start(Integer ${field.attName}Start){
this.${field.attName}Start = ${field.attName}Start;
return this;
}
/**
* 设置 结束 ${field.remarks}
* @param ${field.attName}End
*/
public ${entityClassName}Query ${field.attName}End(Integer ${field.attName}End){
this.${field.attName}End = ${field.attName}End;
return this;
}
/**
* 设置 增加 ${field.remarks}
* @param ${field.attName}Increment
*/
public ${entityClassName}Query ${field.attName}Increment(Integer ${field.attName}Increment){
this.${field.attName}Increment = ${field.attName}Increment;
return this;
}
/**
* 设置 ${field.remarks}
* @param ${field.attName}List
*/
public ${entityClassName}Query ${field.attName}List(List<Integer> ${field.attName}List){
this.${field.attName}List = ${field.attName}List;
return this;
}
</#if>
<#if field.typeName == "BigDecimal">
/**
* 设置 ${field.remarks}
* @param ${field.attName}
*/
public ${entityClassName}Query ${field.attName}(BigDecimal ${field.attName}){
set${field.attName?cap_first}(${field.attName});
return this;
}
/**
* 设置 开始 ${field.remarks}
* @param ${field.attName}Start
*/
public ${entityClassName}Query ${field.attName}Start(BigDecimal ${field.attName}Start){
this.${field.attName}Start = ${field.attName}Start;
return this;
}
/**
* 设置 结束 ${field.remarks}
* @param ${field.attName}End
*/
public ${entityClassName}Query ${field.attName}End(BigDecimal ${field.attName}End){
this.${field.attName}End = ${field.attName}End;
return this;
}
/**
* 设置 增加 ${field.remarks}
* @param ${field.attName}Increment
*/
public ${entityClassName}Query ${field.attName}Increment(BigDecimal ${field.attName}Increment){
this.${field.attName}Increment = ${field.attName}Increment;
return this;
}
/**
* 设置 ${field.remarks}
* @param ${field.attName}List
*/
public ${entityClassName}Query ${field.attName}List(List<BigDecimal> ${field.attName}List){
this.${field.attName}List = ${field.attName}List;
return this;
}
</#if>
<#if field.typeName == "java.util.Date">
/**
* 设置 开始 ${field.remarks}
* @param ${field.attName}Start
*/
public ${entityClassName}Query ${field.attName}Start(String ${field.attName}Start){
this.${field.attName}Start = ${field.attName}Start;
return this;
}
/**
* 设置 结束 ${field.remarks}
* @param ${field.attName}End
*/
public ${entityClassName}Query ${field.attName}End(String ${field.attName}End){
this.${field.attName}End = ${field.attName}End;
return this;
}
</#if>
</#list>
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<${entityClassName}Query> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<${entityClassName}Query> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<${entityClassName}Query> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<${entityClassName}Query> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
government-manager/src/main/resources/template/java/service.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
import com.mortals.framework.service.ICRUDService;
import ${pack}.model.${entityClassName}Entity;
/**
* <p>Title: ${entityDesc}</p>
* <p>Description: ${entityClassName}Service service接口 </p>
* <p>Copyright: Copyright &reg; </p>
* @version 1.0.0
*/
public interface ${entityClassName}Service extends ICRUDService<${entityClassName}Entity,Long>{
}
\ No newline at end of file
government-manager/src/main/resources/template/java/serviceImpl.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import ${pack}.dao.${entityClassName}Dao;
import ${pack}.model.${entityClassName}Entity;
import ${pack}.service.${entityClassName}Service;
/**
* <p>Title: ${entityDesc}</p>
* <p>Description: ${entityClassName}Service service接口 </p>
* <p>Copyright: Copyright &reg; </p>
* @version 1.0.0
*/
@Service("${entityClassName?uncap_first}Service")
public class ${entityClassName}ServiceImpl extends AbstractCRUDServiceImpl<${entityClassName}Dao, ${entityClassName}Entity, Long> implements ${entityClassName}Service {
}
\ No newline at end of file
government-manager/src/main/resources/template/java/submterDao.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
import com.mortals.framework.dao.ICRUDSubmeterDao;
import ${pack}.model.${entityClassName}Entity;
/**
* <p>Title: ${entityDesc}</p>
* <p>Description: ${entityClassName}Dao DAO接口 </p>
* @author
* @version 1.0.0
*/
public interface ${entityClassName}Dao extends ICRUDSubmeterDao<${entityClassName}Entity,Long>{
}
government-manager/src/main/resources/template/java/submterDaoImpl.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
import org.springframework.stereotype.Repository;
import com.mortals.framework.common.code.TaskExcuteStrategy;
import com.mortals.framework.dao.ibatis.SubmeterDaoImpl;
import com.mortals.framework.model.TableParam;
import com.mortals.framework.model.TableStrategy;
import ${pack}.dao.${entityClassName}Dao;
import ${pack}.model.${entityClassName}Entity;
/**
* <p>Title: ${entityDesc}</p>
* <p>Description: ${entityClassName}DaoImpl DAO接口 </p>
* @author
* @version 1.0.0
*/
@Repository("${entityClassName?uncap_first}Dao")
public class ${entityClassName}DaoImpl extends SubmeterDaoImpl<${entityClassName}Entity,Long> implements ${entityClassName}Dao {
@Override
protected TableStrategy getTableStrategy()
{
return new TableStrategy("mortals_iot_zd_${entityClassName?lower_case}_<#noparse>$</#noparse>{unionTime}", TableStrategy.${STRATEGY});
}
@Override
public TableParam getTableParam(${entityClassName}Entity entity)
{
TableParam param = new TableParam();
return param;
}
}
government-manager/src/main/resources/template/java/web.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.mortals.framework.web.BaseCRUDJsonController;
import org.springframework.web.bind.annotation.PostMapping;
import com.alibaba.fastjson.JSONObject;
import ${pack}.model.${entityClassName}Entity;
import ${pack}.service.${entityClassName}Service;
/**
* <p>Title: ${entityDesc}</p>
* <p>Description: ${entityClassName}Controller </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
*/
@RestController
@RequestMapping("${RequestMapping}")
public class ${entityClassName}Controller extends BaseCRUDJsonController<${entityClassName}Service,${entityClassName}Form,${entityClassName}Entity,Long> {
public ${entityClassName}Controller(){
super.setFormClass(${entityClassName}Form.class);
super.setModuleDesc( "${entityDesc}");
}
/**
* 查询${entityDesc}
*/
@PostMapping(value="list")
public String list(${entityClassName}Form form) {
try{
return super.list(form);
}catch(Exception e){
log.error("查询${entityDesc}列表错误",e);
JSONObject ret = new JSONObject();
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, super.convertException(e));
return ret.toJSONString();
}
}
/**
* 添加${entityDesc}
*/
@PostMapping(value="add")
public String add(${entityClassName}Form form) {
try{
return super.add(form);
}catch(Exception e){
log.error("添加${entityDesc}错误",e);
JSONObject ret = new JSONObject();
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, super.convertException(e));
return ret.toJSONString();
}
}
/**
* 编辑${entityDesc}
*/
@PostMapping(value="edit")
public String edit(${entityClassName}Form form) {
try{
return super.edit(form);
}catch(Exception e){
log.error("编辑${entityDesc}错误",e);
JSONObject ret = new JSONObject();
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, super.convertException(e));
return ret.toJSONString();
}
}
/**
* 保存${entityDesc}
*/
@PostMapping(value="save")
public String save(${entityClassName}Form form) {
try{
return super.save(request, response, form);
}catch(Exception e){
log.error("保存${entityDesc}错误",e);
JSONObject ret = new JSONObject();
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, super.convertException(e));
return ret.toJSONString();
}
}
/**
* 删除${entityDesc}
*/
@PostMapping(value="delete")
public String delete(${entityClassName}Form form) {
try{
return super.delete(request, response, form);
}catch(Exception e){
log.error("删除${entityDesc}错误",e);
JSONObject ret = new JSONObject();
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, super.convertException(e));
return ret.toJSONString();
}
}
/**
* 查看${entityDesc}
*/
@PostMapping(value="view")
public String view(${entityClassName}Form form) {
try{
return super.view(request, response, form);
}catch(Exception e){
log.error("查看${entityDesc}错误",e);
JSONObject ret = new JSONObject();
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, super.convertException(e));
return ret.toJSONString();
}
}
}
\ No newline at end of file
government-manager/src/main/resources/template/java/webForm.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
import com.mortals.framework.web.BaseCRUDFormLong;
import ${pack}.model.${entityClassName}Entity;
import ${pack}.model.${entityClassName}Query;
/**
* <p>Title: ${entityDesc}</p>
* <p>Description: ${entityClassName}Form </p>
* @author
* @version 1.0.0
*/
public class ${entityClassName}Form extends BaseCRUDFormLong<${entityClassName}Entity> {
private ${entityClassName}Entity entity = new ${entityClassName}Entity();
private ${entityClassName}Query query = new ${entityClassName}Query();
public ${entityClassName}Form(){
}
@Override
public ${entityClassName}Entity getEntity() {
return entity;
}
public void set${entityClassName}(${entityClassName}Entity entity) {
this.entity = entity;
}
@Override
public ${entityClassName}Query getQuery() {
return query;
}
public void setQuery(${entityClassName}Query query) {
this.query = query;
}
}
\ No newline at end of file
government-manager/src/main/resources/template/java/webMapp.ftl 0 → 100644
View file @ be4fe6cf
package ${entityPackageName};
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.mortals.framework.web.BaseCRUDJsonMappingController;
import ${pack}.model.${entityClassName}Entity;
import ${pack}.service.${entityClassName}Service;
/**
* <p>Title: ${entityDesc}</p>
* <p>Description: ${entityClassName}Controller </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author zxfei
* @version 1.0.0
*/
@RestController
@RequestMapping("${RequestMapping}")
public class ${entityClassName}Controller extends BaseCRUDJsonMappingController<${entityClassName}Service,${entityClassName}Form,${entityClassName}Entity,Long> {
public ${entityClassName}Controller(){
super.setFormClass(${entityClassName}Form.class);
super.setModuleDesc("${entityDesc}");
}
}
\ No newline at end of file
government-manager/src/main/resources/template/sql/db.ftl 0 → 100644
View file @ be4fe6cf
<#macro compress_single_line>
<#local captured><#nested></#local>
${ captured?replace("\\n\\r", "", "rm") }
</#macro>
<#list tables as table>
DROP TABLE IF EXISTS `${table.tableName}`;
<@compress_single_line>
CREATE TABLE `${table.tableName}`(
<#list table.fields as field>
<#if (field.pk)??>
<#if field.autoInc=='true'>
`${field.columnName}` ${field.sourceColumnType} NOT NULL auto_increment COMMENT '${field.remarks}',
<#else >
`${field.columnName}` ${field.sourceColumnType} NOT NULL COMMENT '${field.remarks}',
</#if>
<#else>
`${field.columnName}` ${field.sourceColumnType} ${ (field.isNotNull == '是') ?string('NOT NULL','DEFAULT NULL')}<#if (field.defaultValue)??> default '${field.defaultValue}'</#if> COMMENT '${field.remarks}',
</#if>
</#list>
PRIMARY KEY (`${table.pk}`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='${table.tableDesc}';
</@compress_single_line>
</#list>
<#list menus as menu>
<#--INSERT INTO `mortals_iot_menu` VALUES ('${menu.id}', '${menu.name}', '${menu.path}', '${menu.parentId}', '${menu.orderId}', '1', '0', '0','', '${menu.imgPath}', '', '', '0', '0', '3', null, null, null);-->
INSERT INTO `mortals_xhx_menu` VALUES ('${menu.id}', '${menu.name}', '${menu.path}', '${menu.parentId}', '${menu.orderId}','1','0','0','', null, '', '', '0', '0', '3',null, null, null);
</#list>
\ No newline at end of file
government-manager/src/main/resources/template/vue/webRouter.ftl 0 → 100644
View file @ be4fe6cf
import Vue from 'vue'
import Router from 'vue-router'
import Store from './store'
import Layout from './views/Layout.vue'
import fileNotFound from './views/errors/fileNotFound.vue'
Vue.use(Router);
const router = new Router({
routes: [
builder('/authentication', 'login/authentication'),
builder('/login', 'login/login'),
builder('/go', 'codeGen/index'),
{
path: '/',
name: 'layout',
component: Layout,
meta: {
requiresAuth: true
},
children: [
...restBuilder('oper/log', 'system/log'), // 系统管理-操作日志
...restBuilder('validcode', 'system/validcode'), // 接入管理-接入信息
...restBuilder('menu', 'system/menu'), // 系统管理--菜单管理
...restBuilder('resource', 'system/resource'), // 系统管理--资源管理
...restBuilder('role', 'system/role'), // 系统管理--角色管理
...restBuilder('user', 'system/user'), // 用户管理 -- 管理用户
...restBuilder('param', 'system/param'), // 系统管理--参数管理
...restBuilder('task', 'system/task'), // 系统管理--任务管理
...restBuilder('area', 'system/area'), // 系统管理-区域管理
<#list fields as field>
...restBuilder('${field.path}', '${component}'),
</#list>
...restBuilder('device/connhistory', 'device/connhistory'), // 设备管理-连接历史
...restBuilder('device', 'device'), // 系统管理-区域管理
//在此添加业务模块
//以下为基础路由配置
builder('', 'Home'),
builder('index', 'Home'),
builder('login/updatePwd', 'login/updatePwd'),
builder('403', 'errors/403'),
builder('*', 'errors/404'),
]
},
]
})
/**
* rest路由生成器
*
* @param {string} path 路径
* @param {string} [component=path] 文件地址
* @returns {array} [] reset路由数组，包含list/edit/add/view
*/
function restBuilder(path, component = path) {
let arr = [];
arr.push(builder(`<#noparse>$</#noparse>{path}/list`, `<#noparse>$</#noparse>{component}/list`));
arr.push(builder(`<#noparse>$</#noparse>{path}/edit`, `<#noparse>$</#noparse>{component}/show`));
arr.push(builder(`<#noparse>$</#noparse>{path}/add`, `<#noparse>$</#noparse>{component}/show`));
arr.push(builder(`<#noparse>$</#noparse>{path}/view`, `<#noparse>$</#noparse>{component}/show`));
return arr;
}
/**
* 路由生成器
*
* @param {string} path 路径
* @param {string} [component=path] 文件地址
* @param {boolean} [requiresAuth=false] 是否登录后才能访问
* @returns {any} {} 路由对象
*/
function builder(path, component = path, requiresAuth = false) {
return {
path: path,
name: path || 'homepage',
component: getComponent(component),
meta: {
requiresAuth: requiresAuth
}
}
}
function getComponent(fileName) {
try {
return require('./views/' + fileName).default
} catch (error) {
return fileNotFound;
}
}
//检查是否跳转到sso地址
function ssoCheck (to, from, next) {
let redirect = (to.path === '/login/updatePwd') ? '/#/updatePwd' : ''
redirect = (redirect === '' && to.path === '/login') ? (location.protocol + '//' + location.host + '/#' + from.fullPath) : redirect
if (redirect != '') {
next(false)
window.location.href = '//' + location.host + '/m/login/logout?redirect=' + encodeURIComponent(redirect)
return true;
}
return false;
}
router.afterEach(() => {
document.body.scrollTop = 0
document.documentElement.scrollTop = 0
})
// 路由鉴权
router.beforeEach((to, from, next) => {
// if (ssoCheck(to, from, next)) { //sso鉴权检查
// return
// }
if (to.matched.some(record => record.meta.requiresAuth)) {
if (Store.state.isLogin) {
next();
} else {
next({
path: '/authentication',
query: {
redirect: to.fullPath
}
})
}
} else {
next();
}
})
export default router;
\ No newline at end of file
government-manager/src/main/resources/template/vue/webVueList.ftl 0 → 100644
View file @ be4fe6cf
<template>
<div class="page">
<LayoutTable :data='tableData' :config='tableConfig' />
</div>
</template>
<script>
import table from "@/assets/mixins/table";
export default {
components: {
},
mixins: [table],
created() {
},
methods: {
},
data() {
return {
config: {
search: [
],
columns: [
{type: "selection", width: 60},
<#list fields as field>
<#if field.typeName == "java.lang.Long">
{label: "${field.sourceFieldName}", prop: "${field.attName}", formatter: this.formatterString},
</#if>
<#if field.typeName == "String"||field.typeName == "java.lang.Integer">
{label: "${field.sourceFieldName}", prop: "${field.attName}"},
</#if>
<#if field.typeName == "java.util.Date">
{label: "${field.sourceFieldName}", prop: "${field.attName}", formatter: this.formatterDate},
</#if>
<#if field.typeName == "BigDecimal">
{label: "${field.sourceFieldName}", prop: "${field.attName}", formatter: this.formatterMoney},
</#if>
</#list>
{
label: "操作",
width: 180,
formatter: row => {
return (
<div><el-button type="primary" icon="el-icon-edit" round size='mini' onClick={()=>{this.toEdit(row)}}>编辑</el-button></div>
);
}
}
]
}
};
}
};
</script>
\ No newline at end of file
government-manager/src/main/resources/template/vue/webVueShow.ftl 0 → 100644
View file @ be4fe6cf
？<template>
<layout-form>
<el-form :model="form" :loading="loading" :rules="rules" size='small' style="width:100%" label-width='120px' ref="form">
<el-row>
<#list fields as field>
<#if field.columnName != "id">
<Field label="${field.sourceFieldName}" prop="${field.columnName}" v-model="form.${field.columnName}" placeholder="请输入${field.sourceFieldName}"/>
</#if>
</#list>
</el-row>
<form-buttons @submit='submitForm'/>
</el-form>
</layout-form>
</template>
<script>
import form from "@/assets/mixins/form";
export default {
mixins: [form],
data() {
return {
rules: {
<#list fields as field>
<#if field.typeName == "String">
${field.columnName}:[${field.isNotNull}
{max: ${field.sourceTypeVal}, message: '最多只能录入${field.sourceTypeVal}个字符', trigger: 'blur'}],
</#if>
<#if field.typeName == "java.lang.Integer">
${field.attName}:[${field.isNotNull}{type: 'integer', trigger: 'blur'}],
</#if>
<#if field.typeName == "BigDecimal">
${field.attName}:[${field.isNotNull}{type: 'number', trigger: 'blur'}],
</#if>
<#if field.typeName == "java.util.Date">
${field.attName}:[${field.isNotNull}],
</#if>
</#list>
}
};
}
};
</script>
\ No newline at end of file
government-manager/src/main/resources/template/xml/sqlMap.ftl 0 → 100644
View file @ be4fe6cf
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="${entityPackageName}.dao.ibatis.${entityClassName}DaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="${entityClassName}Entity" id="${entityClassName}Entity-Map">
<#list fields as field>
<result property="${field.attName}" column="${field.columnName}" />
</#list>
</resultMap>
<#if isSubmeter??>
<update id="createTable" parameterType="paramDto">
CREATE TABLE `<#noparse>$</#noparse>{tableName}`(
<#list fields as field>
<#if (field.pk)??>
<#if field.autoInc=='true'>
`${field.columnName}` ${field.sourceColumnType} NOT NULL auto_increment COMMENT '${field.remarks}',
<#else >
`${field.columnName}` ${field.sourceColumnType} NOT NULL COMMENT '${field.remarks}',
</#if>
<#else>
`${field.columnName}` ${field.sourceColumnType} ${ (field.isNotNull == '是') ?string('NOT NULL','DEFAULT NULL')}<#if (field.defaultValue)??> default '${field.defaultValue}'</#if> COMMENT '${field.remarks}',
</#if>
</#list>
PRIMARY KEY (`${pk}`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='${entityPackageDesc}';
</update>
</#if>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<#list fields as field>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('${field.attName}') or colPickMode == 1 and data.containsKey('${field.attName}')))">
a.${field.columnName} as ${field.columnName},
</if>
</#list>
</trim>
</sql>
<!-- 新增 -->
<#if auto_inc=="true">
<insert id="insert" parameterType="${entityClassName}Entity" useGeneratedKeys="true" keyProperty="${pk}">
insert into ${sourceTableName}
(<#list fields as field><#if field.columnName != "${pk}">${field.columnName}<#sep>,</#if></#list>)
VALUES
(<#list fields as field><#if field.columnName != "${pk}"><#noparse>#</#noparse>{${field.attName}}<#sep>,</#if></#list>)
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into ${sourceTableName}
(<#list fields as field><#if field.columnName != "${pk}">${field.columnName}<#sep>,</#if></#list>)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(<#list fields as field><#if field.columnName != "${pk}"><#noparse>#</#noparse>{item.${field.attName}}<#sep>,</#if></#list>)
</foreach>
</insert>
<#else>
<insert id="insert" parameterType="${entityClassName}Entity" >
insert into ${sourceTableName}
(<#list fields as field>${field.columnName}<#sep>,</#list>)
VALUES
(<#list fields as field><#noparse>#</#noparse>{${field.attName}}<#sep>,</#list>)
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into ${sourceTableName}
(<#list fields as field>${field.columnName}<#sep>,</#list>)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(<#list fields as field><#noparse>#</#noparse>{item.${field.attName}}<#sep>,</#list>)
</foreach>
</insert>
</#if>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
<#if isSubmeter??>
update <#noparse>$</#noparse>{tableName} as a
<#else>
update ${sourceTableName} as a
</#if>
set
<trim suffixOverrides="," suffix="">
<#list fields as field>
<#if field.columnName != "id">
<if test="(colPickMode==0 and data.containsKey('${field.attName}')) or (colPickMode==1 and !data.containsKey('${field.attName}'))">
a.${field.columnName}=<#noparse>#</#noparse>{data.${field.attName}},
</if>
<#if field.typeName == "java.lang.Integer"||field.typeName == "java.lang.Long"||field.typeName == "BigDecimal">
<if test="(colPickMode==0 and data.containsKey('${field.attName}Increment')) or (colPickMode==1 and !data.containsKey('${field.attName}Increment'))">
a.${field.columnName}=ifnull(a.${field.columnName},0) + <#noparse>#</#noparse>{data.${field.attName}Increment},
</if>
</#if>
</#if>
</#list>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update ${sourceTableName} as a
<trim prefix="set" suffixOverrides=",">
<#list fields as field>
<#if field.columnName != "id">
<#if field.typeName == "String"||field.typeName == "java.util.Date">
<trim prefix="${field.columnName}=(case" suffix="ELSE ${field.columnName} end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('${field.attName}')) or (colPickMode==1 and !item.containsKey('${field.attName}'))">
when a.id=<#noparse>#</#noparse>{item.id} then <#noparse>#</#noparse>{item.${field.attName}}
</if>
</foreach>
</trim>
</#if>
<#if field.typeName == "java.lang.Integer"||field.typeName == "java.lang.Long"||field.typeName == "BigDecimal">
<trim prefix="${field.columnName}=(case" suffix="ELSE ${field.columnName} end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('${field.attName}')) or (colPickMode==1 and !item.containsKey('${field.attName}'))">
when a.id=<#noparse>#</#noparse>{item.id} then <#noparse>#</#noparse>{item.${field.attName}}
</when>
<when test="(colPickMode==0 and item.containsKey('${field.attName}Increment')) or (colPickMode==1 and !item.containsKey('${field.attName}Increment'))">
when a.id=<#noparse>#</#noparse>{item.id} then ifnull(a.${field.columnName},0) + <#noparse>#</#noparse>{item.${field.attName}Increment}
</when>
</choose>
</foreach>
</trim>
</#if>
</#if>
</#list>
</trim>
where ${pk} in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
<#noparse>#</#noparse>{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="${entityClassName}Entity-Map">
select <include refid="_columns"/>
from ${sourceTableName} as a
where a.${pk}=<#noparse>#</#noparse>{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from ${sourceTableName} as a where a.${pk}=<#noparse>#</#noparse>{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from ${sourceTableName} where ${pk} in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
<#noparse>#</#noparse>{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from ${sourceTableName} as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="${entityClassName}Entity-Map">
select <include refid="_columns"/>
from ${sourceTableName} as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from ${sourceTableName} as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="<#noparse>${_conditionParam_}</#noparse>"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
<#noparse>${_conditionType_}</#noparse> a.${pk}=<#noparse>#{${_conditionParam_}.id}</#noparse>
</if>
</if>
<#list fields as field>
<#if field.typeName == "java.lang.Long"||field.typeName == "java.lang.Integer"||field.typeName == "BigDecimal">
<if test="conditionParamRef.containsKey('${field.attName}')">
<if test="conditionParamRef.${field.attName} != null ">
<#noparse>${_conditionType_}</#noparse> a.${field.columnName} = <#noparse>#{${_conditionParam_}</#noparse>.${field.attName}}
</if>
<if test="conditionParamRef.${field.attName} == null">
<#noparse>${_conditionType_}</#noparse> a.${field.columnName} is null
</if>
</if>
<if test="conditionParamRef.containsKey('${field.attName}List')">
<#noparse>${_conditionType_}</#noparse> a.${field.columnName} in
<foreach collection="conditionParamRef.${field.attName}List" open="(" close=")" index="index" item="item" separator=",">
<#noparse>#{item}</#noparse>
</foreach>
</if>
<if test="conditionParamRef.containsKey('${field.attName}Start') and conditionParamRef.${field.attName}Start != null">
<#noparse>${_conditionType_}</#noparse> a.${field.columnName} <![CDATA[ >= ]]> <#noparse>#{${_conditionParam_}</#noparse>.${field.attName}Start}
</if>
<if test="conditionParamRef.containsKey('${field.attName}End') and conditionParamRef.${field.attName}End != null">
<#noparse>${_conditionType_}</#noparse> a.${field.columnName} <![CDATA[ <= ]]> <#noparse>#{${_conditionParam_}</#noparse>.${field.attName}End}
</if>
</#if>
<#if field.typeName == "String">
<if test="conditionParamRef.containsKey('${field.attName}')">
<if test="conditionParamRef.${field.attName} != null and conditionParamRef.${field.attName} != ''">
<#noparse>${_conditionType_}</#noparse> a.${field.columnName} like <#noparse>#{${_conditionParam_}</#noparse>.${field.attName}}
</if>
<if test="conditionParamRef.${field.attName} == null">
<#noparse>${_conditionType_}</#noparse> a.${field.columnName} is null
</if>
</if>
<if test="conditionParamRef.containsKey('${field.attName}List')">
<#noparse>${_conditionType_}</#noparse> a.${field.columnName} in
<foreach collection="conditionParamRef.${field.attName}List" open="(" close=")" index="index" item="item" separator=",">
<#noparse>#</#noparse>{item}
</foreach>
</if>
</#if>
<#if field.typeName == "java.util.Date">
<if test="conditionParamRef.containsKey('${field.attName}')">
<if test="conditionParamRef.${field.attName} != null ">
<#noparse>$</#noparse>{_conditionType_} a.${field.columnName} = <#noparse>#{$</#noparse>{_conditionParam_}.${field.attName}}
</if>
<if test="conditionParamRef.${field.attName} == null">
<#noparse>$</#noparse>{_conditionType_} a.${field.columnName} is null
</if>
</if>
<if test="conditionParamRef.containsKey('${field.attName}Start') and conditionParamRef.${field.attName}Start != null and conditionParamRef.${field.attName}Start!=''">
<#noparse>$</#noparse>{_conditionType_} a.${field.columnName} <![CDATA[ >= ]]> STR_TO_DATE(left(concat(<#noparse>#{$</#noparse>{_conditionParam_}.${field.attName}Start},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('${field.attName}End') and conditionParamRef.${field.attName}End != null and conditionParamRef.${field.attName}End!=''">
<#noparse>$</#noparse>{_conditionType_} a.${field.columnName} <![CDATA[ <= ]]> STR_TO_DATE(left(concat(<#noparse>#{$</#noparse>{_conditionParam_}.${field.attName}End},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</#if>
</#list>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
<#noparse> ${item.colName} ${item.sortKind}</#noparse>
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<#list fields as field>
<if test="orderCol.containsKey('${field.attName}')">
a.${field.columnName}
<if test='orderCol.${field.attName} != null and "DESC".equalsIgnoreCase(orderCol.${field.attName})'>DESC</if>
,
</if>
</#list>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
<#noparse>$</#noparse>{item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
government-manager/src/main/resources/template/xml/sqlMapTwo.ftl 0 → 100644
View file @ be4fe6cf
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="${entityPackageName}.dao.ibatis.${entityClassName}DaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="${entityClassName}Entity" id="${entityClassName}Entity-Map">
<#list fields as field>
<result property="${field.attName}" column="${field.columnName}" />
</#list>
</resultMap>
<#if isSubmeter??>
<update id="createTable" parameterType="paramDto">
CREATE TABLE `<#noparse>$</#noparse>{tableName}`(
<#list fields as field>
<#if field.columnName == "id">
`id` bigint(20) NOT NULL ${field.autoInc!""} COMMENT '${field.remarks}',
<#else >
<#if field.typeName == "String">
`${field.columnName}` ${field.sourceColumnType} CHARACTER SET utf8 COLLATE utf8_general_ci ${ (field.isNotNull == '是') ?string('NOT NULL','NULL DEFAULT NULL')} COMMENT '${field.remarks}',
<#else >
`${field.columnName}` ${field.sourceColumnType} ${ (field.isNotNull == '是') ?string('NOT NULL','NULL DEFAULT NULL')} COMMENT '${field.remarks}',
</#if>
</#if>
</#list>
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='${entityPackageDesc}';
</update>
</#if>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<#list fields as field>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('${field.columnName}') or colPickMode == 1 and data.containsKey('${field.columnName}')))">
a.${field.columnName} as ${field.columnName},
</if>
</#list>
</trim>
</sql>
<!-- 新增 -->
<#if auto_inc=="true">
<insert id="insert" parameterType="${entityClassName}Entity" useGeneratedKeys="true" keyProperty="id">
insert into ${sourceTableName}
(<#list fields as field><#if field.columnName != "id">${field.columnName}<#sep>,</#if></#list>)
VALUES
(<#list fields as field><#if field.columnName != "id"><#noparse>#</#noparse>{${field.columnName}}<#sep>,</#if></#list>)
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into ${sourceTableName}
(<#list fields as field><#if field.columnName != "id">${field.columnName}<#sep>,</#if></#list>)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(<#list fields as field><#if field.columnName != "id"><#noparse>#</#noparse>{item.${field.columnName}}<#sep>,</#if></#list>)
</foreach>
</insert>
<#else>
<insert id="insert" parameterType="${entityClassName}Entity" >
insert into ${sourceTableName}
(<#list fields as field>${field.columnName}<#sep>,</#list>)
VALUES
(<#list fields as field><#noparse>#</#noparse>{${field.columnName}}<#sep>,</#list>)
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into ${sourceTableName}
(<#list fields as field>${field.columnName}<#sep>,</#list>)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(<#list fields as field><#noparse>#</#noparse>{item.${field.columnName}}<#sep>,</#list>)
</foreach>
</insert>
</#if>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update ${sourceTableName} as a
set
<trim suffixOverrides="," suffix="">
<#list fields as field>
<#if field.columnName != "id">
<if test="(colPickMode==0 and data.containsKey('${field.columnName}')) or (colPickMode==1 and !data.containsKey('${field.columnName}'))">
a.${field.columnName}=<#noparse>#</#noparse>{data.${field.columnName}},
</if>
<#if field.typeName == "java.lang.Integer"||field.typeName == "java.lang.Long"||field.typeName == "BigDecimal">
<if test="(colPickMode==0 and data.containsKey('${field.columnName}Increment')) or (colPickMode==1 and !data.containsKey('${field.columnName}Increment'))">
a.${field.columnName}=ifnull(a.${field.columnName},0) + <#noparse>#</#noparse>{data.${field.columnName}Increment},
</if>
</#if>
</#if>
</#list>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update ${sourceTableName} as a
<trim prefix="set" suffixOverrides=",">
<#list fields as field>
<#if field.columnName != "id">
<#if field.typeName == "String"||field.typeName == "java.util.Date">
<trim prefix="${field.columnName}=(case" suffix="ELSE ${field.columnName} end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('${field.columnName}')) or (colPickMode==1 and !item.containsKey('${field.columnName}'))">
when a.id=<#noparse>#</#noparse>{item.id} then <#noparse>#</#noparse>{item.${field.columnName}}
</if>
</foreach>
</trim>
</#if>
<#if field.typeName == "java.lang.Integer"||field.typeName == "java.lang.Long"||field.typeName == "BigDecimal">
<trim prefix="${field.columnName}=(case" suffix="ELSE ${field.columnName} end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('${field.columnName}')) or (colPickMode==1 and !item.containsKey('${field.columnName}'))">
when a.id=<#noparse>#</#noparse>{item.id} then <#noparse>#</#noparse>{item.${field.columnName}}
</when>
<when test="(colPickMode==0 and item.containsKey('${field.columnName}Increment')) or (colPickMode==1 and !item.containsKey('${field.columnName}Increment'))">
when a.id=<#noparse>#</#noparse>{item.id} then ifnull(a.${field.columnName},0) + <#noparse>#</#noparse>{item.${field.columnName}Increment}
</when>
</choose>
</foreach>
</trim>
</#if>
</#if>
</#list>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
<#noparse>#</#noparse>{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="${entityClassName}Entity-Map">
select <include refid="_columns"/>
from ${sourceTableName} as a
where a.id=<#noparse>#</#noparse>{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from ${sourceTableName} as a where a.id=<#noparse>#</#noparse>{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from ${sourceTableName} where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
<#noparse>#</#noparse>{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from ${sourceTableName} as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="${entityClassName}Entity-Map">
select <include refid="_columns"/>
from ${sourceTableName} as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from ${sourceTableName} as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<#list fields as field>
<#if field.typeName == "java.lang.Long"||field.typeName == "java.lang.Integer"||field.typeName == "BigDecimal">
<if test="condition.containsKey('${field.columnName}')">
<if test="condition.${field.columnName} != null ">
and a.${field.columnName} = <#noparse>#</#noparse>{condition.${field.columnName}}
</if>
<if test="condition.${field.columnName} == null">
and a.${field.columnName} is null
</if>
</if>
<if test="condition.containsKey('${field.columnName}List')">
and a.${field.columnName} in
<foreach collection="condition.${field.columnName}List" open="(" close=")" index="index" item="item" separator=",">
<#noparse>#{item}</#noparse>
</foreach>
</if>
<if test="condition.containsKey('${field.columnName}Start') and condition.${field.columnName}Start != null">
<![CDATA[ and a.${field.columnName} >= <#noparse>#</#noparse>{condition.${field.columnName}Start} ]]>
</if>
<if test="condition.containsKey('${field.columnName}End') and condition.${field.columnName}End != null">
<![CDATA[ and a.${field.columnName} <= <#noparse>#</#noparse>{condition.${field.columnName}End} ]]>
</if>
</#if>
<#if field.typeName == "String">
<if test="condition.containsKey('${field.columnName}')">
<if test="condition.${field.columnName} != null and condition.${field.columnName} != ''">
and a.${field.columnName} like <#noparse>#</#noparse>{condition.${field.columnName}}
</if>
<if test="condition.${field.columnName} == null">
and a.${field.columnName} is null
</if>
</if>
<if test="condition.containsKey('${field.columnName}List')">
and a.${field.columnName} in
<foreach collection="condition.${field.columnName}List" open="(" close=")" index="index" item="item" separator=",">
<#noparse>#{item}</#noparse>
</foreach>
</if>
</#if>
<#if field.typeName == "java.util.Date">
<if test="condition.containsKey('${field.columnName}')">
<if test="condition.${field.columnName} != null ">
and a.${field.columnName} = <#noparse>#</#noparse>{condition.${field.columnName}}
</if>
<if test="condition.${field.columnName} == null">
and a.${field.columnName} is null
</if>
</if>
<if test="condition.containsKey('${field.columnName}Start') and condition.${field.columnName}Start != null and condition.${field.columnName}Start!=''">
<![CDATA[ and a.${field.columnName} >= STR_TO_DATE(left(concat(<#noparse>#</#noparse>{condition.${field.columnName}Start},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s') ]]>
</if>
<if test="condition.containsKey('${field.columnName}End') and condition.${field.columnName}End != null and condition.${field.columnName}End!=''">
<![CDATA[ and a.${field.columnName} <= STR_TO_DATE(left(concat( <#noparse>#</#noparse>{condition.${field.columnName}End},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ]]>
</if>
</#if>
</#list>
</if>
</sql>
<sql id="_orderCols_">
<#-- <if test="orderColList != null and !orderColList.isEmpty()">-->
<#-- order by-->
<#-- <trim suffixOverrides="," suffix="">-->
<#-- <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">-->
<#-- <#noparse> #{item.colName} #{item.sortKind}</#noparse>-->
<#-- </foreach>-->
<#-- </trim>-->
<#-- </if>-->
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<#list fields as field>
<if test="orderCol.containsKey('${field.columnName}') ">
a.${field.columnName}
<if test="orderCol.${field.columnName}!= null and orderCol.${field.columnName}== 'desc'" >
desc
</if>
,
</if>
</#list>
</trim>
</if>
</sql>
<#-- <sql id="_group_by_">-->
<#-- <if test="groupList != null and !groupList.isEmpty()">-->
<#-- GROUP BY-->
<#-- <trim suffixOverrides="," suffix="">-->
<#-- <foreach collection="groupList" open="" close="" index="index" item="item" separator=",">-->
<#-- <#noparse>#</#noparse>{item}-->
<#-- </foreach>-->
<#-- </trim>-->
<#-- </if>-->
<#-- </sql>-->
</mapper>
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment