Skip to content

A
attendance-performance-platform
Commit 468eee28 authored by dll's avatar dll
Browse files
Options

提交

parents 959b666f ef1b9707
Hide whitespace changes
Inline Side-by-side
Showing with 4117 additions and 2381 deletions
attendance-performance-manager-ui/admin/src/assets/utils/table.js
View file @ 468eee28
......@@ -103,6 +103,33 @@ const find = (list, key, val) => {
}
}
/**
* 构造树型结构数据
* @param {*} data 数据源
* @param {*} id id字段 默认 'id'
* @param {*} parentId 父节点字段 默认 'parentId'
* @param {*} children 孩子节点字段 默认 'children'
* @param {*} rootId 根Id 默认 0
*/
function handleTree(data, id, parentId, children, rootId) {
id = id || 'id'
parentId = parentId || 'parentId'
children = children || 'children'
rootId = rootId || Math.min.apply(Math, data.map(item => { return item[parentId] })) || 0
//对源数据深度克隆
const cloneData = JSON.parse(JSON.stringify(data))
//循环所有项
const treeData = cloneData.filter(father => {
let branchArr = cloneData.filter(child => {
//返回每一项的子级数组
return father[id] === child[parentId]
});
branchArr.length > 0 ? father.children = branchArr : '';
//返回第一层
return father[parentId] === rootId;
});
return treeData != '' ? treeData : data;
};
export {
formatter,
......@@ -110,4 +137,5 @@ export {
formatterDate,
formatterDateOnly,
find,
handleTree
};
attendance-performance-manager-ui/admin/src/components/Header.vue
View file @ 468eee28
......@@ -73,7 +73,6 @@ export default {
this.$router.push({path})
let thirdArr = this.headBar.children.find(item => item.path === path)
let arr = []
console.log(thirdArr,'ssssss')
if(thirdArr.children.length === 0){
arr.push(
{
......
attendance-performance-manager-ui/admin/src/store.js
View file @ 468eee28
......@@ -14,9 +14,7 @@ try {
userData = JSON.parse(window.sessionStorage.userData || '{}');
currentParentName = window.sessionStorage.currentParentName || ''
headBar = JSON.parse(window.sessionStorage.headBar || '{}')
CurrentThirdArr = JSON.parse(window.sessionStorage.CurrentThirdArr || '{}')
ThirdPath = window.sessionStorage.ThirdPath || ''
CurrentSecondPath = window.sessionStorage.CurrentSecondPath || ''
} catch (error) {
......
attendance-performance-manager-ui/admin/src/views/attendance/leave/record/drawershow.vue
View file @ 468eee28
......@@ -7,7 +7,7 @@
size="50%">
<el-form ref="form" :model="form" :rules="rules" label-width="120px">
<el-row>
<Field label="请假人id" prop="leavePersonId" v-model="form.leavePersonId" placeholder="请输入请假人id"/>
<Field label="请假人id" prop="leavePersonId" v-model="form.leavePersonId" placeholder="请输入请假人id"/>
<Field label="请假人" prop="leavePerson" v-model="form.leavePerson" placeholder="请输入请假人"/>
<Field label="所属部门id" prop="deptId" v-model="form.deptId" placeholder="请输入所属部门id"/>
<Field label="所属部门" prop="deptName" v-model="form.deptName" type="textarea" placeholder="请输入所属部门"/>
......
attendance-performance-manager-ui/admin/src/views/attendance/leave/record/list.vue
View file @ 468eee28
<template>
<div class="page">
<LayoutTable :data="tableData" :config="tableConfig">
</LayoutTable>
<LayoutTable :data="tableData" :config="tableConfig"></LayoutTable>
<drawer-show ref="drawerform" @ok="getData" />
......
attendance-performance-manager-ui/admin/src/views/dept/list.vue
View file @ 468eee28
......@@ -49,6 +49,7 @@
// fuzzy: true
// },
// ],
showType:'treetable',
isshowTabPane:true,
columns: [
{type: "selection", width: 60},
......
attendance-performance-manager-ui/admin/src/views/job/list.vue
View file @ 468eee28
......@@ -50,6 +50,7 @@
},
mixins: [table,tree],
created() {
this.getpositions()
},
computed:{
thirdList(){
......@@ -75,7 +76,9 @@
},
// 获取全部职位
getpositions(){
this.$post("/job/treeselect", {}).then(({ data }) => {
this.areaData = data.result
})
},
handleClick(key){
this.$store.commit('setThirdPath',key)
......@@ -131,8 +134,7 @@
}
}
]
},
areaData:[]
}
}
}
};
......
attendance-performance-manager-ui/admin/src/views/staff/care/list.vue
View file @ 468eee28
......@@ -170,7 +170,7 @@ export default {
}, { type: "excel" }).then(() => this.isExport = false).catch(error => {
this.isExport = false;
this.$message.error(error.message);
});
})
},
/** 重写新增方法 */
toAdd(row) {
......
attendance-performance-manager-ui/admin/src/views/staff/drawershow.vue
View file @ 468eee28
......@@ -24,7 +24,7 @@
<Field label="所属部门" prop="deptName" v-model="form.deptName" placeholder="请选择所属部门" @focus="ishowBumen = true"/>
<Field label="职位" prop="positionId" v-model="form.positionId" type="select" placeholder="请选择职位" />
<Field label="职位" prop="positionId" v-model="form.positionId" :enumData="dict.politicalstatus" type="select" placeholder="请选择职位" />
<Field label="工号" prop="workNum" v-model="form.workNum" placeholder="请输入工号"/>
......
attendance-performance-manager-ui/admin/src/views/staff/list.vue
View file @ 468eee28
......@@ -43,7 +43,7 @@
<el-row>
<LayoutTable notDel :data="tableData" :config="tableConfig">
<el-button type="primary"
<el-button type="primary" @click="doExport" :disabled="isExport"
size="mini" slot="table-head-left2">导出</el-button>
<el-dropdown class="moreControll" slot="table-head-left2" style="margin-left:20px">
<el-button type="primary" size="mini">
......@@ -167,6 +167,16 @@
this.currentNode = node;
this.query = { deptId: node.id };
this.getData();
},
doExport(){
this.isExport = true;
this.$download("/staff/list/exportExcel", {
"idList": this.selection,
'name': this.$route.query['name'],
}, { type: "excel" }).then(() => this.isExport = false).catch(error => {
this.isExport = false;
this.$message.error(error.message);
})
}
},
data() {
......@@ -189,8 +199,14 @@
{
name: "name",
type: "text",
label: "员工姓名或手机号",
label: "员工姓名",
fuzzy: true
},
{
name:'phoneNumber',
type:'text',
label:'手机号',
fuzzy:true
}
],
columns: [
......@@ -218,7 +234,8 @@
},
activeName:'first',
isshowHome:false,
personData:[]
personData:[],
isExport:false
}
},
computed:{
......@@ -247,6 +264,9 @@
</style>
<style lang="scss" scoped>
.page{
min-width: 1400px;
}
.totalNum{
background: rgba(64, 158, 255,0.2);
padding: 15px;
......
attendance-performance-manager-ui/admin/src/views/system/menu/dialogshow.vue
View file @ 468eee28
// 添加，编辑设备
<template>
<!-- 弹出框表单 -->
<el-dialog :title="title" :visible.sync="open" width="35%" append-to-body>
<el-form
ref="form"
:model="form"
:rules="rules"
label-width="110px"
label-position="right"
>
<el-dialog :title="title" :visible.sync="open" width="90%" append-to-body>
<el-form ref="form" :model="form" :rules="rules" label-width="120px">
<el-row>
<Field
:span="22"
label="ID"
prop="id"
v-model="form.id"
v-if="pageInfo.type !== 'add'"
disabled
/>
<Field :span="22" label="名称" prop="name" v-model="form.name" />
<Field
:span="22"
label="权限类型"
prop="authType"
v-model="form.authType"
:enumData="dict.authType"
type="select"
/>
<Field
:span="22"
label="父级菜单"
prop="parentId"
v-model="form.parentId"
:enumData="menu"
type="select"
/>
<Field :span="22" label="访问地址" prop="url" v-model="form.url" />
<Field
:span="22"
label="状态"
prop="status"
v-model="form.status"
:enumData="dict.status"
type="radio"
/>
<el-col :span="24" v-if="form.parentId !== 0">
<el-form-item label="上级节点" prop="parentId">
<treeselect
v-model="form.parentId"
:options="menuOptions"
:normalizer="normalizer"
placeholder="选择上级菜单信息"
/>
</el-form-item>
</el-col>
<Field
:span="22"
label="图标"
placeholder="请输入图标名称"
prop="imgPath"
v-model="form.imgPath"
/>
<!-- <Field v-else :span="22" label="图标" prop="imgPath">
<el-radio-group v-model="form.imgPath" class="form-el-radio-group">
<el-radio-button label="">不需要图标</el-radio-button>
<el-radio-button
v-for="(icon, index) in icons"
:key="index"
:label="icon"
>
<i :class="'el-icon-' + icon"></i>
{{ icon }}
<!--<Field label="ID" prop="id" v-model="form.id" v-if='pageInfo.type !== "add"' disabled />-->
<Field label="名称" prop="name" v-model="form.name"/>
<Field label="权限类型" prop="authType" v-model="form.authType" :enumData='dict.authType' type='select' />
<Field label="访问地址" prop="url" v-model="form.url" />
<Field label="状态" prop="status" v-model="form.status" :enumData='dict.status' type='radio' />
<Field class="radio-group-container" label="图标" prop="imgPath" :span='24'>
<el-radio-group v-model="form.imgPath" class='form-el-radio-group'>
<el-radio-button style="width: 180px" label="">不需要图标</el-radio-button>
<el-radio-button style="width: 180px" v-for='(icon, index) in icons' :key='index' :label="icon">
<i :class="'el-icon-'+icon" style="font-size: 20px"></i>
{{icon}}
</el-radio-button>
</el-radio-group>
</Field> -->
</Field>
</el-row>
</el-form>
<div slot="footer" class="dialog-footer">
<el-button
type="primary"
v-if="pageInfo.type !== 'view'"
@click="submitForm"
>确 定</el-button
>
<el-button type="primary" @click="submitForm">确 定</el-button>
<el-button @click="cancel">取 消</el-button>
</div>
</el-dialog>
......@@ -81,55 +39,81 @@
<script>
import form from "@/assets/mixins/formdialog";
import dialogShow from "./dialogshow";
import Treeselect from "@riophae/vue-treeselect";
import "@riophae/vue-treeselect/dist/vue-treeselect.css";
import axios from 'axios'
export default {
mixins: [form],
components: {
dialogShow,
Treeselect,
},
computed: {
menu() {
let menu = { 0: "无" };
this.$store.state.userData.barList.forEach((item) => {
menu[item.id + ""] = item.name;
});
return menu;
}
data() {
return {
fileContent:"",
icons: [
'info', 'error', 'success', 'warning', 'question',
'tickets', 'document', 'goods', 'sold-out', 'news',
'message', 'date', 'printer', 'time', 'bell',
'mobile-phone', 'service', 'view', 'menu', 'star-on',
'location', 'phone', 'picture', 'delete', 'search',
'edit', 'rank', 'refresh', 'share', 'setting',
'upload', 'upload2', 'download', 'loading',
],
menuOptions: [],
// 遮罩层
loading: true,
// 弹出层标题
title: "菜单信息",
// 是否显示弹出层
open: false,
toString:[
"status",
"linkType",
"commMenu",
"menuType",
"authType",
],
// 表单校验
rules: {
}
};
},
created() {
axios.get('/icon.txt')
.then(response => {
this.fileContent = response.data
this.icons = this.fileContent.split('\n')
})
},
methods: {
afterSubmit() {
this.$store.dispatch("login");
this.$router.go(-1);
},
/** 编辑 */
edit(row) {
this.reset();
edit(row, menuOptions) {
this.reset()
this.query = { id: row.id };
this.urls.currUrl = this.pageInfo.editUrl;
this.urls.currUrl =this.pageInfo.editUrl;;
this.getData();
this.pageInfo.type = "edit";
this.title = "修改菜单";
this.menuOptions = menuOptions;
this.title = "修改菜单信息";
},
/** 新增 */
add(row) {
this.reset();
add(row, menuOptions) {
this.reset()
this.query = { id: row.id };
this.urls.currUrl = this.pageInfo.addUrl;
this.getData();
this.pageInfo.type = "add";
this.open = true;
this.title = "新增菜单";
if(row.id){
this.form.parentId=row.id
}
this.menuOptions = menuOptions;
this.title = "新增菜单信息";
},
/** 查看*/
view(row) {
this.reset();
view(row, menuOptions) {
this.query = { id: row.id };
this.urls.currUrl = this.pageInfo.viewUrl;
this.urls.currUrl =this.pageInfo.viewUrl;;
this.getData();
this.pageInfo.type = "view";
this.open = true;
this.title = "菜单详细";
this.menuOptions = menuOptions;
this.title = "菜单信息详细";
},
/**取消按钮 */
cancel() {
......@@ -139,14 +123,42 @@ export default {
afterRender(data) {
this.open = true;
},
afterSubmit(data) {
this.open = false;
this.$emit("ok");
},
/** 转换菜单信息数据结构 */
normalizer(node) {
if (node.children && !node.children.length) {
delete node.children;
}
return {
id: node.id,
label: node.name,
children: node.children,
};
},
// 表单重置
reset() {
// this.form={}
this.form = {
name : null,
url : null,
ancestors : null,
parentId : null,
orderId : null,
status : 1,
linkType : 0,
groupId : 1,
groupName : null,
imgPath : null,
buttonImgPath : null,
imgCommPath : null,
commMenu : 0,
menuType : 0,
authType : 3,
createUserName : null,
};
this.resetForm("form");
},
resetForm(refName) {
......@@ -155,74 +167,42 @@ export default {
}
},
},
data() {
return {
// 遮罩层
loading: true,
// 弹出层标题
title: "菜单",
// 是否显示弹出层
open: false,
toString: ["parentId", "authType", "status"],
icons: [
"info",
"error",
"success",
"warning",
"question",
"tickets",
"document",
"goods",
"sold-out",
"news",
"message",
"date",
"printer",
"time",
"bell",
"mobile-phone",
"service",
"view",
"menu",
"star-on",
"location",
"phone",
"picture",
"delete",
"search",
"edit",
"rank",
"refresh",
"share",
"setting",
"upload",
"upload2",
"download",
"loading",
"reading",
],
rules: {
name: [{ required: true, message: "请输入名称", trigger: "blur" }],
},
};
},
};
</script>
<style lang="less">
.el-select {
width: 100%;
}
.el-date-editor.el-input {
width: 100%;
}
.form-el-radio-group.label {
width: 160px;
<style lang="scss">
.ml-row {
margin-bottom: 5px;
}
.el-radio-button__inner {
border: 0;
// width: 82px;
height: 36px;
border-radius: 4px 0px 0px 4px;
border: 1px solid rgba(0, 0, 0, 0) !important;
border-radius: 2px !important;
background-color: rgba(0, 0, 0, 0);
font-size: 14px;
font-weight: 400;
color: #606677;
line-height: 14px;
outline: none;
box-shadow: none;
}
</style>
.el-radio-button__orig-radio:checked+.el-radio-button__inner {
background: rgba(0, 0, 0, 0);
border: 1px solid #3E7BFA !important;
color: #3E7BFA;
line-height: 14px;
outline: none;
box-shadow: none;
}
.ml-top-button {
border-color: #ffffff;
background: rgba(0, 0, 0, 0);
font-size: 16px;
margin: 0 10px 0 10px;
}
</style>
attendance-performance-manager-ui/admin/src/views/system/menu/list.vue
View file @ 468eee28
<template>
<div class="page">
<!-- <LayoutTable :data='tableData' :config='tableConfig' notPagination /> -->
<!-- <dialog-show ref="dialogform" @ok="getData" /> -->
<el-table
:data="tableData"
style="width: 100%;margin-bottom: 20px;"
row-key="id"
border
default-expand-all
:tree-props="{children: 'children', hasChildren: 'hasChildren'}">
<el-table-column
v-for="(item,index) in config.columns" :key="index"
:prop="item.prop"
:label="item.label"
width="180">
</el-table-column>
</el-table>
<el-pagination
@size-change="handleSizeChange"
@current-change="handleCurrentChange"
:current-page="query.page"
:page-sizes="[10, 20, 30, 40]"
:page-size="query.size"
layout="total, sizes, prev, pager, next, jumper"
:total="total">
</el-pagination>
<div className="page">
<el-card>
<LayoutTable notPagination ref="layoutTable" :data="tableData" :config="tableConfig"/>
</el-card>
<dialog-show ref="dialogform" @ok="getData"/>
</div>
</template>
<script>
// import table from '@/assets/mixins/table';
import {handleTree} from "@/assets/utils/table";
import Treeselect from "@riophae/vue-treeselect";
import "@riophae/vue-treeselect/dist/vue-treeselect.css";
import table from "@/assets/mixins/table";
import dialogShow from "./dialogshow";
export default {
// mixins: [table],
components: { dialogShow },
name: "Menu",
mixins: [table],
components: {Treeselect, dialogShow},
created() {
this.query={"page":1,"size":-1}
},
methods: {
// 菜单表格
gettableList(){
this.$post('/menu/list',this.query).then(res => {
if(res.code == 1){
// 原数组
let arr = res.data.data
this.tableData = this.resetTableList(arr)
this.total = res.data.total
}
})
},
// 重排表格
resetTableList(arr){
let result = arr.map(item => {
// 一级目录
if(item.childList.length == 0){
return {
...item,
children:[]
}
}else if(item.childList.length > 0){
return {
...item,
children:this.resetTableList(item.childList)
}
}
})
return result
},
//
handleSizeChange(size){
this.query.size = size
this.gettableList()
},
handleCurrentChange(page){
this.query.page = page
this.gettableList()
},
beforeRender(data) {
this.allMenu = this.sortByGroup(this.util_copy(data.data));
console.log(this.allMenu,'菜单数据')
// 存在查询条件，展开全部
if(Object.keys(this.$route.query).length) {
this.select = this.allMenu.filter(i=>!i.parentId).map(i=>i.id);
}
return data;
},
afterRender() {
this.showChild();
},
// 按parentId排序分组
sortByGroup(data) {
return data.filter(i=>!i.parentId).reduce((prev, item)=>{
return prev.concat([item], data.filter(i=>i.parentId == item.id))
}, [])
},
//重排table
resetTable(arr){
// 一级父级
afterRender(data) {
console.log(data)
data.data = handleTree(data.data, "id", "parentId");
console.log("tree data:",data.data)
this.menuOptions = data.data;
this.$refs.layoutTable.showType = "treetable"
},
// 查看下级菜单
selectHandler({id}) {
// 如果已展开，则关闭
const index = this.select.indexOf(id);
if(index > -1) {
this.select.splice(index, 1);
}else{
this.select.push(id);
}
this.showChild();
},
showChild() {
this.tableData.data = this.allMenu.filter(item=>{
return !item.parentId || this.select.indexOf(item.parentId) > -1
})
},
// 展示菜单图标
showIcon(row, column) {
return <i class={'el-icon-'+row.imgPath}></i>
},
// 操作菜单状态
changeStatus(row, column) {
return (
<my-switch
confirm
url='/menu/save'
row={row}
onChange={this.statusChange}
value={this.tableData.data}
onInput={(data)=>{
this.tableData.data = data;
}}/>
)
},
afterDel(id) {
this.$store.dispatch('login');
},
statusChange() {
this.$store.dispatch('login');
},
handleUp(data) {
handleUp(data) {
let type = 0;
let url = "/menu/upOrDown";
this.switchSort(url, data.id, type);
......@@ -146,7 +38,7 @@ export default {
handleDown(data) {
let type = 1;
let url = "/menu/upOrDown";
let url = "/menu/upOrDown";
this.switchSort(url, data.id, type);
},
......@@ -156,69 +48,85 @@ export default {
id: id,
type: type,
})
.then((res) => {
if (res && res.code && res.code == 1) {
this.getData()
.then((res) => {
if (res && res.code && res.code == 1) {
this.getData()
this.loading = false;
this.$message.success("更新排序成功！");
}
})
.catch((error) => {
this.loading = false;
this.$message.success("更新排序成功！");
}
})
.catch((error) => {
this.loading = false;
this.$message.error(error.message);
});
this.$message.error(error.message);
});
},
handleAdd(row) {
this.$refs.dialogform.add(row, this.menuOptions);
},
/** 重写新增方法 */
// toAdd(row) {
// this.$refs.dialogform.add(row);
// },
// /** 重写编辑方法 */
// toEdit(row) {
// this.$refs.dialogform.edit(row);
// },
// /** 重写查看方法 */
// toView(row) {
// this.$refs.dialogform.view(row);
// },
toAdd(row) {
this.$refs.dialogform.add(row, this.menuOptions);
},
/** 重写编辑方法 */
toEdit(row) {
this.loading = true;
this.$post(this.pageInfo.exclude, {id: row.id})
.then((res) => {
if (res && res.code && res.code == 1) {
this.menuOptions = handleTree(res.data.data);
this.$refs.dialogform.edit(row, this.menuOptions);
this.loading = false;
}
})
.catch((error) => {
this.$message.error(error.message);
});
},
/** 重写查看方法 */
toView(row) {
this.$refs.dialogform.view(row, this.menuOptions);
},
// 展示菜单图标
showIcon(row, column) {
return <i class={'el-icon-'+row.imgPath}></i>
},
// 操作菜单状态
changeStatus(row, column) {
return (
<my-switch
confirm
url='/menu/save'
row={row}
onChange={this.statusChange}
value={this.tableData.data}
onInput={(data)=>{
this.tableData.data = data;
}}/>
)
},
statusChange() {
this.$store.dispatch('login');
},
},
data() {
return {
tableData:[],
allMenu: [], // 经过分组排序的表格数据
select: [], // 当前展开的树节点
query: {
page:1,
size:10
},
total:0,
config: {
search: [
/** 树表是否默认展开 */
expand: false,
showType: "treetable",
search: [],
columns: [
{
name: 'name',
type: 'text',
label: '菜单名称',
type: 'selection',
width: 60,
},
],
columns: [
// { type: "selection",reserveSelection:true, width: 60 },
// { type: "index", label: "序号",align:"center", width: 50 },
// {
// width: 60,
// formatter: row => {
// const icon = this.select.indexOf(row.id) === -1 ? 'right' : 'down';
// return (
// !row.parentId||row.childList.length>0
// ? <div onClick={()=>{this.selectHandler(row)}}>
// <i class={'el-icon-arrow-'+icon}></i>
// </div>
// : ''
// )
// }
// },
{
prop: 'id',
label: 'ID',
width: 60,
width: 120,
},
{
prop: 'name',
......@@ -228,8 +136,8 @@ export default {
{
prop: 'imgPath',
label: '图标',
width: 120,
// formatter: this.showIcon,
width: 50,
formatter: this.showIcon,
},
{
prop: 'authType',
......@@ -250,43 +158,54 @@ export default {
width: 100,
formatter: this.changeStatus,
},
// {
// label: '操作',
// formatter: (row)=> {
// return (
// <div>
// <el-link
// style="margin-right:5px;margin-left:5px"
// icon="el-icon-top"
// onClick={() => {
// this.handleUp(row);
// }}
// ></el-link>
{
label: "操作",
width: 280,
formatter: row => {
return (
<div>
<el-link
style="margin-right:5px;margin-left:5px"
icon="el-icon-top"
onClick={() => {
this.handleUp(row);
}}
></el-link>
// <el-link
// style="margin-right:5px;margin-left:5px"
// icon="el-icon-bottom"
// onClick={() => {
// this.handleDown(row);
// }}
// ></el-link>
<el-link
style="margin-right:5px;margin-left:5px"
icon="el-icon-bottom"
onClick={() => {
this.handleDown(row);
}}
// <table-buttons noView row={row} onEdit={this.toEdit} onDel={this.toDel} />
></el-link>
// </div>
// )
// },
// },
],
},
}
},
created(){
this.gettableList()
<el-button
size="mini"
type="text"
icon="el-icon-edit-outline"
onClick={() => {
this.handleAdd(row);
}}
>
新增
</el-button>
<table-buttons
noAdd
noView
row={row}
onEdit={this.toEdit}
onView={this.toView}
onDel={this.toDel}
/>
</div>
);
}
}
]
}
};
}
}
};
</script>
attendance-performance-manager/src/main/java/com/mortals/xhx/base/framework/interceptor/AuthTokenServiceImpl.java
View file @ 468eee28
......@@ -56,8 +56,8 @@ public class AuthTokenServiceImpl implements IAuthTokenService {
@Value("${token.database:0}")
private Integer portalDb;
@Autowired
private IUserFeign userFeign;
// @Autowired
// private IUserFeign userFeign;
protected static final Long SECOND = 1l;
......
attendance-performance-manager/src/main/java/com/mortals/xhx/base/login/web/LoginController.java
View file @ 468eee28
......@@ -21,11 +21,7 @@ import com.mortals.xhx.base.system.user.model.UserEntity;
import com.mortals.xhx.base.system.user.service.UserService;
import com.mortals.xhx.base.system.valid.service.ValidCodeService;
import com.mortals.xhx.common.key.RedisKey;
import com.mortals.xhx.common.pdu.user.UserPdu;
import com.mortals.xhx.feign.user.IUserFeign;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.RequestBody;
......@@ -59,8 +55,7 @@ public class LoginController extends BaseCRUDJsonBodyMappingController<UserServi
private ICacheService cacheService;
@Autowired
private IAuthTokenService authTokenService;
@Autowired
private IUserFeign userFeign;
@RequestMapping("login")
public String login(@RequestBody LoginForm loginForm) throws Exception {
......
attendance-performance-manager/src/main/java/com/mortals/xhx/base/system/menu/dao/MenuDao.java
View file @ 468eee28
/**
* 文件：MenuDao.java
* 版本：1.0.0
* 日期：
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.menu.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.base.system.menu.model.MenuEntity;
import java.util.List;
/**
* <p>Title: 菜单信息</p>
* <p>Description: MenuDao DAO接口 </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
*/
* 菜单信息Dao
* 菜单信息 DAO接口
*
* @author zxfei
* @date 2023-04-10
*/
public interface MenuDao extends ICRUDDao<MenuEntity,Long>{
/**
* 查询子节点
*
* @param
* @return
*/
List<MenuEntity> selectChildrenMenuById(String menuId);
public interface MenuDao extends ICRUDDao<MenuEntity,Long> {
}
\ No newline at end of file
}
attendance-performance-manager/src/main/java/com/mortals/xhx/base/system/menu/dao/ibatis/MenuDaoImpl.java
View file @ 468eee28
/**
* 文件：MenuDaoImpl.java
* 版本：1.0.0
* 日期：
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.menu.dao.ibatis;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import com.mortals.xhx.base.system.menu.dao.MenuDao;
import com.mortals.xhx.base.system.menu.model.MenuEntity;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* <p>Title: 菜单信息</p>
* <p>Description: MenuDaoImpl DAO接口 </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
*/
* 菜单信息DaoImpl DAO接口
*
* @author zxfei
* @date 2023-04-10
*/
@Repository("menuDao")
public class MenuDaoImpl extends BaseCRUDDaoMybatis<MenuEntity,Long> implements MenuDao {
}
\ No newline at end of file
@Override
public List<MenuEntity> selectChildrenMenuById(String menuId) {
return getSqlSession().selectList(getSqlId("selectChildrenMenuById"), menuId);
}
}
attendance-performance-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuEntity.java
View file @ 468eee28
/**
* 文件：MenuEntity.java
* 版本：1.0.0
* 日期：
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.menu.model;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.menu.model.vo.MenuVo;
/**
* <p>Title: 菜单信息</p>
* <p>Description: MenuEntity </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
* 菜单信息实体对象
*
* @author zxfei
* @date 2023-04-10
*/
public class MenuEntity extends BaseEntityLong{
private static final long serialVersionUID = 1547777703328L;
/** 菜单名称 */
private String name;
/** 连接地址 */
private String url;
/** 父菜单ID，一级菜单的该字段值为-1 */
private Long parentId;
/** 排序编号 */
private Integer orderId;
/** 菜单状态，0：禁用，1：启用，默认1 */
private Integer status;
/** 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkType;
/** 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Integer groupId;
/** 分组名称 */
private Integer groupName;
/** 主菜单图标，主菜单图标的css样式名 */
private String imgPath;
/** 按钮图标，按钮图标的css样式名 */
private String buttonImgPath;
/** 常用菜单图标，常用菜单图标的css样式名 */
private String imgCommPath;
/** 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenu;
/** 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuType;
/** 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authType;
/** 创建时间 */
private Date createTime;
/** 创建用户 */
private String createUser;
/** 创建用户名称 */
private String createUserName;
private Integer type;
private List<MenuEntity> childList = new ArrayList<MenuEntity>();
public MenuEntity() {
}
public Integer getType() {
return type;
}
public void setType(Integer type) {
this.type = type;
}
/**
* 获取 菜单名称
* @return name
*/
public String getName() {
return this.name;
}
/**
* 设置 菜单名称
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取 连接地址
* @return url
*/
public String getUrl() {
return this.url;
}
/**
* 设置 连接地址
* @param url
*/
public void setUrl(String url) {
this.url = url;
}
/**
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentId
*/
public Long getParentId() {
return this.parentId;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentId
*/
public void setParentId(Long parentId) {
this.parentId = parentId;
}
/**
* 获取 排序编号
* @return orderId
*/
public Integer getOrderId() {
return this.orderId;
}
/**
* 设置 排序编号
* @param orderId
*/
public void setOrderId(Integer orderId) {
this.orderId = orderId;
}
/**
* 获取 菜单状态，0：禁用，1：启用，默认1
* @return status
*/
public Integer getStatus() {
return this.status;
}
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param status
*/
public void setStatus(Integer status) {
this.status = status;
}
/**
* 获取 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkType
*/
public Integer getLinkType() {
return this.linkType;
}
/**
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkType
*/
public void setLinkType(Integer linkType) {
this.linkType = linkType;
}
/**
* 获取 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupId
*/
public Integer getGroupId() {
return this.groupId;
}
/**
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupId
*/
public void setGroupId(Integer groupId) {
this.groupId = groupId;
}
public Integer getGroupName() {
return groupName;
}
public void setGroupName(Integer groupName) {
this.groupName = groupName;
}
/**
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPath
*/
public String getImgPath() {
return this.imgPath;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPath
*/
public void setImgPath(String imgPath) {
this.imgPath = imgPath;
}
/**
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPath
*/
public String getButtonImgPath() {
return this.buttonImgPath;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPath
*/
public void setButtonImgPath(String buttonImgPath) {
this.buttonImgPath = buttonImgPath;
}
/**
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPath
*/
public String getImgCommPath() {
return this.imgCommPath;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPath
*/
public void setImgCommPath(String imgCommPath) {
this.imgCommPath = imgCommPath;
}
/**
* 获取 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenu
*/
public Integer getCommMenu() {
return this.commMenu;
}
/**
* 设置 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenu
*/
public void setCommMenu(Integer commMenu) {
this.commMenu = commMenu;
}
/**
* 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuType
*/
public Integer getMenuType() {
return this.menuType;
}
/**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuType
*/
public void setMenuType(Integer menuType) {
this.menuType = menuType;
}
/**
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authType
*/
public Integer getAuthType() {
return this.authType;
}
/**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authType
*/
public void setAuthType(Integer authType) {
this.authType = authType;
}
/**
* 获取 创建时间
* @return createTime
*/
@Override
public Date getCreateTime() {
return this.createTime;
}
/**
* 设置 创建时间
* @param createTime
*/
@Override
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
/**
* 获取 创建用户
* @return createUser
*/
@Override
public String getCreateUser() {
return this.createUser;
}
/**
* 设置 创建用户
* @param createUser
*/
@Override
public void setCreateUser(String createUser) {
this.createUser = createUser;
}
/**
* 获取 创建用户名称
* @return createUserName
*/
@Override
public String getCreateUserName() {
return this.createUserName;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
@Override
public void setCreateUserName(String createUserName) {
this.createUserName = createUserName;
}
public List<MenuEntity> getChildList() {
return childList;
}
public void setChildList(List<MenuEntity> childList) {
this.childList = childList;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (obj instanceof MenuEntity) {
MenuEntity tmp = (MenuEntity) obj;
if (this.getId().longValue() == tmp.getId().longValue()) {
return true;
}
}
return false;
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder("");
sb.append("id:").append(getId())
.append(",name:").append(getName())
.append(",url:").append(getUrl())
.append(",parentId:").append(getParentId())
.append(",orderId:").append(getOrderId())
.append(",status:").append(getStatus())
.append(",linkType:").append(getLinkType())
.append(",groupId:").append(getGroupId())
.append(",groupName:").append(getGroupName())
.append(",imgPath:").append(getImgPath())
.append(",buttonImgPath:").append(getButtonImgPath())
.append(",imgCommPath:").append(getImgCommPath())
.append(",commMenu:").append(getCommMenu())
.append(",menuType:").append(getMenuType())
.append(",authType:").append(getAuthType())
.append(",createTime:").append(getCreateTime())
.append(",createUser:").append(getCreateUser())
.append(",createUserName:").append(getCreateUserName());
return sb.toString();
}
@Override
public void initAttrValue() {
this.name = null;
this.url = null;
this.parentId = null;
this.orderId = 0;
this.status = 1;
this.linkType = 0;
this.groupId = 1;
this.imgPath = null;
this.buttonImgPath = null;
this.imgCommPath = null;
this.commMenu = 0;
this.menuType = 0;
this.authType = 3;
this.createTime = null;
this.createUser = null;
this.createUserName = null;
}
public class MenuEntity extends MenuVo {
private static final long serialVersionUID = 1L;
/**
* 菜单名称
*/
private String name;
/**
* 连接地址
*/
private String url;
/**
* 当前节点父id路径，“，”分割，服务端生成
*/
private String ancestors;
/**
* 父菜单ID，一级菜单的该字段值为-1
*/
private Long parentId;
/**
* 排序编号
*/
private Integer orderId;
/**
* 菜单状态，0：禁用，1：启用，默认1
*/
private Integer status;
/**
* 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
*/
private Integer linkType;
/**
* 分组编号，使用菜单分隔符按该值分隔，默认1
*/
private Long groupId;
/**
*
*/
private String groupName;
/**
* 主菜单图标，主菜单图标的css样式名
*/
private String imgPath;
/**
* 按钮图标，按钮图标的css样式名
*/
private String buttonImgPath;
/**
* 常用菜单图标，常用菜单图标的css样式名
*/
private String imgCommPath;
/**
* 是否常用菜单，0：非常用，1：常用，默认0
*/
private Integer commMenu;
/**
* 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
*/
private Integer menuType;
/**
* 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
*/
private Integer authType;
/**
* 创建用户名称
*/
private String createUserName;
public MenuEntity(){}
/**
* 获取 菜单名称
* @return String
*/
public String getName(){
return name;
}
/**
* 设置 菜单名称
* @param name
*/
public void setName(String name){
this.name = name;
}
/**
* 获取 连接地址
* @return String
*/
public String getUrl(){
return url;
}
/**
* 设置 连接地址
* @param url
*/
public void setUrl(String url){
this.url = url;
}
/**
* 获取 当前节点父id路径，“，”分割，服务端生成
* @return String
*/
public String getAncestors(){
return ancestors;
}
/**
* 设置 当前节点父id路径，“，”分割，服务端生成
* @param ancestors
*/
public void setAncestors(String ancestors){
this.ancestors = ancestors;
}
/**
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return Long
*/
public Long getParentId(){
return parentId;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentId
*/
public void setParentId(Long parentId){
this.parentId = parentId;
}
/**
* 获取 排序编号
* @return Integer
*/
public Integer getOrderId(){
return orderId;
}
/**
* 设置 排序编号
* @param orderId
*/
public void setOrderId(Integer orderId){
this.orderId = orderId;
}
/**
* 获取 菜单状态，0：禁用，1：启用，默认1
* @return Integer
*/
public Integer getStatus(){
return status;
}
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param status
*/
public void setStatus(Integer status){
this.status = status;
}
/**
* 获取 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return Integer
*/
public Integer getLinkType(){
return linkType;
}
/**
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkType
*/
public void setLinkType(Integer linkType){
this.linkType = linkType;
}
/**
* 获取 分组编号，使用菜单分隔符按该值分隔，默认1
* @return Long
*/
public Long getGroupId(){
return groupId;
}
/**
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupId
*/
public void setGroupId(Long groupId){
this.groupId = groupId;
}
/**
* 获取
* @return String
*/
public String getGroupName(){
return groupName;
}
/**
* 设置
* @param groupName
*/
public void setGroupName(String groupName){
this.groupName = groupName;
}
/**
* 获取 主菜单图标，主菜单图标的css样式名
* @return String
*/
public String getImgPath(){
return imgPath;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPath
*/
public void setImgPath(String imgPath){
this.imgPath = imgPath;
}
/**
* 获取 按钮图标，按钮图标的css样式名
* @return String
*/
public String getButtonImgPath(){
return buttonImgPath;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPath
*/
public void setButtonImgPath(String buttonImgPath){
this.buttonImgPath = buttonImgPath;
}
/**
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return String
*/
public String getImgCommPath(){
return imgCommPath;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPath
*/
public void setImgCommPath(String imgCommPath){
this.imgCommPath = imgCommPath;
}
/**
* 获取 是否常用菜单，0：非常用，1：常用，默认0
* @return Integer
*/
public Integer getCommMenu(){
return commMenu;
}
/**
* 设置 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenu
*/
public void setCommMenu(Integer commMenu){
this.commMenu = commMenu;
}
/**
* 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return Integer
*/
public Integer getMenuType(){
return menuType;
}
/**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuType
*/
public void setMenuType(Integer menuType){
this.menuType = menuType;
}
/**
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return Integer
*/
public Integer getAuthType(){
return authType;
}
/**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authType
*/
public void setAuthType(Integer authType){
this.authType = authType;
}
/**
* 获取 创建用户名称
* @return String
*/
public String getCreateUserName(){
return createUserName;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
public void setCreateUserName(String createUserName){
this.createUserName = createUserName;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof MenuEntity) {
MenuEntity tmp = (MenuEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",name:").append(getName());
sb.append(",url:").append(getUrl());
sb.append(",ancestors:").append(getAncestors());
sb.append(",parentId:").append(getParentId());
sb.append(",orderId:").append(getOrderId());
sb.append(",status:").append(getStatus());
sb.append(",linkType:").append(getLinkType());
sb.append(",groupId:").append(getGroupId());
sb.append(",groupName:").append(getGroupName());
sb.append(",imgPath:").append(getImgPath());
sb.append(",buttonImgPath:").append(getButtonImgPath());
sb.append(",imgCommPath:").append(getImgCommPath());
sb.append(",commMenu:").append(getCommMenu());
sb.append(",menuType:").append(getMenuType());
sb.append(",authType:").append(getAuthType());
sb.append(",createUserName:").append(getCreateUserName());
return sb.toString();
}
public void initAttrValue(){
this.name = "";
this.url = "";
this.ancestors = "";
this.parentId = 0L;
this.orderId = 1;
this.status = 1;
this.linkType = 0;
this.groupId = 1L;
this.groupName = "";
this.imgPath = "";
this.buttonImgPath = "";
this.imgCommPath = "";
this.commMenu = 0;
this.menuType = 0;
this.authType = 3;
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuQuery.java
View file @ 468eee28
/**
* 文件：MenuQuery.java
* 版本：1.0.0
* 日期：
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.menu.model;
import java.util.List;
/**
* <p>Title: 菜单信息</p>
* <p>Description: MenuQuery </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
* 菜单信息查询对象
*
* @author zxfei
* @date 2023-04-10
*/
public class MenuQuery extends MenuEntity{
private static final long serialVersionUID = 1547777703329L;
/** 开始 菜单ID，主键，自增长 */
private Long idStart;
public class MenuQuery extends MenuEntity {
/** 开始 菜单ID，主键，自增长 */
private Long idStart;
/** 结束 菜单ID，主键，自增长 */
private Long idEnd;
/** 增加 菜单ID，主键，自增长 */
private Long idIncrement;
/** 菜单ID，主键，自增长列表 */
private List <Long> idList;
/** 菜单ID，主键，自增长排除列表 */
private List <Long> idNotList;
/** 菜单名称 */
private List<String> nameList;
/** 菜单名称排除列表 */
private List <String> nameNotList;
/** 连接地址 */
private List<String> urlList;
/** 连接地址排除列表 */
private List <String> urlNotList;
/** 当前节点父id路径，“，”分割，服务端生成 */
private List<String> ancestorsList;
/** 结束 菜单ID，主键，自增长 */
private Long idEnd;
/** 当前节点父id路径，“，”分割，服务端生成排除列表 */
private List <String> ancestorsNotList;
/** 开始 父菜单ID，一级菜单的该字段值为-1 */
private Long parentIdStart;
/** 增加 菜单ID，主键，自增长 */
private Long idIncrement;
/** 结束 父菜单ID，一级菜单的该字段值为-1 */
private Long parentIdEnd;
/** 菜单ID，主键，自增长 */
private List<Long> idList;
/** 增加 父菜单ID，一级菜单的该字段值为-1 */
private Long parentIdIncrement;
/** 菜单名称 */
private List<String> nameList;
/** 父菜单ID，一级菜单的该字段值为-1列表 */
private List <Long> parentIdList;
/** 连接地址 */
private List<String> urlList;
/** 父菜单ID，一级菜单的该字段值为-1排除列表 */
private List <Long> parentIdNotList;
/** 开始 父菜单ID，一级菜单的该字段值为-1 */
private Long parentIdStart;
/** 开始 排序编号 */
private Integer orderIdStart;
/** 结束 父菜单ID，一级菜单的该字段值为-1 */
private Long parentIdEnd;
/** 结束 排序编号 */
private Integer orderIdEnd;
/** 增加 父菜单ID，一级菜单的该字段值为-1 */
private Long parentIdIncrement;
/** 增加 排序编号 */
private Integer orderIdIncrement;
/** 父菜单ID，一级菜单的该字段值为-1 */
private List<Long> parentIdList;
/** 排序编号列表 */
private List <Integer> orderIdList;
/** 开始 排序编号 */
private Integer orderIdStart;
/** 排序编号排除列表 */
private List <Integer> orderIdNotList;
/** 结束 排序编号 */
private Integer orderIdEnd;
/** 开始 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusStart;
/** 增加 排序编号 */
private Integer orderIdIncrement;
/** 结束 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusEnd;
/** 排序编号 */
private List<Integer> orderIdList;
/** 增加 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusIncrement;
/** 开始 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusStart;
/** 菜单状态，0：禁用，1：启用，默认1列表 */
private List <Integer> statusList;
/** 结束 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusEnd;
/** 菜单状态，0：禁用，1：启用，默认1排除列表 */
private List <Integer> statusNotList;
/** 增加 菜单状态，0：禁用，1：启用，默认1 */
private Integer statusIncrement;
/** 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkTypeStart;
/** 菜单状态，0：禁用，1：启用，默认1 */
private List<Integer> statusList;
/** 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkTypeEnd;
/** 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkTypeStart;
/** 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkTypeIncrement;
/** 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkTypeEnd;
/** 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0列表 */
private List <Integer> linkTypeList;
/** 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private Integer linkTypeIncrement;
/** 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0排除列表 */
private List <Integer> linkTypeNotList;
/** 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0 */
private List<Integer> linkTypeList;
/** 开始 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Long groupIdStart;
/** 开始 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Integer groupIdStart;
/** 结束 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Long groupIdEnd;
/** 结束 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Integer groupIdEnd;
/** 增加 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Long groupIdIncrement;
/** 增加 分组编号，使用菜单分隔符按该值分隔，默认1 */
private Integer groupIdIncrement;
/** 分组编号，使用菜单分隔符按该值分隔，默认1列表 */
private List <Long> groupIdList;
/** 分组编号，使用菜单分隔符按该值分隔，默认1 */
private List<Integer> groupIdList;
/** 分组编号，使用菜单分隔符按该值分隔，默认1排除列表 */
private List <Long> groupIdNotList;
/** 分组名称 */
private List<String> groupNameList;
/** */
private List<String> groupNameList;
/** 主菜单图标，主菜单图标的css样式名 */
private List<String> imgPathList;
/** 排除列表 */
private List <String> groupNameNotList;
/** 主菜单图标，主菜单图标的css样式名 */
private List<String> imgPathList;
/** 按钮图标，按钮图标的css样式名 */
private List<String> buttonImgPathList;
/** 主菜单图标，主菜单图标的css样式名排除列表 */
private List <String> imgPathNotList;
/** 按钮图标，按钮图标的css样式名 */
private List<String> buttonImgPathList;
/** 常用菜单图标，常用菜单图标的css样式名 */
private List<String> imgCommPathList;
/** 按钮图标，按钮图标的css样式名排除列表 */
private List <String> buttonImgPathNotList;
/** 常用菜单图标，常用菜单图标的css样式名 */
private List<String> imgCommPathList;
/** 开始 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenuStart;
/** 常用菜单图标，常用菜单图标的css样式名排除列表 */
private List <String> imgCommPathNotList;
/** 开始 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenuStart;
/** 结束 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenuEnd;
/** 结束 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenuEnd;
/** 增加 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenuIncrement;
/** 增加 是否常用菜单，0：非常用，1：常用，默认0 */
private Integer commMenuIncrement;
/** 是否常用菜单，0：非常用，1：常用，默认0 */
private List<Integer> commMenuList;
/** 是否常用菜单，0：非常用，1：常用，默认0列表 */
private List <Integer> commMenuList;
/** 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuTypeStart;
/** 是否常用菜单，0：非常用，1：常用，默认0排除列表 */
private List <Integer> commMenuNotList;
/** 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuTypeEnd;
/** 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuTypeStart;
/** 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuTypeIncrement;
/** 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuTypeEnd;
/** 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private List<Integer> menuTypeList;
/** 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0 */
private Integer menuTypeIncrement;
/** 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authTypeStart;
/** 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0列表 */
private List <Integer> menuTypeList;
/** 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authTypeEnd;
/** 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0排除列表 */
private List <Integer> menuTypeNotList;
/** 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authTypeIncrement;
/** 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authTypeStart;
/** 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private List<Integer> authTypeList;
/** 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authTypeEnd;
/** 开始 创建时间 */
private String createTimeStart;
/** 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3 */
private Integer authTypeIncrement;
/** 结束 创建时间 */
private String createTimeEnd;
/** 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3列表 */
private List <Integer> authTypeList;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户 */
private List<Long> createUserIdList;
/** 创建用户名称 */
private List<String> createUserNameList;
public MenuQuery(){
}
/**
* 获取 开始 菜单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 nameList
*/
public List<String> getNameList(){
return this.nameList;
}
/**
* 设置 菜单名称
* @param nameList
*/
public void setNameList(List<String> nameList){
this.nameList = nameList;
}
/**
* 获取 连接地址
* @return urlList
*/
public List<String> getUrlList(){
return this.urlList;
}
/**
* 设置 连接地址
* @param urlList
*/
public void setUrlList(List<String> urlList){
this.urlList = urlList;
}
/**
* 获取 开始 父菜单ID，一级菜单的该字段值为-1
* @return parentIdStart
*/
public Long getParentIdStart(){
return this.parentIdStart;
}
/**
* 设置 开始 父菜单ID，一级菜单的该字段值为-1
* @param parentIdStart
*/
public void setParentIdStart(Long parentIdStart){
this.parentIdStart = parentIdStart;
}
/**
* 获取 结束 父菜单ID，一级菜单的该字段值为-1
* @return parentIdEnd
*/
public Long getParentIdEnd(){
return this.parentIdEnd;
}
/**
* 设置 结束 父菜单ID，一级菜单的该字段值为-1
* @param parentIdEnd
*/
public void setParentIdEnd(Long parentIdEnd){
this.parentIdEnd = parentIdEnd;
}
/**
* 获取 增加 父菜单ID，一级菜单的该字段值为-1
* @return parentIdIncrement
*/
public Long getParentIdIncrement(){
return this.parentIdIncrement;
}
/**
* 设置 增加 父菜单ID，一级菜单的该字段值为-1
* @param parentIdIncrement
*/
public void setParentIdIncrement(Long parentIdIncrement){
this.parentIdIncrement = parentIdIncrement;
}
/**
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentIdList
*/
public List<Long> getParentIdList(){
return this.parentIdList;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdList
*/
public void setParentIdList(List<Long> parentIdList){
this.parentIdList = parentIdList;
}
/**
* 获取 开始 排序编号
* @return orderIdStart
*/
public Integer getOrderIdStart(){
return this.orderIdStart;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
public void setOrderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
}
/**
* 获取 结束 排序编号
* @return orderIdEnd
*/
public Integer getOrderIdEnd(){
return this.orderIdEnd;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
public void setOrderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
}
/**
* 获取 增加 排序编号
* @return orderIdIncrement
*/
public Integer getOrderIdIncrement(){
return this.orderIdIncrement;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public void setOrderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
}
/**
* 获取 排序编号
* @return orderIdList
*/
public List<Integer> getOrderIdList(){
return this.orderIdList;
}
/**
* 设置 排序编号
* @param orderIdList
*/
public void setOrderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
}
/**
* 获取 开始 菜单状态，0：禁用，1：启用，默认1
* @return statusStart
*/
public Integer getStatusStart(){
return this.statusStart;
}
/**
* 设置 开始 菜单状态，0：禁用，1：启用，默认1
* @param statusStart
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
}
/**
* 获取 结束 菜单状态，0：禁用，1：启用，默认1
* @return statusEnd
*/
public Integer getStatusEnd(){
return this.statusEnd;
}
/**
* 设置 结束 菜单状态，0：禁用，1：启用，默认1
* @param statusEnd
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
}
/**
* 获取 增加 菜单状态，0：禁用，1：启用，默认1
* @return statusIncrement
*/
public Integer getStatusIncrement(){
return this.statusIncrement;
}
/**
* 设置 增加 菜单状态，0：禁用，1：启用，默认1
* @param statusIncrement
*/
public void setStatusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
}
/**
* 获取 菜单状态，0：禁用，1：启用，默认1
* @return statusList
*/
public List<Integer> getStatusList(){
return this.statusList;
}
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/**
* 获取 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeStart
*/
public Integer getLinkTypeStart(){
return this.linkTypeStart;
}
/**
* 设置 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeStart
*/
public void setLinkTypeStart(Integer linkTypeStart){
this.linkTypeStart = linkTypeStart;
}
/**
* 获取 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeEnd
*/
public Integer getLinkTypeEnd(){
return this.linkTypeEnd;
}
/**
* 设置 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeEnd
*/
public void setLinkTypeEnd(Integer linkTypeEnd){
this.linkTypeEnd = linkTypeEnd;
}
/**
* 获取 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeIncrement
*/
public Integer getLinkTypeIncrement(){
return this.linkTypeIncrement;
}
/**
* 设置 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeIncrement
*/
public void setLinkTypeIncrement(Integer linkTypeIncrement){
this.linkTypeIncrement = linkTypeIncrement;
}
/**
* 获取 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeList
*/
public List<Integer> getLinkTypeList(){
return this.linkTypeList;
}
/**
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeList
*/
public void setLinkTypeList(List<Integer> linkTypeList){
this.linkTypeList = linkTypeList;
}
/**
* 获取 开始 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdStart
*/
public Integer getGroupIdStart(){
return this.groupIdStart;
}
/**
* 设置 开始 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdStart
*/
public void setGroupIdStart(Integer groupIdStart){
this.groupIdStart = groupIdStart;
}
/**
* 获取 结束 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdEnd
*/
public Integer getGroupIdEnd(){
return this.groupIdEnd;
}
/**
* 设置 结束 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdEnd
*/
public void setGroupIdEnd(Integer groupIdEnd){
this.groupIdEnd = groupIdEnd;
}
/**
* 获取 增加 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdIncrement
*/
public Integer getGroupIdIncrement(){
return this.groupIdIncrement;
}
/**
* 设置 增加 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdIncrement
*/
public void setGroupIdIncrement(Integer groupIdIncrement){
this.groupIdIncrement = groupIdIncrement;
}
/**
* 获取 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdList
*/
public List<Integer> getGroupIdList(){
return this.groupIdList;
}
/**
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdList
*/
public void setGroupIdList(List<Integer> groupIdList){
this.groupIdList = groupIdList;
}
/**
* 获取 分组名称
* @return groupNameList
*/
public List<String> getGroupNameList(){
return this.groupNameList;
}
/**
* 设置 分组名称
* @param groupNameList
*/
public void setGroupNameList(List<String> groupNameList){
this.groupNameList = groupNameList;
}
/**
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathList
*/
public List<String> getImgPathList(){
return this.imgPathList;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
*/
public void setImgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
}
/**
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathList
*/
public List<String> getButtonImgPathList(){
return this.buttonImgPathList;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList
*/
public void setButtonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
}
/**
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathList
*/
public List<String> getImgCommPathList(){
return this.imgCommPathList;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathList
*/
public void setImgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
}
/**
* 获取 开始 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuStart
*/
public Integer getCommMenuStart(){
return this.commMenuStart;
}
/**
* 设置 开始 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuStart
*/
public void setCommMenuStart(Integer commMenuStart){
this.commMenuStart = commMenuStart;
}
/**
* 获取 结束 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuEnd
*/
public Integer getCommMenuEnd(){
return this.commMenuEnd;
}
/**
* 设置 结束 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuEnd
*/
public void setCommMenuEnd(Integer commMenuEnd){
this.commMenuEnd = commMenuEnd;
}
/**
* 获取 增加 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuIncrement
*/
public Integer getCommMenuIncrement(){
return this.commMenuIncrement;
}
/**
* 设置 增加 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuIncrement
*/
public void setCommMenuIncrement(Integer commMenuIncrement){
this.commMenuIncrement = commMenuIncrement;
}
/**
* 获取 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuList
*/
public List<Integer> getCommMenuList(){
return this.commMenuList;
}
/**
* 设置 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuList
*/
public void setCommMenuList(List<Integer> commMenuList){
this.commMenuList = commMenuList;
}
/**
* 获取 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeStart
*/
public Integer getMenuTypeStart(){
return this.menuTypeStart;
}
/**
* 设置 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeStart
*/
public void setMenuTypeStart(Integer menuTypeStart){
this.menuTypeStart = menuTypeStart;
}
/**
* 获取 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeEnd
*/
public Integer getMenuTypeEnd(){
return this.menuTypeEnd;
}
/**
* 设置 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeEnd
*/
public void setMenuTypeEnd(Integer menuTypeEnd){
this.menuTypeEnd = menuTypeEnd;
}
/**
* 获取 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeIncrement
*/
public Integer getMenuTypeIncrement(){
return this.menuTypeIncrement;
}
/**
* 设置 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeIncrement
*/
public void setMenuTypeIncrement(Integer menuTypeIncrement){
this.menuTypeIncrement = menuTypeIncrement;
}
/**
* 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeList
*/
public List<Integer> getMenuTypeList(){
return this.menuTypeList;
}
/**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeList
*/
public void setMenuTypeList(List<Integer> menuTypeList){
this.menuTypeList = menuTypeList;
}
/**
* 获取 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeStart
*/
public Integer getAuthTypeStart(){
return this.authTypeStart;
}
/**
* 设置 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeStart
*/
public void setAuthTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart;
}
/**
* 获取 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeEnd
*/
public Integer getAuthTypeEnd(){
return this.authTypeEnd;
}
/**
* 设置 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeEnd
*/
public void setAuthTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
}
/**
* 获取 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeIncrement
*/
public Integer getAuthTypeIncrement(){
return this.authTypeIncrement;
}
/**
* 设置 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeIncrement
*/
public void setAuthTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
}
/**
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeList
*/
public List<Integer> getAuthTypeList(){
return this.authTypeList;
}
/**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeList
*/
public void setAuthTypeList(List<Integer> authTypeList){
this.authTypeList = authTypeList;
}
/**
* 获取 开始 创建时间
* @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;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户名称
* @return createUserNameList
*/
public List<String> getCreateUserNameList(){
return this.createUserNameList;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public void setCreateUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
}
/** 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3排除列表 */
private List <Integer> authTypeNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 创建用户名称 */
private List<String> createUserNameList;
/** 创建用户名称排除列表 */
private List <String> createUserNameNotList;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<MenuQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<MenuQuery> andConditionList;
public MenuQuery(){}
/**
* 获取 开始 菜单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;
}
/**
* 获取 菜单ID，主键，自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 菜单ID，主键，自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 菜单名称
* @return nameList
*/
public List<String> getNameList(){
return this.nameList;
}
/**
* 设置 菜单名称
* @param nameList
*/
public void setNameList(List<String> nameList){
this.nameList = nameList;
}
/**
* 获取 菜单名称
* @return nameNotList
*/
public List<String> getNameNotList(){
return this.nameNotList;
}
/**
* 设置 菜单名称
* @param nameNotList
*/
public void setNameNotList(List<String> nameNotList){
this.nameNotList = nameNotList;
}
/**
* 获取 连接地址
* @return urlList
*/
public List<String> getUrlList(){
return this.urlList;
}
/**
* 设置 连接地址
* @param urlList
*/
public void setUrlList(List<String> urlList){
this.urlList = urlList;
}
/**
* 获取 连接地址
* @return urlNotList
*/
public List<String> getUrlNotList(){
return this.urlNotList;
}
/**
* 设置 连接地址
* @param urlNotList
*/
public void setUrlNotList(List<String> urlNotList){
this.urlNotList = urlNotList;
}
/**
* 获取 当前节点父id路径，“，”分割，服务端生成
* @return ancestorsList
*/
public List<String> getAncestorsList(){
return this.ancestorsList;
}
/**
* 设置 当前节点父id路径，“，”分割，服务端生成
* @param ancestorsList
*/
public void setAncestorsList(List<String> ancestorsList){
this.ancestorsList = ancestorsList;
}
/**
* 获取 当前节点父id路径，“，”分割，服务端生成
* @return ancestorsNotList
*/
public List<String> getAncestorsNotList(){
return this.ancestorsNotList;
}
/**
* 设置 当前节点父id路径，“，”分割，服务端生成
* @param ancestorsNotList
*/
public void setAncestorsNotList(List<String> ancestorsNotList){
this.ancestorsNotList = ancestorsNotList;
}
/**
* 获取 开始 父菜单ID，一级菜单的该字段值为-1
* @return parentIdStart
*/
public Long getParentIdStart(){
return this.parentIdStart;
}
/**
* 设置 开始 父菜单ID，一级菜单的该字段值为-1
* @param parentIdStart
*/
public void setParentIdStart(Long parentIdStart){
this.parentIdStart = parentIdStart;
}
/**
* 获取 结束 父菜单ID，一级菜单的该字段值为-1
* @return $parentIdEnd
*/
public Long getParentIdEnd(){
return this.parentIdEnd;
}
/**
* 设置 结束 父菜单ID，一级菜单的该字段值为-1
* @param parentIdEnd
*/
public void setParentIdEnd(Long parentIdEnd){
this.parentIdEnd = parentIdEnd;
}
/**
* 获取 增加 父菜单ID，一级菜单的该字段值为-1
* @return parentIdIncrement
*/
public Long getParentIdIncrement(){
return this.parentIdIncrement;
}
/**
* 设置 增加 父菜单ID，一级菜单的该字段值为-1
* @param parentIdIncrement
*/
public void setParentIdIncrement(Long parentIdIncrement){
this.parentIdIncrement = parentIdIncrement;
}
/**
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentIdList
*/
public List<Long> getParentIdList(){
return this.parentIdList;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdList
*/
public void setParentIdList(List<Long> parentIdList){
this.parentIdList = parentIdList;
}
/**
* 获取 父菜单ID，一级菜单的该字段值为-1
* @return parentIdNotList
*/
public List<Long> getParentIdNotList(){
return this.parentIdNotList;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdNotList
*/
public void setParentIdNotList(List<Long> parentIdNotList){
this.parentIdNotList = parentIdNotList;
}
/**
* 获取 开始 排序编号
* @return orderIdStart
*/
public Integer getOrderIdStart(){
return this.orderIdStart;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
public void setOrderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
}
/**
* 获取 结束 排序编号
* @return $orderIdEnd
*/
public Integer getOrderIdEnd(){
return this.orderIdEnd;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
public void setOrderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
}
/**
* 获取 增加 排序编号
* @return orderIdIncrement
*/
public Integer getOrderIdIncrement(){
return this.orderIdIncrement;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public void setOrderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
}
/**
* 获取 排序编号
* @return orderIdList
*/
public List<Integer> getOrderIdList(){
return this.orderIdList;
}
/**
* 设置 排序编号
* @param orderIdList
*/
public void setOrderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
}
/**
* 获取 排序编号
* @return orderIdNotList
*/
public List<Integer> getOrderIdNotList(){
return this.orderIdNotList;
}
/**
* 设置 排序编号
* @param orderIdNotList
*/
public void setOrderIdNotList(List<Integer> orderIdNotList){
this.orderIdNotList = orderIdNotList;
}
/**
* 获取 开始 菜单状态，0：禁用，1：启用，默认1
* @return statusStart
*/
public Integer getStatusStart(){
return this.statusStart;
}
/**
* 设置 开始 菜单状态，0：禁用，1：启用，默认1
* @param statusStart
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
}
/**
* 获取 结束 菜单状态，0：禁用，1：启用，默认1
* @return $statusEnd
*/
public Integer getStatusEnd(){
return this.statusEnd;
}
/**
* 设置 结束 菜单状态，0：禁用，1：启用，默认1
* @param statusEnd
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
}
/**
* 获取 增加 菜单状态，0：禁用，1：启用，默认1
* @return statusIncrement
*/
public Integer getStatusIncrement(){
return this.statusIncrement;
}
/**
* 设置 增加 菜单状态，0：禁用，1：启用，默认1
* @param statusIncrement
*/
public void setStatusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
}
/**
* 获取 菜单状态，0：禁用，1：启用，默认1
* @return statusList
*/
public List<Integer> getStatusList(){
return this.statusList;
}
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/**
* 获取 菜单状态，0：禁用，1：启用，默认1
* @return statusNotList
*/
public List<Integer> getStatusNotList(){
return this.statusNotList;
}
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param statusNotList
*/
public void setStatusNotList(List<Integer> statusNotList){
this.statusNotList = statusNotList;
}
/**
* 获取 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeStart
*/
public Integer getLinkTypeStart(){
return this.linkTypeStart;
}
/**
* 设置 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeStart
*/
public void setLinkTypeStart(Integer linkTypeStart){
this.linkTypeStart = linkTypeStart;
}
/**
* 获取 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return $linkTypeEnd
*/
public Integer getLinkTypeEnd(){
return this.linkTypeEnd;
}
/**
* 设置 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeEnd
*/
public void setLinkTypeEnd(Integer linkTypeEnd){
this.linkTypeEnd = linkTypeEnd;
}
/**
* 获取 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeIncrement
*/
public Integer getLinkTypeIncrement(){
return this.linkTypeIncrement;
}
/**
* 设置 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeIncrement
*/
public void setLinkTypeIncrement(Integer linkTypeIncrement){
this.linkTypeIncrement = linkTypeIncrement;
}
/**
* 获取 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeList
*/
public List<Integer> getLinkTypeList(){
return this.linkTypeList;
}
/**
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeList
*/
public void setLinkTypeList(List<Integer> linkTypeList){
this.linkTypeList = linkTypeList;
}
/**
* 获取 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @return linkTypeNotList
*/
public List<Integer> getLinkTypeNotList(){
return this.linkTypeNotList;
}
/**
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeNotList
*/
public void setLinkTypeNotList(List<Integer> linkTypeNotList){
this.linkTypeNotList = linkTypeNotList;
}
/**
* 获取 开始 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdStart
*/
public Long getGroupIdStart(){
return this.groupIdStart;
}
/**
* 设置 开始 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdStart
*/
public void setGroupIdStart(Long groupIdStart){
this.groupIdStart = groupIdStart;
}
/**
* 获取 结束 分组编号，使用菜单分隔符按该值分隔，默认1
* @return $groupIdEnd
*/
public Long getGroupIdEnd(){
return this.groupIdEnd;
}
/**
* 设置 结束 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdEnd
*/
public void setGroupIdEnd(Long groupIdEnd){
this.groupIdEnd = groupIdEnd;
}
/**
* 获取 增加 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdIncrement
*/
public Long getGroupIdIncrement(){
return this.groupIdIncrement;
}
/**
* 设置 增加 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdIncrement
*/
public void setGroupIdIncrement(Long groupIdIncrement){
this.groupIdIncrement = groupIdIncrement;
}
/**
* 获取 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdList
*/
public List<Long> getGroupIdList(){
return this.groupIdList;
}
/**
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdList
*/
public void setGroupIdList(List<Long> groupIdList){
this.groupIdList = groupIdList;
}
/**
* 获取 分组编号，使用菜单分隔符按该值分隔，默认1
* @return groupIdNotList
*/
public List<Long> getGroupIdNotList(){
return this.groupIdNotList;
}
/**
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdNotList
*/
public void setGroupIdNotList(List<Long> groupIdNotList){
this.groupIdNotList = groupIdNotList;
}
/**
* 获取
* @return groupNameList
*/
public List<String> getGroupNameList(){
return this.groupNameList;
}
/**
* 设置
* @param groupNameList
*/
public void setGroupNameList(List<String> groupNameList){
this.groupNameList = groupNameList;
}
/**
* 获取
* @return groupNameNotList
*/
public List<String> getGroupNameNotList(){
return this.groupNameNotList;
}
/**
* 设置
* @param groupNameNotList
*/
public void setGroupNameNotList(List<String> groupNameNotList){
this.groupNameNotList = groupNameNotList;
}
/**
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathList
*/
public List<String> getImgPathList(){
return this.imgPathList;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
*/
public void setImgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
}
/**
* 获取 主菜单图标，主菜单图标的css样式名
* @return imgPathNotList
*/
public List<String> getImgPathNotList(){
return this.imgPathNotList;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathNotList
*/
public void setImgPathNotList(List<String> imgPathNotList){
this.imgPathNotList = imgPathNotList;
}
/**
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathList
*/
public List<String> getButtonImgPathList(){
return this.buttonImgPathList;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList
*/
public void setButtonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
}
/**
* 获取 按钮图标，按钮图标的css样式名
* @return buttonImgPathNotList
*/
public List<String> getButtonImgPathNotList(){
return this.buttonImgPathNotList;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathNotList
*/
public void setButtonImgPathNotList(List<String> buttonImgPathNotList){
this.buttonImgPathNotList = buttonImgPathNotList;
}
/**
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathList
*/
public List<String> getImgCommPathList(){
return this.imgCommPathList;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathList
*/
public void setImgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
}
/**
* 获取 常用菜单图标，常用菜单图标的css样式名
* @return imgCommPathNotList
*/
public List<String> getImgCommPathNotList(){
return this.imgCommPathNotList;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathNotList
*/
public void setImgCommPathNotList(List<String> imgCommPathNotList){
this.imgCommPathNotList = imgCommPathNotList;
}
/**
* 获取 开始 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuStart
*/
public Integer getCommMenuStart(){
return this.commMenuStart;
}
/**
* 设置 开始 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuStart
*/
public void setCommMenuStart(Integer commMenuStart){
this.commMenuStart = commMenuStart;
}
/**
* 获取 结束 是否常用菜单，0：非常用，1：常用，默认0
* @return $commMenuEnd
*/
public Integer getCommMenuEnd(){
return this.commMenuEnd;
}
/**
* 设置 结束 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuEnd
*/
public void setCommMenuEnd(Integer commMenuEnd){
this.commMenuEnd = commMenuEnd;
}
/**
* 获取 增加 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuIncrement
*/
public Integer getCommMenuIncrement(){
return this.commMenuIncrement;
}
/**
* 设置 增加 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuIncrement
*/
public void setCommMenuIncrement(Integer commMenuIncrement){
this.commMenuIncrement = commMenuIncrement;
}
/**
* 获取 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuList
*/
public List<Integer> getCommMenuList(){
return this.commMenuList;
}
/**
* 设置 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuList
*/
public void setCommMenuList(List<Integer> commMenuList){
this.commMenuList = commMenuList;
}
/**
* 获取 是否常用菜单，0：非常用，1：常用，默认0
* @return commMenuNotList
*/
public List<Integer> getCommMenuNotList(){
return this.commMenuNotList;
}
/**
* 设置 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuNotList
*/
public void setCommMenuNotList(List<Integer> commMenuNotList){
this.commMenuNotList = commMenuNotList;
}
/**
* 获取 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeStart
*/
public Integer getMenuTypeStart(){
return this.menuTypeStart;
}
/**
* 设置 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeStart
*/
public void setMenuTypeStart(Integer menuTypeStart){
this.menuTypeStart = menuTypeStart;
}
/**
* 获取 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return $menuTypeEnd
*/
public Integer getMenuTypeEnd(){
return this.menuTypeEnd;
}
/**
* 设置 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeEnd
*/
public void setMenuTypeEnd(Integer menuTypeEnd){
this.menuTypeEnd = menuTypeEnd;
}
/**
* 获取 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeIncrement
*/
public Integer getMenuTypeIncrement(){
return this.menuTypeIncrement;
}
/**
* 设置 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeIncrement
*/
public void setMenuTypeIncrement(Integer menuTypeIncrement){
this.menuTypeIncrement = menuTypeIncrement;
}
/**
* 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeList
*/
public List<Integer> getMenuTypeList(){
return this.menuTypeList;
}
/**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeList
*/
public void setMenuTypeList(List<Integer> menuTypeList){
this.menuTypeList = menuTypeList;
}
/**
* 获取 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @return menuTypeNotList
*/
public List<Integer> getMenuTypeNotList(){
return this.menuTypeNotList;
}
/**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeNotList
*/
public void setMenuTypeNotList(List<Integer> menuTypeNotList){
this.menuTypeNotList = menuTypeNotList;
}
/**
* 获取 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeStart
*/
public Integer getAuthTypeStart(){
return this.authTypeStart;
}
/**
* 设置 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeStart
*/
public void setAuthTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart;
}
/**
* 获取 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return $authTypeEnd
*/
public Integer getAuthTypeEnd(){
return this.authTypeEnd;
}
/**
* 设置 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeEnd
*/
public void setAuthTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
}
/**
* 获取 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeIncrement
*/
public Integer getAuthTypeIncrement(){
return this.authTypeIncrement;
}
/**
* 设置 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeIncrement
*/
public void setAuthTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
}
/**
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeList
*/
public List<Integer> getAuthTypeList(){
return this.authTypeList;
}
/**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeList
*/
public void setAuthTypeList(List<Integer> authTypeList){
this.authTypeList = authTypeList;
}
/**
* 获取 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @return authTypeNotList
*/
public List<Integer> getAuthTypeNotList(){
return this.authTypeNotList;
}
/**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeNotList
*/
public void setAuthTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
}
/**
* 获取 开始 创建时间
* @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;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户
* @return createUserIdNotList
*/
public List<Long> getCreateUserIdNotList(){
return this.createUserIdNotList;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public void setCreateUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
}
/**
* 获取 创建用户名称
* @return createUserNameList
*/
public List<String> getCreateUserNameList(){
return this.createUserNameList;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public void setCreateUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
}
/**
* 获取 创建用户名称
* @return createUserNameNotList
*/
public List<String> getCreateUserNameNotList(){
return this.createUserNameNotList;
}
/**
* 设置 创建用户名称
* @param createUserNameNotList
*/
public void setCreateUserNameNotList(List<String> createUserNameNotList){
this.createUserNameNotList = createUserNameNotList;
}
/**
* 设置 菜单ID，主键，自增长
* @param id
*/
public MenuQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 菜单ID，主键，自增长
* @param idStart
*/
public MenuQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 菜单ID，主键，自增长
* @param idEnd
*/
public MenuQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 菜单ID，主键，自增长
* @param idIncrement
*/
public MenuQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 菜单ID，主键，自增长
* @param idList
*/
public MenuQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 菜单ID，主键，自增长
* @param idNotList
*/
public MenuQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 菜单名称
* @param name
*/
public MenuQuery name(String name){
setName(name);
return this;
}
/**
* 设置 菜单名称
* @param nameList
*/
public MenuQuery nameList(List<String> nameList){
this.nameList = nameList;
return this;
}
/**
* 设置 连接地址
* @param url
*/
public MenuQuery url(String url){
setUrl(url);
return this;
}
/**
* 设置 连接地址
* @param urlList
*/
public MenuQuery urlList(List<String> urlList){
this.urlList = urlList;
return this;
}
/**
* 设置 当前节点父id路径，“，”分割，服务端生成
* @param ancestors
*/
public MenuQuery ancestors(String ancestors){
setAncestors(ancestors);
return this;
}
/**
* 设置 当前节点父id路径，“，”分割，服务端生成
* @param ancestorsList
*/
public MenuQuery ancestorsList(List<String> ancestorsList){
this.ancestorsList = ancestorsList;
return this;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentId
*/
public MenuQuery parentId(Long parentId){
setParentId(parentId);
return this;
}
/**
* 设置 开始 父菜单ID，一级菜单的该字段值为-1
* @param parentIdStart
*/
public MenuQuery parentIdStart(Long parentIdStart){
this.parentIdStart = parentIdStart;
return this;
}
/**
* 设置 结束 父菜单ID，一级菜单的该字段值为-1
* @param parentIdEnd
*/
public MenuQuery parentIdEnd(Long parentIdEnd){
this.parentIdEnd = parentIdEnd;
return this;
}
/**
* 设置 增加 父菜单ID，一级菜单的该字段值为-1
* @param parentIdIncrement
*/
public MenuQuery parentIdIncrement(Long parentIdIncrement){
this.parentIdIncrement = parentIdIncrement;
return this;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdList
*/
public MenuQuery parentIdList(List<Long> parentIdList){
this.parentIdList = parentIdList;
return this;
}
/**
* 设置 父菜单ID，一级菜单的该字段值为-1
* @param parentIdNotList
*/
public MenuQuery parentIdNotList(List<Long> parentIdNotList){
this.parentIdNotList = parentIdNotList;
return this;
}
/**
* 设置 排序编号
* @param orderId
*/
public MenuQuery orderId(Integer orderId){
setOrderId(orderId);
return this;
}
/**
* 设置 开始 排序编号
* @param orderIdStart
*/
public MenuQuery orderIdStart(Integer orderIdStart){
this.orderIdStart = orderIdStart;
return this;
}
/**
* 设置 结束 排序编号
* @param orderIdEnd
*/
public MenuQuery orderIdEnd(Integer orderIdEnd){
this.orderIdEnd = orderIdEnd;
return this;
}
/**
* 设置 增加 排序编号
* @param orderIdIncrement
*/
public MenuQuery orderIdIncrement(Integer orderIdIncrement){
this.orderIdIncrement = orderIdIncrement;
return this;
}
/**
* 设置 排序编号
* @param orderIdList
*/
public MenuQuery orderIdList(List<Integer> orderIdList){
this.orderIdList = orderIdList;
return this;
}
/**
* 设置 排序编号
* @param orderIdNotList
*/
public MenuQuery orderIdNotList(List<Integer> orderIdNotList){
this.orderIdNotList = orderIdNotList;
return this;
}
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param status
*/
public MenuQuery status(Integer status){
setStatus(status);
return this;
}
/**
* 设置 开始 菜单状态，0：禁用，1：启用，默认1
* @param statusStart
*/
public MenuQuery statusStart(Integer statusStart){
this.statusStart = statusStart;
return this;
}
/**
* 设置 结束 菜单状态，0：禁用，1：启用，默认1
* @param statusEnd
*/
public MenuQuery statusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
return this;
}
/**
* 设置 增加 菜单状态，0：禁用，1：启用，默认1
* @param statusIncrement
*/
public MenuQuery statusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
return this;
}
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param statusList
*/
public MenuQuery statusList(List<Integer> statusList){
this.statusList = statusList;
return this;
}
/**
* 设置 菜单状态，0：禁用，1：启用，默认1
* @param statusNotList
*/
public MenuQuery statusNotList(List<Integer> statusNotList){
this.statusNotList = statusNotList;
return this;
}
/**
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkType
*/
public MenuQuery linkType(Integer linkType){
setLinkType(linkType);
return this;
}
/**
* 设置 开始 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeStart
*/
public MenuQuery linkTypeStart(Integer linkTypeStart){
this.linkTypeStart = linkTypeStart;
return this;
}
/**
* 设置 结束 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeEnd
*/
public MenuQuery linkTypeEnd(Integer linkTypeEnd){
this.linkTypeEnd = linkTypeEnd;
return this;
}
/**
* 设置 增加 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeIncrement
*/
public MenuQuery linkTypeIncrement(Integer linkTypeIncrement){
this.linkTypeIncrement = linkTypeIncrement;
return this;
}
/**
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeList
*/
public MenuQuery linkTypeList(List<Integer> linkTypeList){
this.linkTypeList = linkTypeList;
return this;
}
/**
* 设置 链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0
* @param linkTypeNotList
*/
public MenuQuery linkTypeNotList(List<Integer> linkTypeNotList){
this.linkTypeNotList = linkTypeNotList;
return this;
}
/**
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupId
*/
public MenuQuery groupId(Long groupId){
setGroupId(groupId);
return this;
}
/**
* 设置 开始 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdStart
*/
public MenuQuery groupIdStart(Long groupIdStart){
this.groupIdStart = groupIdStart;
return this;
}
/**
* 设置 结束 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdEnd
*/
public MenuQuery groupIdEnd(Long groupIdEnd){
this.groupIdEnd = groupIdEnd;
return this;
}
/**
* 设置 增加 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdIncrement
*/
public MenuQuery groupIdIncrement(Long groupIdIncrement){
this.groupIdIncrement = groupIdIncrement;
return this;
}
/**
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdList
*/
public MenuQuery groupIdList(List<Long> groupIdList){
this.groupIdList = groupIdList;
return this;
}
/**
* 设置 分组编号，使用菜单分隔符按该值分隔，默认1
* @param groupIdNotList
*/
public MenuQuery groupIdNotList(List<Long> groupIdNotList){
this.groupIdNotList = groupIdNotList;
return this;
}
/**
* 设置
* @param groupName
*/
public MenuQuery groupName(String groupName){
setGroupName(groupName);
return this;
}
/**
* 设置
* @param groupNameList
*/
public MenuQuery groupNameList(List<String> groupNameList){
this.groupNameList = groupNameList;
return this;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPath
*/
public MenuQuery imgPath(String imgPath){
setImgPath(imgPath);
return this;
}
/**
* 设置 主菜单图标，主菜单图标的css样式名
* @param imgPathList
*/
public MenuQuery imgPathList(List<String> imgPathList){
this.imgPathList = imgPathList;
return this;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPath
*/
public MenuQuery buttonImgPath(String buttonImgPath){
setButtonImgPath(buttonImgPath);
return this;
}
/**
* 设置 按钮图标，按钮图标的css样式名
* @param buttonImgPathList
*/
public MenuQuery buttonImgPathList(List<String> buttonImgPathList){
this.buttonImgPathList = buttonImgPathList;
return this;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPath
*/
public MenuQuery imgCommPath(String imgCommPath){
setImgCommPath(imgCommPath);
return this;
}
/**
* 设置 常用菜单图标，常用菜单图标的css样式名
* @param imgCommPathList
*/
public MenuQuery imgCommPathList(List<String> imgCommPathList){
this.imgCommPathList = imgCommPathList;
return this;
}
/**
* 设置 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenu
*/
public MenuQuery commMenu(Integer commMenu){
setCommMenu(commMenu);
return this;
}
/**
* 设置 开始 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuStart
*/
public MenuQuery commMenuStart(Integer commMenuStart){
this.commMenuStart = commMenuStart;
return this;
}
/**
* 设置 结束 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuEnd
*/
public MenuQuery commMenuEnd(Integer commMenuEnd){
this.commMenuEnd = commMenuEnd;
return this;
}
/**
* 设置 增加 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuIncrement
*/
public MenuQuery commMenuIncrement(Integer commMenuIncrement){
this.commMenuIncrement = commMenuIncrement;
return this;
}
/**
* 设置 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuList
*/
public MenuQuery commMenuList(List<Integer> commMenuList){
this.commMenuList = commMenuList;
return this;
}
/**
* 设置 是否常用菜单，0：非常用，1：常用，默认0
* @param commMenuNotList
*/
public MenuQuery commMenuNotList(List<Integer> commMenuNotList){
this.commMenuNotList = commMenuNotList;
return this;
}
/**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuType
*/
public MenuQuery menuType(Integer menuType){
setMenuType(menuType);
return this;
}
/**
* 设置 开始 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeStart
*/
public MenuQuery menuTypeStart(Integer menuTypeStart){
this.menuTypeStart = menuTypeStart;
return this;
}
/**
* 设置 结束 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeEnd
*/
public MenuQuery menuTypeEnd(Integer menuTypeEnd){
this.menuTypeEnd = menuTypeEnd;
return this;
}
/**
* 设置 增加 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeIncrement
*/
public MenuQuery menuTypeIncrement(Integer menuTypeIncrement){
this.menuTypeIncrement = menuTypeIncrement;
return this;
}
/**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeList
*/
public MenuQuery menuTypeList(List<Integer> menuTypeList){
this.menuTypeList = menuTypeList;
return this;
}
/**
* 设置 菜单类型，0：主菜单，1：非主菜单(功能操作组)，默认0
* @param menuTypeNotList
*/
public MenuQuery menuTypeNotList(List<Integer> menuTypeNotList){
this.menuTypeNotList = menuTypeNotList;
return this;
}
/**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authType
*/
public MenuQuery authType(Integer authType){
setAuthType(authType);
return this;
}
/**
* 设置 开始 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeStart
*/
public MenuQuery authTypeStart(Integer authTypeStart){
this.authTypeStart = authTypeStart;
return this;
}
/**
* 设置 结束 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeEnd
*/
public MenuQuery authTypeEnd(Integer authTypeEnd){
this.authTypeEnd = authTypeEnd;
return this;
}
/**
* 设置 增加 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeIncrement
*/
public MenuQuery authTypeIncrement(Integer authTypeIncrement){
this.authTypeIncrement = authTypeIncrement;
return this;
}
/**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeList
*/
public MenuQuery authTypeList(List<Integer> authTypeList){
this.authTypeList = authTypeList;
return this;
}
/**
* 设置 权限类型，0：无限制，1：无需登录查看，2：需要登录查看，3：需要角色权限查看，默认3
* @param authTypeNotList
*/
public MenuQuery authTypeNotList(List<Integer> authTypeNotList){
this.authTypeNotList = authTypeNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public MenuQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public MenuQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public MenuQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public MenuQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public MenuQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public MenuQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
public MenuQuery createUserName(String createUserName){
setCreateUserName(createUserName);
return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
public MenuQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<MenuQuery> 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<MenuQuery> 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<MenuQuery> 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<MenuQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/base/system/menu/model/MenuTreeSelect.java 0 → 100644
View file @ 468eee28
package com.mortals.xhx.base.system.menu.model;
import com.fasterxml.jackson.annotation.JsonInclude;
import lombok.Data;
import java.io.Serializable;
import java.util.List;
import java.util.stream.Collectors;
/**
* 菜单信息前端映射树结构实体类
*
* @author zxfei
* @date 2023-04-10
*/
@Data
public class MenuTreeSelect implements Serializable {
private static final long serialVersionUID = 1L;
/**
* 节点ID
*/
private Long id;
/**
* 节点名称
*/
private String label;
/**
* 子节点
*/
@JsonInclude(JsonInclude.Include.NON_EMPTY)
private List<MenuTreeSelect> children;
public MenuTreeSelect(MenuEntity entity) {
this.id = entity.getId();
this.label = entity.getName();
this.children = entity.getChildList().stream().map(MenuTreeSelect::new).collect(Collectors.toList());
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/base/system/menu/model/vo/MenuVo.java 0 → 100644
View file @ 468eee28
package com.mortals.xhx.base.system.menu.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.base.system.menu.model.MenuEntity;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
/**
* 菜单信息视图对象
*
* @author zxfei
* @date 2023-04-10
*/
@Data
public class MenuVo extends BaseEntityLong {
/** 子菜单信息 */
private List<MenuEntity> childList = new ArrayList<>();
private Integer type;
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/base/system/menu/service/MenuService.java
View file @ 468eee28
/**
* 文件：MenuService.java
* 版本：1.0.0
* 日期：
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.menu.service;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService;
import com.mortals.framework.service.IUser;
import com.mortals.xhx.base.system.menu.model.MenuEntity;
import com.mortals.xhx.base.system.menu.model.MenuTreeSelect;
import java.util.List;
import java.util.Set;
/**
* <p>Title: 菜单信息</p>
* <p>Description: MenuService service接口 </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
* @author
* @version 1.0.0
* MenuService
* <p>
* 菜单信息 service接口
*
* @author zxfei
* @date 2023-04-10
*/
public interface MenuService extends ICRUDService<MenuEntity, Long> {
public interface MenuService extends ICRUDService<MenuEntity,Long> {
/**
* 获取所有可用菜单
*
......@@ -56,8 +49,47 @@ public interface MenuService extends ICRUDService<MenuEntity,Long> {
/**
* 更新排列顺序
*
* @param id
* @param type
*/
void upOrDown(Long id, Integer type);
/**
* 是否存在菜单信息节点
*
* @param menuId 菜单信息ID
* @return 结果
*/
boolean hasChildByMenuId(Long menuId);
/**
* 查询菜单信息数据
*
* @param menu 菜单信息
* @return 菜单信息集合
*/
List<MenuEntity> selectMenuList(MenuEntity menu);
/**
* 构建前端所需要下拉树结构
*
* @param menuList 菜单信息列表
* @return 下拉树结构列表
*/
List<MenuTreeSelect> buildMenuTreeSelect(List<MenuEntity> menuList);
/**
* 根据父id查询子节点
*
* @param parentId
* @param context
* @return
*/
List<MenuTreeSelect> getListByParentId(Long parentId, Context context);
Set<Long> getPathSetById(Long id, Context context);
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/base/system/menu/service/impl/MenuServiceImpl.java
View file @ 468eee28
/**
* 文件：MenuServiceImpl.java
* 版本：1.0.0
* 日期：
* Copyright &reg;
* All right reserved.
*/
package com.mortals.xhx.base.system.menu.service.impl;
import com.mortals.framework.common.code.YesNo;
......@@ -18,23 +10,22 @@ import com.mortals.framework.util.StringUtils;
import com.mortals.xhx.base.system.menu.dao.MenuDao;
import com.mortals.xhx.base.system.menu.model.MenuEntity;
import com.mortals.xhx.base.system.menu.model.MenuQuery;
import com.mortals.xhx.base.system.menu.model.MenuTreeSelect;
import com.mortals.xhx.base.system.menu.service.MenuService;
import com.mortals.xhx.common.code.SatusEnum;
import com.mortals.xhx.common.code.YesNoEnum;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import java.util.*;
import java.util.stream.Collectors;
/**
* <p>Title: 菜单信息</p>
* <p>Description: MenuServiceImpl service接口 </p>
* <p>Copyright: Copyright &reg; </p>
* <p>Company: </p>
*
* @author
* @version 1.0.0
*/
* MenuService
* 菜单信息 service实现
*
* @author zxfei
* @date 2023-04-10
*/
@Service("menuService")
public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity, Long> implements MenuService {
......@@ -168,8 +159,10 @@ public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity
}
@Override
protected void saveBefore(MenuEntity entity, Context context) throws AppException {
MenuQuery query = new MenuQuery();
query.setParentId(entity.getParentId());
Comparator<Integer> comparator = Comparator.comparing(Integer::intValue);
......@@ -178,6 +171,188 @@ public class MenuServiceImpl extends AbstractCRUDServiceImpl<MenuDao, MenuEntity
e=e+1;
entity.setOrderId(e);
});
MenuEntity parentMenuEntity = this.get(entity.getParentId());
if (!ObjectUtils.isEmpty(parentMenuEntity) && SatusEnum.DISENABLE.getValue() == parentMenuEntity.getStatus()) {
throw new AppException("菜单信息停用，不允许新增");
}
if (!ObjectUtils.isEmpty(parentMenuEntity)) {
entity.setAncestors(parentMenuEntity.getAncestors() + "," + entity.getParentId());
}
super.saveBefore(entity, context);
}
@Override
protected void updateBefore(MenuEntity entity, Context context) throws AppException {
MenuEntity newParentEntity = this.get(entity.getParentId());
MenuEntity oldEntity = this.get(entity.getId());
if (!ObjectUtils.isEmpty(newParentEntity) && !ObjectUtils.isEmpty(oldEntity)) {
String newAncestors = newParentEntity.getAncestors() + "," + newParentEntity.getId();
String oldAncestors = oldEntity.getAncestors();
entity.setAncestors(newAncestors);
updateMenuChildren(entity.getId(), newAncestors, oldAncestors, context);
}
super.updateBefore(entity, context);
}
@Override
protected void updateAfter(MenuEntity entity, Context context) throws AppException {
if (SatusEnum.ENABLE.getValue() == entity.getStatus()) {
entity= this.get(entity.getId());
updateParentMenuStatus(entity, context);
}
super.updateAfter(entity, context);
}
/**
* 修改该菜单信息的父级菜单信息状态
*
* @param menu 当前菜单信息
*/
private void updateParentMenuStatus(MenuEntity menu, Context context) {
MenuEntity menuEntity = this.get(menu.getParentId());
if(!ObjectUtils.isEmpty(menuEntity)){
menuEntity.setStatus(SatusEnum.ENABLE.getValue());
menuEntity.setUpdateTime(new Date());
menuEntity.setUpdateUser(context.getUser().getLoginName());
MenuEntity condition = new MenuEntity();
condition.setId(menuEntity.getId());
this.updateBatch(menuEntity, condition, context);
}
}
/**
* 修改子元素关系
*
* @param menuId 被修改的菜单信息ID
* @param newAncestors 新的父ID集合
* @param oldAncestors 旧的父ID集合
*/
public void updateMenuChildren(Long menuId, String newAncestors, String oldAncestors, Context context) {
List<MenuEntity> children = getDao().selectChildrenMenuById(menuId.toString());
for (MenuEntity child : children) {
child.setAncestors(child.getAncestors().replace(oldAncestors, newAncestors));
}
if (children.size() > 0) {
this.updateAfter(children, context);
}
}
@Override
protected void removeBefore(Long[] ids, Context context) throws AppException {
//有子节点 禁止删除
if (hasChildByMenuId(ids[0])) {
throw new AppException("存在下级菜单信息,不允许删除");
}
super.removeBefore(ids, context);
}
@Override
public boolean hasChildByMenuId(Long menuId) {
List<MenuEntity> list = this.find(new MenuQuery().parentId(menuId));
return list.size() > 0 ? true : false;
}
@Override
public List<MenuEntity> selectMenuList(MenuEntity menu) {
return this.find(new MenuQuery());
}
@Override
public List<MenuTreeSelect> buildMenuTreeSelect(List<MenuEntity> list) {
List<MenuEntity> returnList = new ArrayList<>();
List<Long> tempList = list.stream().map(MenuEntity::getId).collect(Collectors.toList());
for (Iterator<MenuEntity> iterator = list.iterator(); iterator.hasNext(); ) {
MenuEntity menuEntity = iterator.next();
if (!tempList.contains(menuEntity.getParentId())) {
recursionFn(list, menuEntity);
returnList.add(menuEntity);
}
}
if (returnList.isEmpty()) {
returnList = list;
}
return returnList.stream().map(MenuTreeSelect::new).collect(Collectors.toList());
}
/**
* 递归列表
*/
private void recursionFn(List<MenuEntity> list, MenuEntity t) {
// 得到子节点列表
List<MenuEntity> childList = getChildList(list, t);
t.setChildList(childList);
for (MenuEntity tChild : childList) {
if (hasChild(list, tChild)) {
recursionFn(list, tChild);
}
}
}
/**
* 判断是否有子节点
*/
private boolean hasChild(List<MenuEntity> list, MenuEntity t) {
return getChildList(list, t).size() > 0 ? true : false;
}
/**
* 得到子节点列表
*/
private List<MenuEntity> getChildList(List<MenuEntity> list, MenuEntity t) {
return list.stream().map(item->{
if (!ObjectUtils.isEmpty(item.getParentId()) && item.getParentId() == t.getId()) {
return item;
}
return null;
}).filter(f->f!=null).collect(Collectors.toList());
}
@Override
public List<MenuTreeSelect> getListByParentId(Long parentId, Context context) {
if (ObjectUtils.isEmpty(parentId)) {
parentId = 0L;
}
//只做一层
List<MenuTreeSelect> collect = this.find(new MenuQuery().parentId(parentId), context).stream().map(item -> new MenuTreeSelect(item)
).collect(Collectors.toList());
if ("0".equals(parentId)) {
return collect;
}
return collect;
}
@Override
public Set<Long> getPathSetById(Long id, Context context) {
Set<Long> idSet = new HashSet<>();
//idSet.add(id);
MenuEntity menuEntity = this.get(id, context);
if(!ObjectUtils.isEmpty(menuEntity)){
return extracted(context, idSet, menuEntity);
}
return idSet;
}
private Set<Long> extracted(Context context, Set<Long> idSet, MenuEntity menuEntity) {
MenuEntity parentMenu = this.get(menuEntity.getParentId(), context);
if(!ObjectUtils.isEmpty(parentMenu)){
idSet.add(parentMenu.getId());
return extracted(context,idSet,parentMenu);
}
return idSet;
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/base/system/menu/web/MenuController.java
View file @ 468eee28
package com.mortals.xhx.base.system.menu.web;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.framework.model.OrderCol;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.menu.model.MenuQuery;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.web.BaseCRUDJsonMappingController;
import com.mortals.xhx.base.system.menu.model.MenuEntity;
import com.mortals.xhx.base.system.menu.model.MenuQuery;
import com.mortals.xhx.base.system.menu.model.MenuTreeSelect;
import com.mortals.xhx.base.system.menu.service.MenuService;
import com.mortals.xhx.common.code.DataSatus;
import com.mortals.xhx.common.code.MenuAuthType;
import com.mortals.xhx.common.code.MenuComm;
import com.mortals.xhx.common.code.MenuLinkType;
import com.mortals.xhx.common.code.MenuType;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.mortals.xhx.base.system.param.service.ParamService;
import com.mortals.xhx.common.code.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.*;
import java.util.stream.Collectors;
import static com.mortals.framework.ap.SysConstains.RESULT_KEY;
/**
* 菜单信息
*
* @author: zxfei
* @date: 2021/11/30 10:02
*/
*
* 菜单信息
*
* @author zxfei
* @date 2023-04-10
*/
@RestController
@RequestMapping("menu")
public class MenuController extends BaseCRUDJsonBodyMappingController<MenuService, MenuEntity, Long> {
public class MenuController extends BaseCRUDJsonBodyMappingController<MenuService,MenuEntity,Long> {
public MenuController() {
super.setModuleDesc("菜单信息");
}
@Autowired
private ParamService paramService;
@Override
......@@ -110,4 +101,88 @@ public class MenuController extends BaseCRUDJsonBodyMappingController<MenuServic
}
return ret.toJSONString();
}
@PostMapping("list/exclude")
public String excludeList(@RequestBody MenuEntity query) {
Map<String, Object> model = new HashMap<>();
JSONObject ret = new JSONObject();
String busiDesc = "查询" + this.getModuleDesc();
int code=VALUE_RESULT_SUCCESS;
try {
//查询所有菜单 排除当前菜单路径
Set<Long> idSet = new HashSet<>();
idSet.add(query.getId());
//Set<Long> idSets = this.service.getPathSetById(query.getId(), getContext());
List<MenuEntity> collect = this.service.find(new MenuQuery()).stream().map(item -> {
if(idSet.contains(item.getId())) return null;
//if(idSets.contains(item.getId())) return null;
//ArrayUtils.contains()
// if(ObjectUtils.isEmpty(item.getAncestors())){
// return null;
// }
// if (item.getId().intValue() == id || ArrayUtils.contains(StringUtils.split(item.getAncestors(), ","), id + "")) {
// return null;
// }
return item;
}).filter(f -> f != null).collect(Collectors.toList());
model.put("data", collect);
recordSysLog(request, busiDesc + " 【成功】");
} catch (Exception e) {
code = VALUE_RESULT_FAILURE;
this.doException(request, busiDesc, model, e);
}
ret.put(KEY_RESULT_DATA, model);
ret.put(KEY_RESULT_CODE, code);
return ret.toJSONString();
}
/**
* 获取站点下拉树列表
*/
@PostMapping("treeselect")
public String treeselect(MenuEntity query) {
Map<String, Object> model = new HashMap<>();
JSONObject ret = new JSONObject();
String busiDesc = "查询" + this.getModuleDesc();
int code=VALUE_RESULT_SUCCESS;
try {
List<MenuEntity> list = this.service.find(new MenuQuery());
List<MenuTreeSelect> treeSelects = this.service.buildMenuTreeSelect(list);
model.put("result", treeSelects);
recordSysLog(request, busiDesc + " 【成功】");
} catch (Exception e) {
code = VALUE_RESULT_FAILURE;
this.doException(request, busiDesc, model, e);
}
ret.put(KEY_RESULT_DATA, model);
ret.put(KEY_RESULT_CODE, code);
return ret.toJSONString();
}
/**
* 根据parentId查询子信息
*/
@GetMapping(value = "getListByParentId")
public String getListByParentId(Long parentId) {
JSONObject ret = new JSONObject();
Map<String, Object> model = new HashMap<>();
String busiDesc = "查询" + this.getModuleDesc()+"子节点";
try {
List<MenuTreeSelect> treeList = this.service.getListByParentId(parentId, getContext());
model.put(RESULT_KEY,treeList);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_SUCCESS);
ret.put(KEY_RESULT_DATA, model);
recordSysLog(request, busiDesc+"【成功】");
} catch (Exception e) {
log.error("根据parentId查询子信息错误", e);
this.doException(request, busiDesc, model, e);
ret.put(KEY_RESULT_CODE, VALUE_RESULT_FAILURE);
ret.put(KEY_RESULT_MSG, e.getMessage());
}
return ret.toJSONString();
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/common/code/SatusEnum.java 0 → 100644
View file @ 468eee28
package com.mortals.xhx.common.code;
import java.util.LinkedHashMap;
import java.util.Map;
/**
* 状态
* @author
*
*/
public enum SatusEnum {
DISENABLE(0, "禁用"),
ENABLE(1, "启用");
private int value;
private String desc;
SatusEnum(int value, String desc) {
this.value = value;
this.desc = desc;
}
public int getValue() {
return this.value;
}
public String getDesc() {
return desc;
}
public static SatusEnum getByValue(int value) {
for (SatusEnum examStatus : SatusEnum.values()) {
if (examStatus.getValue() == value) {
return examStatus;
}
}
return null;
}
/**
* 获取Map集合
* @param eItem 不包含项
* @return
*/
public static Map<String,String> getEnumMap(int... eItem) {
Map<String,String> resultMap= new LinkedHashMap<String,String>();
for (SatusEnum item : SatusEnum.values()) {
try{
boolean hasE = false;
for (int e : eItem){
if(item.getValue()==e){
hasE = true;
break;
}
}
if(!hasE){
resultMap.put(item.getValue()+"", item.getDesc());
}
}catch(Exception ex){
}
}
return resultMap;
}
}
attendance-performance-manager/src/main/java/com/mortals/xhx/daemon/task/SyncUserTaskImpl.java
View file @ 468eee28
......@@ -10,7 +10,6 @@ import com.mortals.xhx.busiz.rsp.DeptHikData;
import com.mortals.xhx.busiz.rsp.ListDept;
import com.mortals.xhx.busiz.rsp.ListItem;
import com.mortals.xhx.busiz.rsp.PersonHikData;
import com.mortals.xhx.feign.user.IUserFeign;
import com.mortals.xhx.module.dept.dao.ibatis.DeptDaoImpl;
import com.mortals.xhx.module.dept.model.DeptEntity;
import com.mortals.xhx.module.staff.dao.ibatis.StaffDaoImpl;
......@@ -30,12 +29,6 @@ import java.util.Objects;
@Service("SyncUserTask")
public class SyncUserTaskImpl implements ITaskExcuteService {
@Autowired
private UserService userService;
@Autowired
private IUserFeign userFeign;
@Autowired
private JsonUtils jsonUtils;
......
attendance-performance-manager/src/main/java/com/mortals/xhx/module/staff/model/StaffEntity.java
View file @ 468eee28
......@@ -483,6 +483,6 @@ public class StaffEntity extends StaffVo {
this.remarkId = "";
this.source = 1;
this.source = 2;
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/staff/service/impl/StaffRegularServiceImpl.java
View file @ 468eee28
package com.mortals.xhx.module.staff.service.impl;
import com.mortals.xhx.module.staff.model.StaffEntity;
import com.mortals.xhx.module.staff.service.StaffService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
......@@ -6,6 +9,9 @@ import com.mortals.framework.model.Context;
import com.mortals.xhx.module.staff.dao.StaffRegularDao;
import com.mortals.xhx.module.staff.model.StaffRegularEntity;
import com.mortals.xhx.module.staff.service.StaffRegularService;
import java.util.List;
/**
* StaffRegularService
* 员工转正信息 service实现
......@@ -15,5 +21,17 @@ import com.mortals.xhx.module.staff.service.StaffRegularService;
*/
@Service("staffRegularService")
public class StaffRegularServiceImpl extends AbstractCRUDServiceImpl<StaffRegularDao, StaffRegularEntity, Long> implements StaffRegularService {
@Autowired
private StaffService staffService;
private void test(){
StaffEntity cache = staffService.getCache("1");
List<StaffEntity> cacheList = staffService.getCacheList();
StaffEntity work001 = staffService.getExtCache("work001");
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/staff/service/impl/StaffServiceImpl.java
View file @ 468eee28
package com.mortals.xhx.module.staff.service.impl;
import com.mortals.framework.service.impl.AbstractCRUDCacheServiceImpl;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
......@@ -8,20 +7,22 @@ import com.mortals.framework.model.Context;
import com.mortals.xhx.module.staff.dao.StaffDao;
import com.mortals.xhx.module.staff.model.StaffEntity;
import com.mortals.xhx.module.staff.service.StaffService;
/**
* StaffService
* 员工基本信息 service实现
*
* @author zxfei
* @date 2023-04-07
*/
* StaffService
* 员工基本信息 service实现
*
* @author zxfei
* @date 2023-04-07
*/
@Service("staffService")
public class StaffServiceImpl extends AbstractCRUDCacheServiceImpl<StaffDao, StaffEntity, Long> implements StaffService {
@Override
protected String getExtKey(StaffEntity data) {
//工号作为redis 扩展key
//工号作为redis 扩展key
return data.getWorkNum();
}
}
\ No newline at end of file
attendance-performance-manager/src/main/java/com/mortals/xhx/module/staff/web/StaffController.java
View file @ 468eee28
......@@ -6,6 +6,7 @@ import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import com.mortals.xhx.module.staff.model.StaffEntity;
import com.mortals.xhx.module.staff.model.vo.HolidayListVo;
import com.mortals.xhx.module.staff.model.vo.StaffVo;
import com.mortals.xhx.module.staff.service.StaffService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
......@@ -50,6 +51,12 @@ public class StaffController extends BaseCRUDJsonBodyMappingController<StaffServ
@Override
protected int doListAfter(StaffEntity query, Map<String, Object> model, Context context) throws AppException {
//
model.put("stat",new StaffVo());
return super.doListAfter(query, model, context);
}
......@@ -82,4 +89,6 @@ public class StaffController extends BaseCRUDJsonBodyMappingController<StaffServ
return super.infoAfter(id, model, entity, context);
}
}
\ No newline at end of file
attendance-performance-manager/src/main/resources/sqlmap/base/system/menu.xml
View file @ 468eee28
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.base.system.menu.dao.ibatis.MenuDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="MenuEntity" id="MenuEntity-Map">
<result property="id" column="id" />
<id property="id" column="id" />
<result property="name" column="name" />
<result property="url" column="url" />
<result property="ancestors" column="ancestors" />
<result property="parentId" column="parentId" />
<result property="orderId" column="orderId" />
<result property="status" column="status" />
......@@ -23,194 +24,371 @@
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
</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,
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
a.name as name,
a.name,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('url') or colPickMode == 1 and data.containsKey('url')))">
a.url as url,
a.url,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('ancestors') or colPickMode == 1 and data.containsKey('ancestors')))">
a.ancestors,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('parentId') or colPickMode == 1 and data.containsKey('parentId')))">
a.parentId as parentId,
a.parentId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('orderId') or colPickMode == 1 and data.containsKey('orderId')))">
a.orderId as orderId,
a.orderId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('status') or colPickMode == 1 and data.containsKey('status')))">
a.status as status,
a.status,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('linkType') or colPickMode == 1 and data.containsKey('linkType')))">
a.linkType as linkType,
a.linkType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupId') or colPickMode == 1 and data.containsKey('groupId')))">
a.groupId as groupId,
a.groupId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupName') or colPickMode == 1 and data.containsKey('groupName')))">
a.groupName as groupName,
a.groupName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('imgPath') or colPickMode == 1 and data.containsKey('imgPath')))">
a.imgPath as imgPath,
a.imgPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('buttonImgPath') or colPickMode == 1 and data.containsKey('buttonImgPath')))">
a.buttonImgPath as buttonImgPath,
a.buttonImgPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('imgCommPath') or colPickMode == 1 and data.containsKey('imgCommPath')))">
a.imgCommPath as imgCommPath,
a.imgCommPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('commMenu') or colPickMode == 1 and data.containsKey('commMenu')))">
a.commMenu as commMenu,
a.commMenu,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('menuType') or colPickMode == 1 and data.containsKey('menuType')))">
a.menuType as menuType,
a.menuType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('authType') or colPickMode == 1 and data.containsKey('authType')))">
a.authType as authType,
a.authType,
</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,
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId as createUserId,
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserName') or colPickMode == 1 and data.containsKey('createUserName')))">
a.createUserName as createUserName,
a.createUserName,
</if>
</trim>
</sql>
<!-- 新增 -->
<insert id="insert" parameterType="MenuEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_menu
(name,url,parentId,orderId,status,
linkType,groupId,groupName,imgPath,buttonImgPath,
imgCommPath,commMenu,menuType,authType,createTime,
createUserId,createUserName
)VALUES(#{name},#{url},#{parentId},#{orderId},#{status},
#{linkType},#{groupId},#{groupName},#{imgPath},#{buttonImgPath},
#{imgCommPath},#{commMenu},#{menuType},#{authType},#{createTime},
#{createUserId},#{createUserName})
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="MenuEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_menu
(name,url,ancestors,parentId,orderId,status,linkType,groupId,groupName,imgPath,buttonImgPath,imgCommPath,commMenu,menuType,authType,createTime,createUserId,createUserName)
VALUES
(#{name},#{url},#{ancestors},#{parentId},#{orderId},#{status},#{linkType},#{groupId},#{groupName},#{imgPath},#{buttonImgPath},#{imgCommPath},#{commMenu},#{menuType},#{authType},#{createTime},#{createUserId},#{createUserName})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_menu
(name,url,parentId,orderId,status,
linkType,groupId,groupName,imgPath,buttonImgPath,
imgCommPath,commMenu,menuType,authType,createTime,
createUserId,createUserName
)
insert into mortals_xhx_menu
(name,url,ancestors,parentId,orderId,status,linkType,groupId,groupName,imgPath,buttonImgPath,imgCommPath,commMenu,menuType,authType,createTime,createUserId,createUserName)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.url},#{item.parentId},#{item.orderId},#{item.status},
#{item.linkType},#{item.groupId},#{item.groupName},#{item.imgPath},#{item.buttonImgPath},
#{item.imgCommPath},#{item.commMenu},#{item.menuType},#{item.authType},#{item.createTime},
#{item.createUserId},#{item.createUserName})
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.url},#{item.ancestors},#{item.parentId},#{item.orderId},#{item.status},#{item.linkType},#{item.groupId},#{item.groupName},#{item.imgPath},#{item.buttonImgPath},#{item.imgCommPath},#{item.commMenu},#{item.menuType},#{item.authType},#{item.createTime},#{item.createUserId},#{item.createUserName})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_menu as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('name')) or (colPickMode==1 and !data.containsKey('name'))">
a.name=#{data.name},
</if>
<if test="(colPickMode==0 and data.containsKey('url')) or (colPickMode==1 and !data.containsKey('url'))">
a.url=#{data.url},
</if>
<if test="(colPickMode==0 and data.containsKey('parentId')) or (colPickMode==1 and !data.containsKey('parentId'))">
a.parentId=#{data.parentId},
</if>
<if test="(colPickMode==0 and data.containsKey('parentIdIncrement')) or (colPickMode==1 and !data.containsKey('parentIdIncrement'))">
a.parentId=ifnull(a.parentId,0) + #{data.parentIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('orderId')) or (colPickMode==1 and !data.containsKey('orderId'))">
a.orderId=#{data.orderId},
</if>
<if test="(colPickMode==0 and data.containsKey('orderIdIncrement')) or (colPickMode==1 and !data.containsKey('orderIdIncrement'))">
a.orderId=ifnull(a.orderId,0) + #{data.orderIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('status')) or (colPickMode==1 and !data.containsKey('status'))">
a.status=#{data.status},
</if>
<if test="(colPickMode==0 and data.containsKey('statusIncrement')) or (colPickMode==1 and !data.containsKey('statusIncrement'))">
a.status=ifnull(a.status,0) + #{data.statusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('linkType')) or (colPickMode==1 and !data.containsKey('linkType'))">
a.linkType=#{data.linkType},
</if>
<if test="(colPickMode==0 and data.containsKey('linkTypeIncrement')) or (colPickMode==1 and !data.containsKey('linkTypeIncrement'))">
a.linkType=ifnull(a.linkType,0) + #{data.linkTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('groupId')) or (colPickMode==1 and !data.containsKey('groupId'))">
a.groupId=#{data.groupId},
</if>
<if test="(colPickMode==0 and data.containsKey('groupIdIncrement')) or (colPickMode==1 and !data.containsKey('groupIdIncrement'))">
a.groupId=ifnull(a.groupId,0) + #{data.groupIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('groupName')) or (colPickMode==1 and !data.containsKey('groupName'))">
a.groupName=#{data.groupName},
</if>
<if test="(colPickMode==0 and data.containsKey('imgPath')) or (colPickMode==1 and !data.containsKey('imgPath'))">
a.imgPath=#{data.imgPath},
</if>
<if test="(colPickMode==0 and data.containsKey('buttonImgPath')) or (colPickMode==1 and !data.containsKey('buttonImgPath'))">
a.buttonImgPath=#{data.buttonImgPath},
</if>
<if test="(colPickMode==0 and data.containsKey('imgCommPath')) or (colPickMode==1 and !data.containsKey('imgCommPath'))">
a.imgCommPath=#{data.imgCommPath},
</if>
<if test="(colPickMode==0 and data.containsKey('commMenu')) or (colPickMode==1 and !data.containsKey('commMenu'))">
a.commMenu=#{data.commMenu},
</if>
<if test="(colPickMode==0 and data.containsKey('commMenuIncrement')) or (colPickMode==1 and !data.containsKey('commMenuIncrement'))">
a.commMenu=ifnull(a.commMenu,0) + #{data.commMenuIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('menuType')) or (colPickMode==1 and !data.containsKey('menuType'))">
a.menuType=#{data.menuType},
</if>
<if test="(colPickMode==0 and data.containsKey('menuTypeIncrement')) or (colPickMode==1 and !data.containsKey('menuTypeIncrement'))">
a.menuType=ifnull(a.menuType,0) + #{data.menuTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('authType')) or (colPickMode==1 and !data.containsKey('authType'))">
a.authType=#{data.authType},
</if>
<if test="(colPickMode==0 and data.containsKey('authTypeIncrement')) or (colPickMode==1 and !data.containsKey('authTypeIncrement'))">
a.authType=ifnull(a.authType,0) + #{data.authTypeIncrement},
</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('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserName')) or (colPickMode==1 and !data.containsKey('createUserName'))">
a.createUserName=#{data.createUserName},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('name')) or (colPickMode==1 and !data.containsKey('name'))">
a.name=#{data.name},
</if>
<if test="(colPickMode==0 and data.containsKey('url')) or (colPickMode==1 and !data.containsKey('url'))">
a.url=#{data.url},
</if>
<if test="(colPickMode==0 and data.containsKey('ancestors')) or (colPickMode==1 and !data.containsKey('ancestors'))">
a.ancestors=#{data.ancestors},
</if>
<if test="(colPickMode==0 and data.containsKey('parentId')) or (colPickMode==1 and !data.containsKey('parentId'))">
a.parentId=#{data.parentId},
</if>
<if test="(colPickMode==0 and data.containsKey('parentIdIncrement')) or (colPickMode==1 and !data.containsKey('parentIdIncrement'))">
a.parentId=ifnull(a.parentId,0) + #{data.parentIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('orderId')) or (colPickMode==1 and !data.containsKey('orderId'))">
a.orderId=#{data.orderId},
</if>
<if test="(colPickMode==0 and data.containsKey('orderIdIncrement')) or (colPickMode==1 and !data.containsKey('orderIdIncrement'))">
a.orderId=ifnull(a.orderId,0) + #{data.orderIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('status')) or (colPickMode==1 and !data.containsKey('status'))">
a.status=#{data.status},
</if>
<if test="(colPickMode==0 and data.containsKey('statusIncrement')) or (colPickMode==1 and !data.containsKey('statusIncrement'))">
a.status=ifnull(a.status,0) + #{data.statusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('linkType')) or (colPickMode==1 and !data.containsKey('linkType'))">
a.linkType=#{data.linkType},
</if>
<if test="(colPickMode==0 and data.containsKey('linkTypeIncrement')) or (colPickMode==1 and !data.containsKey('linkTypeIncrement'))">
a.linkType=ifnull(a.linkType,0) + #{data.linkTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('groupId')) or (colPickMode==1 and !data.containsKey('groupId'))">
a.groupId=#{data.groupId},
</if>
<if test="(colPickMode==0 and data.containsKey('groupIdIncrement')) or (colPickMode==1 and !data.containsKey('groupIdIncrement'))">
a.groupId=ifnull(a.groupId,0) + #{data.groupIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('groupName')) or (colPickMode==1 and !data.containsKey('groupName'))">
a.groupName=#{data.groupName},
</if>
<if test="(colPickMode==0 and data.containsKey('imgPath')) or (colPickMode==1 and !data.containsKey('imgPath'))">
a.imgPath=#{data.imgPath},
</if>
<if test="(colPickMode==0 and data.containsKey('buttonImgPath')) or (colPickMode==1 and !data.containsKey('buttonImgPath'))">
a.buttonImgPath=#{data.buttonImgPath},
</if>
<if test="(colPickMode==0 and data.containsKey('imgCommPath')) or (colPickMode==1 and !data.containsKey('imgCommPath'))">
a.imgCommPath=#{data.imgCommPath},
</if>
<if test="(colPickMode==0 and data.containsKey('commMenu')) or (colPickMode==1 and !data.containsKey('commMenu'))">
a.commMenu=#{data.commMenu},
</if>
<if test="(colPickMode==0 and data.containsKey('commMenuIncrement')) or (colPickMode==1 and !data.containsKey('commMenuIncrement'))">
a.commMenu=ifnull(a.commMenu,0) + #{data.commMenuIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('menuType')) or (colPickMode==1 and !data.containsKey('menuType'))">
a.menuType=#{data.menuType},
</if>
<if test="(colPickMode==0 and data.containsKey('menuTypeIncrement')) or (colPickMode==1 and !data.containsKey('menuTypeIncrement'))">
a.menuType=ifnull(a.menuType,0) + #{data.menuTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('authType')) or (colPickMode==1 and !data.containsKey('authType'))">
a.authType=#{data.authType},
</if>
<if test="(colPickMode==0 and data.containsKey('authTypeIncrement')) or (colPickMode==1 and !data.containsKey('authTypeIncrement'))">
a.authType=ifnull(a.authType,0) + #{data.authTypeIncrement},
</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('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserName')) or (colPickMode==1 and !data.containsKey('createUserName'))">
a.createUserName=#{data.createUserName},
</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_menu as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="name=(case" suffix="ELSE name end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
when a.id=#{item.id} then #{item.name}
</if>
</foreach>
</trim>
<trim prefix="url=(case" suffix="ELSE url end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('url')) or (colPickMode==1 and !item.containsKey('url'))">
when a.id=#{item.id} then #{item.url}
</if>
</foreach>
</trim>
<trim prefix="ancestors=(case" suffix="ELSE ancestors end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('ancestors')) or (colPickMode==1 and !item.containsKey('ancestors'))">
when a.id=#{item.id} then #{item.ancestors}
</if>
</foreach>
</trim>
<trim prefix="parentId=(case" suffix="ELSE parentId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('parentId')) or (colPickMode==1 and !item.containsKey('parentId'))">
when a.id=#{item.id} then #{item.parentId}
</when>
<when test="(colPickMode==0 and item.containsKey('parentIdIncrement')) or (colPickMode==1 and !item.containsKey('parentIdIncrement'))">
when a.id=#{item.id} then ifnull(a.parentId,0) + #{item.parentIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="orderId=(case" suffix="ELSE orderId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('orderId')) or (colPickMode==1 and !item.containsKey('orderId'))">
when a.id=#{item.id} then #{item.orderId}
</when>
<when test="(colPickMode==0 and item.containsKey('orderIdIncrement')) or (colPickMode==1 and !item.containsKey('orderIdIncrement'))">
when a.id=#{item.id} then ifnull(a.orderId,0) + #{item.orderIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="status=(case" suffix="ELSE status end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('status')) or (colPickMode==1 and !item.containsKey('status'))">
when a.id=#{item.id} then #{item.status}
</when>
<when test="(colPickMode==0 and item.containsKey('statusIncrement')) or (colPickMode==1 and !item.containsKey('statusIncrement'))">
when a.id=#{item.id} then ifnull(a.status,0) + #{item.statusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="linkType=(case" suffix="ELSE linkType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('linkType')) or (colPickMode==1 and !item.containsKey('linkType'))">
when a.id=#{item.id} then #{item.linkType}
</when>
<when test="(colPickMode==0 and item.containsKey('linkTypeIncrement')) or (colPickMode==1 and !item.containsKey('linkTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.linkType,0) + #{item.linkTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="groupId=(case" suffix="ELSE groupId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('groupId')) or (colPickMode==1 and !item.containsKey('groupId'))">
when a.id=#{item.id} then #{item.groupId}
</when>
<when test="(colPickMode==0 and item.containsKey('groupIdIncrement')) or (colPickMode==1 and !item.containsKey('groupIdIncrement'))">
when a.id=#{item.id} then ifnull(a.groupId,0) + #{item.groupIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="groupName=(case" suffix="ELSE groupName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('groupName')) or (colPickMode==1 and !item.containsKey('groupName'))">
when a.id=#{item.id} then #{item.groupName}
</if>
</foreach>
</trim>
<trim prefix="imgPath=(case" suffix="ELSE imgPath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('imgPath')) or (colPickMode==1 and !item.containsKey('imgPath'))">
when a.id=#{item.id} then #{item.imgPath}
</if>
</foreach>
</trim>
<trim prefix="buttonImgPath=(case" suffix="ELSE buttonImgPath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('buttonImgPath')) or (colPickMode==1 and !item.containsKey('buttonImgPath'))">
when a.id=#{item.id} then #{item.buttonImgPath}
</if>
</foreach>
</trim>
<trim prefix="imgCommPath=(case" suffix="ELSE imgCommPath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('imgCommPath')) or (colPickMode==1 and !item.containsKey('imgCommPath'))">
when a.id=#{item.id} then #{item.imgCommPath}
</if>
</foreach>
</trim>
<trim prefix="commMenu=(case" suffix="ELSE commMenu end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('commMenu')) or (colPickMode==1 and !item.containsKey('commMenu'))">
when a.id=#{item.id} then #{item.commMenu}
</when>
<when test="(colPickMode==0 and item.containsKey('commMenuIncrement')) or (colPickMode==1 and !item.containsKey('commMenuIncrement'))">
when a.id=#{item.id} then ifnull(a.commMenu,0) + #{item.commMenuIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="menuType=(case" suffix="ELSE menuType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('menuType')) or (colPickMode==1 and !item.containsKey('menuType'))">
when a.id=#{item.id} then #{item.menuType}
</when>
<when test="(colPickMode==0 and item.containsKey('menuTypeIncrement')) or (colPickMode==1 and !item.containsKey('menuTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.menuType,0) + #{item.menuTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="authType=(case" suffix="ELSE authType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('authType')) or (colPickMode==1 and !item.containsKey('authType'))">
when a.id=#{item.id} then #{item.authType}
</when>
<when test="(colPickMode==0 and item.containsKey('authTypeIncrement')) or (colPickMode==1 and !item.containsKey('authTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.authType,0) + #{item.authTypeIncrement}
</when>
</choose>
</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="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createUserName=(case" suffix="ELSE createUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createUserName')) or (colPickMode==1 and !item.containsKey('createUserName'))">
when a.id=#{item.id} then #{item.createUserName}
</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="MenuEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_menu as a
where a.id=#{condition.id}
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
......@@ -223,11 +401,26 @@
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_xhx_menu where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_menu where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_menu as a
<trim suffixOverrides="where" suffix="">
where
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
......@@ -236,355 +429,535 @@
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="MenuEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_menu as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
from mortals_xhx_menu as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取子节点 -->
<select id="selectChildrenMenuById" parameterType="String" resultMap="MenuEntity-Map">
select * from mortals_xhx_menu as a where find_in_set(#{menuId}, ancestors)
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_xhx_menu as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
from mortals_xhx_menu 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()">
<if test="condition.containsKey('id')">
<if test="condition.id != null">
and a.id=#{condition.id}
</if>
</if>
<if test="condition.containsKey('id')">
<if test="condition.id != null ">
and a.id = #{condition.id}
</if>
<if test="condition.id == null">
and a.id is null
</if>
</if>
<if test="condition.containsKey('idList')">
and a.id in
<foreach collection="condition.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('idStart') and condition.idStart != null">
<![CDATA[ and a.id >= #{condition.idStart} ]]>
</if>
<if test="condition.containsKey('idEnd') and condition.idEnd != null">
<![CDATA[ and a.id <= #{condition.idEnd} ]]>
</if>
<if test="condition.containsKey('name')">
<if test="condition.name != null and condition.name != ''">
and a.name like #{condition.name}
</if>
<if test="condition.name == null">
and a.name is null
</if>
</if>
<if test="condition.containsKey('nameList')">
and a.name in
<foreach collection="condition.nameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('url')">
<if test="condition.url != null and condition.url != ''">
and a.url like #{condition.url}
</if>
<if test="condition.url == null">
and a.url is null
</if>
</if>
<if test="condition.containsKey('urlList')">
and a.url in
<foreach collection="condition.urlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('parentId')">
<if test="condition.parentId != null ">
and a.parentId = #{condition.parentId}
</if>
<if test="condition.parentId == null">
and a.parentId is null
</if>
</if>
<if test="condition.containsKey('parentIdList')">
and a.parentId in
<foreach collection="condition.parentIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('parentIdStart') and condition.parentIdStart != null">
<![CDATA[ and a.parentId >= #{condition.parentIdStart} ]]>
</if>
<if test="condition.containsKey('parentIdEnd') and condition.parentIdEnd != null">
<![CDATA[ and a.parentId <= #{condition.parentIdEnd} ]]>
</if>
<if test="condition.containsKey('orderId')">
<if test="condition.orderId != null ">
and a.orderId = #{condition.orderId}
</if>
<if test="condition.orderId == null">
and a.orderId is null
</if>
</if>
<if test="condition.containsKey('orderIdList')">
and a.orderId in
<foreach collection="condition.orderIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('orderIdStart') and condition.orderIdStart != null">
<![CDATA[ and a.orderId >= #{condition.orderIdStart} ]]>
</if>
<if test="condition.containsKey('orderIdEnd') and condition.orderIdEnd != null">
<![CDATA[ and a.orderId <= #{condition.orderIdEnd} ]]>
</if>
<if test="condition.containsKey('status')">
<if test="condition.status != null ">
and a.status = #{condition.status}
</if>
<if test="condition.status == null">
and a.status is null
</if>
</if>
<if test="condition.containsKey('statusList')">
and a.status in
<foreach collection="condition.statusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('statusStart') and condition.statusStart != null">
<![CDATA[ and a.status >= #{condition.statusStart} ]]>
</if>
<if test="condition.containsKey('statusEnd') and condition.statusEnd != null">
<![CDATA[ and a.status <= #{condition.statusEnd} ]]>
</if>
<if test="condition.containsKey('linkType')">
<if test="condition.linkType != null ">
and a.linkType = #{condition.linkType}
</if>
<if test="condition.linkType == null">
and a.linkType is null
</if>
</if>
<if test="condition.containsKey('linkTypeList')">
and a.linkType in
<foreach collection="condition.linkTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('linkTypeStart') and condition.linkTypeStart != null">
<![CDATA[ and a.linkType >= #{condition.linkTypeStart} ]]>
</if>
<if test="condition.containsKey('linkTypeEnd') and condition.linkTypeEnd != null">
<![CDATA[ and a.linkType <= #{condition.linkTypeEnd} ]]>
</if>
<if test="condition.containsKey('groupId')">
<if test="condition.groupId != null ">
and a.groupId = #{condition.groupId}
</if>
<if test="condition.groupId == null">
and a.groupId is null
</if>
</if>
<if test="condition.containsKey('groupIdList')">
and a.groupId in
<foreach collection="condition.groupIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('groupIdStart') and condition.groupIdStart != null">
<![CDATA[ and a.groupId >= #{condition.groupIdStart} ]]>
</if>
<if test="condition.containsKey('groupIdEnd') and condition.groupIdEnd != null">
<![CDATA[ and a.groupId <= #{condition.groupIdEnd} ]]>
</if>
<if test="condition.containsKey('groupName')">
<if test="condition.groupName != null and condition.groupName != ''">
and a.groupName like #{condition.groupName}
</if>
<if test="condition.groupName == null">
and a.groupName is null
</if>
</if>
<if test="condition.containsKey('groupNameList')">
and a.groupName in
<foreach collection="condition.groupNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('imgPath')">
<if test="condition.imgPath != null and condition.imgPath != ''">
and a.imgPath like #{condition.imgPath}
</if>
<if test="condition.imgPath == null">
and a.imgPath is null
</if>
</if>
<if test="condition.containsKey('imgPathList')">
and a.imgPath in
<foreach collection="condition.imgPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('buttonImgPath')">
<if test="condition.buttonImgPath != null and condition.buttonImgPath != ''">
and a.buttonImgPath like #{condition.buttonImgPath}
</if>
<if test="condition.buttonImgPath == null">
and a.buttonImgPath is null
</if>
</if>
<if test="condition.containsKey('buttonImgPathList')">
and a.buttonImgPath in
<foreach collection="condition.buttonImgPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('imgCommPath')">
<if test="condition.imgCommPath != null and condition.imgCommPath != ''">
and a.imgCommPath like #{condition.imgCommPath}
</if>
<if test="condition.imgCommPath == null">
and a.imgCommPath is null
</if>
</if>
<if test="condition.containsKey('imgCommPathList')">
and a.imgCommPath in
<foreach collection="condition.imgCommPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('commMenu')">
<if test="condition.commMenu != null ">
and a.commMenu = #{condition.commMenu}
</if>
<if test="condition.commMenu == null">
and a.commMenu is null
</if>
</if>
<if test="condition.containsKey('commMenuList')">
and a.commMenu in
<foreach collection="condition.commMenuList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('commMenuStart') and condition.commMenuStart != null">
<![CDATA[ and a.commMenu >= #{condition.commMenuStart} ]]>
</if>
<if test="condition.containsKey('commMenuEnd') and condition.commMenuEnd != null">
<![CDATA[ and a.commMenu <= #{condition.commMenuEnd} ]]>
</if>
<if test="condition.containsKey('menuType')">
<if test="condition.menuType != null ">
and a.menuType = #{condition.menuType}
</if>
<if test="condition.menuType == null">
and a.menuType is null
</if>
</if>
<if test="condition.containsKey('menuTypeList')">
and a.menuType in
<foreach collection="condition.menuTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('menuTypeStart') and condition.menuTypeStart != null">
<![CDATA[ and a.menuType >= #{condition.menuTypeStart} ]]>
</if>
<if test="condition.containsKey('menuTypeEnd') and condition.menuTypeEnd != null">
<![CDATA[ and a.menuType <= #{condition.menuTypeEnd} ]]>
</if>
<if test="condition.containsKey('authType')">
<if test="condition.authType != null ">
and a.authType = #{condition.authType}
</if>
<if test="condition.authType == null">
and a.authType is null
</if>
</if>
<if test="condition.containsKey('authTypeList')">
and a.authType in
<foreach collection="condition.authTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('authTypeStart') and condition.authTypeStart != null">
<![CDATA[ and a.authType >= #{condition.authTypeStart} ]]>
</if>
<if test="condition.containsKey('authTypeEnd') and condition.authTypeEnd != null">
<![CDATA[ and a.authType <= #{condition.authTypeEnd} ]]>
</if>
<if test="condition.containsKey('createTime')">
<if test="condition.createTime != null ">
and a.createTime = #{condition.createTime}
</if>
<if test="condition.createTime == null">
and a.createTime is null
</if>
</if>
<if test="condition.containsKey('createTimeStart') and condition.createTimeStart != null and condition.createTimeStart!=''">
<![CDATA[ and a.createTime >= STR_TO_DATE(left(concat(#{condition.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s') ]]>
</if>
<if test="condition.containsKey('createTimeEnd') and condition.createTimeEnd != null and condition.createTimeEnd!=''">
<![CDATA[ and a.createTime <= STR_TO_DATE(left(concat(#{condition.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s') ]]>
</if>
<if test="condition.containsKey('createUserId')">
<if test="condition.createUserId != null ">
and a.createUserId = #{condition.createUserId}
</if>
<if test="condition.createUserId == null">
and a.createUserId is null
</if>
</if>
<if test="condition.containsKey('createUserIdList')">
and a.createUserId in
<foreach collection="condition.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="condition.containsKey('createUserIdStart') and condition.createUserIdStart != null">
<![CDATA[ and a.createUserId >= #{condition.createUserIdStart} ]]>
</if>
<if test="condition.containsKey('createUserIdEnd') and condition.createUserIdEnd != null">
<![CDATA[ and a.createUserId <= #{condition.createUserIdEnd} ]]>
</if>
<if test="condition.containsKey('createUserName')">
<if test="condition.createUserName != null and condition.createUserName != ''">
and a.createUserName like #{condition.createUserName}
</if>
<if test="condition.createUserName == null">
and a.createUserName is null
</if>
</if>
<if test="condition.containsKey('createUserNameList')">
and a.createUserName in
<foreach collection="condition.createUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<!-- 条件映射-普通条件 -->
<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') and conditionParamRef.idList.size() > 0">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
${_conditionType_} a.id not in
<foreach collection="conditionParamRef.idNotList" 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('name')">
<if test="conditionParamRef.name != null and conditionParamRef.name != ''">
${_conditionType_} a.name like #{${_conditionParam_}.name}
</if>
<if test="conditionParamRef.name == null">
${_conditionType_} a.name is null
</if>
</if>
<if test="conditionParamRef.containsKey('nameList') and conditionParamRef.nameList.size() > 0">
${_conditionType_} a.name in
<foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('nameNotList') and conditionParamRef.nameNotList.size() > 0">
${_conditionType_} a.name not in
<foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('url')">
<if test="conditionParamRef.url != null and conditionParamRef.url != ''">
${_conditionType_} a.url like #{${_conditionParam_}.url}
</if>
<if test="conditionParamRef.url == null">
${_conditionType_} a.url is null
</if>
</if>
<if test="conditionParamRef.containsKey('urlList') and conditionParamRef.urlList.size() > 0">
${_conditionType_} a.url in
<foreach collection="conditionParamRef.urlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('urlNotList') and conditionParamRef.urlNotList.size() > 0">
${_conditionType_} a.url not in
<foreach collection="conditionParamRef.urlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ancestors')">
<if test="conditionParamRef.ancestors != null and conditionParamRef.ancestors != ''">
${_conditionType_} a.ancestors like #{${_conditionParam_}.ancestors}
</if>
<if test="conditionParamRef.ancestors == null">
${_conditionType_} a.ancestors is null
</if>
</if>
<if test="conditionParamRef.containsKey('ancestorsList') and conditionParamRef.ancestorsList.size() > 0">
${_conditionType_} a.ancestors in
<foreach collection="conditionParamRef.ancestorsList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('ancestorsNotList') and conditionParamRef.ancestorsNotList.size() > 0">
${_conditionType_} a.ancestors not in
<foreach collection="conditionParamRef.ancestorsNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('parentId')">
<if test="conditionParamRef.parentId != null ">
${_conditionType_} a.parentId = #{${_conditionParam_}.parentId}
</if>
<if test="conditionParamRef.parentId == null">
${_conditionType_} a.parentId is null
</if>
</if>
<if test="conditionParamRef.containsKey('parentIdList') and conditionParamRef.parentIdList.size() > 0">
${_conditionType_} a.parentId in
<foreach collection="conditionParamRef.parentIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('parentIdNotList') and conditionParamRef.parentIdNotList.size() > 0">
${_conditionType_} a.parentId not in
<foreach collection="conditionParamRef.parentIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('parentIdStart') and conditionParamRef.parentIdStart != null">
${_conditionType_} a.parentId <![CDATA[ >= ]]> #{${_conditionParam_}.parentIdStart}
</if>
<if test="conditionParamRef.containsKey('parentIdEnd') and conditionParamRef.parentIdEnd != null">
${_conditionType_} a.parentId <![CDATA[ <= ]]> #{${_conditionParam_}.parentIdEnd}
</if>
<if test="conditionParamRef.containsKey('orderId')">
<if test="conditionParamRef.orderId != null ">
${_conditionType_} a.orderId = #{${_conditionParam_}.orderId}
</if>
<if test="conditionParamRef.orderId == null">
${_conditionType_} a.orderId is null
</if>
</if>
<if test="conditionParamRef.containsKey('orderIdList') and conditionParamRef.orderIdList.size() > 0">
${_conditionType_} a.orderId in
<foreach collection="conditionParamRef.orderIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('orderIdNotList') and conditionParamRef.orderIdNotList.size() > 0">
${_conditionType_} a.orderId not in
<foreach collection="conditionParamRef.orderIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('orderIdStart') and conditionParamRef.orderIdStart != null">
${_conditionType_} a.orderId <![CDATA[ >= ]]> #{${_conditionParam_}.orderIdStart}
</if>
<if test="conditionParamRef.containsKey('orderIdEnd') and conditionParamRef.orderIdEnd != null">
${_conditionType_} a.orderId <![CDATA[ <= ]]> #{${_conditionParam_}.orderIdEnd}
</if>
<if test="conditionParamRef.containsKey('status')">
<if test="conditionParamRef.status != null ">
${_conditionType_} a.status = #{${_conditionParam_}.status}
</if>
<if test="conditionParamRef.status == null">
${_conditionType_} a.status is null
</if>
</if>
<if test="conditionParamRef.containsKey('statusList') and conditionParamRef.statusList.size() > 0">
${_conditionType_} a.status in
<foreach collection="conditionParamRef.statusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('statusNotList') and conditionParamRef.statusNotList.size() > 0">
${_conditionType_} a.status not in
<foreach collection="conditionParamRef.statusNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('statusStart') and conditionParamRef.statusStart != null">
${_conditionType_} a.status <![CDATA[ >= ]]> #{${_conditionParam_}.statusStart}
</if>
<if test="conditionParamRef.containsKey('statusEnd') and conditionParamRef.statusEnd != null">
${_conditionType_} a.status <![CDATA[ <= ]]> #{${_conditionParam_}.statusEnd}
</if>
<if test="conditionParamRef.containsKey('linkType')">
<if test="conditionParamRef.linkType != null ">
${_conditionType_} a.linkType = #{${_conditionParam_}.linkType}
</if>
<if test="conditionParamRef.linkType == null">
${_conditionType_} a.linkType is null
</if>
</if>
<if test="conditionParamRef.containsKey('linkTypeList') and conditionParamRef.linkTypeList.size() > 0">
${_conditionType_} a.linkType in
<foreach collection="conditionParamRef.linkTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('linkTypeNotList') and conditionParamRef.linkTypeNotList.size() > 0">
${_conditionType_} a.linkType not in
<foreach collection="conditionParamRef.linkTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('linkTypeStart') and conditionParamRef.linkTypeStart != null">
${_conditionType_} a.linkType <![CDATA[ >= ]]> #{${_conditionParam_}.linkTypeStart}
</if>
<if test="conditionParamRef.containsKey('linkTypeEnd') and conditionParamRef.linkTypeEnd != null">
${_conditionType_} a.linkType <![CDATA[ <= ]]> #{${_conditionParam_}.linkTypeEnd}
</if>
<if test="conditionParamRef.containsKey('groupId')">
<if test="conditionParamRef.groupId != null ">
${_conditionType_} a.groupId = #{${_conditionParam_}.groupId}
</if>
<if test="conditionParamRef.groupId == null">
${_conditionType_} a.groupId is null
</if>
</if>
<if test="conditionParamRef.containsKey('groupIdList') and conditionParamRef.groupIdList.size() > 0">
${_conditionType_} a.groupId in
<foreach collection="conditionParamRef.groupIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupIdNotList') and conditionParamRef.groupIdNotList.size() > 0">
${_conditionType_} a.groupId not in
<foreach collection="conditionParamRef.groupIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupIdStart') and conditionParamRef.groupIdStart != null">
${_conditionType_} a.groupId <![CDATA[ >= ]]> #{${_conditionParam_}.groupIdStart}
</if>
<if test="conditionParamRef.containsKey('groupIdEnd') and conditionParamRef.groupIdEnd != null">
${_conditionType_} a.groupId <![CDATA[ <= ]]> #{${_conditionParam_}.groupIdEnd}
</if>
<if test="conditionParamRef.containsKey('groupName')">
<if test="conditionParamRef.groupName != null and conditionParamRef.groupName != ''">
${_conditionType_} a.groupName like #{${_conditionParam_}.groupName}
</if>
<if test="conditionParamRef.groupName == null">
${_conditionType_} a.groupName is null
</if>
</if>
<if test="conditionParamRef.containsKey('groupNameList') and conditionParamRef.groupNameList.size() > 0">
${_conditionType_} a.groupName in
<foreach collection="conditionParamRef.groupNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupNameNotList') and conditionParamRef.groupNameNotList.size() > 0">
${_conditionType_} a.groupName not in
<foreach collection="conditionParamRef.groupNameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('imgPath')">
<if test="conditionParamRef.imgPath != null and conditionParamRef.imgPath != ''">
${_conditionType_} a.imgPath like #{${_conditionParam_}.imgPath}
</if>
<if test="conditionParamRef.imgPath == null">
${_conditionType_} a.imgPath is null
</if>
</if>
<if test="conditionParamRef.containsKey('imgPathList') and conditionParamRef.imgPathList.size() > 0">
${_conditionType_} a.imgPath in
<foreach collection="conditionParamRef.imgPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('imgPathNotList') and conditionParamRef.imgPathNotList.size() > 0">
${_conditionType_} a.imgPath not in
<foreach collection="conditionParamRef.imgPathNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('buttonImgPath')">
<if test="conditionParamRef.buttonImgPath != null and conditionParamRef.buttonImgPath != ''">
${_conditionType_} a.buttonImgPath like #{${_conditionParam_}.buttonImgPath}
</if>
<if test="conditionParamRef.buttonImgPath == null">
${_conditionType_} a.buttonImgPath is null
</if>
</if>
<if test="conditionParamRef.containsKey('buttonImgPathList') and conditionParamRef.buttonImgPathList.size() > 0">
${_conditionType_} a.buttonImgPath in
<foreach collection="conditionParamRef.buttonImgPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('buttonImgPathNotList') and conditionParamRef.buttonImgPathNotList.size() > 0">
${_conditionType_} a.buttonImgPath not in
<foreach collection="conditionParamRef.buttonImgPathNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('imgCommPath')">
<if test="conditionParamRef.imgCommPath != null and conditionParamRef.imgCommPath != ''">
${_conditionType_} a.imgCommPath like #{${_conditionParam_}.imgCommPath}
</if>
<if test="conditionParamRef.imgCommPath == null">
${_conditionType_} a.imgCommPath is null
</if>
</if>
<if test="conditionParamRef.containsKey('imgCommPathList') and conditionParamRef.imgCommPathList.size() > 0">
${_conditionType_} a.imgCommPath in
<foreach collection="conditionParamRef.imgCommPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('imgCommPathNotList') and conditionParamRef.imgCommPathNotList.size() > 0">
${_conditionType_} a.imgCommPath not in
<foreach collection="conditionParamRef.imgCommPathNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('commMenu')">
<if test="conditionParamRef.commMenu != null ">
${_conditionType_} a.commMenu = #{${_conditionParam_}.commMenu}
</if>
<if test="conditionParamRef.commMenu == null">
${_conditionType_} a.commMenu is null
</if>
</if>
<if test="conditionParamRef.containsKey('commMenuList') and conditionParamRef.commMenuList.size() > 0">
${_conditionType_} a.commMenu in
<foreach collection="conditionParamRef.commMenuList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('commMenuNotList') and conditionParamRef.commMenuNotList.size() > 0">
${_conditionType_} a.commMenu not in
<foreach collection="conditionParamRef.commMenuNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('commMenuStart') and conditionParamRef.commMenuStart != null">
${_conditionType_} a.commMenu <![CDATA[ >= ]]> #{${_conditionParam_}.commMenuStart}
</if>
<if test="conditionParamRef.containsKey('commMenuEnd') and conditionParamRef.commMenuEnd != null">
${_conditionType_} a.commMenu <![CDATA[ <= ]]> #{${_conditionParam_}.commMenuEnd}
</if>
<if test="conditionParamRef.containsKey('menuType')">
<if test="conditionParamRef.menuType != null ">
${_conditionType_} a.menuType = #{${_conditionParam_}.menuType}
</if>
<if test="conditionParamRef.menuType == null">
${_conditionType_} a.menuType is null
</if>
</if>
<if test="conditionParamRef.containsKey('menuTypeList') and conditionParamRef.menuTypeList.size() > 0">
${_conditionType_} a.menuType in
<foreach collection="conditionParamRef.menuTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('menuTypeNotList') and conditionParamRef.menuTypeNotList.size() > 0">
${_conditionType_} a.menuType not in
<foreach collection="conditionParamRef.menuTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('menuTypeStart') and conditionParamRef.menuTypeStart != null">
${_conditionType_} a.menuType <![CDATA[ >= ]]> #{${_conditionParam_}.menuTypeStart}
</if>
<if test="conditionParamRef.containsKey('menuTypeEnd') and conditionParamRef.menuTypeEnd != null">
${_conditionType_} a.menuType <![CDATA[ <= ]]> #{${_conditionParam_}.menuTypeEnd}
</if>
<if test="conditionParamRef.containsKey('authType')">
<if test="conditionParamRef.authType != null ">
${_conditionType_} a.authType = #{${_conditionParam_}.authType}
</if>
<if test="conditionParamRef.authType == null">
${_conditionType_} a.authType is null
</if>
</if>
<if test="conditionParamRef.containsKey('authTypeList') and conditionParamRef.authTypeList.size() > 0">
${_conditionType_} a.authType in
<foreach collection="conditionParamRef.authTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('authTypeNotList') and conditionParamRef.authTypeNotList.size() > 0">
${_conditionType_} a.authType not in
<foreach collection="conditionParamRef.authTypeNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('authTypeStart') and conditionParamRef.authTypeStart != null">
${_conditionType_} a.authType <![CDATA[ >= ]]> #{${_conditionParam_}.authTypeStart}
</if>
<if test="conditionParamRef.containsKey('authTypeEnd') and conditionParamRef.authTypeEnd != null">
${_conditionType_} a.authType <![CDATA[ <= ]]> #{${_conditionParam_}.authTypeEnd}
</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('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
${_conditionType_} a.createUserId not in
<foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createUserName')">
<if test="conditionParamRef.createUserName != null and conditionParamRef.createUserName != ''">
${_conditionType_} a.createUserName like #{${_conditionParam_}.createUserName}
</if>
<if test="conditionParamRef.createUserName == null">
${_conditionType_} a.createUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserNameList') and conditionParamRef.createUserNameList.size() > 0">
${_conditionType_} a.createUserName in
<foreach collection="conditionParamRef.createUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserNameNotList') and conditionParamRef.createUserNameNotList.size() > 0">
${_conditionType_} a.createUserName not in
<foreach collection="conditionParamRef.createUserNameNotList" 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="">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
......@@ -593,128 +966,97 @@
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test="orderCol.id!= null">
${orderCol.id}
</if>
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('name')">
a.name
<if test="orderCol.name!= null">
${orderCol.name}
</if>
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('url')">
a.url
<if test="orderCol.url!= null">
${orderCol.url}
</if>
<if test='orderCol.url != null and "DESC".equalsIgnoreCase(orderCol.url)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('ancestors')">
a.ancestors
<if test='orderCol.ancestors != null and "DESC".equalsIgnoreCase(orderCol.ancestors)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('parentId')">
a.parentId
<if test="orderCol.parentId!= null">
${orderCol.parentId}
</if>
<if test='orderCol.parentId != null and "DESC".equalsIgnoreCase(orderCol.parentId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('orderId')">
a.orderId
<if test="orderCol.orderId!= null">
${orderCol.orderId}
</if>
<if test='orderCol.orderId != null and "DESC".equalsIgnoreCase(orderCol.orderId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('status')">
a.status
<if test="orderCol.status!= null">
${orderCol.status}
</if>
<if test='orderCol.status != null and "DESC".equalsIgnoreCase(orderCol.status)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('linkType')">
a.linkType
<if test="orderCol.linkType!= null">
${orderCol.linkType}
</if>
<if test='orderCol.linkType != null and "DESC".equalsIgnoreCase(orderCol.linkType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('groupId')">
a.groupId
<if test="orderCol.groupId!= null">
${orderCol.groupId}
</if>
<if test='orderCol.groupId != null and "DESC".equalsIgnoreCase(orderCol.groupId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('groupName')">
a.groupName
<if test="orderCol.groupName!= null">
${orderCol.groupName}
</if>
<if test='orderCol.groupName != null and "DESC".equalsIgnoreCase(orderCol.groupName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('imgPath')">
a.imgPath
<if test="orderCol.imgPath!= null">
${orderCol.imgPath}
</if>
<if test='orderCol.imgPath != null and "DESC".equalsIgnoreCase(orderCol.imgPath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('buttonImgPath')">
a.buttonImgPath
<if test="orderCol.buttonImgPath!= null">
${orderCol.buttonImgPath}
</if>
<if test='orderCol.buttonImgPath != null and "DESC".equalsIgnoreCase(orderCol.buttonImgPath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('imgCommPath')">
a.imgCommPath
<if test="orderCol.imgCommPath!= null">
${orderCol.imgCommPath}
</if>
<if test='orderCol.imgCommPath != null and "DESC".equalsIgnoreCase(orderCol.imgCommPath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('commMenu')">
a.commMenu
<if test="orderCol.commMenu!= null">
${orderCol.commMenu}
</if>
<if test='orderCol.commMenu != null and "DESC".equalsIgnoreCase(orderCol.commMenu)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('menuType')">
a.menuType
<if test="orderCol.menuType!= null">
${orderCol.menuType}
</if>
<if test='orderCol.menuType != null and "DESC".equalsIgnoreCase(orderCol.menuType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('authType')">
a.authType
<if test="orderCol.authType!= null">
${orderCol.authType}
</if>
<if test='orderCol.authType != null and "DESC".equalsIgnoreCase(orderCol.authType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test="orderCol.createTime!= null">
${orderCol.createTime}
</if>
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test="orderCol.createUserId!= null">
${orderCol.createUserId}
</if>
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserName')">
a.createUserName
<if test="orderCol.createUserName!= null">
${orderCol.createUserName}
</if>
<if test='orderCol.createUserName != null and "DESC".equalsIgnoreCase(orderCol.createUserName)'>DESC</if>
,
</if>
</trim>
......@@ -725,7 +1067,7 @@
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
${item}
</foreach>
</trim>
</if>
......
common-lib/src/main/java/com/mortals/xhx/feign/user/IUserFeign.java
View file @ 468eee28
......@@ -18,7 +18,7 @@ import java.util.List;
* @author zxfei
* @date 2022-07-06
*/
@FeignClient(name = "portal-manager", path = "/zwfw", fallbackFactory = UserFeignFallbackFactory.class)
//@FeignClient(name = "portal-manager", path = "/zwfw", fallbackFactory = UserFeignFallbackFactory.class)
public interface IUserFeign extends IFeign {
......
db/base.sql
View file @ 468eee28
......@@ -29,6 +29,7 @@ CREATE TABLE `mortals_xhx_menu` (
`name` varchar(50) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '菜单名称',
`url` varchar(256) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '连接地址',
`parentId` bigint(20) NULL DEFAULT NULL COMMENT '父菜单ID，一级菜单的该字段值为-1',
`ancestors` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '',
`orderId` int(11) NULL DEFAULT NULL COMMENT '排序编号',
`status` tinyint(2) NULL DEFAULT 1 COMMENT '菜单状态，0：禁用，1：启用，默认1',
`linkType` tinyint(2) NULL DEFAULT 0 COMMENT '链接方式，0：普通，1：弹出，2：脚本（JavaScript），默认0',
......
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