Skip to content

S
self-service
Commit f51ac288 authored by 廖旭伟's avatar 廖旭伟
Browse files
Options

基础设置增加桌面终端应用编排设置

parent 9c5b55e7
Show whitespace changes
Inline Side-by-side
Showing with 3549 additions and 9 deletions
sst-manager/db/add_db.sql 0 → 100644
View file @ f51ac288
-- ----------------------------
-- 桌面终端应用编排表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_xhx_sst_apps_desk`;
CREATE TABLE mortals_xhx_sst_apps_desk(
`id` bigint(20) AUTO_INCREMENT COMMENT '序号，主键，自增长',
`siteId` bigint(20) NOT NULL COMMENT '站点id',
`appId` bigint(20) NOT NULL COMMENT '应用id',
`name` varchar(64) COMMENT '应用名称',
`describe` varchar(64) COMMENT '应用描述',
`url` varchar(128) COMMENT '应用访问地址',
`showBasic` tinyint(2) DEFAULT '1' COMMENT '是否展示基础应用1是0否',
`basicSort` int(4) COMMENT '基础应用排序号',
`showHot` tinyint(2) DEFAULT '1' COMMENT '是否展示热门应用1是0否',
`hotSort` int(4) COMMENT '热门应用排序号',
`createUserId` bigint(20) COMMENT '创建用户',
`createTime` datetime COMMENT '创建时间',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='桌面终端应用编排';
-- ----------------------------
-- 申报事项表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_sys_matter_apply`;
CREATE TABLE mortals_sys_matter_apply(
`id` bigint(20) AUTO_INCREMENT COMMENT '序号，主键，自增长',
`siteId` bigint(20) COMMENT '站点id',
`siteName` varchar(255) COMMENT '站点名称',
`siteMatterId` bigint(20) COMMENT '站点事项id',
`matterId` bigint(20) COMMENT '事项ID',
`matterName` varchar(1024) COMMENT '事项名称',
`matterCode` varchar(512) COMMENT '事项编码',
`deptId` bigint(20) COMMENT '部门ID',
`deptName` varchar(128) COMMENT '部门名称',
`deptCode` varchar(255) COMMENT '部门编码',
`themeCode` varchar(255) COMMENT '事项主题',
`themeName` varchar(255) COMMENT '事项主题',
`source` tinyint(2) COMMENT '事项来源',
`reportCount` int(8) DEFAULT '0' COMMENT '申报次数',
`datumCount` int(8) DEFAULT '0' COMMENT '材料数量',
`govUrl` varchar(255) COMMENT '政务网地址',
`isConvert` tinyint(2) DEFAULT '0' COMMENT '是否生成本地附件',
`createUserId` bigint(20) NOT NULL COMMENT '创建用户',
`createTime` datetime NOT NULL COMMENT '创建时间',
`updateUserId` bigint(20) COMMENT '更新用户',
`updateTime` datetime COMMENT '更新时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='申报事项';
-- ----------------------------
-- 事项申请材料业务表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_sys_matter_datum`;
CREATE TABLE mortals_sys_matter_datum(
`id` bigint(20) AUTO_INCREMENT COMMENT '主键，自增长',
`matterId` bigint(20) COMMENT '事项基础表matter id',
`materialName` varchar(1024) NOT NULL COMMENT '材料名',
`isMust` varchar(32) DEFAULT '1' COMMENT '必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）',
`materialType` varchar(32) DEFAULT '1' COMMENT '材料类型（1.无，2.原件，3.复印件，4.原件和复印件)',
`materialProperty` varchar(32) DEFAULT '1' COMMENT '材料形式（1.纸质，2.电子，3.纸质|电子）',
`electronicgs` varchar(32) DEFAULT '1' COMMENT '电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）',
`materialSource` varchar(32) DEFAULT '1' COMMENT '材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）',
`paperNum` tinyint(4) DEFAULT '1' COMMENT '纸质材料份数',
`paperGg` varchar(32) COMMENT '纸质材料规格',
`jianmMs` varchar(32) DEFAULT '1' COMMENT '减免模式（1.无，2.减，3.免）',
`sealWay` varchar(32) COMMENT '盖章方式',
`isjianm` varchar(32) DEFAULT '1' COMMENT '是否减免（0.否，1.是）',
`isLack` varchar(32) DEFAULT '1' COMMENT '材料是否容缺（1.必要，2.非必要）',
`ybUrl` varchar(512) COMMENT '材料地址',
`materialSourceSm` varchar(512) COMMENT '来源渠道说明',
`remarkSub` text COMMENT '填报须知',
`clauseContent` text COMMENT '要求提供材料的依据',
`summary` text COMMENT '受理标准',
`remark` varchar(512) COMMENT '备注',
`source` tinyint(2) DEFAULT '0' COMMENT '事项来源(0.政务网，1.自定义)',
`createTime` datetime COMMENT '创建时间',
`createUserId` bigint(20) COMMENT '创建用户',
`updateTime` datetime COMMENT '修改时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='事项申请材料业务';
-- ----------------------------
-- 材料附件业务表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_sys_matter_datum_file`;
CREATE TABLE mortals_sys_matter_datum_file(
`id` bigint(20) AUTO_INCREMENT COMMENT '主键，自增长',
`datumId` bigint(20) NOT NULL COMMENT '材料id',
`matterId` bigint(20) COMMENT '事项基础表matter id',
`matterCode` varchar(512) COMMENT '事项编码',
`materialName` varchar(1024) NOT NULL COMMENT '材料名',
`fileName` varchar(255) COMMENT '附件名称',
`fileUrl` varchar(255) COMMENT '附件下载地址',
`filetype` tinyint(2) DEFAULT '1' COMMENT '附件类型 (1.示例样表，2.空白表格)',
`source` tinyint(2) DEFAULT '0' COMMENT '附件来源 (0.政务网，1.自定义)',
`localFileUrl` varchar(255) COMMENT '本地文件地址',
`previewUrl` varchar(255) COMMENT '文件预览地址',
`createTime` datetime COMMENT '创建时间',
`createUserId` bigint(20) COMMENT '创建用户',
`updateTime` datetime COMMENT '修改时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='材料附件业务';
-- ----------------------------
-- 站点材料公共库表
-- ----------------------------
DROP TABLE IF EXISTS `mortals_sys_datum_library`;
CREATE TABLE mortals_sys_datum_library(
`id` bigint(20) AUTO_INCREMENT COMMENT '主键，自增长',
`siteId` bigint(20) COMMENT '站点id',
`siteName` varchar(255) COMMENT '站点名称',
`datumId` bigint(20) COMMENT '材料id',
`matterId` bigint(20) COMMENT '事项基础表matter id',
`matterCode` varchar(512) COMMENT '事项编码',
`matterName` varchar(1024) COMMENT '事项名称',
`materialName` varchar(1024) NOT NULL COMMENT '材料名',
`isMust` varchar(32) DEFAULT '1' COMMENT '必交性（1.非必要，2.必要，3.必要|容缺后补，4.非必要|容缺后补）',
`materialType` varchar(32) DEFAULT '1' COMMENT '材料类型（1.无，2.原件，3.复印件，4.原件和复印件)',
`materialProperty` varchar(32) DEFAULT '1' COMMENT '材料形式（1.纸质，2.电子，3.纸质|电子）',
`electronicgs` varchar(32) DEFAULT '1' COMMENT '电子材料格式（1.无，2.不限，3.jpg，4.jpeg，5.pdf，6.word，7.pdf,jpg,jpeg，8.pdf,jpg）',
`materialSource` varchar(32) DEFAULT '1' COMMENT '材料来源渠道（1.无，2.申请人自备，3.政府部门核发，4.其他）',
`paperNum` tinyint(4) DEFAULT '1' COMMENT '纸质材料份数',
`paperGg` varchar(32) COMMENT '纸质材料规格',
`jianmMs` varchar(32) DEFAULT '1' COMMENT '减免模式（1.无，2.减，3.免）',
`sealWay` varchar(32) COMMENT '盖章方式',
`isjianm` varchar(32) DEFAULT '1' COMMENT '是否减免（0.否，1.是）',
`isLack` varchar(32) DEFAULT '1' COMMENT '材料是否容缺（1.必要，2.非必要）',
`ybUrl` varchar(512) COMMENT '材料地址',
`materialSourceSm` varchar(512) COMMENT '来源渠道说明',
`remarkSub` text COMMENT '填报须知',
`clauseContent` text COMMENT '要求提供材料的依据',
`summary` text COMMENT '受理标准',
`remark` varchar(512) COMMENT '备注',
`source` tinyint(2) DEFAULT '0' COMMENT '事项来源(0.政务网，1.自定义)',
`createTime` datetime COMMENT '创建时间',
`createUserId` bigint(20) COMMENT '创建用户',
`updateTime` datetime COMMENT '修改时间',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='站点材料公共库';
sst-manager/doc/api.md
View file @ f51ac288
......@@ -509,6 +509,9 @@ data|object|数据对象
 allApps|array|所有应用结果集
 showApps|array|基础应用展示结果集列表
 hotApps|array|热门应用展示结果集列表
 allAppsDesk|array|桌面终端所有应用结果集
 showAppsDesk|array|桌面终端基础应用展示结果集列表
 hotAppsDesk|array|桌面终端热门应用展示结果集列表
 basicInfo|object|数据对象
  id|Long|序号，主键，自增长
  siteId|Long|站点id
......@@ -518,6 +521,7 @@ data|object|数据对象
  wechatCode|String|微信微博二维码图片地址
  saverTime|Integer|屏保时间单位分
  saverPic|String|屏保图片地址
  carouselPic|String|轮播图图片地址
  support|String|技术支持
  sponsor|String|主办单位
  organizer|String|承办单位
......@@ -537,6 +541,9 @@ dict|object|字典对象
"allApps":[],
"showApps":[],
"hotApps":[],
"allAppsDesk":[],
"showAppsDesk":[],
"hotAppsDesk":[],
"basicInfo": {
"id": 1,
"createUserId": 1,
......@@ -566,6 +573,7 @@ dict|object|字典对象
"wechatCode": "微信微博二维码图片地址",
"saverTime": 5,
"saverPic": "屏保图片地址",
"carouselPic":"轮播图图片地址",
"support": "技术支持",
"sponsor": "主办单位",
"organizer": "承办单位",
......@@ -597,6 +605,7 @@ appletCode|String|否|小程序二维码图片地址
wechatCode|String|否|微信微博二维码图片地址
saverTime|Integer|否|屏保时间单位分
saverPic|String|否|屏保图片地址
carouselPic|String|否|轮播图图片地址
support|String|否|技术支持
sponsor|String|否|主办单位
organizer|String|否|承办单位
......@@ -604,6 +613,8 @@ record|String|否|备案号
elderEnable|Integer|是|启用长辈模式0不启用1启用
showAppIds|String|否|基础应用展示
hotAppIds|String|否|热门应用展示
deskShowAppIds|String|否|桌面终端基础应用展示
deskHotAppIds|String|否|桌面终端热门应用展示
**请求样例:**
```
......@@ -615,13 +626,16 @@ hotAppIds|String|否|热门应用展示
"organizer": "承办单位",
"record": "备案号",
"saverPic": "屏保图片地址",
"carouselPic":"轮播图图片地址",
"saverTime": 5,
"sponsor": "主办单位",
"support": "技术支持",
"titleName": "标题名称",
"wechatCode": "微信微博二维码图片地址",
"showAppIds":"2,3,4,5,6,7",
"hotAppIds":"4,5,6,8,9,10"
"hotAppIds":"4,5,6,8,9,10",
"deskShowAppIds":"1,2,4,5",
"deskHotAppIds":"3,6,7"
}
```
......@@ -1372,6 +1386,253 @@ msg|String|消息|-
}
```
## 桌面终端应用编排
### 查询桌面终端应用编排列表
**请求URL:** sst/apps/desk/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询桌面终端应用编排
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
page|Integer|否|当前页
size|Integer|否|每页条数，值为-1，查询所有记录
name|String|否|应用名称,字段前后添加%%模糊查询
describe|String|否|应用描述,字段前后添加%%模糊查询
url|String|否|应用访问地址,字段前后添加%%模糊查询
**请求样例:**
```
{
"name":"bcw7jb",
"describe":"au8uua",
"url":"crthic",
"page":1,
"size":10
}
```
**响应参数:**
参数名称|参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
 per_page|Integer|每页条数
 total|Integer|总条数
 last_page|Integer|总页数
 current_page|Integer|当前页
 data|array|结果集列表|数组
  id|Long|序号，主键，自增长
  siteId|Long|站点id
  appId|Long|应用id
  name|String|应用名称
  describe|String|应用描述
  url|String|应用访问地址
  showBasic|Integer|是否展示基础应用1是0否
  basicSort|Integer|基础应用排序号
  showHot|Integer|是否展示热门应用1是0否
  hotSort|Integer|热门应用排序号
  createUserId|Long|创建用户
  createTime|Date|创建时间
  updateUserId|Long|更新用户
  updateTime|Date|更新时间
dict|object|字典对象
**响应消息样例:**
```
{
"code":1,
"data":{
}
}
```
### 查看桌面终端应用编排
**请求URL:** sst/apps/desk/info
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 查看桌面终端应用编排，返回实例详细信息
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|Long|是|ID
**请求样例:**
```
http://localhost/sst/apps/desk/info?id=549
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:-------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
 id|Long|序号，主键，自增长
 siteId|Long|站点id
 appId|Long|应用id
 name|String|应用名称
 describe|String|应用描述
 url|String|应用访问地址
 showBasic|Integer|是否展示基础应用1是0否
 basicSort|Integer|基础应用排序号
 showHot|Integer|是否展示热门应用1是0否
 hotSort|Integer|热门应用排序号
 createUserId|Long|创建用户
 createTime|Date|创建时间
 updateUserId|Long|更新用户
 updateTime|Date|更新时间
dict|object|字典对象
**响应消息样例:**
```
{
"code": 1,
"data": {
"id":8302,
"siteId":4290,
"appId":4481,
"name":"smy8nc",
"describe":"zcaz8j",
"url":"87zhok",
"showBasic":4580,
"basicSort":6852,
"showHot":2629,
"hotSort":9319,
"createUserId":4095,
"createTime":"2023-04-09",
"updateUserId":5444,
"updateTime":"2023-04-09"
}
}
```
### 保存更新桌面终端应用编排
**请求URL:** sst/apps/desk/save
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 保存或更新桌面终端应用编排：id为空时为新增保存，否则为更新提交
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
siteId|Long|是|站点id
appId|Long|是|应用id
name|String|否|应用名称
describe|String|否|应用描述
url|String|否|应用访问地址
showBasic|Integer|否|是否展示基础应用1是0否
basicSort|Integer|否|基础应用排序号
showHot|Integer|否|是否展示热门应用1是0否
hotSort|Integer|否|热门应用排序号
**请求样例:**
```
{
"siteId":3066,
"appId":4983,
"name":"10rngp",
"describe":"xkp4kf",
"url":"fy0bkm",
"showBasic":2413,
"basicSort":9938,
"showHot":4550,
"hotSort":8704,
}
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
 id|Long|保存后主键id
 entity|object|保存更新实体
  id|Long|序号，主键，自增长
  siteId|Long|站点id
  appId|Long|应用id
  name|String|应用名称
  describe|String|应用描述
  url|String|应用访问地址
  showBasic|Integer|是否展示基础应用1是0否
  basicSort|Integer|基础应用排序号
  showHot|Integer|是否展示热门应用1是0否
  hotSort|Integer|热门应用排序号
  createUserId|Long|创建用户
  createTime|Date|创建时间
  updateUserId|Long|更新用户
  updateTime|Date|更新时间
**响应消息样例:**
```
{
"msg":"新增模块成功",
"code":1,
"data":{}
}
}
```
### 删除桌面终端应用编排
**请求URL:** sst/apps/desk/delete
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 删除桌面终端应用编排
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|String|是|数组
**请求样例:**
```
http://localhost:8080/sst/apps/desk/delete?id=1&id=2'
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
## 应用信息
### 查询应用信息列表
......@@ -3105,12 +3366,13 @@ msg|String|消息|-
}
```
--------------------------------
## 后台管理接口
### 查询部门列表
**请求URL:** dept/list
**请求URL:** sst/dept/list
**请求方式:** POST
......@@ -3153,7 +3415,7 @@ msg|String|消息|-
### 查询站点事项列表
**请求URL:** site/matter/list
**请求URL:** sst/site/matter/list
**请求方式:** POST
......@@ -3198,7 +3460,7 @@ msg|String|消息|-
### 查询事项主题列表
**请求URL:** site/theme/list
**请求URL:** sst/site/theme/list
**请求方式:** POST
......@@ -3241,7 +3503,7 @@ msg|String|消息|-
### 站点事项加入申请事项
**请求URL:** site/matter/addToAssist
**请求URL:** sst/site/matter/addToAssist
**请求方式:** POST
......@@ -3279,7 +3541,7 @@ msg|String|消息|-
### 公共库加入材料
**请求URL:** datum/library/addToMatterDatum
**请求URL:** sst/datum/library/addToMatterDatum
**请求方式:** POST
......@@ -3357,7 +3619,7 @@ msg|String|消息|-
### 查询站点基础事项详情
**请求URL:** base/matter/info
**请求URL:** sst/base/matter/info
**请求方式:** GET
......@@ -3565,7 +3827,7 @@ data|object|数据对象
### 申报事项增加申报次数
**请求URL:** matter/apply/addReport
**请求URL:** sst/matter/apply/addReport
**请求方式:** GET
......
sst-manager/src/main/java/com/mortals/xhx/module/sst/dao/SstAppsDeskDao.java 0 → 100644
View file @ f51ac288
package com.mortals.xhx.module.sst.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.sst.model.SstAppsDeskEntity;
import java.util.List;
/**
* 桌面终端应用编排Dao
* 桌面终端应用编排 DAO接口
*
* @author zxfei
* @date 2023-04-09
*/
public interface SstAppsDeskDao extends ICRUDDao<SstAppsDeskEntity,Long>{
}
sst-manager/src/main/java/com/mortals/xhx/module/sst/dao/ibatis/SstAppsDeskDaoImpl.java 0 → 100644
View file @ f51ac288
package com.mortals.xhx.module.sst.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.sst.dao.SstAppsDeskDao;
import com.mortals.xhx.module.sst.model.SstAppsDeskEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 桌面终端应用编排DaoImpl DAO接口
*
* @author zxfei
* @date 2023-04-09
*/
@Repository("sstAppsDeskDao")
public class SstAppsDeskDaoImpl extends BaseCRUDDaoMybatis<SstAppsDeskEntity,Long> implements SstAppsDeskDao {
}
sst-manager/src/main/java/com/mortals/xhx/module/sst/model/SstAppsDeskEntity.java 0 → 100644
View file @ f51ac288
package com.mortals.xhx.module.sst.model;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.sst.model.vo.SstAppsDeskVo;
/**
* 桌面终端应用编排实体对象
*
* @author zxfei
* @date 2023-04-09
*/
public class SstAppsDeskEntity extends SstAppsDeskVo {
private static final long serialVersionUID = 1L;
/**
* 站点id
*/
private Long siteId;
/**
* 应用id
*/
private Long appId;
/**
* 应用名称
*/
private String name;
/**
* 应用描述
*/
private String describe;
/**
* 应用访问地址
*/
private String url;
/**
* 是否展示基础应用1是0否
*/
private Integer showBasic;
/**
* 基础应用排序号
*/
private Integer basicSort;
/**
* 是否展示热门应用1是0否
*/
private Integer showHot;
/**
* 热门应用排序号
*/
private Integer hotSort;
public SstAppsDeskEntity(){}
/**
* 获取 站点id
* @return Long
*/
public Long getSiteId(){
return siteId;
}
/**
* 设置 站点id
* @param siteId
*/
public void setSiteId(Long siteId){
this.siteId = siteId;
}
/**
* 获取 应用id
* @return Long
*/
public Long getAppId(){
return appId;
}
/**
* 设置 应用id
* @param appId
*/
public void setAppId(Long appId){
this.appId = appId;
}
/**
* 获取 应用名称
* @return String
*/
public String getName(){
return name;
}
/**
* 设置 应用名称
* @param name
*/
public void setName(String name){
this.name = name;
}
/**
* 获取 应用描述
* @return String
*/
public String getDescribe(){
return describe;
}
/**
* 设置 应用描述
* @param describe
*/
public void setDescribe(String describe){
this.describe = describe;
}
/**
* 获取 应用访问地址
* @return String
*/
public String getUrl(){
return url;
}
/**
* 设置 应用访问地址
* @param url
*/
public void setUrl(String url){
this.url = url;
}
/**
* 获取 是否展示基础应用1是0否
* @return Integer
*/
public Integer getShowBasic(){
return showBasic;
}
/**
* 设置 是否展示基础应用1是0否
* @param showBasic
*/
public void setShowBasic(Integer showBasic){
this.showBasic = showBasic;
}
/**
* 获取 基础应用排序号
* @return Integer
*/
public Integer getBasicSort(){
return basicSort;
}
/**
* 设置 基础应用排序号
* @param basicSort
*/
public void setBasicSort(Integer basicSort){
this.basicSort = basicSort;
}
/**
* 获取 是否展示热门应用1是0否
* @return Integer
*/
public Integer getShowHot(){
return showHot;
}
/**
* 设置 是否展示热门应用1是0否
* @param showHot
*/
public void setShowHot(Integer showHot){
this.showHot = showHot;
}
/**
* 获取 热门应用排序号
* @return Integer
*/
public Integer getHotSort(){
return hotSort;
}
/**
* 设置 热门应用排序号
* @param hotSort
*/
public void setHotSort(Integer hotSort){
this.hotSort = hotSort;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof SstAppsDeskEntity) {
SstAppsDeskEntity tmp = (SstAppsDeskEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",siteId:").append(getSiteId());
sb.append(",appId:").append(getAppId());
sb.append(",name:").append(getName());
sb.append(",describe:").append(getDescribe());
sb.append(",url:").append(getUrl());
sb.append(",showBasic:").append(getShowBasic());
sb.append(",basicSort:").append(getBasicSort());
sb.append(",showHot:").append(getShowHot());
sb.append(",hotSort:").append(getHotSort());
return sb.toString();
}
public void initAttrValue(){
this.siteId = null;
this.appId = null;
this.name = "";
this.describe = "";
this.url = "";
this.showBasic = 1;
this.basicSort = null;
this.showHot = 1;
this.hotSort = null;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/sst/model/SstAppsDeskQuery.java 0 → 100644
View file @ f51ac288
package com.mortals.xhx.module.sst.model;
import java.util.List;
import com.mortals.xhx.module.sst.model.SstAppsDeskEntity;
/**
* 桌面终端应用编排查询对象
*
* @author zxfei
* @date 2023-04-09
*/
public class SstAppsDeskQuery extends SstAppsDeskEntity {
/** 开始 序号，主键，自增长 */
private Long idStart;
/** 结束 序号，主键，自增长 */
private Long idEnd;
/** 增加 序号，主键，自增长 */
private Long idIncrement;
/** 序号，主键，自增长列表 */
private List <Long> idList;
/** 序号，主键，自增长排除列表 */
private List <Long> idNotList;
/** 开始 站点id */
private Long siteIdStart;
/** 结束 站点id */
private Long siteIdEnd;
/** 增加 站点id */
private Long siteIdIncrement;
/** 站点id列表 */
private List <Long> siteIdList;
/** 站点id排除列表 */
private List <Long> siteIdNotList;
/** 开始 应用id */
private Long appIdStart;
/** 结束 应用id */
private Long appIdEnd;
/** 增加 应用id */
private Long appIdIncrement;
/** 应用id列表 */
private List <Long> appIdList;
/** 应用id排除列表 */
private List <Long> appIdNotList;
/** 应用名称 */
private List<String> nameList;
/** 应用名称排除列表 */
private List <String> nameNotList;
/** 应用描述 */
private List<String> describeList;
/** 应用描述排除列表 */
private List <String> describeNotList;
/** 应用访问地址 */
private List<String> urlList;
/** 应用访问地址排除列表 */
private List <String> urlNotList;
/** 开始 是否展示基础应用1是0否 */
private Integer showBasicStart;
/** 结束 是否展示基础应用1是0否 */
private Integer showBasicEnd;
/** 增加 是否展示基础应用1是0否 */
private Integer showBasicIncrement;
/** 是否展示基础应用1是0否列表 */
private List <Integer> showBasicList;
/** 是否展示基础应用1是0否排除列表 */
private List <Integer> showBasicNotList;
/** 开始 基础应用排序号 */
private Integer basicSortStart;
/** 结束 基础应用排序号 */
private Integer basicSortEnd;
/** 增加 基础应用排序号 */
private Integer basicSortIncrement;
/** 基础应用排序号列表 */
private List <Integer> basicSortList;
/** 基础应用排序号排除列表 */
private List <Integer> basicSortNotList;
/** 开始 是否展示热门应用1是0否 */
private Integer showHotStart;
/** 结束 是否展示热门应用1是0否 */
private Integer showHotEnd;
/** 增加 是否展示热门应用1是0否 */
private Integer showHotIncrement;
/** 是否展示热门应用1是0否列表 */
private List <Integer> showHotList;
/** 是否展示热门应用1是0否排除列表 */
private List <Integer> showHotNotList;
/** 开始 热门应用排序号 */
private Integer hotSortStart;
/** 结束 热门应用排序号 */
private Integer hotSortEnd;
/** 增加 热门应用排序号 */
private Integer hotSortIncrement;
/** 热门应用排序号列表 */
private List <Integer> hotSortList;
/** 热门应用排序号排除列表 */
private List <Integer> hotSortNotList;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 创建用户排除列表 */
private List <Long> createUserIdNotList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 结束 更新用户 */
private Long updateUserIdEnd;
/** 增加 更新用户 */
private Long updateUserIdIncrement;
/** 更新用户列表 */
private List <Long> updateUserIdList;
/** 更新用户排除列表 */
private List <Long> updateUserIdNotList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<SstAppsDeskQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<SstAppsDeskQuery> andConditionList;
public SstAppsDeskQuery(){}
/**
* 获取 开始 序号，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 序号，主键，自增长
* @return idNotList
*/
public List<Long> getIdNotList(){
return this.idNotList;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public void setIdNotList(List<Long> idNotList){
this.idNotList = idNotList;
}
/**
* 获取 开始 站点id
* @return siteIdStart
*/
public Long getSiteIdStart(){
return this.siteIdStart;
}
/**
* 设置 开始 站点id
* @param siteIdStart
*/
public void setSiteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
}
/**
* 获取 结束 站点id
* @return $siteIdEnd
*/
public Long getSiteIdEnd(){
return this.siteIdEnd;
}
/**
* 设置 结束 站点id
* @param siteIdEnd
*/
public void setSiteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
}
/**
* 获取 增加 站点id
* @return siteIdIncrement
*/
public Long getSiteIdIncrement(){
return this.siteIdIncrement;
}
/**
* 设置 增加 站点id
* @param siteIdIncrement
*/
public void setSiteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
}
/**
* 获取 站点id
* @return siteIdList
*/
public List<Long> getSiteIdList(){
return this.siteIdList;
}
/**
* 设置 站点id
* @param siteIdList
*/
public void setSiteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
}
/**
* 获取 站点id
* @return siteIdNotList
*/
public List<Long> getSiteIdNotList(){
return this.siteIdNotList;
}
/**
* 设置 站点id
* @param siteIdNotList
*/
public void setSiteIdNotList(List<Long> siteIdNotList){
this.siteIdNotList = siteIdNotList;
}
/**
* 获取 开始 应用id
* @return appIdStart
*/
public Long getAppIdStart(){
return this.appIdStart;
}
/**
* 设置 开始 应用id
* @param appIdStart
*/
public void setAppIdStart(Long appIdStart){
this.appIdStart = appIdStart;
}
/**
* 获取 结束 应用id
* @return $appIdEnd
*/
public Long getAppIdEnd(){
return this.appIdEnd;
}
/**
* 设置 结束 应用id
* @param appIdEnd
*/
public void setAppIdEnd(Long appIdEnd){
this.appIdEnd = appIdEnd;
}
/**
* 获取 增加 应用id
* @return appIdIncrement
*/
public Long getAppIdIncrement(){
return this.appIdIncrement;
}
/**
* 设置 增加 应用id
* @param appIdIncrement
*/
public void setAppIdIncrement(Long appIdIncrement){
this.appIdIncrement = appIdIncrement;
}
/**
* 获取 应用id
* @return appIdList
*/
public List<Long> getAppIdList(){
return this.appIdList;
}
/**
* 设置 应用id
* @param appIdList
*/
public void setAppIdList(List<Long> appIdList){
this.appIdList = appIdList;
}
/**
* 获取 应用id
* @return appIdNotList
*/
public List<Long> getAppIdNotList(){
return this.appIdNotList;
}
/**
* 设置 应用id
* @param appIdNotList
*/
public void setAppIdNotList(List<Long> appIdNotList){
this.appIdNotList = appIdNotList;
}
/**
* 获取 应用名称
* @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 describeList
*/
public List<String> getDescribeList(){
return this.describeList;
}
/**
* 设置 应用描述
* @param describeList
*/
public void setDescribeList(List<String> describeList){
this.describeList = describeList;
}
/**
* 获取 应用描述
* @return describeNotList
*/
public List<String> getDescribeNotList(){
return this.describeNotList;
}
/**
* 设置 应用描述
* @param describeNotList
*/
public void setDescribeNotList(List<String> describeNotList){
this.describeNotList = describeNotList;
}
/**
* 获取 应用访问地址
* @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;
}
/**
* 获取 开始 是否展示基础应用1是0否
* @return showBasicStart
*/
public Integer getShowBasicStart(){
return this.showBasicStart;
}
/**
* 设置 开始 是否展示基础应用1是0否
* @param showBasicStart
*/
public void setShowBasicStart(Integer showBasicStart){
this.showBasicStart = showBasicStart;
}
/**
* 获取 结束 是否展示基础应用1是0否
* @return $showBasicEnd
*/
public Integer getShowBasicEnd(){
return this.showBasicEnd;
}
/**
* 设置 结束 是否展示基础应用1是0否
* @param showBasicEnd
*/
public void setShowBasicEnd(Integer showBasicEnd){
this.showBasicEnd = showBasicEnd;
}
/**
* 获取 增加 是否展示基础应用1是0否
* @return showBasicIncrement
*/
public Integer getShowBasicIncrement(){
return this.showBasicIncrement;
}
/**
* 设置 增加 是否展示基础应用1是0否
* @param showBasicIncrement
*/
public void setShowBasicIncrement(Integer showBasicIncrement){
this.showBasicIncrement = showBasicIncrement;
}
/**
* 获取 是否展示基础应用1是0否
* @return showBasicList
*/
public List<Integer> getShowBasicList(){
return this.showBasicList;
}
/**
* 设置 是否展示基础应用1是0否
* @param showBasicList
*/
public void setShowBasicList(List<Integer> showBasicList){
this.showBasicList = showBasicList;
}
/**
* 获取 是否展示基础应用1是0否
* @return showBasicNotList
*/
public List<Integer> getShowBasicNotList(){
return this.showBasicNotList;
}
/**
* 设置 是否展示基础应用1是0否
* @param showBasicNotList
*/
public void setShowBasicNotList(List<Integer> showBasicNotList){
this.showBasicNotList = showBasicNotList;
}
/**
* 获取 开始 基础应用排序号
* @return basicSortStart
*/
public Integer getBasicSortStart(){
return this.basicSortStart;
}
/**
* 设置 开始 基础应用排序号
* @param basicSortStart
*/
public void setBasicSortStart(Integer basicSortStart){
this.basicSortStart = basicSortStart;
}
/**
* 获取 结束 基础应用排序号
* @return $basicSortEnd
*/
public Integer getBasicSortEnd(){
return this.basicSortEnd;
}
/**
* 设置 结束 基础应用排序号
* @param basicSortEnd
*/
public void setBasicSortEnd(Integer basicSortEnd){
this.basicSortEnd = basicSortEnd;
}
/**
* 获取 增加 基础应用排序号
* @return basicSortIncrement
*/
public Integer getBasicSortIncrement(){
return this.basicSortIncrement;
}
/**
* 设置 增加 基础应用排序号
* @param basicSortIncrement
*/
public void setBasicSortIncrement(Integer basicSortIncrement){
this.basicSortIncrement = basicSortIncrement;
}
/**
* 获取 基础应用排序号
* @return basicSortList
*/
public List<Integer> getBasicSortList(){
return this.basicSortList;
}
/**
* 设置 基础应用排序号
* @param basicSortList
*/
public void setBasicSortList(List<Integer> basicSortList){
this.basicSortList = basicSortList;
}
/**
* 获取 基础应用排序号
* @return basicSortNotList
*/
public List<Integer> getBasicSortNotList(){
return this.basicSortNotList;
}
/**
* 设置 基础应用排序号
* @param basicSortNotList
*/
public void setBasicSortNotList(List<Integer> basicSortNotList){
this.basicSortNotList = basicSortNotList;
}
/**
* 获取 开始 是否展示热门应用1是0否
* @return showHotStart
*/
public Integer getShowHotStart(){
return this.showHotStart;
}
/**
* 设置 开始 是否展示热门应用1是0否
* @param showHotStart
*/
public void setShowHotStart(Integer showHotStart){
this.showHotStart = showHotStart;
}
/**
* 获取 结束 是否展示热门应用1是0否
* @return $showHotEnd
*/
public Integer getShowHotEnd(){
return this.showHotEnd;
}
/**
* 设置 结束 是否展示热门应用1是0否
* @param showHotEnd
*/
public void setShowHotEnd(Integer showHotEnd){
this.showHotEnd = showHotEnd;
}
/**
* 获取 增加 是否展示热门应用1是0否
* @return showHotIncrement
*/
public Integer getShowHotIncrement(){
return this.showHotIncrement;
}
/**
* 设置 增加 是否展示热门应用1是0否
* @param showHotIncrement
*/
public void setShowHotIncrement(Integer showHotIncrement){
this.showHotIncrement = showHotIncrement;
}
/**
* 获取 是否展示热门应用1是0否
* @return showHotList
*/
public List<Integer> getShowHotList(){
return this.showHotList;
}
/**
* 设置 是否展示热门应用1是0否
* @param showHotList
*/
public void setShowHotList(List<Integer> showHotList){
this.showHotList = showHotList;
}
/**
* 获取 是否展示热门应用1是0否
* @return showHotNotList
*/
public List<Integer> getShowHotNotList(){
return this.showHotNotList;
}
/**
* 设置 是否展示热门应用1是0否
* @param showHotNotList
*/
public void setShowHotNotList(List<Integer> showHotNotList){
this.showHotNotList = showHotNotList;
}
/**
* 获取 开始 热门应用排序号
* @return hotSortStart
*/
public Integer getHotSortStart(){
return this.hotSortStart;
}
/**
* 设置 开始 热门应用排序号
* @param hotSortStart
*/
public void setHotSortStart(Integer hotSortStart){
this.hotSortStart = hotSortStart;
}
/**
* 获取 结束 热门应用排序号
* @return $hotSortEnd
*/
public Integer getHotSortEnd(){
return this.hotSortEnd;
}
/**
* 设置 结束 热门应用排序号
* @param hotSortEnd
*/
public void setHotSortEnd(Integer hotSortEnd){
this.hotSortEnd = hotSortEnd;
}
/**
* 获取 增加 热门应用排序号
* @return hotSortIncrement
*/
public Integer getHotSortIncrement(){
return this.hotSortIncrement;
}
/**
* 设置 增加 热门应用排序号
* @param hotSortIncrement
*/
public void setHotSortIncrement(Integer hotSortIncrement){
this.hotSortIncrement = hotSortIncrement;
}
/**
* 获取 热门应用排序号
* @return hotSortList
*/
public List<Integer> getHotSortList(){
return this.hotSortList;
}
/**
* 设置 热门应用排序号
* @param hotSortList
*/
public void setHotSortList(List<Integer> hotSortList){
this.hotSortList = hotSortList;
}
/**
* 获取 热门应用排序号
* @return hotSortNotList
*/
public List<Integer> getHotSortNotList(){
return this.hotSortNotList;
}
/**
* 设置 热门应用排序号
* @param hotSortNotList
*/
public void setHotSortNotList(List<Integer> hotSortNotList){
this.hotSortNotList = hotSortNotList;
}
/**
* 获取 开始 创建用户
* @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 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 updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 更新用户
* @return updateUserIdNotList
*/
public List<Long> getUpdateUserIdNotList(){
return this.updateUserIdNotList;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public SstAppsDeskQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public SstAppsDeskQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public SstAppsDeskQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public SstAppsDeskQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public SstAppsDeskQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idNotList
*/
public SstAppsDeskQuery idNotList(List<Long> idNotList){
this.idNotList = idNotList;
return this;
}
/**
* 设置 站点id
* @param siteId
*/
public SstAppsDeskQuery siteId(Long siteId){
setSiteId(siteId);
return this;
}
/**
* 设置 开始 站点id
* @param siteIdStart
*/
public SstAppsDeskQuery siteIdStart(Long siteIdStart){
this.siteIdStart = siteIdStart;
return this;
}
/**
* 设置 结束 站点id
* @param siteIdEnd
*/
public SstAppsDeskQuery siteIdEnd(Long siteIdEnd){
this.siteIdEnd = siteIdEnd;
return this;
}
/**
* 设置 增加 站点id
* @param siteIdIncrement
*/
public SstAppsDeskQuery siteIdIncrement(Long siteIdIncrement){
this.siteIdIncrement = siteIdIncrement;
return this;
}
/**
* 设置 站点id
* @param siteIdList
*/
public SstAppsDeskQuery siteIdList(List<Long> siteIdList){
this.siteIdList = siteIdList;
return this;
}
/**
* 设置 站点id
* @param siteIdNotList
*/
public SstAppsDeskQuery siteIdNotList(List<Long> siteIdNotList){
this.siteIdNotList = siteIdNotList;
return this;
}
/**
* 设置 应用id
* @param appId
*/
public SstAppsDeskQuery appId(Long appId){
setAppId(appId);
return this;
}
/**
* 设置 开始 应用id
* @param appIdStart
*/
public SstAppsDeskQuery appIdStart(Long appIdStart){
this.appIdStart = appIdStart;
return this;
}
/**
* 设置 结束 应用id
* @param appIdEnd
*/
public SstAppsDeskQuery appIdEnd(Long appIdEnd){
this.appIdEnd = appIdEnd;
return this;
}
/**
* 设置 增加 应用id
* @param appIdIncrement
*/
public SstAppsDeskQuery appIdIncrement(Long appIdIncrement){
this.appIdIncrement = appIdIncrement;
return this;
}
/**
* 设置 应用id
* @param appIdList
*/
public SstAppsDeskQuery appIdList(List<Long> appIdList){
this.appIdList = appIdList;
return this;
}
/**
* 设置 应用id
* @param appIdNotList
*/
public SstAppsDeskQuery appIdNotList(List<Long> appIdNotList){
this.appIdNotList = appIdNotList;
return this;
}
/**
* 设置 应用名称
* @param name
*/
public SstAppsDeskQuery name(String name){
setName(name);
return this;
}
/**
* 设置 应用名称
* @param nameList
*/
public SstAppsDeskQuery nameList(List<String> nameList){
this.nameList = nameList;
return this;
}
/**
* 设置 应用描述
* @param describe
*/
public SstAppsDeskQuery describe(String describe){
setDescribe(describe);
return this;
}
/**
* 设置 应用描述
* @param describeList
*/
public SstAppsDeskQuery describeList(List<String> describeList){
this.describeList = describeList;
return this;
}
/**
* 设置 应用访问地址
* @param url
*/
public SstAppsDeskQuery url(String url){
setUrl(url);
return this;
}
/**
* 设置 应用访问地址
* @param urlList
*/
public SstAppsDeskQuery urlList(List<String> urlList){
this.urlList = urlList;
return this;
}
/**
* 设置 是否展示基础应用1是0否
* @param showBasic
*/
public SstAppsDeskQuery showBasic(Integer showBasic){
setShowBasic(showBasic);
return this;
}
/**
* 设置 开始 是否展示基础应用1是0否
* @param showBasicStart
*/
public SstAppsDeskQuery showBasicStart(Integer showBasicStart){
this.showBasicStart = showBasicStart;
return this;
}
/**
* 设置 结束 是否展示基础应用1是0否
* @param showBasicEnd
*/
public SstAppsDeskQuery showBasicEnd(Integer showBasicEnd){
this.showBasicEnd = showBasicEnd;
return this;
}
/**
* 设置 增加 是否展示基础应用1是0否
* @param showBasicIncrement
*/
public SstAppsDeskQuery showBasicIncrement(Integer showBasicIncrement){
this.showBasicIncrement = showBasicIncrement;
return this;
}
/**
* 设置 是否展示基础应用1是0否
* @param showBasicList
*/
public SstAppsDeskQuery showBasicList(List<Integer> showBasicList){
this.showBasicList = showBasicList;
return this;
}
/**
* 设置 是否展示基础应用1是0否
* @param showBasicNotList
*/
public SstAppsDeskQuery showBasicNotList(List<Integer> showBasicNotList){
this.showBasicNotList = showBasicNotList;
return this;
}
/**
* 设置 基础应用排序号
* @param basicSort
*/
public SstAppsDeskQuery basicSort(Integer basicSort){
setBasicSort(basicSort);
return this;
}
/**
* 设置 开始 基础应用排序号
* @param basicSortStart
*/
public SstAppsDeskQuery basicSortStart(Integer basicSortStart){
this.basicSortStart = basicSortStart;
return this;
}
/**
* 设置 结束 基础应用排序号
* @param basicSortEnd
*/
public SstAppsDeskQuery basicSortEnd(Integer basicSortEnd){
this.basicSortEnd = basicSortEnd;
return this;
}
/**
* 设置 增加 基础应用排序号
* @param basicSortIncrement
*/
public SstAppsDeskQuery basicSortIncrement(Integer basicSortIncrement){
this.basicSortIncrement = basicSortIncrement;
return this;
}
/**
* 设置 基础应用排序号
* @param basicSortList
*/
public SstAppsDeskQuery basicSortList(List<Integer> basicSortList){
this.basicSortList = basicSortList;
return this;
}
/**
* 设置 基础应用排序号
* @param basicSortNotList
*/
public SstAppsDeskQuery basicSortNotList(List<Integer> basicSortNotList){
this.basicSortNotList = basicSortNotList;
return this;
}
/**
* 设置 是否展示热门应用1是0否
* @param showHot
*/
public SstAppsDeskQuery showHot(Integer showHot){
setShowHot(showHot);
return this;
}
/**
* 设置 开始 是否展示热门应用1是0否
* @param showHotStart
*/
public SstAppsDeskQuery showHotStart(Integer showHotStart){
this.showHotStart = showHotStart;
return this;
}
/**
* 设置 结束 是否展示热门应用1是0否
* @param showHotEnd
*/
public SstAppsDeskQuery showHotEnd(Integer showHotEnd){
this.showHotEnd = showHotEnd;
return this;
}
/**
* 设置 增加 是否展示热门应用1是0否
* @param showHotIncrement
*/
public SstAppsDeskQuery showHotIncrement(Integer showHotIncrement){
this.showHotIncrement = showHotIncrement;
return this;
}
/**
* 设置 是否展示热门应用1是0否
* @param showHotList
*/
public SstAppsDeskQuery showHotList(List<Integer> showHotList){
this.showHotList = showHotList;
return this;
}
/**
* 设置 是否展示热门应用1是0否
* @param showHotNotList
*/
public SstAppsDeskQuery showHotNotList(List<Integer> showHotNotList){
this.showHotNotList = showHotNotList;
return this;
}
/**
* 设置 热门应用排序号
* @param hotSort
*/
public SstAppsDeskQuery hotSort(Integer hotSort){
setHotSort(hotSort);
return this;
}
/**
* 设置 开始 热门应用排序号
* @param hotSortStart
*/
public SstAppsDeskQuery hotSortStart(Integer hotSortStart){
this.hotSortStart = hotSortStart;
return this;
}
/**
* 设置 结束 热门应用排序号
* @param hotSortEnd
*/
public SstAppsDeskQuery hotSortEnd(Integer hotSortEnd){
this.hotSortEnd = hotSortEnd;
return this;
}
/**
* 设置 增加 热门应用排序号
* @param hotSortIncrement
*/
public SstAppsDeskQuery hotSortIncrement(Integer hotSortIncrement){
this.hotSortIncrement = hotSortIncrement;
return this;
}
/**
* 设置 热门应用排序号
* @param hotSortList
*/
public SstAppsDeskQuery hotSortList(List<Integer> hotSortList){
this.hotSortList = hotSortList;
return this;
}
/**
* 设置 热门应用排序号
* @param hotSortNotList
*/
public SstAppsDeskQuery hotSortNotList(List<Integer> hotSortNotList){
this.hotSortNotList = hotSortNotList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public SstAppsDeskQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public SstAppsDeskQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public SstAppsDeskQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public SstAppsDeskQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public SstAppsDeskQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 创建用户
* @param createUserIdNotList
*/
public SstAppsDeskQuery createUserIdNotList(List<Long> createUserIdNotList){
this.createUserIdNotList = createUserIdNotList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public SstAppsDeskQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public SstAppsDeskQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public SstAppsDeskQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public SstAppsDeskQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public SstAppsDeskQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdNotList
*/
public SstAppsDeskQuery updateUserIdNotList(List<Long> updateUserIdNotList){
this.updateUserIdNotList = updateUserIdNotList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<SstAppsDeskQuery> 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<SstAppsDeskQuery> 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<SstAppsDeskQuery> 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<SstAppsDeskQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/sst/model/vo/SstAppsDeskVo.java 0 → 100644
View file @ f51ac288
package com.mortals.xhx.module.sst.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.sst.model.SstAppsDeskEntity;
import java.util.ArrayList;
import java.util.List;
/**
* 桌面终端应用编排视图对象
*
* @author zxfei
* @date 2023-04-09
*/
public class SstAppsDeskVo extends BaseEntityLong {
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/sst/model/vo/SstBasicVo.java
View file @ f51ac288
......@@ -16,6 +16,11 @@ public class SstBasicVo extends BaseEntityLong {
/** 热门应用 */
private String hotAppIds;
/** 桌面展示的应用 */
private String deskShowAppIds;
/** 桌面热门应用 */
private String deskHotAppIds;
public String getShowAppIds() {
return showAppIds;
}
......@@ -31,4 +36,20 @@ public class SstBasicVo extends BaseEntityLong {
public void setHotAppIds(String hotAppIds) {
this.hotAppIds = hotAppIds;
}
public String getDeskShowAppIds() {
return deskShowAppIds;
}
public void setDeskShowAppIds(String deskShowAppIds) {
this.deskShowAppIds = deskShowAppIds;
}
public String getDeskHotAppIds() {
return deskHotAppIds;
}
public void setDeskHotAppIds(String deskHotAppIds) {
this.deskHotAppIds = deskHotAppIds;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/sst/service/SstAppsDeskService.java 0 → 100644
View file @ f51ac288
package com.mortals.xhx.module.sst.service;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.sst.model.SstAppsDeskEntity;
import java.util.Map;
/**
* SstAppsDeskService
*
* 桌面终端应用编排 service接口
*
* @author zxfei
* @date 2023-04-09
*/
public interface SstAppsDeskService extends ICRUDService<SstAppsDeskEntity,Long>{
/**
* 获取站点应用列表
* @param siteId
* @return
*/
Map<String, Object> getAppsBySiteId(Long siteId) throws AppException;
/**
* 保存基础设置
* @param showAppIds
* @param hotAppIds
* @throws AppException
*/
void settingSave(Long siteId, String showAppIds, String hotAppIds, Context context) throws AppException;
/***
* 获取站点热门应用or展示应用
* @param siteId 站点ID
* @return
*/
Map<String, Object> getAppListBySite(Long siteId,String host);
/**
* 应用下架
* @param appId
* @param userId
*/
void forbidden(Long appId,Long userId);
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/sst/service/impl/SstAppsDeskServiceImpl.java 0 → 100644
View file @ f51ac288
package com.mortals.xhx.module.sst.service.impl;
import com.mortals.framework.util.DataUtil;
import com.mortals.xhx.common.utils.StringUtils;
import com.mortals.xhx.module.apps.model.AppsInfoEntity;
import com.mortals.xhx.module.apps.service.AppsInfoService;
import com.mortals.xhx.module.sst.model.SstAppsDeskEntity;
import org.apache.commons.collections4.CollectionUtils;
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;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.sst.dao.SstAppsDeskDao;
import com.mortals.xhx.module.sst.model.SstAppsDeskEntity;
import com.mortals.xhx.module.sst.service.SstAppsDeskService;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* SstAppsDeskService
* 桌面终端应用编排 service实现
*
* @author zxfei
* @date 2023-04-09
*/
@Service("sstAppsDeskService")
public class SstAppsDeskServiceImpl extends AbstractCRUDServiceImpl<SstAppsDeskDao, SstAppsDeskEntity, Long> implements SstAppsDeskService {
@Autowired
private AppsInfoService appsInfoService;
@Override
public Map<String, Object> getAppsBySiteId(Long siteId) throws AppException {
if(siteId == null){
throw new AppException("站点id不能为空");
}
AppsInfoEntity appsInfoQuery = new AppsInfoEntity();
appsInfoQuery.setSiteId(siteId);
List<AppsInfoEntity> allApps = appsInfoService.find(appsInfoQuery);
SstAppsDeskEntity query = new SstAppsDeskEntity();
Map<String,String> orderCols = new HashMap<>();
orderCols.put("basicSort","DESC");
query.setOrderCols(orderCols);
query.setSiteId(siteId);
List<SstAppsDeskEntity> appsEntities = this.find(query);
Map<String, Object> siteApp = new HashMap<>();
siteApp.put("allApps", allApps);
if(CollectionUtils.isNotEmpty(appsEntities)){
List<SstAppsDeskEntity> showApps = new ArrayList<>();
List<SstAppsDeskEntity> hotApps = new ArrayList<>();
for(SstAppsDeskEntity SstAppsDeskEntity:appsEntities){
if(SstAppsDeskEntity.getShowBasic()==1){
showApps.add(SstAppsDeskEntity);
}
if(SstAppsDeskEntity.getShowHot()==1){
hotApps.add(SstAppsDeskEntity);
}
}
siteApp.put("showApps", showApps);
siteApp.put("hotApps", hotApps);
}else {
siteApp.put("showApps", Collections.emptyList());
siteApp.put("hotApps", Collections.emptyList());
}
return siteApp;
}
@Override
public void settingSave(Long siteId, String showAppIds, String hotAppIds,Context context) throws AppException {
Map<Long,SstAppsDeskEntity> sstAppIds = new HashMap<>();
if(StringUtils.isNotEmpty(showAppIds)){
String appIds[] = showAppIds.split(",");
int sort = 99;
for(String id:appIds){
Long appId = DataUtil.converStr2Long(id,0l);
AppsInfoEntity appsInfoEntity = appsInfoService.get(appId);
if(appsInfoEntity!=null) {
SstAppsDeskEntity SstAppsDeskEntity = new SstAppsDeskEntity();
SstAppsDeskEntity.setSiteId(siteId);
SstAppsDeskEntity.setAppId(appId);
SstAppsDeskEntity.setName(appsInfoEntity.getName());
SstAppsDeskEntity.setDescribe(appsInfoEntity.getDescribe());
SstAppsDeskEntity.setUrl(appsInfoEntity.getUrl());
SstAppsDeskEntity.setShowBasic(1);
SstAppsDeskEntity.setBasicSort(sort);
SstAppsDeskEntity.setShowHot(0);
SstAppsDeskEntity.setHotSort(0);
if(context!=null){
SstAppsDeskEntity.setCreateUserId(context.getUser().getId());
SstAppsDeskEntity.setCreateTime(new Date());
}
sstAppIds.put(appId, SstAppsDeskEntity);
sort--;
}
}
}
if(StringUtils.isNotEmpty(hotAppIds)){
String appIds[] = hotAppIds.split(",");
int sort = 99;
for(String id:appIds){
Long appId = DataUtil.converStr2Long(id,0l);
if(sstAppIds.containsKey(appId)){
sstAppIds.get(appId).setShowHot(1);
sstAppIds.get(appId).setHotSort(sort);
sort--;
}else {
AppsInfoEntity appsInfoEntity = appsInfoService.get(appId);
if (appsInfoEntity != null) {
SstAppsDeskEntity SstAppsDeskEntity = new SstAppsDeskEntity();
SstAppsDeskEntity.setSiteId(siteId);
SstAppsDeskEntity.setAppId(appId);
SstAppsDeskEntity.setName(appsInfoEntity.getName());
SstAppsDeskEntity.setDescribe(appsInfoEntity.getDescribe());
SstAppsDeskEntity.setUrl(appsInfoEntity.getUrl());
SstAppsDeskEntity.setShowBasic(0);
SstAppsDeskEntity.setBasicSort(0);
SstAppsDeskEntity.setShowHot(1);
SstAppsDeskEntity.setHotSort(sort);
if (context != null) {
SstAppsDeskEntity.setCreateUserId(context.getUser().getId());
SstAppsDeskEntity.setCreateTime(new Date());
}
sstAppIds.put(appId, SstAppsDeskEntity);
sort--;
}
}
}
}
Map<String,Object> condition = new HashMap<>();
condition.put("siteId",siteId);
this.dao.delete(condition);
if(sstAppIds.size()>0){
List<SstAppsDeskEntity> list = sstAppIds.values().stream().collect(Collectors.toList());
this.dao.insertBatch(list);
}
}
@Override
public Map<String, Object> getAppListBySite(Long siteId,String host) {
SstAppsDeskEntity query = new SstAppsDeskEntity();
Map<String,String> orderCols = new HashMap<>();
orderCols.put("basicSort","DESC");
query.setOrderCols(orderCols);
query.setSiteId(siteId);
List<SstAppsDeskEntity> appsEntities = this.find(query);
AppsInfoEntity appsInfoQuery = new AppsInfoEntity();
appsInfoQuery.setSiteId(siteId);
List<AppsInfoEntity> allApps = appsInfoService.find(appsInfoQuery);
for(AppsInfoEntity appsInfoEntity:allApps){
if(com.mortals.framework.util.StringUtils.isNotEmpty(host)) {
appsInfoEntity.setCustUrl(host + "/" + appsInfoEntity.getCustUrl());
}
}
Map<Long,AppsInfoEntity> appInfoMap = allApps.stream().collect(Collectors.toMap(AppsInfoEntity::getId, Function.identity()));
Map<String, Object> siteApp = new HashMap<>();
siteApp.put("allApps", allApps);
if(CollectionUtils.isNotEmpty(appsEntities)){
List<AppsInfoEntity> showApps = new ArrayList<>();
List<AppsInfoEntity> hotApps = new ArrayList<>();
for(SstAppsDeskEntity SstAppsDeskEntity:appsEntities){
if(SstAppsDeskEntity.getShowBasic()==1){
showApps.add(appInfoMap.get(SstAppsDeskEntity.getAppId()));
}
if(SstAppsDeskEntity.getShowHot()==1){
hotApps.add(appInfoMap.get(SstAppsDeskEntity.getAppId()));
}
}
siteApp.put("showApps", showApps);
siteApp.put("hotApps", hotApps);
}else {
siteApp.put("showApps", Collections.emptyList());
siteApp.put("hotApps", Collections.emptyList());
}
return siteApp;
}
@Override
public void forbidden(Long appId, Long userId) {
Map<String,Object> condition = new HashMap<>();
condition.put("appId",appId);
this.dao.delete(condition);
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/sst/web/SstAppsDeskController.java 0 → 100644
View file @ f51ac288
package com.mortals.xhx.module.sst.web;
import com.mortals.framework.common.Rest;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.service.IUser;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import com.mortals.xhx.module.sst.model.SstAppsEntity;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.sst.model.SstAppsDeskEntity;
import com.mortals.xhx.module.sst.service.SstAppsDeskService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 桌面终端应用编排
*
* @author zxfei
* @date 2023-04-09
*/
@RestController
@RequestMapping("sst/apps/desk")
public class SstAppsDeskController extends BaseCRUDJsonBodyMappingController<SstAppsDeskService,SstAppsDeskEntity,Long> {
@Autowired
private ParamService paramService;
public SstAppsDeskController(){
super.setModuleDesc( "桌面终端应用编排");
}
@Override
protected void init(Map<String, Object> model, Context context) {
this.addDict(model, "showBasic", paramService.getParamBySecondOrganize("SstApps","showBasic"));
this.addDict(model, "showHot", paramService.getParamBySecondOrganize("SstApps","showHot"));
super.init(model, context);
}
@PostMapping({"forbidden"})
public Rest<Object> forbidden(@RequestBody SstAppsDeskEntity entity) {
IUser user = this.getCurUser();
if(user==null){
throw new AppException("用户未登录");
}
Rest<Object> ret = new Rest();
Map<String, Object> model = new HashMap();
String busiDesc = "自助终端应用下架" ;
int code=1;
try {
this.service.forbidden(entity.getAppId(),user.getId());
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var9) {
code = -1;
this.doException(this.request, busiDesc, model, var9);
}
ret.setCode(code);
ret.setData(model);
ret.setDict(model.get("dict"));
ret.setMsg(model.get("message_info") == null ? "" : model.remove("message_info").toString());
return ret;
}
}
\ No newline at end of file
sst-manager/src/main/java/com/mortals/xhx/module/sst/web/SstBasicController.java
View file @ f51ac288
......@@ -17,6 +17,7 @@ import com.mortals.xhx.feign.base.pdu.SitePdu;
import com.mortals.xhx.feign.rsp.ApiResp;
import com.mortals.xhx.feign.site.ISiteFeign;
import com.mortals.xhx.module.sst.model.SstAppsEntity;
import com.mortals.xhx.module.sst.service.SstAppsDeskService;
import com.mortals.xhx.module.sst.service.SstAppsService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
......@@ -58,6 +59,9 @@ public class SstBasicController extends BaseCRUDJsonBodyMappingController<SstBas
@Autowired
private SstAppsService sstAppsService;
@Autowired
private SstAppsDeskService sstAppsDeskService;
@Autowired
private ISiteFeign iSiteFeign;
......@@ -84,10 +88,14 @@ public class SstBasicController extends BaseCRUDJsonBodyMappingController<SstBas
try {
SstBasicEntity sstBasic = this.service.getBasicBySiteId(query.getSiteId());
Map<String, Object> sstApps = sstAppsService.getAppsBySiteId(query.getSiteId());
Map<String, Object> sstAppsDesk = sstAppsDeskService.getAppsBySiteId(query.getSiteId());
model.put("basicInfo", sstBasic);
model.put("showApps", sstApps.get("showApps"));
model.put("hotApps", sstApps.get("hotApps"));
model.put("allApps", sstApps.get("allApps"));
model.put("showAppsDesk", sstAppsDesk.get("showApps"));
model.put("hotAppsDesk", sstAppsDesk.get("hotApps"));
model.put("allAppsDesk", sstAppsDesk.get("allApps"));
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var9) {
......@@ -115,6 +123,7 @@ public class SstBasicController extends BaseCRUDJsonBodyMappingController<SstBas
try {
this.service.settingSave(basicEntity,this.getContext());
this.sstAppsService.settingSave(basicEntity.getSiteId(),basicEntity.getShowAppIds(),basicEntity.getHotAppIds(),this.getContext());
this.sstAppsDeskService.settingSave(basicEntity.getSiteId(),basicEntity.getDeskShowAppIds(),basicEntity.getDeskHotAppIds(),this.getContext());
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var9) {
......@@ -235,6 +244,10 @@ public class SstBasicController extends BaseCRUDJsonBodyMappingController<SstBas
model.put("showApps", sstApps.get("showApps"));
model.put("hotApps", sstApps.get("hotApps"));
model.put("allApps", sstApps.get("allApps"));
Map<String, Object> sstAppsDesk = sstAppsDeskService.getAppListBySite(query.getSiteId(),host);
model.put("showAppsDesk", sstAppsDesk.get("showApps"));
model.put("hotAppsDesk", sstAppsDesk.get("hotApps"));
model.put("allAppsDesk", sstAppsDesk.get("allApps"));
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var9) {
......
sst-manager/src/main/resources/sqlmap/module/sst/SstAppsDeskMapper.xml 0 → 100644
View file @ f51ac288
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"mybatis-3-mapper.dtd">
<mapper namespace="com.mortals.xhx.module.sst.dao.ibatis.SstAppsDeskDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="SstAppsDeskEntity" id="SstAppsDeskEntity-Map">
<id property="id" column="id" />
<result property="siteId" column="siteId" />
<result property="appId" column="appId" />
<result property="name" column="name" />
<result property="describe" column="describe" />
<result property="url" column="url" />
<result property="showBasic" column="showBasic" />
<result property="basicSort" column="basicSort" />
<result property="showHot" column="showHot" />
<result property="hotSort" column="hotSort" />
<result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" />
</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,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteId') or colPickMode == 1 and data.containsKey('siteId')))">
a.siteId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('appId') or colPickMode == 1 and data.containsKey('appId')))">
a.appId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('name') or colPickMode == 1 and data.containsKey('name')))">
a.name,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('describe') or colPickMode == 1 and data.containsKey('describe')))">
a.describe,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('url') or colPickMode == 1 and data.containsKey('url')))">
a.url,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('showBasic') or colPickMode == 1 and data.containsKey('showBasic')))">
a.showBasic,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('basicSort') or colPickMode == 1 and data.containsKey('basicSort')))">
a.basicSort,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('showHot') or colPickMode == 1 and data.containsKey('showHot')))">
a.showHot,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hotSort') or colPickMode == 1 and data.containsKey('hotSort')))">
a.hotSort,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="SstAppsDeskEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_sst_apps_desk
(siteId,appId,`name`,`describe`,url,showBasic,basicSort,showHot,hotSort,createUserId,createTime,updateUserId,updateTime)
VALUES
(#{siteId},#{appId},#{name},#{describe},#{url},#{showBasic},#{basicSort},#{showHot},#{hotSort},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_sst_apps_desk
(siteId,appId,`name`,`describe`,url,showBasic,basicSort,showHot,hotSort,createUserId,createTime,updateUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.siteId},#{item.appId},#{item.name},#{item.describe},#{item.url},#{item.showBasic},#{item.basicSort},#{item.showHot},#{item.hotSort},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_sst_apps_desk as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('siteId')) or (colPickMode==1 and !data.containsKey('siteId'))">
a.siteId=#{data.siteId},
</if>
<if test="(colPickMode==0 and data.containsKey('siteIdIncrement')) or (colPickMode==1 and !data.containsKey('siteIdIncrement'))">
a.siteId=ifnull(a.siteId,0) + #{data.siteIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('appId')) or (colPickMode==1 and !data.containsKey('appId'))">
a.appId=#{data.appId},
</if>
<if test="(colPickMode==0 and data.containsKey('appIdIncrement')) or (colPickMode==1 and !data.containsKey('appIdIncrement'))">
a.appId=ifnull(a.appId,0) + #{data.appIdIncrement},
</if>
<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('describe')) or (colPickMode==1 and !data.containsKey('describe'))">
a.`describe`=#{data.describe},
</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('showBasic')) or (colPickMode==1 and !data.containsKey('showBasic'))">
a.showBasic=#{data.showBasic},
</if>
<if test="(colPickMode==0 and data.containsKey('showBasicIncrement')) or (colPickMode==1 and !data.containsKey('showBasicIncrement'))">
a.showBasic=ifnull(a.showBasic,0) + #{data.showBasicIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('basicSort')) or (colPickMode==1 and !data.containsKey('basicSort'))">
a.basicSort=#{data.basicSort},
</if>
<if test="(colPickMode==0 and data.containsKey('basicSortIncrement')) or (colPickMode==1 and !data.containsKey('basicSortIncrement'))">
a.basicSort=ifnull(a.basicSort,0) + #{data.basicSortIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('showHot')) or (colPickMode==1 and !data.containsKey('showHot'))">
a.showHot=#{data.showHot},
</if>
<if test="(colPickMode==0 and data.containsKey('showHotIncrement')) or (colPickMode==1 and !data.containsKey('showHotIncrement'))">
a.showHot=ifnull(a.showHot,0) + #{data.showHotIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('hotSort')) or (colPickMode==1 and !data.containsKey('hotSort'))">
a.hotSort=#{data.hotSort},
</if>
<if test="(colPickMode==0 and data.containsKey('hotSortIncrement')) or (colPickMode==1 and !data.containsKey('hotSortIncrement'))">
a.hotSort=ifnull(a.hotSort,0) + #{data.hotSortIncrement},
</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('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</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_sst_apps_desk as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="siteId=(case" suffix="ELSE siteId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('siteId')) or (colPickMode==1 and !item.containsKey('siteId'))">
when a.id=#{item.id} then #{item.siteId}
</when>
<when test="(colPickMode==0 and item.containsKey('siteIdIncrement')) or (colPickMode==1 and !item.containsKey('siteIdIncrement'))">
when a.id=#{item.id} then ifnull(a.siteId,0) + #{item.siteIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="appId=(case" suffix="ELSE appId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('appId')) or (colPickMode==1 and !item.containsKey('appId'))">
when a.id=#{item.id} then #{item.appId}
</when>
<when test="(colPickMode==0 and item.containsKey('appIdIncrement')) or (colPickMode==1 and !item.containsKey('appIdIncrement'))">
when a.id=#{item.id} then ifnull(a.appId,0) + #{item.appIdIncrement}
</when>
</choose>
</foreach>
</trim>
<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="describe=(case" suffix="ELSE describe end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('describe')) or (colPickMode==1 and !item.containsKey('describe'))">
when a.id=#{item.id} then #{item.describe}
</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="showBasic=(case" suffix="ELSE showBasic end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('showBasic')) or (colPickMode==1 and !item.containsKey('showBasic'))">
when a.id=#{item.id} then #{item.showBasic}
</when>
<when test="(colPickMode==0 and item.containsKey('showBasicIncrement')) or (colPickMode==1 and !item.containsKey('showBasicIncrement'))">
when a.id=#{item.id} then ifnull(a.showBasic,0) + #{item.showBasicIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="basicSort=(case" suffix="ELSE basicSort end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('basicSort')) or (colPickMode==1 and !item.containsKey('basicSort'))">
when a.id=#{item.id} then #{item.basicSort}
</when>
<when test="(colPickMode==0 and item.containsKey('basicSortIncrement')) or (colPickMode==1 and !item.containsKey('basicSortIncrement'))">
when a.id=#{item.id} then ifnull(a.basicSort,0) + #{item.basicSortIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="showHot=(case" suffix="ELSE showHot end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('showHot')) or (colPickMode==1 and !item.containsKey('showHot'))">
when a.id=#{item.id} then #{item.showHot}
</when>
<when test="(colPickMode==0 and item.containsKey('showHotIncrement')) or (colPickMode==1 and !item.containsKey('showHotIncrement'))">
when a.id=#{item.id} then ifnull(a.showHot,0) + #{item.showHotIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="hotSort=(case" suffix="ELSE hotSort end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('hotSort')) or (colPickMode==1 and !item.containsKey('hotSort'))">
when a.id=#{item.id} then #{item.hotSort}
</when>
<when test="(colPickMode==0 and item.containsKey('hotSortIncrement')) or (colPickMode==1 and !item.containsKey('hotSortIncrement'))">
when a.id=#{item.id} then ifnull(a.hotSort,0) + #{item.hotSortIncrement}
</when>
</choose>
</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="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="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="SstAppsDeskEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_sst_apps_desk as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_sst_apps_desk as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_sst_apps_desk where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据主健列表删除一批，针对单一主健有效 -->
<delete id="deleteByKeyList">
delete from mortals_xhx_sst_apps_desk where id in
<foreach collection="list" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据对象列表删除一批，针对单一主健有效 -->
<delete id="deleteByEntityList">
delete from mortals_xhx_sst_apps_desk 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_sst_apps_desk as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="SstAppsDeskEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_sst_apps_desk as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_xhx_sst_apps_desk as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idNotList')">
${_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('siteId')">
<if test="conditionParamRef.siteId != null ">
${_conditionType_} a.siteId = #{${_conditionParam_}.siteId}
</if>
<if test="conditionParamRef.siteId == null">
${_conditionType_} a.siteId is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteIdList')">
${_conditionType_} a.siteId in
<foreach collection="conditionParamRef.siteIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteIdNotList')">
${_conditionType_} a.siteId not in
<foreach collection="conditionParamRef.siteIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('siteIdStart') and conditionParamRef.siteIdStart != null">
${_conditionType_} a.siteId <![CDATA[ >= ]]> #{${_conditionParam_}.siteIdStart}
</if>
<if test="conditionParamRef.containsKey('siteIdEnd') and conditionParamRef.siteIdEnd != null">
${_conditionType_} a.siteId <![CDATA[ <= ]]> #{${_conditionParam_}.siteIdEnd}
</if>
<if test="conditionParamRef.containsKey('appId')">
<if test="conditionParamRef.appId != null ">
${_conditionType_} a.appId = #{${_conditionParam_}.appId}
</if>
<if test="conditionParamRef.appId == null">
${_conditionType_} a.appId is null
</if>
</if>
<if test="conditionParamRef.containsKey('appIdList')">
${_conditionType_} a.appId in
<foreach collection="conditionParamRef.appIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('appIdNotList')">
${_conditionType_} a.appId not in
<foreach collection="conditionParamRef.appIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('appIdStart') and conditionParamRef.appIdStart != null">
${_conditionType_} a.appId <![CDATA[ >= ]]> #{${_conditionParam_}.appIdStart}
</if>
<if test="conditionParamRef.containsKey('appIdEnd') and conditionParamRef.appIdEnd != null">
${_conditionType_} a.appId <![CDATA[ <= ]]> #{${_conditionParam_}.appIdEnd}
</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')">
${_conditionType_} a.name in
<foreach collection="conditionParamRef.nameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('nameNotList')">
${_conditionType_} a.name not in
<foreach collection="conditionParamRef.nameNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('describe')">
<if test="conditionParamRef.describe != null and conditionParamRef.describe != ''">
${_conditionType_} a.describe like #{${_conditionParam_}.describe}
</if>
<if test="conditionParamRef.describe == null">
${_conditionType_} a.describe is null
</if>
</if>
<if test="conditionParamRef.containsKey('describeList')">
${_conditionType_} a.describe in
<foreach collection="conditionParamRef.describeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('describeNotList')">
${_conditionType_} a.describe not in
<foreach collection="conditionParamRef.describeNotList" 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')">
${_conditionType_} a.url in
<foreach collection="conditionParamRef.urlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('urlNotList')">
${_conditionType_} a.url not in
<foreach collection="conditionParamRef.urlNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('showBasic')">
<if test="conditionParamRef.showBasic != null ">
${_conditionType_} a.showBasic = #{${_conditionParam_}.showBasic}
</if>
<if test="conditionParamRef.showBasic == null">
${_conditionType_} a.showBasic is null
</if>
</if>
<if test="conditionParamRef.containsKey('showBasicList')">
${_conditionType_} a.showBasic in
<foreach collection="conditionParamRef.showBasicList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('showBasicNotList')">
${_conditionType_} a.showBasic not in
<foreach collection="conditionParamRef.showBasicNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('showBasicStart') and conditionParamRef.showBasicStart != null">
${_conditionType_} a.showBasic <![CDATA[ >= ]]> #{${_conditionParam_}.showBasicStart}
</if>
<if test="conditionParamRef.containsKey('showBasicEnd') and conditionParamRef.showBasicEnd != null">
${_conditionType_} a.showBasic <![CDATA[ <= ]]> #{${_conditionParam_}.showBasicEnd}
</if>
<if test="conditionParamRef.containsKey('basicSort')">
<if test="conditionParamRef.basicSort != null ">
${_conditionType_} a.basicSort = #{${_conditionParam_}.basicSort}
</if>
<if test="conditionParamRef.basicSort == null">
${_conditionType_} a.basicSort is null
</if>
</if>
<if test="conditionParamRef.containsKey('basicSortList')">
${_conditionType_} a.basicSort in
<foreach collection="conditionParamRef.basicSortList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('basicSortNotList')">
${_conditionType_} a.basicSort not in
<foreach collection="conditionParamRef.basicSortNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('basicSortStart') and conditionParamRef.basicSortStart != null">
${_conditionType_} a.basicSort <![CDATA[ >= ]]> #{${_conditionParam_}.basicSortStart}
</if>
<if test="conditionParamRef.containsKey('basicSortEnd') and conditionParamRef.basicSortEnd != null">
${_conditionType_} a.basicSort <![CDATA[ <= ]]> #{${_conditionParam_}.basicSortEnd}
</if>
<if test="conditionParamRef.containsKey('showHot')">
<if test="conditionParamRef.showHot != null ">
${_conditionType_} a.showHot = #{${_conditionParam_}.showHot}
</if>
<if test="conditionParamRef.showHot == null">
${_conditionType_} a.showHot is null
</if>
</if>
<if test="conditionParamRef.containsKey('showHotList')">
${_conditionType_} a.showHot in
<foreach collection="conditionParamRef.showHotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('showHotNotList')">
${_conditionType_} a.showHot not in
<foreach collection="conditionParamRef.showHotNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('showHotStart') and conditionParamRef.showHotStart != null">
${_conditionType_} a.showHot <![CDATA[ >= ]]> #{${_conditionParam_}.showHotStart}
</if>
<if test="conditionParamRef.containsKey('showHotEnd') and conditionParamRef.showHotEnd != null">
${_conditionType_} a.showHot <![CDATA[ <= ]]> #{${_conditionParam_}.showHotEnd}
</if>
<if test="conditionParamRef.containsKey('hotSort')">
<if test="conditionParamRef.hotSort != null ">
${_conditionType_} a.hotSort = #{${_conditionParam_}.hotSort}
</if>
<if test="conditionParamRef.hotSort == null">
${_conditionType_} a.hotSort is null
</if>
</if>
<if test="conditionParamRef.containsKey('hotSortList')">
${_conditionType_} a.hotSort in
<foreach collection="conditionParamRef.hotSortList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('hotSortNotList')">
${_conditionType_} a.hotSort not in
<foreach collection="conditionParamRef.hotSortNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('hotSortStart') and conditionParamRef.hotSortStart != null">
${_conditionType_} a.hotSort <![CDATA[ >= ]]> #{${_conditionParam_}.hotSortStart}
</if>
<if test="conditionParamRef.containsKey('hotSortEnd') and conditionParamRef.hotSortEnd != null">
${_conditionType_} a.hotSort <![CDATA[ <= ]]> #{${_conditionParam_}.hotSortEnd}
</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')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdNotList')">
${_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('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('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList')">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdNotList')">
${_conditionType_} a.updateUserId not in
<foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteId')">
a.siteId
<if test='orderCol.siteId != null and "DESC".equalsIgnoreCase(orderCol.siteId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('appId')">
a.appId
<if test='orderCol.appId != null and "DESC".equalsIgnoreCase(orderCol.appId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('name')">
a.name
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('describe')">
a.describe
<if test='orderCol.describe != null and "DESC".equalsIgnoreCase(orderCol.describe)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('url')">
a.url
<if test='orderCol.url != null and "DESC".equalsIgnoreCase(orderCol.url)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('showBasic')">
a.showBasic
<if test='orderCol.showBasic != null and "DESC".equalsIgnoreCase(orderCol.showBasic)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('basicSort')">
a.basicSort
<if test='orderCol.basicSort != null and "DESC".equalsIgnoreCase(orderCol.basicSort)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('showHot')">
a.showHot
<if test='orderCol.showHot != null and "DESC".equalsIgnoreCase(orderCol.showHot)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('hotSort')">
a.hotSort
<if test='orderCol.hotSort != null and "DESC".equalsIgnoreCase(orderCol.hotSort)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
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