Skip to content

S
smart_gov_platform
Commit 945f2d4f authored by 赵啸非's avatar 赵啸非
Browse files
Options

添加mybatis xml映射文件

parent c8467853
Hide whitespace changes
Inline Side-by-side
Showing with 6263 additions and 951 deletions
base-manager/src/main/java/com/mortals/xhx/daemon/RequestDataController.java
View file @ 945f2d4f
......@@ -44,33 +44,6 @@ public class RequestDataController {
@Autowired
private MatterService matterService;
@Autowired
private MattersService mattersService;
@Autowired
private MattersDetailService mattersDetailService;
@Autowired
private MatterFlowlimitService matterFlowlimitService;
@Autowired
private MatterAcceptService matterAcceptService;
@Autowired
private MatterSetbaseService matterSetbaseService;
@Autowired
private MatterQuestionService matterQuestionService;
@Autowired
private MatterIntermediaryService matterIntermediaryService;
@Autowired
private MatterDatumService matterDatumService;
@Autowired
private MatterDatumFileService matterDatumFileService;
@Autowired
private MatterChargesService matterChargesService;
@Autowired
private ParamService paramService;
@Autowired
private UploadService uploadService;
/**
* 生成基础数据prop
......@@ -129,274 +102,6 @@ public class RequestDataController {
return respPdu;
}
/*
*/
/**
* 同步解析材料
*
* @param
* @return
*//*
@PostMapping("/datumn")
public String datumn(@RequestBody ApiReqPdu<RequestTaskReq> req) {
ApiRespPdu<String> respPdu = new ApiRespPdu<>();
BiMap<String, String> materialPropertyInverseMap = HashBiMap.create(paramService.getParamByFirstOrganize(Constant.Param_materialProperty)).inverse();
BiMap<String, String> materialTypeInverseMap = HashBiMap.create(paramService.getParamByFirstOrganize(Constant.Param_materialType)).inverse();
BiMap<String, String> electronicgsInverseMap = HashBiMap.create(paramService.getParamByFirstOrganize(Constant.Param_electronicgs)).inverse();
BiMap<String, String> materialSourceInverseMap = HashBiMap.create(paramService.getParamByFirstOrganize(Constant.Param_materialSource)).inverse();
BiMap<String, String> paperGgInverseMap = HashBiMap.create(paramService.getParamByFirstOrganize(Constant.Param_paperGg)).inverse();
BiMap<String, String> jianmMsInverseMap = HashBiMap.create(paramService.getParamByFirstOrganize(Constant.Param_jianmMs)).inverse();
BiMap<String, String> sealWayInverseMap = HashBiMap.create(paramService.getParamByFirstOrganize(Constant.Param_sealWay)).inverse();
BiMap<String, String> isMustInverseMap = HashBiMap.create(paramService.getParamByFirstOrganize(Constant.Param_isMust)).inverse();
BiMap<String, String> iszzsbInverseMap = HashBiMap.create(YesNoEnum.getEnumMap()).inverse();
BiMap<String, String> yesOrNoInverseMap = HashBiMap.create(YesNoEnum.getEnumMap()).inverse();
//String value = inverse.getOrDefault(m.getValue().toString(), "0");
try {
//拆分材料库数据
matterDetailService.find(new MatterDetailQuery()).stream().peek(item -> {
String json = item.getMaterialsSqcl();
//log.info("receive json:"+json);
if (ObjectUtils.isEmpty(json) || "{}".equals(json)) {
log.info("json:" + json);
return;
}
JSONObject root = null;
try {
root = JSON.parseObject(json);
} catch (Exception e) {
json = json.replaceAll("\\\\", "\\\\\\\\");
try {
root = JSON.parseObject(json);
} catch (Exception e1) {
log.error("error json:" + json);
return;
}
}
if (root.isEmpty()) {
log.info("root is null");
return;
}
JSONArray jsonArray = null;
try {
jsonArray = root.getJSONArray("申请材料");
} catch (Exception e) {
log.error("error 无申请材料");
}
if (ObjectUtils.isEmpty(jsonArray)) {
log.info("申请材料 is null");
return;
}
for (int i = 0; i < jsonArray.size(); i++) {
JSONObject secondJsonObject = jsonArray.getJSONObject(i);
MatterDatumEntity datumEntity = new MatterDatumEntity();
datumEntity.setMatterId(item.getMatterId());
datumEntity.setSource(0);
datumEntity.setCreateTime(new Date());
datumEntity.setCreateUser("system");
//材料详情
JSONArray jsonArrayThree = secondJsonObject.getJSONArray("材料详情");
if (!ObjectUtils.isEmpty(jsonArrayThree)) {
for (int j = 0; j < jsonArrayThree.size(); j++) {
jsonArrayThree.getJSONObject(j).entrySet().stream().peek(m -> {
Boolean bool = false;
if ("材料名称".equals(m.getKey().trim())) {
datumEntity.setMaterialName(m.getValue().toString());
bool = true;
}
if ("材料形式".equals(m.getKey().trim())) {
//materialPropertyInverseMap
String value = materialPropertyInverseMap.getOrDefault(m.getValue().toString(), "0");
datumEntity.setMaterialProperty(Integer.parseInt(value));
bool = true;
checkKeyValue(materialPropertyInverseMap, m, value);
}
if ("材料必要性".equals(m.getKey().trim())) {
//isMustInverseMap
String value = isMustInverseMap.getOrDefault(m.getValue().toString(), "0");
datumEntity.setIsMust(Integer.parseInt(value));
bool = true;
checkKeyValue(isMustInverseMap, m, value);
}
if ("材料类型".equals(m.getKey().trim())) {
//materialTypeInverseMap
String value = materialTypeInverseMap.getOrDefault(m.getValue().toString(), "0");
datumEntity.setMaterialType(Integer.parseInt(value));
bool = true;
checkKeyValue(materialTypeInverseMap, m, value);
}
if ("电子材料格式".equals(m.getKey().trim())) {
//electronicgsInverseMap
String value = electronicgsInverseMap.getOrDefault(m.getValue().toString(), "0");
datumEntity.setElectronicgs(Integer.parseInt(value));
bool = true;
checkKeyValue(electronicgsInverseMap, m, value);
}
if ("来源渠道".equals(m.getKey().trim())) {
//materialSourceSmInverseMap
String value = materialSourceInverseMap.getOrDefault(m.getValue().toString(), "0");
datumEntity.setMaterialSource(Integer.parseInt(value));
bool = true;
checkKeyValue(materialSourceInverseMap, m, value);
}
if ("来源渠道说明".equals(m.getKey().trim())) {
datumEntity.setMaterialSourceSm(m.getValue().toString());
bool = true;
}
if ("纸质材料份数".equals(m.getKey().trim())) {
//materialSourceSmInverseMap
datumEntity.setPaperNum(Integer.parseInt(m.getValue().toString()));
bool = true;
}
if ("纸质材料规格".equals(m.getKey().trim())) {
//paperGgInverseMap
String value = paperGgInverseMap.getOrDefault(m.getValue().toString(), "0");
datumEntity.setPaperGg(Integer.parseInt(value));
bool = true;
checkKeyValue(paperGgInverseMap, m, value);
datumEntity.setPaperGgText(m.getValue().toString());
}
if ("盖章或盖手印方式".equals(m.getKey().trim())) {
//sealWayInverseMap
String value = sealWayInverseMap.getOrDefault(m.getValue().toString(), "0");
datumEntity.setSealWay(Integer.parseInt(value));
bool = true;
checkKeyValue(sealWayInverseMap, m, value);
datumEntity.setSealWayText(m.getValue().toString());
}
if ("是否容缺".equals(m.getKey().trim())) {
//yesOrNoInverseMap
String value = yesOrNoInverseMap.getOrDefault(m.getValue().toString(), "0");
datumEntity.setIsLack(Integer.parseInt(value));
bool = true;
checkKeyValue(yesOrNoInverseMap, m, value);
}
if ("是否减免".equals(m.getKey().trim())) {
//yesOrNoInverseMap
String value = yesOrNoInverseMap.getOrDefault(m.getValue().toString(), "0");
datumEntity.setIsjianm(Integer.parseInt(value));
bool = true;
checkKeyValue(yesOrNoInverseMap, m, value);
}
if ("减免模式".equals(m.getKey().trim())) {
//jianmMsInverseMap
if ("".equals(m.getValue().toString())) {
m.setValue("无");
}
String value = jianmMsInverseMap.getOrDefault(m.getValue().toString(), "0");
datumEntity.setJianmMs(Integer.parseInt(value));
bool = true;
checkKeyValue(jianmMsInverseMap, m, value);
}
if ("填报须知".equals(m.getKey().trim())) {
datumEntity.setRemarkSub(m.getValue().toString());
bool = true;
}
if ("受理标准".equals(m.getKey().trim())) {
datumEntity.setSummary(m.getValue().toString());
bool = true;
}
if ("要求提供材料的依据".equals(m.getKey().trim())) {
datumEntity.setClauseContent(m.getValue().toString());
bool = true;
}
if ("备注".equals(m.getKey().trim())) {
datumEntity.setRemark(m.getValue().toString());
bool = true;
}
if (!bool) {
System.out.println("name:" + m.getKey());
System.out.print(" value:" + m.getValue());
}
}).count();
}
}
matterDatumService.save(datumEntity);
//示例样表
JSONArray jsonArrayone = secondJsonObject.getJSONArray("示例样表");
if (!ObjectUtils.isEmpty(jsonArrayone)) {
ArrayList<MatterDatumFileEntity> fileArrayList = new ArrayList<>();
for (int j = 0; j < jsonArrayone.size(); j++) {
MatterDatumFileEntity fileEntity = new MatterDatumFileEntity();
fileEntity.setCreateTime(new Date());
fileEntity.setCreateUser("system");
fileEntity.setDatumid(datumEntity.getId());
fileEntity.setSource(0);
fileEntity.setFiletype(1);
jsonArrayone.getJSONObject(j).entrySet().stream().peek(m -> {
fileEntity.setFileName(m.getKey());
fileEntity.setFileUrl(m.getValue().toString());
}).count();
fileArrayList.add(fileEntity);
}
matterDatumFileService.save(fileArrayList);
}
//空白表格
JSONArray jsonArraytwo = secondJsonObject.getJSONArray("空白表格");
if (!ObjectUtils.isEmpty(jsonArraytwo)) {
ArrayList<MatterDatumFileEntity> fileArrayList = new ArrayList<>();
for (int j = 0; j < jsonArraytwo.size(); j++) {
MatterDatumFileEntity fileEntity = new MatterDatumFileEntity();
fileEntity.setCreateTime(new Date());
fileEntity.setCreateUser("system");
fileEntity.setDatumid(datumEntity.getId());
fileEntity.setSource(0);
fileEntity.setFiletype(2);
jsonArraytwo.getJSONObject(j).entrySet().stream().peek(m -> {
fileEntity.setFileName(m.getKey());
fileEntity.setFileUrl(m.getValue().toString());
}).count();
fileArrayList.add(fileEntity);
}
matterDatumFileService.save(fileArrayList);
}
}
}).count();
} catch (Exception e) {
log.error("error", e);
}
return respPdu;
}*/
private void checkKeyValue(BiMap<String, String> map, Map.Entry<String, Object> m, String value) {
if ("0".equals(value)) {
//查看是否为空
......
base-manager/src/main/java/com/mortals/xhx/module/site/service/impl/SiteServiceImpl.java
View file @ 945f2d4f
......@@ -86,20 +86,9 @@ public class SiteServiceImpl extends AbstractCRUDCacheServiceImpl<SiteDao, SiteE
recursionFn(areaMap, areaEntity);
}
}
return buildSiteTreeSelect(areaMap, siteMap);
}
@Override
public List<SiteTreeSelect> getSiteTree(Context context) {
return siteTreeList;
}
@Override
public void setSiteTree(List<SiteTreeSelect> list, Context context) {
this.siteTreeList = list;
}
public List<SiteTreeSelect> buildSiteTreeSelect(Map<String, AreaEntity> areaMap, Map<String, SiteEntity> siteMap) {
List<AreaEntity> areaList = areaMap.values().stream().collect(Collectors.toList());
List<AreaEntity> returnList = new ArrayList<>();
......@@ -112,10 +101,12 @@ public class SiteServiceImpl extends AbstractCRUDCacheServiceImpl<SiteDao, SiteE
returnList.add(areaEntity);
}
}
//区域树
if (returnList.isEmpty()) {
returnList = areaList;
}
//构建站点树
List<SiteTreeSelect> collect = returnList.stream().map(item ->
new SiteTreeSelect(item, siteMap)
).collect(Collectors.toList());
......@@ -124,10 +115,10 @@ public class SiteServiceImpl extends AbstractCRUDCacheServiceImpl<SiteDao, SiteE
}
private void recursion(List<AreaEntity> list, AreaEntity t) {
private void recursion(List<AreaEntity> list, AreaEntity entity) {
// 得到子节点列表
List<AreaEntity> childList = getChildList(list, t);
t.setChildren(childList);
List<AreaEntity> childList = getChildList(list, entity);
entity.setChildren(childList);
for (AreaEntity tChild : childList) {
if (hasChild(list, tChild)) {
recursion(list, tChild);
......@@ -138,8 +129,10 @@ public class SiteServiceImpl extends AbstractCRUDCacheServiceImpl<SiteDao, SiteE
/**
* 得到子节点列表
*/
private List<AreaEntity> getChildList(List<AreaEntity> list, AreaEntity t) {
return list.stream().filter(item -> item.getPid().equals(t.getIid())).collect(Collectors.toList());
private List<AreaEntity> getChildList(List<AreaEntity> list, AreaEntity entity) {
return list.stream()
.filter(item -> item.getPid().equals(entity.getIid()))
.collect(Collectors.toList());
}
/**
......@@ -182,4 +175,14 @@ public class SiteServiceImpl extends AbstractCRUDCacheServiceImpl<SiteDao, SiteE
new Thread(new SyncTreeSiteThread(this,context)).start();
super.removeBefore(ids, context);
}
@Override
public List<SiteTreeSelect> getSiteTree(Context context) {
return siteTreeList;
}
@Override
public void setSiteTree(List<SiteTreeSelect> list, Context context) {
this.siteTreeList = list;
}
}
\ No newline at end of file
base-manager/src/main/java/com/mortals/xhx/module/site/web/SiteController.java
View file @ 945f2d4f
package com.mortals.xhx.module.site.web;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.exception.AppException;
......@@ -17,10 +18,7 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;
/**
......@@ -78,6 +76,8 @@ public class SiteController extends BaseCRUDJsonBodyMappingController<SiteServic
}
//校验
Long siteId = getContext().getUser().getSiteId();
String siteIds = getContext().getUser().getSiteIds();
Set<String> siteSet = Arrays.stream(siteIds.split(",")).collect(Collectors.toSet());
if(!ObjectUtils.isEmpty(siteId)){
//遍历树
SiteTreeSelect temp =reFucurs(siteTree,siteId.toString());
......@@ -118,4 +118,26 @@ public class SiteController extends BaseCRUDJsonBodyMappingController<SiteServic
}
return temp;
}
/*
public SiteTreeSelect reFucurs(List<SiteTreeSelect> siteTree, Set<String> siteSet) {
SiteTreeSelect temp=null;
for (SiteTreeSelect site : siteTree) {
if (site.getId().equals(siteId)) {
log.info("curTree:{}", JSON.toJSONString(site));
temp=site;
break;
} else {
if (!ObjectUtils.isEmpty(site.getChildren())) {
temp=reFucurs(site.getChildren(), siteId);
if(temp!=null){
break;
}
}
}
}
return temp;
}*/
}
\ No newline at end of file
doc/政务一体化.docx
View file @ 945f2d4f
No preview for this file type
portal-manager/db/db.sql
View file @ 945f2d4f
......@@ -163,7 +163,7 @@ CREATE TABLE mortals_xhx_user(
`email` varchar(50) COMMENT '用户邮箱',
`qq` varchar(20) COMMENT 'QQ号码',
`userType` tinyint(2) COMMENT '用户类型，0：系统用户 1:普通用户 2:工作人员，默认2',
`siteInfo` varchar(500) COMMENT '{ "授权站点": { "站点信息": [ { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" } ] }}',
`siteIds` varchar(512) COMMENT '所属站点id,多个逗号分隔',
`status` tinyint(2) COMMENT '用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1',
`customerId` bigint(20) COMMENT '客户ID',
`createTime` datetime COMMENT '创建时间',
......@@ -173,6 +173,7 @@ CREATE TABLE mortals_xhx_user(
`lastLoginAddress` varchar(21) COMMENT '最后一次登录地址',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='用户信息业务';
-- ----------------------------
-- 验证码信息业务表
-- ----------------------------
......
portal-manager/src/main/java/com/mortals/xhx/module/user/model/UserEntity.java
View file @ 945f2d4f
......@@ -9,125 +9,125 @@ import com.mortals.framework.model.BaseEntityLong;
import com.mortals.framework.service.IUser;
import com.mortals.xhx.module.user.model.vo.UserVo;
/**
* 用户信息业务实体对象
*
* @author zxfei
* @date 2022-05-25
*/
* 用户信息业务实体对象
*
* @author zxfei
* @date 2022-05-26
*/
public class UserEntity extends UserVo implements IUser {
private static final long serialVersionUID = 1L;
/**
* 登录名
*/
* 登录名
*/
private String loginName;
/**
* 登录密码，使用md5双次加密
*/
* 登录密码，使用md5双次加密
*/
private String loginPwd;
/**
* 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
*/
* 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
*/
private String loginLimitAddress;
/**
* 用户名
*/
* 用户名
*/
private String realName;
/**
* 用户手机号
*/
* 用户手机号
*/
private String mobile;
/**
* 用户联系电话
*/
* 用户联系电话
*/
private String phone;
/**
* 用户邮箱
*/
* 用户邮箱
*/
private String email;
/**
* QQ号码
*/
* QQ号码
*/
private String qq;
/**
* 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
*/
* 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
*/
private Integer userType;
/**
* { "授权站点": { "站点信息": [ { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" } ] }}
*/
private String siteInfo;
* 所属站点id,多个逗号分隔
*/
private String siteIds;
/**
* 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
*/
* 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
*/
private Integer status;
/**
* 客户ID
*/
* 客户ID
*/
private Long customerId;
/**
* 创建用户名称
*/
* 创建用户名称
*/
private String createUserName;
/**
* 最后一次登录时间
*/
* 最后一次登录时间
*/
private Date lastLoginTime;
/**
* 最后一次登录地址
*/
* 最后一次登录地址
*/
private String lastLoginAddress;
public UserEntity(){}
/**
* 获取 登录名
* @return String
*/
* 获取 登录名
* @return String
*/
public String getLoginName(){
return loginName;
}
/**
* 设置 登录名
* @param loginName
*/
* 设置 登录名
* @param loginName
*/
public void setLoginName(String loginName){
this.loginName = loginName;
}
/**
* 获取 登录密码，使用md5双次加密
* @return String
*/
* 获取 登录密码，使用md5双次加密
* @return String
*/
public String getLoginPwd(){
return loginPwd;
}
/**
* 设置 登录密码，使用md5双次加密
* @param loginPwd
*/
* 设置 登录密码，使用md5双次加密
* @param loginPwd
*/
public void setLoginPwd(String loginPwd){
this.loginPwd = loginPwd;
}
/**
* 获取 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @return String
*/
* 获取 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @return String
*/
public String getLoginLimitAddress(){
return loginLimitAddress;
}
/**
* 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @param loginLimitAddress
*/
* 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @param loginLimitAddress
*/
public void setLoginLimitAddress(String loginLimitAddress){
this.loginLimitAddress = loginLimitAddress;
}
/**
* 获取 用户名
* @return String
*/
* 获取 用户名
* @return String
*/
public String getRealName(){
return realName;
}
......@@ -148,107 +148,118 @@ public class UserEntity extends UserVo implements IUser {
}
/**
* 设置 用户名
* @param realName
*/
* 设置 用户名
* @param realName
*/
public void setRealName(String realName){
this.realName = realName;
}
/**
* 获取 用户手机号
* @return String
*/
* 获取 用户手机号
* @return String
*/
public String getMobile(){
return mobile;
}
/**
* 设置 用户手机号
* @param mobile
*/
* 设置 用户手机号
* @param mobile
*/
public void setMobile(String mobile){
this.mobile = mobile;
}
/**
* 获取 用户联系电话
* @return String
*/
* 获取 用户联系电话
* @return String
*/
public String getPhone(){
return phone;
}
/**
* 设置 用户联系电话
* @param phone
*/
* 设置 用户联系电话
* @param phone
*/
public void setPhone(String phone){
this.phone = phone;
}
/**
* 获取 用户邮箱
* @return String
*/
* 获取 用户邮箱
* @return String
*/
public String getEmail(){
return email;
}
/**
* 设置 用户邮箱
* @param email
*/
* 设置 用户邮箱
* @param email
*/
public void setEmail(String email){
this.email = email;
}
/**
* 获取 QQ号码
* @return String
*/
* 获取 QQ号码
* @return String
*/
public String getQq(){
return qq;
}
/**
* 设置 QQ号码
* @param qq
*/
* 设置 QQ号码
* @param qq
*/
public void setQq(String qq){
this.qq = qq;
}
/**
* 获取 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @return Integer
*/
* 获取 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @return Integer
*/
public Integer getUserType(){
return userType;
}
/**
* 设置 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userType
*/
* 设置 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userType
*/
public void setUserType(Integer userType){
this.userType = userType;
}
/**
* 获取 { "授权站点": { "站点信息": [ { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" } ] }}
* @return String
*/
public String getSiteInfo(){
return siteInfo;
* 获取 所属站点id,多个逗号分隔
* @return String
*/
public String getSiteIds(){
return siteIds;
}
@Override
public Long getCustomerJoinId() {
return null;
}
@Override
public String getCustomerNum() {
return null;
}
/**
* 设置 { "授权站点": { "站点信息": [ { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" } ] }}
* @param siteInfo
*/
public void setSiteInfo(String siteInfo){
this.siteInfo = siteInfo;
* 设置 所属站点id,多个逗号分隔
* @param siteIds
*/
public void setSiteIds(String siteIds){
this.siteIds = siteIds;
}
/**
* 获取 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @return Integer
*/
* 获取 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @return Integer
*/
public Integer getStatus(){
return status;
}
/**
* 设置 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param status
*/
* 设置 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param status
*/
public void setStatus(Integer status){
this.status = status;
}
......@@ -264,9 +275,9 @@ public class UserEntity extends UserVo implements IUser {
}
/**
* 获取 客户ID
* @return Long
*/
* 获取 客户ID
* @return Long
*/
public Long getCustomerId(){
return customerId;
}
......@@ -276,62 +287,52 @@ public class UserEntity extends UserVo implements IUser {
return null;
}
@Override
public Long getCustomerJoinId() {
return null;
}
@Override
public String getCustomerNum() {
return null;
}
/**
* 设置 客户ID
* @param customerId
*/
* 设置 客户ID
* @param customerId
*/
public void setCustomerId(Long customerId){
this.customerId = customerId;
}
/**
* 获取 创建用户名称
* @return String
*/
* 获取 创建用户名称
* @return String
*/
public String getCreateUserName(){
return createUserName;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
* 设置 创建用户名称
* @param createUserName
*/
public void setCreateUserName(String createUserName){
this.createUserName = createUserName;
}
/**
* 获取 最后一次登录时间
* @return Date
*/
* 获取 最后一次登录时间
* @return Date
*/
public Date getLastLoginTime(){
return lastLoginTime;
}
/**
* 设置 最后一次登录时间
* @param lastLoginTime
*/
* 设置 最后一次登录时间
* @param lastLoginTime
*/
public void setLastLoginTime(Date lastLoginTime){
this.lastLoginTime = lastLoginTime;
}
/**
* 获取 最后一次登录地址
* @return String
*/
* 获取 最后一次登录地址
* @return String
*/
public String getLastLoginAddress(){
return lastLoginAddress;
}
/**
* 设置 最后一次登录地址
* @param lastLoginAddress
*/
* 设置 最后一次登录地址
* @param lastLoginAddress
*/
public void setLastLoginAddress(String lastLoginAddress){
this.lastLoginAddress = lastLoginAddress;
}
......@@ -341,7 +342,7 @@ public class UserEntity extends UserVo implements IUser {
@Override
public int hashCode() {
return this.getId().hashCode();
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
......@@ -349,7 +350,7 @@ public class UserEntity extends UserVo implements IUser {
if (obj instanceof UserEntity) {
UserEntity tmp = (UserEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
return true;
}
}
return false;
......@@ -366,7 +367,7 @@ public class UserEntity extends UserVo implements IUser {
sb.append(",email:").append(getEmail());
sb.append(",qq:").append(getQq());
sb.append(",userType:").append(getUserType());
sb.append(",siteInfo:").append(getSiteInfo());
sb.append(",siteIds:").append(getSiteIds());
sb.append(",status:").append(getStatus());
sb.append(",customerId:").append(getCustomerId());
sb.append(",createUserName:").append(getCreateUserName());
......@@ -377,34 +378,34 @@ public class UserEntity extends UserVo implements IUser {
public void initAttrValue(){
this.loginName = "";
this.loginName = "";
this.loginPwd = "";
this.loginPwd = "";
this.loginLimitAddress = "";
this.loginLimitAddress = "";
this.realName = "";
this.realName = "";
this.mobile = "";
this.mobile = "";
this.phone = "";
this.phone = "";
this.email = "";
this.email = "";
this.qq = "";
this.qq = "";
this.userType = null;
this.userType = null;
this.siteInfo = "";
this.siteIds = "";
this.status = 1;
this.status = 1;
this.customerId = null;
this.customerId = null;
this.createUserName = "";
this.createUserName = "";
this.lastLoginTime = null;
this.lastLoginTime = null;
this.lastLoginAddress = "";
this.lastLoginAddress = "";
}
}
\ No newline at end of file
portal-manager/src/main/java/com/mortals/xhx/module/user/model/UserQuery.java
View file @ 945f2d4f
......@@ -4,11 +4,11 @@ import java.util.Date;
import java.util.List;
import com.mortals.xhx.module.user.model.UserEntity;
/**
* 用户信息业务查询对象
*
* @author zxfei
* @date 2022-05-25
*/
* 用户信息业务查询对象
*
* @author zxfei
* @date 2022-05-26
*/
public class UserQuery extends UserEntity {
/** 开始 用户ID，主键，自增长 */
private Long idStart;
......@@ -58,8 +58,8 @@ public class UserQuery extends UserEntity {
/** 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2列表 */
private List <Integer> userTypeList;
/** { "授权站点": { "站点信息": [ { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" } ] }} */
private List<String> siteInfoList;
/** 所属站点id,多个逗号分隔 */
private List<String> siteIdsList;
/** 开始 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1 */
private Integer statusStart;
......@@ -124,1018 +124,1018 @@ public class UserQuery extends UserEntity {
public UserQuery(){}
/**
* 获取 开始 用户ID，主键，自增长
* @return idStart
*/
* 获取 开始 用户ID，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 用户ID，主键，自增长
* @param idStart
*/
* 设置 开始 用户ID，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 用户ID，主键，自增长
* @return $idEnd
*/
* 获取 结束 用户ID，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 用户ID，主键，自增长
* @param idEnd
*/
* 设置 结束 用户ID，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 用户ID，主键，自增长
* @return idIncrement
*/
* 获取 增加 用户ID，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 用户ID，主键，自增长
* @param idIncrement
*/
* 设置 增加 用户ID，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 用户ID，主键，自增长
* @return idList
*/
* 获取 用户ID，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 用户ID，主键，自增长
* @param idList
*/
* 设置 用户ID，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 登录名
* @return loginNameList
*/
* 获取 登录名
* @return loginNameList
*/
public List<String> getLoginNameList(){
return this.loginNameList;
}
/**
* 设置 登录名
* @param loginNameList
*/
* 设置 登录名
* @param loginNameList
*/
public void setLoginNameList(List<String> loginNameList){
this.loginNameList = loginNameList;
}
/**
* 获取 登录密码，使用md5双次加密
* @return loginPwdList
*/
* 获取 登录密码，使用md5双次加密
* @return loginPwdList
*/
public List<String> getLoginPwdList(){
return this.loginPwdList;
}
/**
* 设置 登录密码，使用md5双次加密
* @param loginPwdList
*/
* 设置 登录密码，使用md5双次加密
* @param loginPwdList
*/
public void setLoginPwdList(List<String> loginPwdList){
this.loginPwdList = loginPwdList;
}
/**
* 获取 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @return loginLimitAddressList
*/
* 获取 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @return loginLimitAddressList
*/
public List<String> getLoginLimitAddressList(){
return this.loginLimitAddressList;
}
/**
* 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @param loginLimitAddressList
*/
* 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @param loginLimitAddressList
*/
public void setLoginLimitAddressList(List<String> loginLimitAddressList){
this.loginLimitAddressList = loginLimitAddressList;
}
/**
* 获取 用户名
* @return realNameList
*/
* 获取 用户名
* @return realNameList
*/
public List<String> getRealNameList(){
return this.realNameList;
}
/**
* 设置 用户名
* @param realNameList
*/
* 设置 用户名
* @param realNameList
*/
public void setRealNameList(List<String> realNameList){
this.realNameList = realNameList;
}
/**
* 获取 用户手机号
* @return mobileList
*/
* 获取 用户手机号
* @return mobileList
*/
public List<String> getMobileList(){
return this.mobileList;
}
/**
* 设置 用户手机号
* @param mobileList
*/
* 设置 用户手机号
* @param mobileList
*/
public void setMobileList(List<String> mobileList){
this.mobileList = mobileList;
}
/**
* 获取 用户联系电话
* @return phoneList
*/
* 获取 用户联系电话
* @return phoneList
*/
public List<String> getPhoneList(){
return this.phoneList;
}
/**
* 设置 用户联系电话
* @param phoneList
*/
* 设置 用户联系电话
* @param phoneList
*/
public void setPhoneList(List<String> phoneList){
this.phoneList = phoneList;
}
/**
* 获取 用户邮箱
* @return emailList
*/
* 获取 用户邮箱
* @return emailList
*/
public List<String> getEmailList(){
return this.emailList;
}
/**
* 设置 用户邮箱
* @param emailList
*/
* 设置 用户邮箱
* @param emailList
*/
public void setEmailList(List<String> emailList){
this.emailList = emailList;
}
/**
* 获取 QQ号码
* @return qqList
*/
* 获取 QQ号码
* @return qqList
*/
public List<String> getQqList(){
return this.qqList;
}
/**
* 设置 QQ号码
* @param qqList
*/
* 设置 QQ号码
* @param qqList
*/
public void setQqList(List<String> qqList){
this.qqList = qqList;
}
/**
* 获取 开始 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @return userTypeStart
*/
* 获取 开始 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @return userTypeStart
*/
public Integer getUserTypeStart(){
return this.userTypeStart;
}
/**
* 设置 开始 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeStart
*/
* 设置 开始 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeStart
*/
public void setUserTypeStart(Integer userTypeStart){
this.userTypeStart = userTypeStart;
}
/**
* 获取 结束 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @return $userTypeEnd
*/
* 获取 结束 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @return $userTypeEnd
*/
public Integer getUserTypeEnd(){
return this.userTypeEnd;
}
/**
* 设置 结束 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeEnd
*/
* 设置 结束 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeEnd
*/
public void setUserTypeEnd(Integer userTypeEnd){
this.userTypeEnd = userTypeEnd;
}
/**
* 获取 增加 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @return userTypeIncrement
*/
* 获取 增加 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @return userTypeIncrement
*/
public Integer getUserTypeIncrement(){
return this.userTypeIncrement;
}
/**
* 设置 增加 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeIncrement
*/
* 设置 增加 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeIncrement
*/
public void setUserTypeIncrement(Integer userTypeIncrement){
this.userTypeIncrement = userTypeIncrement;
}
/**
* 获取 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @return userTypeList
*/
* 获取 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @return userTypeList
*/
public List<Integer> getUserTypeList(){
return this.userTypeList;
}
/**
* 设置 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeList
*/
* 设置 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeList
*/
public void setUserTypeList(List<Integer> userTypeList){
this.userTypeList = userTypeList;
}
/**
* 获取 { "授权站点": { "站点信息": [ { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" } ] }}
* @return siteInfoList
*/
public List<String> getSiteInfoList(){
return this.siteInfoList;
* 获取 所属站点id,多个逗号分隔
* @return siteIdsList
*/
public List<String> getSiteIdsList(){
return this.siteIdsList;
}
/**
* 设置 { "授权站点": { "站点信息": [ { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" } ] }}
* @param siteInfoList
*/
public void setSiteInfoList(List<String> siteInfoList){
this.siteInfoList = siteInfoList;
* 设置 所属站点id,多个逗号分隔
* @param siteIdsList
*/
public void setSiteIdsList(List<String> siteIdsList){
this.siteIdsList = siteIdsList;
}
/**
* 获取 开始 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @return statusStart
*/
* 获取 开始 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @return statusStart
*/
public Integer getStatusStart(){
return this.statusStart;
}
/**
* 设置 开始 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusStart
*/
* 设置 开始 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusStart
*/
public void setStatusStart(Integer statusStart){
this.statusStart = statusStart;
}
/**
* 获取 结束 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @return $statusEnd
*/
* 获取 结束 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @return $statusEnd
*/
public Integer getStatusEnd(){
return this.statusEnd;
}
/**
* 设置 结束 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusEnd
*/
* 设置 结束 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusEnd
*/
public void setStatusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
}
/**
* 获取 增加 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @return statusIncrement
*/
* 获取 增加 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @return statusIncrement
*/
public Integer getStatusIncrement(){
return this.statusIncrement;
}
/**
* 设置 增加 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusIncrement
*/
* 设置 增加 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusIncrement
*/
public void setStatusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
}
/**
* 获取 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @return statusList
*/
* 获取 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @return statusList
*/
public List<Integer> getStatusList(){
return this.statusList;
}
/**
* 设置 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusList
*/
* 设置 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusList
*/
public void setStatusList(List<Integer> statusList){
this.statusList = statusList;
}
/**
* 获取 开始 客户ID
* @return customerIdStart
*/
* 获取 开始 客户ID
* @return customerIdStart
*/
public Long getCustomerIdStart(){
return this.customerIdStart;
}
/**
* 设置 开始 客户ID
* @param customerIdStart
*/
* 设置 开始 客户ID
* @param customerIdStart
*/
public void setCustomerIdStart(Long customerIdStart){
this.customerIdStart = customerIdStart;
}
/**
* 获取 结束 客户ID
* @return $customerIdEnd
*/
* 获取 结束 客户ID
* @return $customerIdEnd
*/
public Long getCustomerIdEnd(){
return this.customerIdEnd;
}
/**
* 设置 结束 客户ID
* @param customerIdEnd
*/
* 设置 结束 客户ID
* @param customerIdEnd
*/
public void setCustomerIdEnd(Long customerIdEnd){
this.customerIdEnd = customerIdEnd;
}
/**
* 获取 增加 客户ID
* @return customerIdIncrement
*/
* 获取 增加 客户ID
* @return customerIdIncrement
*/
public Long getCustomerIdIncrement(){
return this.customerIdIncrement;
}
/**
* 设置 增加 客户ID
* @param customerIdIncrement
*/
* 设置 增加 客户ID
* @param customerIdIncrement
*/
public void setCustomerIdIncrement(Long customerIdIncrement){
this.customerIdIncrement = customerIdIncrement;
}
/**
* 获取 客户ID
* @return customerIdList
*/
* 获取 客户ID
* @return customerIdList
*/
public List<Long> getCustomerIdList(){
return this.customerIdList;
}
/**
* 设置 客户ID
* @param customerIdList
*/
* 设置 客户ID
* @param customerIdList
*/
public void setCustomerIdList(List<Long> customerIdList){
this.customerIdList = customerIdList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 创建用户名称
* @return createUserNameList
*/
* 获取 创建用户名称
* @return createUserNameList
*/
public List<String> getCreateUserNameList(){
return this.createUserNameList;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
* 设置 创建用户名称
* @param createUserNameList
*/
public void setCreateUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
}
/**
* 获取 开始 最后一次登录时间
* @return lastLoginTimeStart
*/
* 获取 开始 最后一次登录时间
* @return lastLoginTimeStart
*/
public String getLastLoginTimeStart(){
return this.lastLoginTimeStart;
}
/**
* 设置 开始 最后一次登录时间
* @param lastLoginTimeStart
*/
* 设置 开始 最后一次登录时间
* @param lastLoginTimeStart
*/
public void setLastLoginTimeStart(String lastLoginTimeStart){
this.lastLoginTimeStart = lastLoginTimeStart;
}
/**
* 获取 结束 最后一次登录时间
* @return lastLoginTimeEnd
*/
* 获取 结束 最后一次登录时间
* @return lastLoginTimeEnd
*/
public String getLastLoginTimeEnd(){
return this.lastLoginTimeEnd;
}
/**
* 设置 结束 最后一次登录时间
* @param lastLoginTimeEnd
*/
* 设置 结束 最后一次登录时间
* @param lastLoginTimeEnd
*/
public void setLastLoginTimeEnd(String lastLoginTimeEnd){
this.lastLoginTimeEnd = lastLoginTimeEnd;
}
/**
* 获取 最后一次登录地址
* @return lastLoginAddressList
*/
* 获取 最后一次登录地址
* @return lastLoginAddressList
*/
public List<String> getLastLoginAddressList(){
return this.lastLoginAddressList;
}
/**
* 设置 最后一次登录地址
* @param lastLoginAddressList
*/
* 设置 最后一次登录地址
* @param lastLoginAddressList
*/
public void setLastLoginAddressList(List<String> lastLoginAddressList){
this.lastLoginAddressList = lastLoginAddressList;
}
/**
* 设置 用户ID，主键，自增长
* @param id
*/
* 设置 用户ID，主键，自增长
* @param id
*/
public UserQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 用户ID，主键，自增长
* @param idStart
*/
setId(id);
return this;
}
/**
* 设置 开始 用户ID，主键，自增长
* @param idStart
*/
public UserQuery idStart(Long idStart){
this.idStart = idStart;
return this;
this.idStart = idStart;
return this;
}
/**
* 设置 结束 用户ID，主键，自增长
* @param idEnd
*/
* 设置 结束 用户ID，主键，自增长
* @param idEnd
*/
public UserQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 用户ID，主键，自增长
* @param idIncrement
*/
* 设置 增加 用户ID，主键，自增长
* @param idIncrement
*/
public UserQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 用户ID，主键，自增长
* @param idList
*/
* 设置 用户ID，主键，自增长
* @param idList
*/
public UserQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
return this;
}
/**
* 设置 登录名
* @param loginName
*/
/**
* 设置 登录名
* @param loginName
*/
public UserQuery loginName(String loginName){
setLoginName(loginName);
return this;
return this;
}
/**
* 设置 登录名
* @param loginNameList
*/
* 设置 登录名
* @param loginNameList
*/
public UserQuery loginNameList(List<String> loginNameList){
this.loginNameList = loginNameList;
return this;
return this;
}
/**
* 设置 登录密码，使用md5双次加密
* @param loginPwd
*/
/**
* 设置 登录密码，使用md5双次加密
* @param loginPwd
*/
public UserQuery loginPwd(String loginPwd){
setLoginPwd(loginPwd);
return this;
return this;
}
/**
* 设置 登录密码，使用md5双次加密
* @param loginPwdList
*/
* 设置 登录密码，使用md5双次加密
* @param loginPwdList
*/
public UserQuery loginPwdList(List<String> loginPwdList){
this.loginPwdList = loginPwdList;
return this;
return this;
}
/**
* 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @param loginLimitAddress
*/
/**
* 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @param loginLimitAddress
*/
public UserQuery loginLimitAddress(String loginLimitAddress){
setLoginLimitAddress(loginLimitAddress);
return this;
return this;
}
/**
* 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @param loginLimitAddressList
*/
* 设置 登录限制地址，多个IP地址用逗号分隔，可以使用IP段匹配，如：172.17.*非空：则只能该值内的IP可以登录
* @param loginLimitAddressList
*/
public UserQuery loginLimitAddressList(List<String> loginLimitAddressList){
this.loginLimitAddressList = loginLimitAddressList;
return this;
return this;
}
/**
* 设置 用户名
* @param realName
*/
/**
* 设置 用户名
* @param realName
*/
public UserQuery realName(String realName){
setRealName(realName);
return this;
return this;
}
/**
* 设置 用户名
* @param realNameList
*/
* 设置 用户名
* @param realNameList
*/
public UserQuery realNameList(List<String> realNameList){
this.realNameList = realNameList;
return this;
return this;
}
/**
* 设置 用户手机号
* @param mobile
*/
/**
* 设置 用户手机号
* @param mobile
*/
public UserQuery mobile(String mobile){
setMobile(mobile);
return this;
return this;
}
/**
* 设置 用户手机号
* @param mobileList
*/
* 设置 用户手机号
* @param mobileList
*/
public UserQuery mobileList(List<String> mobileList){
this.mobileList = mobileList;
return this;
return this;
}
/**
* 设置 用户联系电话
* @param phone
*/
/**
* 设置 用户联系电话
* @param phone
*/
public UserQuery phone(String phone){
setPhone(phone);
return this;
return this;
}
/**
* 设置 用户联系电话
* @param phoneList
*/
* 设置 用户联系电话
* @param phoneList
*/
public UserQuery phoneList(List<String> phoneList){
this.phoneList = phoneList;
return this;
return this;
}
/**
* 设置 用户邮箱
* @param email
*/
/**
* 设置 用户邮箱
* @param email
*/
public UserQuery email(String email){
setEmail(email);
return this;
return this;
}
/**
* 设置 用户邮箱
* @param emailList
*/
* 设置 用户邮箱
* @param emailList
*/
public UserQuery emailList(List<String> emailList){
this.emailList = emailList;
return this;
return this;
}
/**
* 设置 QQ号码
* @param qq
*/
/**
* 设置 QQ号码
* @param qq
*/
public UserQuery qq(String qq){
setQq(qq);
return this;
return this;
}
/**
* 设置 QQ号码
* @param qqList
*/
* 设置 QQ号码
* @param qqList
*/
public UserQuery qqList(List<String> qqList){
this.qqList = qqList;
return this;
return this;
}
/**
* 设置 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userType
*/
* 设置 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userType
*/
public UserQuery userType(Integer userType){
setUserType(userType);
return this;
}
/**
* 设置 开始 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeStart
*/
setUserType(userType);
return this;
}
/**
* 设置 开始 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeStart
*/
public UserQuery userTypeStart(Integer userTypeStart){
this.userTypeStart = userTypeStart;
return this;
this.userTypeStart = userTypeStart;
return this;
}
/**
* 设置 结束 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeEnd
*/
* 设置 结束 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeEnd
*/
public UserQuery userTypeEnd(Integer userTypeEnd){
this.userTypeEnd = userTypeEnd;
return this;
this.userTypeEnd = userTypeEnd;
return this;
}
/**
* 设置 增加 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeIncrement
*/
* 设置 增加 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeIncrement
*/
public UserQuery userTypeIncrement(Integer userTypeIncrement){
this.userTypeIncrement = userTypeIncrement;
return this;
this.userTypeIncrement = userTypeIncrement;
return this;
}
/**
* 设置 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeList
*/
* 设置 用户类型，0：系统用户 1:普通用户 2:工作人员，默认2
* @param userTypeList
*/
public UserQuery userTypeList(List<Integer> userTypeList){
this.userTypeList = userTypeList;
return this;
}
return this;
}
/**
* 设置 { "授权站点": { "站点信息": [ { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" } ] }}
* @param siteInfo
*/
public UserQuery siteInfo(String siteInfo){
setSiteInfo(siteInfo);
return this;
/**
* 设置 所属站点id,多个逗号分隔
* @param siteIds
*/
public UserQuery siteIds(String siteIds){
setSiteIds(siteIds);
return this;
}
/**
* 设置 { "授权站点": { "站点信息": [ { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" }, { "站点ID": "1", "站点名称": "1", "站点对应的区域ID": "", "站点对应的区域名称": "" } ] }}
* @param siteInfoList
*/
public UserQuery siteInfoList(List<String> siteInfoList){
this.siteInfoList = siteInfoList;
return this;
* 设置 所属站点id,多个逗号分隔
* @param siteIdsList
*/
public UserQuery siteIdsList(List<String> siteIdsList){
this.siteIdsList = siteIdsList;
return this;
}
/**
* 设置 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param status
*/
* 设置 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param status
*/
public UserQuery status(Integer status){
setStatus(status);
return this;
}
/**
* 设置 开始 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusStart
*/
setStatus(status);
return this;
}
/**
* 设置 开始 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusStart
*/
public UserQuery statusStart(Integer statusStart){
this.statusStart = statusStart;
return this;
this.statusStart = statusStart;
return this;
}
/**
* 设置 结束 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusEnd
*/
* 设置 结束 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusEnd
*/
public UserQuery statusEnd(Integer statusEnd){
this.statusEnd = statusEnd;
return this;
this.statusEnd = statusEnd;
return this;
}
/**
* 设置 增加 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusIncrement
*/
* 设置 增加 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusIncrement
*/
public UserQuery statusIncrement(Integer statusIncrement){
this.statusIncrement = statusIncrement;
return this;
this.statusIncrement = statusIncrement;
return this;
}
/**
* 设置 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusList
*/
* 设置 用户状态，0：停用，1：正常，2：冻结，3：销户，4：离职，默认1
* @param statusList
*/
public UserQuery statusList(List<Integer> statusList){
this.statusList = statusList;
return this;
}
return this;
}
/**
* 设置 客户ID
* @param customerId
*/
* 设置 客户ID
* @param customerId
*/
public UserQuery customerId(Long customerId){
setCustomerId(customerId);
return this;
}
/**
* 设置 开始 客户ID
* @param customerIdStart
*/
setCustomerId(customerId);
return this;
}
/**
* 设置 开始 客户ID
* @param customerIdStart
*/
public UserQuery customerIdStart(Long customerIdStart){
this.customerIdStart = customerIdStart;
return this;
this.customerIdStart = customerIdStart;
return this;
}
/**
* 设置 结束 客户ID
* @param customerIdEnd
*/
* 设置 结束 客户ID
* @param customerIdEnd
*/
public UserQuery customerIdEnd(Long customerIdEnd){
this.customerIdEnd = customerIdEnd;
return this;
this.customerIdEnd = customerIdEnd;
return this;
}
/**
* 设置 增加 客户ID
* @param customerIdIncrement
*/
* 设置 增加 客户ID
* @param customerIdIncrement
*/
public UserQuery customerIdIncrement(Long customerIdIncrement){
this.customerIdIncrement = customerIdIncrement;
return this;
this.customerIdIncrement = customerIdIncrement;
return this;
}
/**
* 设置 客户ID
* @param customerIdList
*/
* 设置 客户ID
* @param customerIdList
*/
public UserQuery customerIdList(List<Long> customerIdList){
this.customerIdList = customerIdList;
return this;
}
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
* 设置 创建用户
* @param createUserId
*/
public UserQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public UserQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public UserQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public UserQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
* 设置 创建用户
* @param createUserIdList
*/
public UserQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
return this;
}
/**
* 设置 创建用户名称
* @param createUserName
*/
/**
* 设置 创建用户名称
* @param createUserName
*/
public UserQuery createUserName(String createUserName){
setCreateUserName(createUserName);
return this;
return this;
}
/**
* 设置 创建用户名称
* @param createUserNameList
*/
* 设置 创建用户名称
* @param createUserNameList
*/
public UserQuery createUserNameList(List<String> createUserNameList){
this.createUserNameList = createUserNameList;
return this;
return this;
}
/**
* 设置 最后一次登录地址
* @param lastLoginAddress
*/
/**
* 设置 最后一次登录地址
* @param lastLoginAddress
*/
public UserQuery lastLoginAddress(String lastLoginAddress){
setLastLoginAddress(lastLoginAddress);
return this;
return this;
}
/**
* 设置 最后一次登录地址
* @param lastLoginAddressList
*/
* 设置 最后一次登录地址
* @param lastLoginAddressList
*/
public UserQuery lastLoginAddressList(List<String> lastLoginAddressList){
this.lastLoginAddressList = lastLoginAddressList;
return this;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<UserQuery> getOrConditionList(){
return this.orConditionList;
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param 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<UserQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<UserQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param 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<UserQuery> andConditionList){
this.andConditionList = andConditionList;
}
......
portal-manager/src/main/resources/sqlmap/module/menu/MenuMapper.xml 0 → 100644
View file @ 945f2d4f
<?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.menu.dao.ibatis.MenuDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="MenuEntity" id="MenuEntity-Map">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="url" column="url" />
<result property="parentId" column="parentId" />
<result property="orderId" column="orderId" />
<result property="status" column="status" />
<result property="linkType" column="linkType" />
<result property="groupId" column="groupId" />
<result property="groupName" column="groupName" />
<result property="imgPath" column="imgPath" />
<result property="buttonImgPath" column="buttonImgPath" />
<result property="imgCommPath" column="imgCommPath" />
<result property="commMenu" column="commMenu" />
<result property="menuType" column="menuType" />
<result property="authType" column="authType" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</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('url') or colPickMode == 1 and data.containsKey('url')))">
a.url,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('parentId') or colPickMode == 1 and data.containsKey('parentId')))">
a.parentId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('orderId') or colPickMode == 1 and data.containsKey('orderId')))">
a.orderId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('status') or colPickMode == 1 and data.containsKey('status')))">
a.status,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('linkType') or colPickMode == 1 and data.containsKey('linkType')))">
a.linkType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupId') or colPickMode == 1 and data.containsKey('groupId')))">
a.groupId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('groupName') or colPickMode == 1 and data.containsKey('groupName')))">
a.groupName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('imgPath') or colPickMode == 1 and data.containsKey('imgPath')))">
a.imgPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('buttonImgPath') or colPickMode == 1 and data.containsKey('buttonImgPath')))">
a.buttonImgPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('imgCommPath') or colPickMode == 1 and data.containsKey('imgCommPath')))">
a.imgCommPath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('commMenu') or colPickMode == 1 and data.containsKey('commMenu')))">
a.commMenu,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('menuType') or colPickMode == 1 and data.containsKey('menuType')))">
a.menuType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('authType') or colPickMode == 1 and data.containsKey('authType')))">
a.authType,
</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('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserName') or colPickMode == 1 and data.containsKey('createUserName')))">
a.createUserName,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="MenuEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_menu
(name,url,parentId,orderId,status,linkType,groupId,groupName,imgPath,buttonImgPath,imgCommPath,commMenu,menuType,authType,createTime,createUserId,createUserName)
VALUES
(#{name},#{url},#{parentId},#{orderId},#{status},#{linkType},#{groupId},#{groupName},#{imgPath},#{buttonImgPath},#{imgCommPath},#{commMenu},#{menuType},#{authType},#{createTime},#{createUserId},#{createUserName})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_menu
(name,url,parentId,orderId,status,linkType,groupId,groupName,imgPath,buttonImgPath,imgCommPath,commMenu,menuType,authType,createTime,createUserId,createUserName)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.url},#{item.parentId},#{item.orderId},#{item.status},#{item.linkType},#{item.groupId},#{item.groupName},#{item.imgPath},#{item.buttonImgPath},#{item.imgCommPath},#{item.commMenu},#{item.menuType},#{item.authType},#{item.createTime},#{item.createUserId},#{item.createUserName})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_menu as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('name')) or (colPickMode==1 and !data.containsKey('name'))">
a.name=#{data.name},
</if>
<if test="(colPickMode==0 and data.containsKey('url')) or (colPickMode==1 and !data.containsKey('url'))">
a.url=#{data.url},
</if>
<if test="(colPickMode==0 and data.containsKey('parentId')) or (colPickMode==1 and !data.containsKey('parentId'))">
a.parentId=#{data.parentId},
</if>
<if test="(colPickMode==0 and data.containsKey('parentIdIncrement')) or (colPickMode==1 and !data.containsKey('parentIdIncrement'))">
a.parentId=ifnull(a.parentId,0) + #{data.parentIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('orderId')) or (colPickMode==1 and !data.containsKey('orderId'))">
a.orderId=#{data.orderId},
</if>
<if test="(colPickMode==0 and data.containsKey('orderIdIncrement')) or (colPickMode==1 and !data.containsKey('orderIdIncrement'))">
a.orderId=ifnull(a.orderId,0) + #{data.orderIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('status')) or (colPickMode==1 and !data.containsKey('status'))">
a.status=#{data.status},
</if>
<if test="(colPickMode==0 and data.containsKey('statusIncrement')) or (colPickMode==1 and !data.containsKey('statusIncrement'))">
a.status=ifnull(a.status,0) + #{data.statusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('linkType')) or (colPickMode==1 and !data.containsKey('linkType'))">
a.linkType=#{data.linkType},
</if>
<if test="(colPickMode==0 and data.containsKey('linkTypeIncrement')) or (colPickMode==1 and !data.containsKey('linkTypeIncrement'))">
a.linkType=ifnull(a.linkType,0) + #{data.linkTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('groupId')) or (colPickMode==1 and !data.containsKey('groupId'))">
a.groupId=#{data.groupId},
</if>
<if test="(colPickMode==0 and data.containsKey('groupIdIncrement')) or (colPickMode==1 and !data.containsKey('groupIdIncrement'))">
a.groupId=ifnull(a.groupId,0) + #{data.groupIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('groupName')) or (colPickMode==1 and !data.containsKey('groupName'))">
a.groupName=#{data.groupName},
</if>
<if test="(colPickMode==0 and data.containsKey('imgPath')) or (colPickMode==1 and !data.containsKey('imgPath'))">
a.imgPath=#{data.imgPath},
</if>
<if test="(colPickMode==0 and data.containsKey('buttonImgPath')) or (colPickMode==1 and !data.containsKey('buttonImgPath'))">
a.buttonImgPath=#{data.buttonImgPath},
</if>
<if test="(colPickMode==0 and data.containsKey('imgCommPath')) or (colPickMode==1 and !data.containsKey('imgCommPath'))">
a.imgCommPath=#{data.imgCommPath},
</if>
<if test="(colPickMode==0 and data.containsKey('commMenu')) or (colPickMode==1 and !data.containsKey('commMenu'))">
a.commMenu=#{data.commMenu},
</if>
<if test="(colPickMode==0 and data.containsKey('commMenuIncrement')) or (colPickMode==1 and !data.containsKey('commMenuIncrement'))">
a.commMenu=ifnull(a.commMenu,0) + #{data.commMenuIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('menuType')) or (colPickMode==1 and !data.containsKey('menuType'))">
a.menuType=#{data.menuType},
</if>
<if test="(colPickMode==0 and data.containsKey('menuTypeIncrement')) or (colPickMode==1 and !data.containsKey('menuTypeIncrement'))">
a.menuType=ifnull(a.menuType,0) + #{data.menuTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('authType')) or (colPickMode==1 and !data.containsKey('authType'))">
a.authType=#{data.authType},
</if>
<if test="(colPickMode==0 and data.containsKey('authTypeIncrement')) or (colPickMode==1 and !data.containsKey('authTypeIncrement'))">
a.authType=ifnull(a.authType,0) + #{data.authTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserName')) or (colPickMode==1 and !data.containsKey('createUserName'))">
a.createUserName=#{data.createUserName},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_menu as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="name=(case" suffix="ELSE name end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
when a.id=#{item.id} then #{item.name}
</if>
</foreach>
</trim>
<trim prefix="url=(case" suffix="ELSE url end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('url')) or (colPickMode==1 and !item.containsKey('url'))">
when a.id=#{item.id} then #{item.url}
</if>
</foreach>
</trim>
<trim prefix="parentId=(case" suffix="ELSE parentId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('parentId')) or (colPickMode==1 and !item.containsKey('parentId'))">
when a.id=#{item.id} then #{item.parentId}
</when>
<when test="(colPickMode==0 and item.containsKey('parentIdIncrement')) or (colPickMode==1 and !item.containsKey('parentIdIncrement'))">
when a.id=#{item.id} then ifnull(a.parentId,0) + #{item.parentIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="orderId=(case" suffix="ELSE orderId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('orderId')) or (colPickMode==1 and !item.containsKey('orderId'))">
when a.id=#{item.id} then #{item.orderId}
</when>
<when test="(colPickMode==0 and item.containsKey('orderIdIncrement')) or (colPickMode==1 and !item.containsKey('orderIdIncrement'))">
when a.id=#{item.id} then ifnull(a.orderId,0) + #{item.orderIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="status=(case" suffix="ELSE status end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('status')) or (colPickMode==1 and !item.containsKey('status'))">
when a.id=#{item.id} then #{item.status}
</when>
<when test="(colPickMode==0 and item.containsKey('statusIncrement')) or (colPickMode==1 and !item.containsKey('statusIncrement'))">
when a.id=#{item.id} then ifnull(a.status,0) + #{item.statusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="linkType=(case" suffix="ELSE linkType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('linkType')) or (colPickMode==1 and !item.containsKey('linkType'))">
when a.id=#{item.id} then #{item.linkType}
</when>
<when test="(colPickMode==0 and item.containsKey('linkTypeIncrement')) or (colPickMode==1 and !item.containsKey('linkTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.linkType,0) + #{item.linkTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="groupId=(case" suffix="ELSE groupId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('groupId')) or (colPickMode==1 and !item.containsKey('groupId'))">
when a.id=#{item.id} then #{item.groupId}
</when>
<when test="(colPickMode==0 and item.containsKey('groupIdIncrement')) or (colPickMode==1 and !item.containsKey('groupIdIncrement'))">
when a.id=#{item.id} then ifnull(a.groupId,0) + #{item.groupIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="groupName=(case" suffix="ELSE groupName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('groupName')) or (colPickMode==1 and !item.containsKey('groupName'))">
when a.id=#{item.id} then #{item.groupName}
</if>
</foreach>
</trim>
<trim prefix="imgPath=(case" suffix="ELSE imgPath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('imgPath')) or (colPickMode==1 and !item.containsKey('imgPath'))">
when a.id=#{item.id} then #{item.imgPath}
</if>
</foreach>
</trim>
<trim prefix="buttonImgPath=(case" suffix="ELSE buttonImgPath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('buttonImgPath')) or (colPickMode==1 and !item.containsKey('buttonImgPath'))">
when a.id=#{item.id} then #{item.buttonImgPath}
</if>
</foreach>
</trim>
<trim prefix="imgCommPath=(case" suffix="ELSE imgCommPath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('imgCommPath')) or (colPickMode==1 and !item.containsKey('imgCommPath'))">
when a.id=#{item.id} then #{item.imgCommPath}
</if>
</foreach>
</trim>
<trim prefix="commMenu=(case" suffix="ELSE commMenu end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('commMenu')) or (colPickMode==1 and !item.containsKey('commMenu'))">
when a.id=#{item.id} then #{item.commMenu}
</when>
<when test="(colPickMode==0 and item.containsKey('commMenuIncrement')) or (colPickMode==1 and !item.containsKey('commMenuIncrement'))">
when a.id=#{item.id} then ifnull(a.commMenu,0) + #{item.commMenuIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="menuType=(case" suffix="ELSE menuType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('menuType')) or (colPickMode==1 and !item.containsKey('menuType'))">
when a.id=#{item.id} then #{item.menuType}
</when>
<when test="(colPickMode==0 and item.containsKey('menuTypeIncrement')) or (colPickMode==1 and !item.containsKey('menuTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.menuType,0) + #{item.menuTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="authType=(case" suffix="ELSE authType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('authType')) or (colPickMode==1 and !item.containsKey('authType'))">
when a.id=#{item.id} then #{item.authType}
</when>
<when test="(colPickMode==0 and item.containsKey('authTypeIncrement')) or (colPickMode==1 and !item.containsKey('authTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.authType,0) + #{item.authTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createUserName=(case" suffix="ELSE createUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createUserName')) or (colPickMode==1 and !item.containsKey('createUserName'))">
when a.id=#{item.id} then #{item.createUserName}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="MenuEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_menu as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_menu as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_menu where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_menu as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="MenuEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_menu as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
<include refid="_orderCols_"/>
</select>
<!-- 获取 -->
<select id="getListCount" parameterType="paramDto" resultType="int">
select count(1)
from mortals_xhx_menu as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('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('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('parentId')">
<if test="conditionParamRef.parentId != null ">
${_conditionType_} a.parentId = #{${_conditionParam_}.parentId}
</if>
<if test="conditionParamRef.parentId == null">
${_conditionType_} a.parentId is null
</if>
</if>
<if test="conditionParamRef.containsKey('parentIdList')">
${_conditionType_} a.parentId in
<foreach collection="conditionParamRef.parentIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('parentIdStart') and conditionParamRef.parentIdStart != null">
${_conditionType_} a.parentId <![CDATA[ >= ]]> #{${_conditionParam_}.parentIdStart}
</if>
<if test="conditionParamRef.containsKey('parentIdEnd') and conditionParamRef.parentIdEnd != null">
${_conditionType_} a.parentId <![CDATA[ <= ]]> #{${_conditionParam_}.parentIdEnd}
</if>
<if test="conditionParamRef.containsKey('orderId')">
<if test="conditionParamRef.orderId != null ">
${_conditionType_} a.orderId = #{${_conditionParam_}.orderId}
</if>
<if test="conditionParamRef.orderId == null">
${_conditionType_} a.orderId is null
</if>
</if>
<if test="conditionParamRef.containsKey('orderIdList')">
${_conditionType_} a.orderId in
<foreach collection="conditionParamRef.orderIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('orderIdStart') and conditionParamRef.orderIdStart != null">
${_conditionType_} a.orderId <![CDATA[ >= ]]> #{${_conditionParam_}.orderIdStart}
</if>
<if test="conditionParamRef.containsKey('orderIdEnd') and conditionParamRef.orderIdEnd != null">
${_conditionType_} a.orderId <![CDATA[ <= ]]> #{${_conditionParam_}.orderIdEnd}
</if>
<if test="conditionParamRef.containsKey('status')">
<if test="conditionParamRef.status != null ">
${_conditionType_} a.status = #{${_conditionParam_}.status}
</if>
<if test="conditionParamRef.status == null">
${_conditionType_} a.status is null
</if>
</if>
<if test="conditionParamRef.containsKey('statusList')">
${_conditionType_} a.status in
<foreach collection="conditionParamRef.statusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('statusStart') and conditionParamRef.statusStart != null">
${_conditionType_} a.status <![CDATA[ >= ]]> #{${_conditionParam_}.statusStart}
</if>
<if test="conditionParamRef.containsKey('statusEnd') and conditionParamRef.statusEnd != null">
${_conditionType_} a.status <![CDATA[ <= ]]> #{${_conditionParam_}.statusEnd}
</if>
<if test="conditionParamRef.containsKey('linkType')">
<if test="conditionParamRef.linkType != null ">
${_conditionType_} a.linkType = #{${_conditionParam_}.linkType}
</if>
<if test="conditionParamRef.linkType == null">
${_conditionType_} a.linkType is null
</if>
</if>
<if test="conditionParamRef.containsKey('linkTypeList')">
${_conditionType_} a.linkType in
<foreach collection="conditionParamRef.linkTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('linkTypeStart') and conditionParamRef.linkTypeStart != null">
${_conditionType_} a.linkType <![CDATA[ >= ]]> #{${_conditionParam_}.linkTypeStart}
</if>
<if test="conditionParamRef.containsKey('linkTypeEnd') and conditionParamRef.linkTypeEnd != null">
${_conditionType_} a.linkType <![CDATA[ <= ]]> #{${_conditionParam_}.linkTypeEnd}
</if>
<if test="conditionParamRef.containsKey('groupId')">
<if test="conditionParamRef.groupId != null ">
${_conditionType_} a.groupId = #{${_conditionParam_}.groupId}
</if>
<if test="conditionParamRef.groupId == null">
${_conditionType_} a.groupId is null
</if>
</if>
<if test="conditionParamRef.containsKey('groupIdList')">
${_conditionType_} a.groupId in
<foreach collection="conditionParamRef.groupIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('groupIdStart') and conditionParamRef.groupIdStart != null">
${_conditionType_} a.groupId <![CDATA[ >= ]]> #{${_conditionParam_}.groupIdStart}
</if>
<if test="conditionParamRef.containsKey('groupIdEnd') and conditionParamRef.groupIdEnd != null">
${_conditionType_} a.groupId <![CDATA[ <= ]]> #{${_conditionParam_}.groupIdEnd}
</if>
<if test="conditionParamRef.containsKey('groupName')">
<if test="conditionParamRef.groupName != null and conditionParamRef.groupName != ''">
${_conditionType_} a.groupName like #{${_conditionParam_}.groupName}
</if>
<if test="conditionParamRef.groupName == null">
${_conditionType_} a.groupName is null
</if>
</if>
<if test="conditionParamRef.containsKey('groupNameList')">
${_conditionType_} a.groupName in
<foreach collection="conditionParamRef.groupNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('imgPath')">
<if test="conditionParamRef.imgPath != null and conditionParamRef.imgPath != ''">
${_conditionType_} a.imgPath like #{${_conditionParam_}.imgPath}
</if>
<if test="conditionParamRef.imgPath == null">
${_conditionType_} a.imgPath is null
</if>
</if>
<if test="conditionParamRef.containsKey('imgPathList')">
${_conditionType_} a.imgPath in
<foreach collection="conditionParamRef.imgPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('buttonImgPath')">
<if test="conditionParamRef.buttonImgPath != null and conditionParamRef.buttonImgPath != ''">
${_conditionType_} a.buttonImgPath like #{${_conditionParam_}.buttonImgPath}
</if>
<if test="conditionParamRef.buttonImgPath == null">
${_conditionType_} a.buttonImgPath is null
</if>
</if>
<if test="conditionParamRef.containsKey('buttonImgPathList')">
${_conditionType_} a.buttonImgPath in
<foreach collection="conditionParamRef.buttonImgPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('imgCommPath')">
<if test="conditionParamRef.imgCommPath != null and conditionParamRef.imgCommPath != ''">
${_conditionType_} a.imgCommPath like #{${_conditionParam_}.imgCommPath}
</if>
<if test="conditionParamRef.imgCommPath == null">
${_conditionType_} a.imgCommPath is null
</if>
</if>
<if test="conditionParamRef.containsKey('imgCommPathList')">
${_conditionType_} a.imgCommPath in
<foreach collection="conditionParamRef.imgCommPathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('commMenu')">
<if test="conditionParamRef.commMenu != null ">
${_conditionType_} a.commMenu = #{${_conditionParam_}.commMenu}
</if>
<if test="conditionParamRef.commMenu == null">
${_conditionType_} a.commMenu is null
</if>
</if>
<if test="conditionParamRef.containsKey('commMenuList')">
${_conditionType_} a.commMenu in
<foreach collection="conditionParamRef.commMenuList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('commMenuStart') and conditionParamRef.commMenuStart != null">
${_conditionType_} a.commMenu <![CDATA[ >= ]]> #{${_conditionParam_}.commMenuStart}
</if>
<if test="conditionParamRef.containsKey('commMenuEnd') and conditionParamRef.commMenuEnd != null">
${_conditionType_} a.commMenu <![CDATA[ <= ]]> #{${_conditionParam_}.commMenuEnd}
</if>
<if test="conditionParamRef.containsKey('menuType')">
<if test="conditionParamRef.menuType != null ">
${_conditionType_} a.menuType = #{${_conditionParam_}.menuType}
</if>
<if test="conditionParamRef.menuType == null">
${_conditionType_} a.menuType is null
</if>
</if>
<if test="conditionParamRef.containsKey('menuTypeList')">
${_conditionType_} a.menuType in
<foreach collection="conditionParamRef.menuTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('menuTypeStart') and conditionParamRef.menuTypeStart != null">
${_conditionType_} a.menuType <![CDATA[ >= ]]> #{${_conditionParam_}.menuTypeStart}
</if>
<if test="conditionParamRef.containsKey('menuTypeEnd') and conditionParamRef.menuTypeEnd != null">
${_conditionType_} a.menuType <![CDATA[ <= ]]> #{${_conditionParam_}.menuTypeEnd}
</if>
<if test="conditionParamRef.containsKey('authType')">
<if test="conditionParamRef.authType != null ">
${_conditionType_} a.authType = #{${_conditionParam_}.authType}
</if>
<if test="conditionParamRef.authType == null">
${_conditionType_} a.authType is null
</if>
</if>
<if test="conditionParamRef.containsKey('authTypeList')">
${_conditionType_} a.authType in
<foreach collection="conditionParamRef.authTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('authTypeStart') and conditionParamRef.authTypeStart != null">
${_conditionType_} a.authType <![CDATA[ >= ]]> #{${_conditionParam_}.authTypeStart}
</if>
<if test="conditionParamRef.containsKey('authTypeEnd') and conditionParamRef.authTypeEnd != null">
${_conditionType_} a.authType <![CDATA[ <= ]]> #{${_conditionParam_}.authTypeEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createUserName')">
<if test="conditionParamRef.createUserName != null and conditionParamRef.createUserName != ''">
${_conditionType_} a.createUserName like #{${_conditionParam_}.createUserName}
</if>
<if test="conditionParamRef.createUserName == null">
${_conditionType_} a.createUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserNameList')">
${_conditionType_} a.createUserName in
<foreach collection="conditionParamRef.createUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('name')">
a.name
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('url')">
a.url
<if test='orderCol.url != null and "DESC".equalsIgnoreCase(orderCol.url)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('parentId')">
a.parentId
<if test='orderCol.parentId != null and "DESC".equalsIgnoreCase(orderCol.parentId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('orderId')">
a.orderId
<if test='orderCol.orderId != null and "DESC".equalsIgnoreCase(orderCol.orderId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('status')">
a.status
<if test='orderCol.status != null and "DESC".equalsIgnoreCase(orderCol.status)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('linkType')">
a.linkType
<if test='orderCol.linkType != null and "DESC".equalsIgnoreCase(orderCol.linkType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('groupId')">
a.groupId
<if test='orderCol.groupId != null and "DESC".equalsIgnoreCase(orderCol.groupId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('groupName')">
a.groupName
<if test='orderCol.groupName != null and "DESC".equalsIgnoreCase(orderCol.groupName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('imgPath')">
a.imgPath
<if test='orderCol.imgPath != null and "DESC".equalsIgnoreCase(orderCol.imgPath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('buttonImgPath')">
a.buttonImgPath
<if test='orderCol.buttonImgPath != null and "DESC".equalsIgnoreCase(orderCol.buttonImgPath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('imgCommPath')">
a.imgCommPath
<if test='orderCol.imgCommPath != null and "DESC".equalsIgnoreCase(orderCol.imgCommPath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('commMenu')">
a.commMenu
<if test='orderCol.commMenu != null and "DESC".equalsIgnoreCase(orderCol.commMenu)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('menuType')">
a.menuType
<if test='orderCol.menuType != null and "DESC".equalsIgnoreCase(orderCol.menuType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('authType')">
a.authType
<if test='orderCol.authType != null and "DESC".equalsIgnoreCase(orderCol.authType)'>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('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserName')">
a.createUserName
<if test='orderCol.createUserName != null and "DESC".equalsIgnoreCase(orderCol.createUserName)'>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
portal-manager/src/main/resources/sqlmap/module/param/ParamMapper.xml 0 → 100644
View file @ 945f2d4f
<?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.param.dao.ibatis.ParamDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="ParamEntity" id="ParamEntity-Map">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="firstOrganize" column="firstOrganize" />
<result property="secondOrganize" column="secondOrganize" />
<result property="paramKey" column="paramKey" />
<result property="paramValue" column="paramValue" />
<result property="validStatus" column="validStatus" />
<result property="modStatus" column="modStatus" />
<result property="displayType" column="displayType" />
<result property="remark" column="remark" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</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('firstOrganize') or colPickMode == 1 and data.containsKey('firstOrganize')))">
a.firstOrganize,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('secondOrganize') or colPickMode == 1 and data.containsKey('secondOrganize')))">
a.secondOrganize,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paramKey') or colPickMode == 1 and data.containsKey('paramKey')))">
a.paramKey,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paramValue') or colPickMode == 1 and data.containsKey('paramValue')))">
a.paramValue,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('validStatus') or colPickMode == 1 and data.containsKey('validStatus')))">
a.validStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('modStatus') or colPickMode == 1 and data.containsKey('modStatus')))">
a.modStatus,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('displayType') or colPickMode == 1 and data.containsKey('displayType')))">
a.displayType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark,
</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('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserName') or colPickMode == 1 and data.containsKey('createUserName')))">
a.createUserName,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="ParamEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_param
(name,firstOrganize,secondOrganize,paramKey,paramValue,validStatus,modStatus,displayType,remark,createTime,createUserId,createUserName)
VALUES
(#{name},#{firstOrganize},#{secondOrganize},#{paramKey},#{paramValue},#{validStatus},#{modStatus},#{displayType},#{remark},#{createTime},#{createUserId},#{createUserName})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_param
(name,firstOrganize,secondOrganize,paramKey,paramValue,validStatus,modStatus,displayType,remark,createTime,createUserId,createUserName)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.firstOrganize},#{item.secondOrganize},#{item.paramKey},#{item.paramValue},#{item.validStatus},#{item.modStatus},#{item.displayType},#{item.remark},#{item.createTime},#{item.createUserId},#{item.createUserName})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_param as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('name')) or (colPickMode==1 and !data.containsKey('name'))">
a.name=#{data.name},
</if>
<if test="(colPickMode==0 and data.containsKey('firstOrganize')) or (colPickMode==1 and !data.containsKey('firstOrganize'))">
a.firstOrganize=#{data.firstOrganize},
</if>
<if test="(colPickMode==0 and data.containsKey('secondOrganize')) or (colPickMode==1 and !data.containsKey('secondOrganize'))">
a.secondOrganize=#{data.secondOrganize},
</if>
<if test="(colPickMode==0 and data.containsKey('paramKey')) or (colPickMode==1 and !data.containsKey('paramKey'))">
a.paramKey=#{data.paramKey},
</if>
<if test="(colPickMode==0 and data.containsKey('paramValue')) or (colPickMode==1 and !data.containsKey('paramValue'))">
a.paramValue=#{data.paramValue},
</if>
<if test="(colPickMode==0 and data.containsKey('validStatus')) or (colPickMode==1 and !data.containsKey('validStatus'))">
a.validStatus=#{data.validStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('validStatusIncrement')) or (colPickMode==1 and !data.containsKey('validStatusIncrement'))">
a.validStatus=ifnull(a.validStatus,0) + #{data.validStatusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('modStatus')) or (colPickMode==1 and !data.containsKey('modStatus'))">
a.modStatus=#{data.modStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('modStatusIncrement')) or (colPickMode==1 and !data.containsKey('modStatusIncrement'))">
a.modStatus=ifnull(a.modStatus,0) + #{data.modStatusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('displayType')) or (colPickMode==1 and !data.containsKey('displayType'))">
a.displayType=#{data.displayType},
</if>
<if test="(colPickMode==0 and data.containsKey('displayTypeIncrement')) or (colPickMode==1 and !data.containsKey('displayTypeIncrement'))">
a.displayType=ifnull(a.displayType,0) + #{data.displayTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserName')) or (colPickMode==1 and !data.containsKey('createUserName'))">
a.createUserName=#{data.createUserName},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_param as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="name=(case" suffix="ELSE name end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
when a.id=#{item.id} then #{item.name}
</if>
</foreach>
</trim>
<trim prefix="firstOrganize=(case" suffix="ELSE firstOrganize end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('firstOrganize')) or (colPickMode==1 and !item.containsKey('firstOrganize'))">
when a.id=#{item.id} then #{item.firstOrganize}
</if>
</foreach>
</trim>
<trim prefix="secondOrganize=(case" suffix="ELSE secondOrganize end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('secondOrganize')) or (colPickMode==1 and !item.containsKey('secondOrganize'))">
when a.id=#{item.id} then #{item.secondOrganize}
</if>
</foreach>
</trim>
<trim prefix="paramKey=(case" suffix="ELSE paramKey end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('paramKey')) or (colPickMode==1 and !item.containsKey('paramKey'))">
when a.id=#{item.id} then #{item.paramKey}
</if>
</foreach>
</trim>
<trim prefix="paramValue=(case" suffix="ELSE paramValue end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('paramValue')) or (colPickMode==1 and !item.containsKey('paramValue'))">
when a.id=#{item.id} then #{item.paramValue}
</if>
</foreach>
</trim>
<trim prefix="validStatus=(case" suffix="ELSE validStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('validStatus')) or (colPickMode==1 and !item.containsKey('validStatus'))">
when a.id=#{item.id} then #{item.validStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('validStatusIncrement')) or (colPickMode==1 and !item.containsKey('validStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.validStatus,0) + #{item.validStatusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="modStatus=(case" suffix="ELSE modStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('modStatus')) or (colPickMode==1 and !item.containsKey('modStatus'))">
when a.id=#{item.id} then #{item.modStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('modStatusIncrement')) or (colPickMode==1 and !item.containsKey('modStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.modStatus,0) + #{item.modStatusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="displayType=(case" suffix="ELSE displayType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('displayType')) or (colPickMode==1 and !item.containsKey('displayType'))">
when a.id=#{item.id} then #{item.displayType}
</when>
<when test="(colPickMode==0 and item.containsKey('displayTypeIncrement')) or (colPickMode==1 and !item.containsKey('displayTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.displayType,0) + #{item.displayTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark}
</if>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createUserName=(case" suffix="ELSE createUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createUserName')) or (colPickMode==1 and !item.containsKey('createUserName'))">
when a.id=#{item.id} then #{item.createUserName}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="ParamEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_param as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_param as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_param where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_param as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="ParamEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_param 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_param as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('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('firstOrganize')">
<if test="conditionParamRef.firstOrganize != null and conditionParamRef.firstOrganize != ''">
${_conditionType_} a.firstOrganize like #{${_conditionParam_}.firstOrganize}
</if>
<if test="conditionParamRef.firstOrganize == null">
${_conditionType_} a.firstOrganize is null
</if>
</if>
<if test="conditionParamRef.containsKey('firstOrganizeList')">
${_conditionType_} a.firstOrganize in
<foreach collection="conditionParamRef.firstOrganizeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('secondOrganize')">
<if test="conditionParamRef.secondOrganize != null and conditionParamRef.secondOrganize != ''">
${_conditionType_} a.secondOrganize like #{${_conditionParam_}.secondOrganize}
</if>
<if test="conditionParamRef.secondOrganize == null">
${_conditionType_} a.secondOrganize is null
</if>
</if>
<if test="conditionParamRef.containsKey('secondOrganizeList')">
${_conditionType_} a.secondOrganize in
<foreach collection="conditionParamRef.secondOrganizeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paramKey')">
<if test="conditionParamRef.paramKey != null and conditionParamRef.paramKey != ''">
${_conditionType_} a.paramKey like #{${_conditionParam_}.paramKey}
</if>
<if test="conditionParamRef.paramKey == null">
${_conditionType_} a.paramKey is null
</if>
</if>
<if test="conditionParamRef.containsKey('paramKeyList')">
${_conditionType_} a.paramKey in
<foreach collection="conditionParamRef.paramKeyList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paramValue')">
<if test="conditionParamRef.paramValue != null and conditionParamRef.paramValue != ''">
${_conditionType_} a.paramValue like #{${_conditionParam_}.paramValue}
</if>
<if test="conditionParamRef.paramValue == null">
${_conditionType_} a.paramValue is null
</if>
</if>
<if test="conditionParamRef.containsKey('paramValueList')">
${_conditionType_} a.paramValue in
<foreach collection="conditionParamRef.paramValueList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('validStatus')">
<if test="conditionParamRef.validStatus != null ">
${_conditionType_} a.validStatus = #{${_conditionParam_}.validStatus}
</if>
<if test="conditionParamRef.validStatus == null">
${_conditionType_} a.validStatus is null
</if>
</if>
<if test="conditionParamRef.containsKey('validStatusList')">
${_conditionType_} a.validStatus in
<foreach collection="conditionParamRef.validStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('validStatusStart') and conditionParamRef.validStatusStart != null">
${_conditionType_} a.validStatus <![CDATA[ >= ]]> #{${_conditionParam_}.validStatusStart}
</if>
<if test="conditionParamRef.containsKey('validStatusEnd') and conditionParamRef.validStatusEnd != null">
${_conditionType_} a.validStatus <![CDATA[ <= ]]> #{${_conditionParam_}.validStatusEnd}
</if>
<if test="conditionParamRef.containsKey('modStatus')">
<if test="conditionParamRef.modStatus != null ">
${_conditionType_} a.modStatus = #{${_conditionParam_}.modStatus}
</if>
<if test="conditionParamRef.modStatus == null">
${_conditionType_} a.modStatus is null
</if>
</if>
<if test="conditionParamRef.containsKey('modStatusList')">
${_conditionType_} a.modStatus in
<foreach collection="conditionParamRef.modStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('modStatusStart') and conditionParamRef.modStatusStart != null">
${_conditionType_} a.modStatus <![CDATA[ >= ]]> #{${_conditionParam_}.modStatusStart}
</if>
<if test="conditionParamRef.containsKey('modStatusEnd') and conditionParamRef.modStatusEnd != null">
${_conditionType_} a.modStatus <![CDATA[ <= ]]> #{${_conditionParam_}.modStatusEnd}
</if>
<if test="conditionParamRef.containsKey('displayType')">
<if test="conditionParamRef.displayType != null ">
${_conditionType_} a.displayType = #{${_conditionParam_}.displayType}
</if>
<if test="conditionParamRef.displayType == null">
${_conditionType_} a.displayType is null
</if>
</if>
<if test="conditionParamRef.containsKey('displayTypeList')">
${_conditionType_} a.displayType in
<foreach collection="conditionParamRef.displayTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('displayTypeStart') and conditionParamRef.displayTypeStart != null">
${_conditionType_} a.displayType <![CDATA[ >= ]]> #{${_conditionParam_}.displayTypeStart}
</if>
<if test="conditionParamRef.containsKey('displayTypeEnd') and conditionParamRef.displayTypeEnd != null">
${_conditionType_} a.displayType <![CDATA[ <= ]]> #{${_conditionParam_}.displayTypeEnd}
</if>
<if test="conditionParamRef.containsKey('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList')">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createUserName')">
<if test="conditionParamRef.createUserName != null and conditionParamRef.createUserName != ''">
${_conditionType_} a.createUserName like #{${_conditionParam_}.createUserName}
</if>
<if test="conditionParamRef.createUserName == null">
${_conditionType_} a.createUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserNameList')">
${_conditionType_} a.createUserName in
<foreach collection="conditionParamRef.createUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('name')">
a.name
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('firstOrganize')">
a.firstOrganize
<if test='orderCol.firstOrganize != null and "DESC".equalsIgnoreCase(orderCol.firstOrganize)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('secondOrganize')">
a.secondOrganize
<if test='orderCol.secondOrganize != null and "DESC".equalsIgnoreCase(orderCol.secondOrganize)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('paramKey')">
a.paramKey
<if test='orderCol.paramKey != null and "DESC".equalsIgnoreCase(orderCol.paramKey)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('paramValue')">
a.paramValue
<if test='orderCol.paramValue != null and "DESC".equalsIgnoreCase(orderCol.paramValue)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('validStatus')">
a.validStatus
<if test='orderCol.validStatus != null and "DESC".equalsIgnoreCase(orderCol.validStatus)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('modStatus')">
a.modStatus
<if test='orderCol.modStatus != null and "DESC".equalsIgnoreCase(orderCol.modStatus)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('displayType')">
a.displayType
<if test='orderCol.displayType != null and "DESC".equalsIgnoreCase(orderCol.displayType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserName')">
a.createUserName
<if test='orderCol.createUserName != null and "DESC".equalsIgnoreCase(orderCol.createUserName)'>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
portal-manager/src/main/resources/sqlmap/module/param/paramExt.xml 0 → 100644
View file @ 945f2d4f
<?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.param.dao.ibatis.ParamDaoImpl">
<update id="update-param-version">
update mortals_xhx_param set paramValue=paramValue+1 where paramKey='param_refresh_count'
</update>
</mapper>
\ No newline at end of file
portal-manager/src/main/resources/sqlmap/module/resource/ResourceMapper.xml 0 → 100644
View file @ 945f2d4f
<?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.resource.dao.ibatis.ResourceDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="ResourceEntity" id="ResourceEntity-Map">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="url" column="url" />
<result property="authType" column="authType" />
<result property="sourceType" column="sourceType" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
<result property="userType" column="userType" />
</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('name') or colPickMode == 1 and data.containsKey('name')))">
a.name,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('url') or colPickMode == 1 and data.containsKey('url')))">
a.url,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('authType') or colPickMode == 1 and data.containsKey('authType')))">
a.authType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('sourceType') or colPickMode == 1 and data.containsKey('sourceType')))">
a.sourceType,
</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('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserName') or colPickMode == 1 and data.containsKey('createUserName')))">
a.createUserName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('userType') or colPickMode == 1 and data.containsKey('userType')))">
a.userType,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="ResourceEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_resource
(name,url,authType,sourceType,createTime,createUserId,createUserName,userType)
VALUES
(#{name},#{url},#{authType},#{sourceType},#{createTime},#{createUserId},#{createUserName},#{userType})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_resource
(name,url,authType,sourceType,createTime,createUserId,createUserName,userType)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.url},#{item.authType},#{item.sourceType},#{item.createTime},#{item.createUserId},#{item.createUserName},#{item.userType})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_resource as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('name')) or (colPickMode==1 and !data.containsKey('name'))">
a.name=#{data.name},
</if>
<if test="(colPickMode==0 and data.containsKey('url')) or (colPickMode==1 and !data.containsKey('url'))">
a.url=#{data.url},
</if>
<if test="(colPickMode==0 and data.containsKey('authType')) or (colPickMode==1 and !data.containsKey('authType'))">
a.authType=#{data.authType},
</if>
<if test="(colPickMode==0 and data.containsKey('authTypeIncrement')) or (colPickMode==1 and !data.containsKey('authTypeIncrement'))">
a.authType=ifnull(a.authType,0) + #{data.authTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('sourceType')) or (colPickMode==1 and !data.containsKey('sourceType'))">
a.sourceType=#{data.sourceType},
</if>
<if test="(colPickMode==0 and data.containsKey('sourceTypeIncrement')) or (colPickMode==1 and !data.containsKey('sourceTypeIncrement'))">
a.sourceType=ifnull(a.sourceType,0) + #{data.sourceTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserName')) or (colPickMode==1 and !data.containsKey('createUserName'))">
a.createUserName=#{data.createUserName},
</if>
<if test="(colPickMode==0 and data.containsKey('userType')) or (colPickMode==1 and !data.containsKey('userType'))">
a.userType=#{data.userType},
</if>
<if test="(colPickMode==0 and data.containsKey('userTypeIncrement')) or (colPickMode==1 and !data.containsKey('userTypeIncrement'))">
a.userType=ifnull(a.userType,0) + #{data.userTypeIncrement},
</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_resource as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="name=(case" suffix="ELSE name end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
when a.id=#{item.id} then #{item.name}
</if>
</foreach>
</trim>
<trim prefix="url=(case" suffix="ELSE url end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('url')) or (colPickMode==1 and !item.containsKey('url'))">
when a.id=#{item.id} then #{item.url}
</if>
</foreach>
</trim>
<trim prefix="authType=(case" suffix="ELSE authType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('authType')) or (colPickMode==1 and !item.containsKey('authType'))">
when a.id=#{item.id} then #{item.authType}
</when>
<when test="(colPickMode==0 and item.containsKey('authTypeIncrement')) or (colPickMode==1 and !item.containsKey('authTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.authType,0) + #{item.authTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="sourceType=(case" suffix="ELSE sourceType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('sourceType')) or (colPickMode==1 and !item.containsKey('sourceType'))">
when a.id=#{item.id} then #{item.sourceType}
</when>
<when test="(colPickMode==0 and item.containsKey('sourceTypeIncrement')) or (colPickMode==1 and !item.containsKey('sourceTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.sourceType,0) + #{item.sourceTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createUserName=(case" suffix="ELSE createUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createUserName')) or (colPickMode==1 and !item.containsKey('createUserName'))">
when a.id=#{item.id} then #{item.createUserName}
</if>
</foreach>
</trim>
<trim prefix="userType=(case" suffix="ELSE userType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('userType')) or (colPickMode==1 and !item.containsKey('userType'))">
when a.id=#{item.id} then #{item.userType}
</when>
<when test="(colPickMode==0 and item.containsKey('userTypeIncrement')) or (colPickMode==1 and !item.containsKey('userTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.userType,0) + #{item.userTypeIncrement}
</when>
</choose>
</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="ResourceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_resource as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_resource as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_resource where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_resource as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="ResourceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_resource 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_resource as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('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('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('authType')">
<if test="conditionParamRef.authType != null ">
${_conditionType_} a.authType = #{${_conditionParam_}.authType}
</if>
<if test="conditionParamRef.authType == null">
${_conditionType_} a.authType is null
</if>
</if>
<if test="conditionParamRef.containsKey('authTypeList')">
${_conditionType_} a.authType in
<foreach collection="conditionParamRef.authTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('authTypeStart') and conditionParamRef.authTypeStart != null">
${_conditionType_} a.authType <![CDATA[ >= ]]> #{${_conditionParam_}.authTypeStart}
</if>
<if test="conditionParamRef.containsKey('authTypeEnd') and conditionParamRef.authTypeEnd != null">
${_conditionType_} a.authType <![CDATA[ <= ]]> #{${_conditionParam_}.authTypeEnd}
</if>
<if test="conditionParamRef.containsKey('sourceType')">
<if test="conditionParamRef.sourceType != null ">
${_conditionType_} a.sourceType = #{${_conditionParam_}.sourceType}
</if>
<if test="conditionParamRef.sourceType == null">
${_conditionType_} a.sourceType is null
</if>
</if>
<if test="conditionParamRef.containsKey('sourceTypeList')">
${_conditionType_} a.sourceType in
<foreach collection="conditionParamRef.sourceTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('sourceTypeStart') and conditionParamRef.sourceTypeStart != null">
${_conditionType_} a.sourceType <![CDATA[ >= ]]> #{${_conditionParam_}.sourceTypeStart}
</if>
<if test="conditionParamRef.containsKey('sourceTypeEnd') and conditionParamRef.sourceTypeEnd != null">
${_conditionType_} a.sourceType <![CDATA[ <= ]]> #{${_conditionParam_}.sourceTypeEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createUserName')">
<if test="conditionParamRef.createUserName != null and conditionParamRef.createUserName != ''">
${_conditionType_} a.createUserName like #{${_conditionParam_}.createUserName}
</if>
<if test="conditionParamRef.createUserName == null">
${_conditionType_} a.createUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserNameList')">
${_conditionType_} a.createUserName in
<foreach collection="conditionParamRef.createUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('userType')">
<if test="conditionParamRef.userType != null ">
${_conditionType_} a.userType = #{${_conditionParam_}.userType}
</if>
<if test="conditionParamRef.userType == null">
${_conditionType_} a.userType is null
</if>
</if>
<if test="conditionParamRef.containsKey('userTypeList')">
${_conditionType_} a.userType in
<foreach collection="conditionParamRef.userTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('userTypeStart') and conditionParamRef.userTypeStart != null">
${_conditionType_} a.userType <![CDATA[ >= ]]> #{${_conditionParam_}.userTypeStart}
</if>
<if test="conditionParamRef.containsKey('userTypeEnd') and conditionParamRef.userTypeEnd != null">
${_conditionType_} a.userType <![CDATA[ <= ]]> #{${_conditionParam_}.userTypeEnd}
</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('name')">
a.name
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('url')">
a.url
<if test='orderCol.url != null and "DESC".equalsIgnoreCase(orderCol.url)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('authType')">
a.authType
<if test='orderCol.authType != null and "DESC".equalsIgnoreCase(orderCol.authType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('sourceType')">
a.sourceType
<if test='orderCol.sourceType != null and "DESC".equalsIgnoreCase(orderCol.sourceType)'>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('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserName')">
a.createUserName
<if test='orderCol.createUserName != null and "DESC".equalsIgnoreCase(orderCol.createUserName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('userType')">
a.userType
<if test='orderCol.userType != null and "DESC".equalsIgnoreCase(orderCol.userType)'>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
portal-manager/src/main/resources/sqlmap/module/resource/resourceExt.xml 0 → 100644
View file @ 945f2d4f
<?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.resource.dao.ibatis.ResourceDaoImpl">
<!-- 获取列表 -->
<select id="getListByUserId" parameterType="paramDto" resultMap="ResourceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_resource as a
where a.authType in(0,1,2) or a.id IN
(select resourceId
from mortals_xhx_role_auth as b
left join mortals_xhx_role_user as c
on b.roleId=c.roleId
where c.userId=#{condition.userId})
</select>
<select id="getAllByUserType" parameterType="java.util.HashMap" resultMap="ResourceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_resource as a
where a.userType=#{userType}
</select>
</mapper>
\ No newline at end of file
portal-manager/src/main/resources/sqlmap/module/role/RoleAuthMapper.xml 0 → 100644
View file @ 945f2d4f
<?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.role.dao.ibatis.RoleAuthDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="RoleAuthEntity" id="RoleAuthEntity-Map">
<id property="id" column="id" />
<result property="roleId" column="roleId" />
<result property="resourceId" column="resourceId" />
</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('roleId') or colPickMode == 1 and data.containsKey('roleId')))">
a.roleId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('resourceId') or colPickMode == 1 and data.containsKey('resourceId')))">
a.resourceId,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="RoleAuthEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_role_auth
(roleId,resourceId)
VALUES
(#{roleId},#{resourceId})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_role_auth
(roleId,resourceId)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.roleId},#{item.resourceId})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_role_auth as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('roleId')) or (colPickMode==1 and !data.containsKey('roleId'))">
a.roleId=#{data.roleId},
</if>
<if test="(colPickMode==0 and data.containsKey('roleIdIncrement')) or (colPickMode==1 and !data.containsKey('roleIdIncrement'))">
a.roleId=ifnull(a.roleId,0) + #{data.roleIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('resourceId')) or (colPickMode==1 and !data.containsKey('resourceId'))">
a.resourceId=#{data.resourceId},
</if>
<if test="(colPickMode==0 and data.containsKey('resourceIdIncrement')) or (colPickMode==1 and !data.containsKey('resourceIdIncrement'))">
a.resourceId=ifnull(a.resourceId,0) + #{data.resourceIdIncrement},
</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_role_auth as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="roleId=(case" suffix="ELSE roleId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('roleId')) or (colPickMode==1 and !item.containsKey('roleId'))">
when a.id=#{item.id} then #{item.roleId}
</when>
<when test="(colPickMode==0 and item.containsKey('roleIdIncrement')) or (colPickMode==1 and !item.containsKey('roleIdIncrement'))">
when a.id=#{item.id} then ifnull(a.roleId,0) + #{item.roleIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="resourceId=(case" suffix="ELSE resourceId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('resourceId')) or (colPickMode==1 and !item.containsKey('resourceId'))">
when a.id=#{item.id} then #{item.resourceId}
</when>
<when test="(colPickMode==0 and item.containsKey('resourceIdIncrement')) or (colPickMode==1 and !item.containsKey('resourceIdIncrement'))">
when a.id=#{item.id} then ifnull(a.resourceId,0) + #{item.resourceIdIncrement}
</when>
</choose>
</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="RoleAuthEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_auth as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_role_auth as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_role_auth where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_role_auth as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="RoleAuthEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_auth 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_role_auth as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('roleId')">
<if test="conditionParamRef.roleId != null ">
${_conditionType_} a.roleId = #{${_conditionParam_}.roleId}
</if>
<if test="conditionParamRef.roleId == null">
${_conditionType_} a.roleId is null
</if>
</if>
<if test="conditionParamRef.containsKey('roleIdList')">
${_conditionType_} a.roleId in
<foreach collection="conditionParamRef.roleIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('roleIdStart') and conditionParamRef.roleIdStart != null">
${_conditionType_} a.roleId <![CDATA[ >= ]]> #{${_conditionParam_}.roleIdStart}
</if>
<if test="conditionParamRef.containsKey('roleIdEnd') and conditionParamRef.roleIdEnd != null">
${_conditionType_} a.roleId <![CDATA[ <= ]]> #{${_conditionParam_}.roleIdEnd}
</if>
<if test="conditionParamRef.containsKey('resourceId')">
<if test="conditionParamRef.resourceId != null ">
${_conditionType_} a.resourceId = #{${_conditionParam_}.resourceId}
</if>
<if test="conditionParamRef.resourceId == null">
${_conditionType_} a.resourceId is null
</if>
</if>
<if test="conditionParamRef.containsKey('resourceIdList')">
${_conditionType_} a.resourceId in
<foreach collection="conditionParamRef.resourceIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('resourceIdStart') and conditionParamRef.resourceIdStart != null">
${_conditionType_} a.resourceId <![CDATA[ >= ]]> #{${_conditionParam_}.resourceIdStart}
</if>
<if test="conditionParamRef.containsKey('resourceIdEnd') and conditionParamRef.resourceIdEnd != null">
${_conditionType_} a.resourceId <![CDATA[ <= ]]> #{${_conditionParam_}.resourceIdEnd}
</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('roleId')">
a.roleId
<if test='orderCol.roleId != null and "DESC".equalsIgnoreCase(orderCol.roleId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('resourceId')">
a.resourceId
<if test='orderCol.resourceId != null and "DESC".equalsIgnoreCase(orderCol.resourceId)'>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
portal-manager/src/main/resources/sqlmap/module/role/RoleMapper.xml 0 → 100644
View file @ 945f2d4f
<?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.role.dao.ibatis.RoleDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="RoleEntity" id="RoleEntity-Map">
<id property="id" column="id" />
<result property="name" column="name" />
<result property="remark" column="remark" />
<result property="roleType" column="roleType" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</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('remark') or colPickMode == 1 and data.containsKey('remark')))">
a.remark,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('roleType') or colPickMode == 1 and data.containsKey('roleType')))">
a.roleType,
</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('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserName') or colPickMode == 1 and data.containsKey('createUserName')))">
a.createUserName,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="RoleEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_role
(name,remark,roleType,createTime,createUserId,createUserName)
VALUES
(#{name},#{remark},#{roleType},#{createTime},#{createUserId},#{createUserName})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_role
(name,remark,roleType,createTime,createUserId,createUserName)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.name},#{item.remark},#{item.roleType},#{item.createTime},#{item.createUserId},#{item.createUserName})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_role as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('name')) or (colPickMode==1 and !data.containsKey('name'))">
a.name=#{data.name},
</if>
<if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
a.remark=#{data.remark},
</if>
<if test="(colPickMode==0 and data.containsKey('roleType')) or (colPickMode==1 and !data.containsKey('roleType'))">
a.roleType=#{data.roleType},
</if>
<if test="(colPickMode==0 and data.containsKey('roleTypeIncrement')) or (colPickMode==1 and !data.containsKey('roleTypeIncrement'))">
a.roleType=ifnull(a.roleType,0) + #{data.roleTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserName')) or (colPickMode==1 and !data.containsKey('createUserName'))">
a.createUserName=#{data.createUserName},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_role as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="name=(case" suffix="ELSE name end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('name')) or (colPickMode==1 and !item.containsKey('name'))">
when a.id=#{item.id} then #{item.name}
</if>
</foreach>
</trim>
<trim prefix="remark=(case" suffix="ELSE remark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
when a.id=#{item.id} then #{item.remark}
</if>
</foreach>
</trim>
<trim prefix="roleType=(case" suffix="ELSE roleType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('roleType')) or (colPickMode==1 and !item.containsKey('roleType'))">
when a.id=#{item.id} then #{item.roleType}
</when>
<when test="(colPickMode==0 and item.containsKey('roleTypeIncrement')) or (colPickMode==1 and !item.containsKey('roleTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.roleType,0) + #{item.roleTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createUserName=(case" suffix="ELSE createUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createUserName')) or (colPickMode==1 and !item.containsKey('createUserName'))">
when a.id=#{item.id} then #{item.createUserName}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="RoleEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_role as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_role where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_role as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="RoleEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role 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_role as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('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('remark')">
<if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
${_conditionType_} a.remark like #{${_conditionParam_}.remark}
</if>
<if test="conditionParamRef.remark == null">
${_conditionType_} a.remark is null
</if>
</if>
<if test="conditionParamRef.containsKey('remarkList')">
${_conditionType_} a.remark in
<foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('roleType')">
<if test="conditionParamRef.roleType != null ">
${_conditionType_} a.roleType = #{${_conditionParam_}.roleType}
</if>
<if test="conditionParamRef.roleType == null">
${_conditionType_} a.roleType is null
</if>
</if>
<if test="conditionParamRef.containsKey('roleTypeList')">
${_conditionType_} a.roleType in
<foreach collection="conditionParamRef.roleTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('roleTypeStart') and conditionParamRef.roleTypeStart != null">
${_conditionType_} a.roleType <![CDATA[ >= ]]> #{${_conditionParam_}.roleTypeStart}
</if>
<if test="conditionParamRef.containsKey('roleTypeEnd') and conditionParamRef.roleTypeEnd != null">
${_conditionType_} a.roleType <![CDATA[ <= ]]> #{${_conditionParam_}.roleTypeEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createUserName')">
<if test="conditionParamRef.createUserName != null and conditionParamRef.createUserName != ''">
${_conditionType_} a.createUserName like #{${_conditionParam_}.createUserName}
</if>
<if test="conditionParamRef.createUserName == null">
${_conditionType_} a.createUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserNameList')">
${_conditionType_} a.createUserName in
<foreach collection="conditionParamRef.createUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('name')">
a.name
<if test='orderCol.name != null and "DESC".equalsIgnoreCase(orderCol.name)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('remark')">
a.remark
<if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('roleType')">
a.roleType
<if test='orderCol.roleType != null and "DESC".equalsIgnoreCase(orderCol.roleType)'>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('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserName')">
a.createUserName
<if test='orderCol.createUserName != null and "DESC".equalsIgnoreCase(orderCol.createUserName)'>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
portal-manager/src/main/resources/sqlmap/module/role/RoleUserMapper.xml 0 → 100644
View file @ 945f2d4f
<?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.role.dao.ibatis.RoleUserDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="RoleUserEntity" id="RoleUserEntity-Map">
<id property="id" column="id" />
<result property="roleId" column="roleId" />
<result property="userId" column="userId" />
</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('roleId') or colPickMode == 1 and data.containsKey('roleId')))">
a.roleId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('userId') or colPickMode == 1 and data.containsKey('userId')))">
a.userId,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="RoleUserEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_role_user
(roleId,userId)
VALUES
(#{roleId},#{userId})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_role_user
(roleId,userId)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.roleId},#{item.userId})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_role_user as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('roleId')) or (colPickMode==1 and !data.containsKey('roleId'))">
a.roleId=#{data.roleId},
</if>
<if test="(colPickMode==0 and data.containsKey('roleIdIncrement')) or (colPickMode==1 and !data.containsKey('roleIdIncrement'))">
a.roleId=ifnull(a.roleId,0) + #{data.roleIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('userId')) or (colPickMode==1 and !data.containsKey('userId'))">
a.userId=#{data.userId},
</if>
<if test="(colPickMode==0 and data.containsKey('userIdIncrement')) or (colPickMode==1 and !data.containsKey('userIdIncrement'))">
a.userId=ifnull(a.userId,0) + #{data.userIdIncrement},
</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_role_user as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="roleId=(case" suffix="ELSE roleId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('roleId')) or (colPickMode==1 and !item.containsKey('roleId'))">
when a.id=#{item.id} then #{item.roleId}
</when>
<when test="(colPickMode==0 and item.containsKey('roleIdIncrement')) or (colPickMode==1 and !item.containsKey('roleIdIncrement'))">
when a.id=#{item.id} then ifnull(a.roleId,0) + #{item.roleIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="userId=(case" suffix="ELSE userId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('userId')) or (colPickMode==1 and !item.containsKey('userId'))">
when a.id=#{item.id} then #{item.userId}
</when>
<when test="(colPickMode==0 and item.containsKey('userIdIncrement')) or (colPickMode==1 and !item.containsKey('userIdIncrement'))">
when a.id=#{item.id} then ifnull(a.userId,0) + #{item.userIdIncrement}
</when>
</choose>
</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="RoleUserEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_user as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_role_user as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_role_user where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_role_user as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="RoleUserEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_role_user 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_role_user as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('roleId')">
<if test="conditionParamRef.roleId != null ">
${_conditionType_} a.roleId = #{${_conditionParam_}.roleId}
</if>
<if test="conditionParamRef.roleId == null">
${_conditionType_} a.roleId is null
</if>
</if>
<if test="conditionParamRef.containsKey('roleIdList')">
${_conditionType_} a.roleId in
<foreach collection="conditionParamRef.roleIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('roleIdStart') and conditionParamRef.roleIdStart != null">
${_conditionType_} a.roleId <![CDATA[ >= ]]> #{${_conditionParam_}.roleIdStart}
</if>
<if test="conditionParamRef.containsKey('roleIdEnd') and conditionParamRef.roleIdEnd != null">
${_conditionType_} a.roleId <![CDATA[ <= ]]> #{${_conditionParam_}.roleIdEnd}
</if>
<if test="conditionParamRef.containsKey('userId')">
<if test="conditionParamRef.userId != null ">
${_conditionType_} a.userId = #{${_conditionParam_}.userId}
</if>
<if test="conditionParamRef.userId == null">
${_conditionType_} a.userId is null
</if>
</if>
<if test="conditionParamRef.containsKey('userIdList')">
${_conditionType_} a.userId in
<foreach collection="conditionParamRef.userIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('userIdStart') and conditionParamRef.userIdStart != null">
${_conditionType_} a.userId <![CDATA[ >= ]]> #{${_conditionParam_}.userIdStart}
</if>
<if test="conditionParamRef.containsKey('userIdEnd') and conditionParamRef.userIdEnd != null">
${_conditionType_} a.userId <![CDATA[ <= ]]> #{${_conditionParam_}.userIdEnd}
</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('roleId')">
a.roleId
<if test='orderCol.roleId != null and "DESC".equalsIgnoreCase(orderCol.roleId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('userId')">
a.userId
<if test='orderCol.userId != null and "DESC".equalsIgnoreCase(orderCol.userId)'>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
portal-manager/src/main/resources/sqlmap/module/system/SystemServiceApiMapper.xml 0 → 100644
View file @ 945f2d4f
<?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.system.dao.ibatis.SystemServiceApiDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="SystemServiceApiEntity" id="SystemServiceApiEntity-Map">
<id property="id" column="id" />
<result property="systemServiceName" column="systemServiceName" />
<result property="systemServiceCode" column="systemServiceCode" />
<result property="systemServiceUrl" column="systemServiceUrl" />
<result property="apiName" column="apiName" />
<result property="apiUrl" column="apiUrl" />
<result property="apiVersion" column="apiVersion" />
<result property="apiStatus" column="apiStatus" />
<result property="createTime" column="createTime" />
<result property="lapseTime" column="lapseTime" />
<result property="apiRemark" column="apiRemark" />
</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('systemServiceName') or colPickMode == 1 and data.containsKey('systemServiceName')))">
a.systemServiceName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('systemServiceCode') or colPickMode == 1 and data.containsKey('systemServiceCode')))">
a.systemServiceCode,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('systemServiceUrl') or colPickMode == 1 and data.containsKey('systemServiceUrl')))">
a.systemServiceUrl,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('apiName') or colPickMode == 1 and data.containsKey('apiName')))">
a.apiName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('apiUrl') or colPickMode == 1 and data.containsKey('apiUrl')))">
a.apiUrl,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('apiVersion') or colPickMode == 1 and data.containsKey('apiVersion')))">
a.apiVersion,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('apiStatus') or colPickMode == 1 and data.containsKey('apiStatus')))">
a.apiStatus,
</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('lapseTime') or colPickMode == 1 and data.containsKey('lapseTime')))">
a.lapseTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('apiRemark') or colPickMode == 1 and data.containsKey('apiRemark')))">
a.apiRemark,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="SystemServiceApiEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_system_service_api
(systemServiceName,systemServiceCode,systemServiceUrl,apiName,apiUrl,apiVersion,apiStatus,createTime,lapseTime,apiRemark)
VALUES
(#{systemServiceName},#{systemServiceCode},#{systemServiceUrl},#{apiName},#{apiUrl},#{apiVersion},#{apiStatus},#{createTime},#{lapseTime},#{apiRemark})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_system_service_api
(systemServiceName,systemServiceCode,systemServiceUrl,apiName,apiUrl,apiVersion,apiStatus,createTime,lapseTime,apiRemark)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.systemServiceName},#{item.systemServiceCode},#{item.systemServiceUrl},#{item.apiName},#{item.apiUrl},#{item.apiVersion},#{item.apiStatus},#{item.createTime},#{item.lapseTime},#{item.apiRemark})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_system_service_api as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('systemServiceName')) or (colPickMode==1 and !data.containsKey('systemServiceName'))">
a.systemServiceName=#{data.systemServiceName},
</if>
<if test="(colPickMode==0 and data.containsKey('systemServiceCode')) or (colPickMode==1 and !data.containsKey('systemServiceCode'))">
a.systemServiceCode=#{data.systemServiceCode},
</if>
<if test="(colPickMode==0 and data.containsKey('systemServiceUrl')) or (colPickMode==1 and !data.containsKey('systemServiceUrl'))">
a.systemServiceUrl=#{data.systemServiceUrl},
</if>
<if test="(colPickMode==0 and data.containsKey('apiName')) or (colPickMode==1 and !data.containsKey('apiName'))">
a.apiName=#{data.apiName},
</if>
<if test="(colPickMode==0 and data.containsKey('apiUrl')) or (colPickMode==1 and !data.containsKey('apiUrl'))">
a.apiUrl=#{data.apiUrl},
</if>
<if test="(colPickMode==0 and data.containsKey('apiVersion')) or (colPickMode==1 and !data.containsKey('apiVersion'))">
a.apiVersion=#{data.apiVersion},
</if>
<if test="(colPickMode==0 and data.containsKey('apiStatus')) or (colPickMode==1 and !data.containsKey('apiStatus'))">
a.apiStatus=#{data.apiStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('apiStatusIncrement')) or (colPickMode==1 and !data.containsKey('apiStatusIncrement'))">
a.apiStatus=ifnull(a.apiStatus,0) + #{data.apiStatusIncrement},
</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('lapseTime')) or (colPickMode==1 and !data.containsKey('lapseTime'))">
a.lapseTime=#{data.lapseTime},
</if>
<if test="(colPickMode==0 and data.containsKey('apiRemark')) or (colPickMode==1 and !data.containsKey('apiRemark'))">
a.apiRemark=#{data.apiRemark},
</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_system_service_api as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="systemServiceName=(case" suffix="ELSE systemServiceName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('systemServiceName')) or (colPickMode==1 and !item.containsKey('systemServiceName'))">
when a.id=#{item.id} then #{item.systemServiceName}
</if>
</foreach>
</trim>
<trim prefix="systemServiceCode=(case" suffix="ELSE systemServiceCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('systemServiceCode')) or (colPickMode==1 and !item.containsKey('systemServiceCode'))">
when a.id=#{item.id} then #{item.systemServiceCode}
</if>
</foreach>
</trim>
<trim prefix="systemServiceUrl=(case" suffix="ELSE systemServiceUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('systemServiceUrl')) or (colPickMode==1 and !item.containsKey('systemServiceUrl'))">
when a.id=#{item.id} then #{item.systemServiceUrl}
</if>
</foreach>
</trim>
<trim prefix="apiName=(case" suffix="ELSE apiName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('apiName')) or (colPickMode==1 and !item.containsKey('apiName'))">
when a.id=#{item.id} then #{item.apiName}
</if>
</foreach>
</trim>
<trim prefix="apiUrl=(case" suffix="ELSE apiUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('apiUrl')) or (colPickMode==1 and !item.containsKey('apiUrl'))">
when a.id=#{item.id} then #{item.apiUrl}
</if>
</foreach>
</trim>
<trim prefix="apiVersion=(case" suffix="ELSE apiVersion end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('apiVersion')) or (colPickMode==1 and !item.containsKey('apiVersion'))">
when a.id=#{item.id} then #{item.apiVersion}
</if>
</foreach>
</trim>
<trim prefix="apiStatus=(case" suffix="ELSE apiStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('apiStatus')) or (colPickMode==1 and !item.containsKey('apiStatus'))">
when a.id=#{item.id} then #{item.apiStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('apiStatusIncrement')) or (colPickMode==1 and !item.containsKey('apiStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.apiStatus,0) + #{item.apiStatusIncrement}
</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="lapseTime=(case" suffix="ELSE lapseTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('lapseTime')) or (colPickMode==1 and !item.containsKey('lapseTime'))">
when a.id=#{item.id} then #{item.lapseTime}
</if>
</foreach>
</trim>
<trim prefix="apiRemark=(case" suffix="ELSE apiRemark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('apiRemark')) or (colPickMode==1 and !item.containsKey('apiRemark'))">
when a.id=#{item.id} then #{item.apiRemark}
</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="SystemServiceApiEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_system_service_api as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_system_service_api as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_system_service_api where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_system_service_api as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="SystemServiceApiEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_system_service_api 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_system_service_api as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('systemServiceName')">
<if test="conditionParamRef.systemServiceName != null and conditionParamRef.systemServiceName != ''">
${_conditionType_} a.systemServiceName like #{${_conditionParam_}.systemServiceName}
</if>
<if test="conditionParamRef.systemServiceName == null">
${_conditionType_} a.systemServiceName is null
</if>
</if>
<if test="conditionParamRef.containsKey('systemServiceNameList')">
${_conditionType_} a.systemServiceName in
<foreach collection="conditionParamRef.systemServiceNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('systemServiceCode')">
<if test="conditionParamRef.systemServiceCode != null and conditionParamRef.systemServiceCode != ''">
${_conditionType_} a.systemServiceCode like #{${_conditionParam_}.systemServiceCode}
</if>
<if test="conditionParamRef.systemServiceCode == null">
${_conditionType_} a.systemServiceCode is null
</if>
</if>
<if test="conditionParamRef.containsKey('systemServiceCodeList')">
${_conditionType_} a.systemServiceCode in
<foreach collection="conditionParamRef.systemServiceCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('systemServiceUrl')">
<if test="conditionParamRef.systemServiceUrl != null and conditionParamRef.systemServiceUrl != ''">
${_conditionType_} a.systemServiceUrl like #{${_conditionParam_}.systemServiceUrl}
</if>
<if test="conditionParamRef.systemServiceUrl == null">
${_conditionType_} a.systemServiceUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('systemServiceUrlList')">
${_conditionType_} a.systemServiceUrl in
<foreach collection="conditionParamRef.systemServiceUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('apiName')">
<if test="conditionParamRef.apiName != null and conditionParamRef.apiName != ''">
${_conditionType_} a.apiName like #{${_conditionParam_}.apiName}
</if>
<if test="conditionParamRef.apiName == null">
${_conditionType_} a.apiName is null
</if>
</if>
<if test="conditionParamRef.containsKey('apiNameList')">
${_conditionType_} a.apiName in
<foreach collection="conditionParamRef.apiNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('apiUrl')">
<if test="conditionParamRef.apiUrl != null and conditionParamRef.apiUrl != ''">
${_conditionType_} a.apiUrl like #{${_conditionParam_}.apiUrl}
</if>
<if test="conditionParamRef.apiUrl == null">
${_conditionType_} a.apiUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('apiUrlList')">
${_conditionType_} a.apiUrl in
<foreach collection="conditionParamRef.apiUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('apiVersion')">
<if test="conditionParamRef.apiVersion != null and conditionParamRef.apiVersion != ''">
${_conditionType_} a.apiVersion like #{${_conditionParam_}.apiVersion}
</if>
<if test="conditionParamRef.apiVersion == null">
${_conditionType_} a.apiVersion is null
</if>
</if>
<if test="conditionParamRef.containsKey('apiVersionList')">
${_conditionType_} a.apiVersion in
<foreach collection="conditionParamRef.apiVersionList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('apiStatus')">
<if test="conditionParamRef.apiStatus != null ">
${_conditionType_} a.apiStatus = #{${_conditionParam_}.apiStatus}
</if>
<if test="conditionParamRef.apiStatus == null">
${_conditionType_} a.apiStatus is null
</if>
</if>
<if test="conditionParamRef.containsKey('apiStatusList')">
${_conditionType_} a.apiStatus in
<foreach collection="conditionParamRef.apiStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('apiStatusStart') and conditionParamRef.apiStatusStart != null">
${_conditionType_} a.apiStatus <![CDATA[ >= ]]> #{${_conditionParam_}.apiStatusStart}
</if>
<if test="conditionParamRef.containsKey('apiStatusEnd') and conditionParamRef.apiStatusEnd != null">
${_conditionType_} a.apiStatus <![CDATA[ <= ]]> #{${_conditionParam_}.apiStatusEnd}
</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('lapseTime')">
<if test="conditionParamRef.lapseTime != null ">
${_conditionType_} a.lapseTime = #{${_conditionParam_}.lapseTime}
</if>
<if test="conditionParamRef.lapseTime == null">
${_conditionType_} a.lapseTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('lapseTimeStart') and conditionParamRef.lapseTimeStart != null and conditionParamRef.lapseTimeStart!=''">
${_conditionType_} a.lapseTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lapseTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('lapseTimeEnd') and conditionParamRef.lapseTimeEnd != null and conditionParamRef.lapseTimeEnd!=''">
${_conditionType_} a.lapseTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lapseTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('apiRemark')">
<if test="conditionParamRef.apiRemark != null and conditionParamRef.apiRemark != ''">
${_conditionType_} a.apiRemark like #{${_conditionParam_}.apiRemark}
</if>
<if test="conditionParamRef.apiRemark == null">
${_conditionType_} a.apiRemark is null
</if>
</if>
<if test="conditionParamRef.containsKey('apiRemarkList')">
${_conditionType_} a.apiRemark in
<foreach collection="conditionParamRef.apiRemarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('systemServiceName')">
a.systemServiceName
<if test='orderCol.systemServiceName != null and "DESC".equalsIgnoreCase(orderCol.systemServiceName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('systemServiceCode')">
a.systemServiceCode
<if test='orderCol.systemServiceCode != null and "DESC".equalsIgnoreCase(orderCol.systemServiceCode)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('systemServiceUrl')">
a.systemServiceUrl
<if test='orderCol.systemServiceUrl != null and "DESC".equalsIgnoreCase(orderCol.systemServiceUrl)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('apiName')">
a.apiName
<if test='orderCol.apiName != null and "DESC".equalsIgnoreCase(orderCol.apiName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('apiUrl')">
a.apiUrl
<if test='orderCol.apiUrl != null and "DESC".equalsIgnoreCase(orderCol.apiUrl)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('apiVersion')">
a.apiVersion
<if test='orderCol.apiVersion != null and "DESC".equalsIgnoreCase(orderCol.apiVersion)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('apiStatus')">
a.apiStatus
<if test='orderCol.apiStatus != null and "DESC".equalsIgnoreCase(orderCol.apiStatus)'>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('lapseTime')">
a.lapseTime
<if test='orderCol.lapseTime != null and "DESC".equalsIgnoreCase(orderCol.lapseTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('apiRemark')">
a.apiRemark
<if test='orderCol.apiRemark != null and "DESC".equalsIgnoreCase(orderCol.apiRemark)'>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
portal-manager/src/main/resources/sqlmap/module/system/SystemServiceMapper.xml 0 → 100644
View file @ 945f2d4f
<?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.system.dao.ibatis.SystemServiceDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="SystemServiceEntity" id="SystemServiceEntity-Map">
<id property="id" column="id" />
<result property="systemServiceName" column="systemServiceName" />
<result property="systemServiceCode" column="systemServiceCode" />
<result property="systemServiceUrl" column="systemServiceUrl" />
<result property="packageName" column="packageName" />
<result property="packagePath" column="packagePath" />
<result property="packageVersion" column="packageVersion" />
<result property="apiStatus" column="apiStatus" />
<result property="createTime" column="createTime" />
<result property="lapseTime" column="lapseTime" />
<result property="packageRemark" column="packageRemark" />
</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('systemServiceName') or colPickMode == 1 and data.containsKey('systemServiceName')))">
a.systemServiceName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('systemServiceCode') or colPickMode == 1 and data.containsKey('systemServiceCode')))">
a.systemServiceCode,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('systemServiceUrl') or colPickMode == 1 and data.containsKey('systemServiceUrl')))">
a.systemServiceUrl,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('packageName') or colPickMode == 1 and data.containsKey('packageName')))">
a.packageName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('packagePath') or colPickMode == 1 and data.containsKey('packagePath')))">
a.packagePath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('packageVersion') or colPickMode == 1 and data.containsKey('packageVersion')))">
a.packageVersion,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('apiStatus') or colPickMode == 1 and data.containsKey('apiStatus')))">
a.apiStatus,
</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('lapseTime') or colPickMode == 1 and data.containsKey('lapseTime')))">
a.lapseTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('packageRemark') or colPickMode == 1 and data.containsKey('packageRemark')))">
a.packageRemark,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="SystemServiceEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_system_service
(systemServiceName,systemServiceCode,systemServiceUrl,packageName,packagePath,packageVersion,apiStatus,createTime,lapseTime,packageRemark)
VALUES
(#{systemServiceName},#{systemServiceCode},#{systemServiceUrl},#{packageName},#{packagePath},#{packageVersion},#{apiStatus},#{createTime},#{lapseTime},#{packageRemark})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_system_service
(systemServiceName,systemServiceCode,systemServiceUrl,packageName,packagePath,packageVersion,apiStatus,createTime,lapseTime,packageRemark)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.systemServiceName},#{item.systemServiceCode},#{item.systemServiceUrl},#{item.packageName},#{item.packagePath},#{item.packageVersion},#{item.apiStatus},#{item.createTime},#{item.lapseTime},#{item.packageRemark})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_system_service as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('systemServiceName')) or (colPickMode==1 and !data.containsKey('systemServiceName'))">
a.systemServiceName=#{data.systemServiceName},
</if>
<if test="(colPickMode==0 and data.containsKey('systemServiceCode')) or (colPickMode==1 and !data.containsKey('systemServiceCode'))">
a.systemServiceCode=#{data.systemServiceCode},
</if>
<if test="(colPickMode==0 and data.containsKey('systemServiceUrl')) or (colPickMode==1 and !data.containsKey('systemServiceUrl'))">
a.systemServiceUrl=#{data.systemServiceUrl},
</if>
<if test="(colPickMode==0 and data.containsKey('packageName')) or (colPickMode==1 and !data.containsKey('packageName'))">
a.packageName=#{data.packageName},
</if>
<if test="(colPickMode==0 and data.containsKey('packagePath')) or (colPickMode==1 and !data.containsKey('packagePath'))">
a.packagePath=#{data.packagePath},
</if>
<if test="(colPickMode==0 and data.containsKey('packageVersion')) or (colPickMode==1 and !data.containsKey('packageVersion'))">
a.packageVersion=#{data.packageVersion},
</if>
<if test="(colPickMode==0 and data.containsKey('apiStatus')) or (colPickMode==1 and !data.containsKey('apiStatus'))">
a.apiStatus=#{data.apiStatus},
</if>
<if test="(colPickMode==0 and data.containsKey('apiStatusIncrement')) or (colPickMode==1 and !data.containsKey('apiStatusIncrement'))">
a.apiStatus=ifnull(a.apiStatus,0) + #{data.apiStatusIncrement},
</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('lapseTime')) or (colPickMode==1 and !data.containsKey('lapseTime'))">
a.lapseTime=#{data.lapseTime},
</if>
<if test="(colPickMode==0 and data.containsKey('packageRemark')) or (colPickMode==1 and !data.containsKey('packageRemark'))">
a.packageRemark=#{data.packageRemark},
</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_system_service as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="systemServiceName=(case" suffix="ELSE systemServiceName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('systemServiceName')) or (colPickMode==1 and !item.containsKey('systemServiceName'))">
when a.id=#{item.id} then #{item.systemServiceName}
</if>
</foreach>
</trim>
<trim prefix="systemServiceCode=(case" suffix="ELSE systemServiceCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('systemServiceCode')) or (colPickMode==1 and !item.containsKey('systemServiceCode'))">
when a.id=#{item.id} then #{item.systemServiceCode}
</if>
</foreach>
</trim>
<trim prefix="systemServiceUrl=(case" suffix="ELSE systemServiceUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('systemServiceUrl')) or (colPickMode==1 and !item.containsKey('systemServiceUrl'))">
when a.id=#{item.id} then #{item.systemServiceUrl}
</if>
</foreach>
</trim>
<trim prefix="packageName=(case" suffix="ELSE packageName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('packageName')) or (colPickMode==1 and !item.containsKey('packageName'))">
when a.id=#{item.id} then #{item.packageName}
</if>
</foreach>
</trim>
<trim prefix="packagePath=(case" suffix="ELSE packagePath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('packagePath')) or (colPickMode==1 and !item.containsKey('packagePath'))">
when a.id=#{item.id} then #{item.packagePath}
</if>
</foreach>
</trim>
<trim prefix="packageVersion=(case" suffix="ELSE packageVersion end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('packageVersion')) or (colPickMode==1 and !item.containsKey('packageVersion'))">
when a.id=#{item.id} then #{item.packageVersion}
</if>
</foreach>
</trim>
<trim prefix="apiStatus=(case" suffix="ELSE apiStatus end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('apiStatus')) or (colPickMode==1 and !item.containsKey('apiStatus'))">
when a.id=#{item.id} then #{item.apiStatus}
</when>
<when test="(colPickMode==0 and item.containsKey('apiStatusIncrement')) or (colPickMode==1 and !item.containsKey('apiStatusIncrement'))">
when a.id=#{item.id} then ifnull(a.apiStatus,0) + #{item.apiStatusIncrement}
</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="lapseTime=(case" suffix="ELSE lapseTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('lapseTime')) or (colPickMode==1 and !item.containsKey('lapseTime'))">
when a.id=#{item.id} then #{item.lapseTime}
</if>
</foreach>
</trim>
<trim prefix="packageRemark=(case" suffix="ELSE packageRemark end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('packageRemark')) or (colPickMode==1 and !item.containsKey('packageRemark'))">
when a.id=#{item.id} then #{item.packageRemark}
</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="SystemServiceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_system_service as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_system_service as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_system_service where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_system_service as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="SystemServiceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_system_service 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_system_service as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('systemServiceName')">
<if test="conditionParamRef.systemServiceName != null and conditionParamRef.systemServiceName != ''">
${_conditionType_} a.systemServiceName like #{${_conditionParam_}.systemServiceName}
</if>
<if test="conditionParamRef.systemServiceName == null">
${_conditionType_} a.systemServiceName is null
</if>
</if>
<if test="conditionParamRef.containsKey('systemServiceNameList')">
${_conditionType_} a.systemServiceName in
<foreach collection="conditionParamRef.systemServiceNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('systemServiceCode')">
<if test="conditionParamRef.systemServiceCode != null and conditionParamRef.systemServiceCode != ''">
${_conditionType_} a.systemServiceCode like #{${_conditionParam_}.systemServiceCode}
</if>
<if test="conditionParamRef.systemServiceCode == null">
${_conditionType_} a.systemServiceCode is null
</if>
</if>
<if test="conditionParamRef.containsKey('systemServiceCodeList')">
${_conditionType_} a.systemServiceCode in
<foreach collection="conditionParamRef.systemServiceCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('systemServiceUrl')">
<if test="conditionParamRef.systemServiceUrl != null and conditionParamRef.systemServiceUrl != ''">
${_conditionType_} a.systemServiceUrl like #{${_conditionParam_}.systemServiceUrl}
</if>
<if test="conditionParamRef.systemServiceUrl == null">
${_conditionType_} a.systemServiceUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('systemServiceUrlList')">
${_conditionType_} a.systemServiceUrl in
<foreach collection="conditionParamRef.systemServiceUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('packageName')">
<if test="conditionParamRef.packageName != null and conditionParamRef.packageName != ''">
${_conditionType_} a.packageName like #{${_conditionParam_}.packageName}
</if>
<if test="conditionParamRef.packageName == null">
${_conditionType_} a.packageName is null
</if>
</if>
<if test="conditionParamRef.containsKey('packageNameList')">
${_conditionType_} a.packageName in
<foreach collection="conditionParamRef.packageNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('packagePath')">
<if test="conditionParamRef.packagePath != null and conditionParamRef.packagePath != ''">
${_conditionType_} a.packagePath like #{${_conditionParam_}.packagePath}
</if>
<if test="conditionParamRef.packagePath == null">
${_conditionType_} a.packagePath is null
</if>
</if>
<if test="conditionParamRef.containsKey('packagePathList')">
${_conditionType_} a.packagePath in
<foreach collection="conditionParamRef.packagePathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('packageVersion')">
<if test="conditionParamRef.packageVersion != null and conditionParamRef.packageVersion != ''">
${_conditionType_} a.packageVersion like #{${_conditionParam_}.packageVersion}
</if>
<if test="conditionParamRef.packageVersion == null">
${_conditionType_} a.packageVersion is null
</if>
</if>
<if test="conditionParamRef.containsKey('packageVersionList')">
${_conditionType_} a.packageVersion in
<foreach collection="conditionParamRef.packageVersionList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('apiStatus')">
<if test="conditionParamRef.apiStatus != null ">
${_conditionType_} a.apiStatus = #{${_conditionParam_}.apiStatus}
</if>
<if test="conditionParamRef.apiStatus == null">
${_conditionType_} a.apiStatus is null
</if>
</if>
<if test="conditionParamRef.containsKey('apiStatusList')">
${_conditionType_} a.apiStatus in
<foreach collection="conditionParamRef.apiStatusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('apiStatusStart') and conditionParamRef.apiStatusStart != null">
${_conditionType_} a.apiStatus <![CDATA[ >= ]]> #{${_conditionParam_}.apiStatusStart}
</if>
<if test="conditionParamRef.containsKey('apiStatusEnd') and conditionParamRef.apiStatusEnd != null">
${_conditionType_} a.apiStatus <![CDATA[ <= ]]> #{${_conditionParam_}.apiStatusEnd}
</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('lapseTime')">
<if test="conditionParamRef.lapseTime != null ">
${_conditionType_} a.lapseTime = #{${_conditionParam_}.lapseTime}
</if>
<if test="conditionParamRef.lapseTime == null">
${_conditionType_} a.lapseTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('lapseTimeStart') and conditionParamRef.lapseTimeStart != null and conditionParamRef.lapseTimeStart!=''">
${_conditionType_} a.lapseTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lapseTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('lapseTimeEnd') and conditionParamRef.lapseTimeEnd != null and conditionParamRef.lapseTimeEnd!=''">
${_conditionType_} a.lapseTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lapseTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('packageRemark')">
<if test="conditionParamRef.packageRemark != null and conditionParamRef.packageRemark != ''">
${_conditionType_} a.packageRemark like #{${_conditionParam_}.packageRemark}
</if>
<if test="conditionParamRef.packageRemark == null">
${_conditionType_} a.packageRemark is null
</if>
</if>
<if test="conditionParamRef.containsKey('packageRemarkList')">
${_conditionType_} a.packageRemark in
<foreach collection="conditionParamRef.packageRemarkList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('systemServiceName')">
a.systemServiceName
<if test='orderCol.systemServiceName != null and "DESC".equalsIgnoreCase(orderCol.systemServiceName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('systemServiceCode')">
a.systemServiceCode
<if test='orderCol.systemServiceCode != null and "DESC".equalsIgnoreCase(orderCol.systemServiceCode)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('systemServiceUrl')">
a.systemServiceUrl
<if test='orderCol.systemServiceUrl != null and "DESC".equalsIgnoreCase(orderCol.systemServiceUrl)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('packageName')">
a.packageName
<if test='orderCol.packageName != null and "DESC".equalsIgnoreCase(orderCol.packageName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('packagePath')">
a.packagePath
<if test='orderCol.packagePath != null and "DESC".equalsIgnoreCase(orderCol.packagePath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('packageVersion')">
a.packageVersion
<if test='orderCol.packageVersion != null and "DESC".equalsIgnoreCase(orderCol.packageVersion)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('apiStatus')">
a.apiStatus
<if test='orderCol.apiStatus != null and "DESC".equalsIgnoreCase(orderCol.apiStatus)'>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('lapseTime')">
a.lapseTime
<if test='orderCol.lapseTime != null and "DESC".equalsIgnoreCase(orderCol.lapseTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('packageRemark')">
a.packageRemark
<if test='orderCol.packageRemark != null and "DESC".equalsIgnoreCase(orderCol.packageRemark)'>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
portal-manager/src/main/resources/sqlmap/module/uploadfile/UploadfileMapper.xml 0 → 100644
View file @ 945f2d4f
<?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.uploadfile.dao.ibatis.UploadfileDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="UploadfileEntity" id="UploadfileEntity-Map">
<id property="id" column="id" />
<result property="fileName" column="fileName" />
<result property="filePath" column="filePath" />
<result property="fileType" column="fileType" />
<result property="createTime" column="createTime" />
<result property="createUser" column="createUser" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fileName') or colPickMode == 1 and data.containsKey('fileName')))">
a.fileName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('filePath') or colPickMode == 1 and data.containsKey('filePath')))">
a.filePath,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fileType') or colPickMode == 1 and data.containsKey('fileType')))">
a.fileType,
</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('createUser') or colPickMode == 1 and data.containsKey('createUser')))">
a.createUser,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="UploadfileEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_uploadfile
(fileName,filePath,fileType,createTime,createUser)
VALUES
(#{fileName},#{filePath},#{fileType},#{createTime},#{createUser})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_uploadfile
(fileName,filePath,fileType,createTime,createUser)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.fileName},#{item.filePath},#{item.fileType},#{item.createTime},#{item.createUser})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_uploadfile as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('fileName')) or (colPickMode==1 and !data.containsKey('fileName'))">
a.fileName=#{data.fileName},
</if>
<if test="(colPickMode==0 and data.containsKey('filePath')) or (colPickMode==1 and !data.containsKey('filePath'))">
a.filePath=#{data.filePath},
</if>
<if test="(colPickMode==0 and data.containsKey('fileType')) or (colPickMode==1 and !data.containsKey('fileType'))">
a.fileType=#{data.fileType},
</if>
<if test="(colPickMode==0 and data.containsKey('fileTypeIncrement')) or (colPickMode==1 and !data.containsKey('fileTypeIncrement'))">
a.fileType=ifnull(a.fileType,0) + #{data.fileTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUser')) or (colPickMode==1 and !data.containsKey('createUser'))">
a.createUser=#{data.createUser},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_uploadfile as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="fileName=(case" suffix="ELSE fileName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('fileName')) or (colPickMode==1 and !item.containsKey('fileName'))">
when a.id=#{item.id} then #{item.fileName}
</if>
</foreach>
</trim>
<trim prefix="filePath=(case" suffix="ELSE filePath end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('filePath')) or (colPickMode==1 and !item.containsKey('filePath'))">
when a.id=#{item.id} then #{item.filePath}
</if>
</foreach>
</trim>
<trim prefix="fileType=(case" suffix="ELSE fileType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('fileType')) or (colPickMode==1 and !item.containsKey('fileType'))">
when a.id=#{item.id} then #{item.fileType}
</when>
<when test="(colPickMode==0 and item.containsKey('fileTypeIncrement')) or (colPickMode==1 and !item.containsKey('fileTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.fileType,0) + #{item.fileTypeIncrement}
</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="createUser=(case" suffix="ELSE createUser end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createUser')) or (colPickMode==1 and !item.containsKey('createUser'))">
when a.id=#{item.id} then #{item.createUser}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="UploadfileEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_uploadfile as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_uploadfile as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_uploadfile where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_uploadfile as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="UploadfileEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_uploadfile 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_uploadfile as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('fileName')">
<if test="conditionParamRef.fileName != null and conditionParamRef.fileName != ''">
${_conditionType_} a.fileName like #{${_conditionParam_}.fileName}
</if>
<if test="conditionParamRef.fileName == null">
${_conditionType_} a.fileName is null
</if>
</if>
<if test="conditionParamRef.containsKey('fileNameList')">
${_conditionType_} a.fileName in
<foreach collection="conditionParamRef.fileNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('filePath')">
<if test="conditionParamRef.filePath != null and conditionParamRef.filePath != ''">
${_conditionType_} a.filePath like #{${_conditionParam_}.filePath}
</if>
<if test="conditionParamRef.filePath == null">
${_conditionType_} a.filePath is null
</if>
</if>
<if test="conditionParamRef.containsKey('filePathList')">
${_conditionType_} a.filePath in
<foreach collection="conditionParamRef.filePathList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fileType')">
<if test="conditionParamRef.fileType != null ">
${_conditionType_} a.fileType = #{${_conditionParam_}.fileType}
</if>
<if test="conditionParamRef.fileType == null">
${_conditionType_} a.fileType is null
</if>
</if>
<if test="conditionParamRef.containsKey('fileTypeList')">
${_conditionType_} a.fileType in
<foreach collection="conditionParamRef.fileTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('fileTypeStart') and conditionParamRef.fileTypeStart != null">
${_conditionType_} a.fileType <![CDATA[ >= ]]> #{${_conditionParam_}.fileTypeStart}
</if>
<if test="conditionParamRef.containsKey('fileTypeEnd') and conditionParamRef.fileTypeEnd != null">
${_conditionType_} a.fileType <![CDATA[ <= ]]> #{${_conditionParam_}.fileTypeEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUser')">
<if test="conditionParamRef.createUser != null and conditionParamRef.createUser != ''">
${_conditionType_} a.createUser like #{${_conditionParam_}.createUser}
</if>
<if test="conditionParamRef.createUser == null">
${_conditionType_} a.createUser is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserList')">
${_conditionType_} a.createUser in
<foreach collection="conditionParamRef.createUserList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('fileName')">
a.fileName
<if test='orderCol.fileName != null and "DESC".equalsIgnoreCase(orderCol.fileName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('filePath')">
a.filePath
<if test='orderCol.filePath != null and "DESC".equalsIgnoreCase(orderCol.filePath)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('fileType')">
a.fileType
<if test='orderCol.fileType != null and "DESC".equalsIgnoreCase(orderCol.fileType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUser')">
a.createUser
<if test='orderCol.createUser != null and "DESC".equalsIgnoreCase(orderCol.createUser)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
portal-manager/src/main/resources/sqlmap/module/user/UserMapper.xml 0 → 100644
View file @ 945f2d4f
<?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.user.dao.ibatis.UserDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="UserEntity" id="UserEntity-Map">
<id property="id" column="id" />
<result property="loginName" column="loginName" />
<result property="loginPwd" column="loginPwd" />
<result property="loginLimitAddress" column="loginLimitAddress" />
<result property="realName" column="realName" />
<result property="mobile" column="mobile" />
<result property="phone" column="phone" />
<result property="email" column="email" />
<result property="qq" column="qq" />
<result property="userType" column="userType" />
<result property="siteIds" column="siteIds" />
<result property="status" column="status" />
<result property="customerId" column="customerId" />
<result property="createTime" column="createTime" />
<result property="createUserId" column="createUserId" />
<result property="createUserName" column="createUserName" />
<result property="lastLoginTime" column="lastLoginTime" />
<result property="lastLoginAddress" column="lastLoginAddress" />
</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('loginName') or colPickMode == 1 and data.containsKey('loginName')))">
a.loginName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('loginPwd') or colPickMode == 1 and data.containsKey('loginPwd')))">
a.loginPwd,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('loginLimitAddress') or colPickMode == 1 and data.containsKey('loginLimitAddress')))">
a.loginLimitAddress,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('realName') or colPickMode == 1 and data.containsKey('realName')))">
a.realName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('mobile') or colPickMode == 1 and data.containsKey('mobile')))">
a.mobile,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('phone') or colPickMode == 1 and data.containsKey('phone')))">
a.phone,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('email') or colPickMode == 1 and data.containsKey('email')))">
a.email,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('qq') or colPickMode == 1 and data.containsKey('qq')))">
a.qq,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('userType') or colPickMode == 1 and data.containsKey('userType')))">
a.userType,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('siteIds') or colPickMode == 1 and data.containsKey('siteIds')))">
a.siteIds,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('status') or colPickMode == 1 and data.containsKey('status')))">
a.status,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('customerId') or colPickMode == 1 and data.containsKey('customerId')))">
a.customerId,
</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('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserName') or colPickMode == 1 and data.containsKey('createUserName')))">
a.createUserName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('lastLoginTime') or colPickMode == 1 and data.containsKey('lastLoginTime')))">
a.lastLoginTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('lastLoginAddress') or colPickMode == 1 and data.containsKey('lastLoginAddress')))">
a.lastLoginAddress,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="UserEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_user
(loginName,loginPwd,loginLimitAddress,realName,mobile,phone,email,qq,userType,siteIds,status,customerId,createTime,createUserId,createUserName,lastLoginTime,lastLoginAddress)
VALUES
(#{loginName},#{loginPwd},#{loginLimitAddress},#{realName},#{mobile},#{phone},#{email},#{qq},#{userType},#{siteIds},#{status},#{customerId},#{createTime},#{createUserId},#{createUserName},#{lastLoginTime},#{lastLoginAddress})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_user
(loginName,loginPwd,loginLimitAddress,realName,mobile,phone,email,qq,userType,siteIds,status,customerId,createTime,createUserId,createUserName,lastLoginTime,lastLoginAddress)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.loginName},#{item.loginPwd},#{item.loginLimitAddress},#{item.realName},#{item.mobile},#{item.phone},#{item.email},#{item.qq},#{item.userType},#{item.siteIds},#{item.status},#{item.customerId},#{item.createTime},#{item.createUserId},#{item.createUserName},#{item.lastLoginTime},#{item.lastLoginAddress})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_user as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('loginName')) or (colPickMode==1 and !data.containsKey('loginName'))">
a.loginName=#{data.loginName},
</if>
<if test="(colPickMode==0 and data.containsKey('loginPwd')) or (colPickMode==1 and !data.containsKey('loginPwd'))">
a.loginPwd=#{data.loginPwd},
</if>
<if test="(colPickMode==0 and data.containsKey('loginLimitAddress')) or (colPickMode==1 and !data.containsKey('loginLimitAddress'))">
a.loginLimitAddress=#{data.loginLimitAddress},
</if>
<if test="(colPickMode==0 and data.containsKey('realName')) or (colPickMode==1 and !data.containsKey('realName'))">
a.realName=#{data.realName},
</if>
<if test="(colPickMode==0 and data.containsKey('mobile')) or (colPickMode==1 and !data.containsKey('mobile'))">
a.mobile=#{data.mobile},
</if>
<if test="(colPickMode==0 and data.containsKey('phone')) or (colPickMode==1 and !data.containsKey('phone'))">
a.phone=#{data.phone},
</if>
<if test="(colPickMode==0 and data.containsKey('email')) or (colPickMode==1 and !data.containsKey('email'))">
a.email=#{data.email},
</if>
<if test="(colPickMode==0 and data.containsKey('qq')) or (colPickMode==1 and !data.containsKey('qq'))">
a.qq=#{data.qq},
</if>
<if test="(colPickMode==0 and data.containsKey('userType')) or (colPickMode==1 and !data.containsKey('userType'))">
a.userType=#{data.userType},
</if>
<if test="(colPickMode==0 and data.containsKey('userTypeIncrement')) or (colPickMode==1 and !data.containsKey('userTypeIncrement'))">
a.userType=ifnull(a.userType,0) + #{data.userTypeIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('siteIds')) or (colPickMode==1 and !data.containsKey('siteIds'))">
a.siteIds=#{data.siteIds},
</if>
<if test="(colPickMode==0 and data.containsKey('status')) or (colPickMode==1 and !data.containsKey('status'))">
a.status=#{data.status},
</if>
<if test="(colPickMode==0 and data.containsKey('statusIncrement')) or (colPickMode==1 and !data.containsKey('statusIncrement'))">
a.status=ifnull(a.status,0) + #{data.statusIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('customerId')) or (colPickMode==1 and !data.containsKey('customerId'))">
a.customerId=#{data.customerId},
</if>
<if test="(colPickMode==0 and data.containsKey('customerIdIncrement')) or (colPickMode==1 and !data.containsKey('customerIdIncrement'))">
a.customerId=ifnull(a.customerId,0) + #{data.customerIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserName')) or (colPickMode==1 and !data.containsKey('createUserName'))">
a.createUserName=#{data.createUserName},
</if>
<if test="(colPickMode==0 and data.containsKey('lastLoginTime')) or (colPickMode==1 and !data.containsKey('lastLoginTime'))">
a.lastLoginTime=#{data.lastLoginTime},
</if>
<if test="(colPickMode==0 and data.containsKey('lastLoginAddress')) or (colPickMode==1 and !data.containsKey('lastLoginAddress'))">
a.lastLoginAddress=#{data.lastLoginAddress},
</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_user as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="loginName=(case" suffix="ELSE loginName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('loginName')) or (colPickMode==1 and !item.containsKey('loginName'))">
when a.id=#{item.id} then #{item.loginName}
</if>
</foreach>
</trim>
<trim prefix="loginPwd=(case" suffix="ELSE loginPwd end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('loginPwd')) or (colPickMode==1 and !item.containsKey('loginPwd'))">
when a.id=#{item.id} then #{item.loginPwd}
</if>
</foreach>
</trim>
<trim prefix="loginLimitAddress=(case" suffix="ELSE loginLimitAddress end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('loginLimitAddress')) or (colPickMode==1 and !item.containsKey('loginLimitAddress'))">
when a.id=#{item.id} then #{item.loginLimitAddress}
</if>
</foreach>
</trim>
<trim prefix="realName=(case" suffix="ELSE realName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('realName')) or (colPickMode==1 and !item.containsKey('realName'))">
when a.id=#{item.id} then #{item.realName}
</if>
</foreach>
</trim>
<trim prefix="mobile=(case" suffix="ELSE mobile end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('mobile')) or (colPickMode==1 and !item.containsKey('mobile'))">
when a.id=#{item.id} then #{item.mobile}
</if>
</foreach>
</trim>
<trim prefix="phone=(case" suffix="ELSE phone end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('phone')) or (colPickMode==1 and !item.containsKey('phone'))">
when a.id=#{item.id} then #{item.phone}
</if>
</foreach>
</trim>
<trim prefix="email=(case" suffix="ELSE email end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('email')) or (colPickMode==1 and !item.containsKey('email'))">
when a.id=#{item.id} then #{item.email}
</if>
</foreach>
</trim>
<trim prefix="qq=(case" suffix="ELSE qq end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('qq')) or (colPickMode==1 and !item.containsKey('qq'))">
when a.id=#{item.id} then #{item.qq}
</if>
</foreach>
</trim>
<trim prefix="userType=(case" suffix="ELSE userType end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('userType')) or (colPickMode==1 and !item.containsKey('userType'))">
when a.id=#{item.id} then #{item.userType}
</when>
<when test="(colPickMode==0 and item.containsKey('userTypeIncrement')) or (colPickMode==1 and !item.containsKey('userTypeIncrement'))">
when a.id=#{item.id} then ifnull(a.userType,0) + #{item.userTypeIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="siteIds=(case" suffix="ELSE siteIds end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('siteIds')) or (colPickMode==1 and !item.containsKey('siteIds'))">
when a.id=#{item.id} then #{item.siteIds}
</if>
</foreach>
</trim>
<trim prefix="status=(case" suffix="ELSE status end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('status')) or (colPickMode==1 and !item.containsKey('status'))">
when a.id=#{item.id} then #{item.status}
</when>
<when test="(colPickMode==0 and item.containsKey('statusIncrement')) or (colPickMode==1 and !item.containsKey('statusIncrement'))">
when a.id=#{item.id} then ifnull(a.status,0) + #{item.statusIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="customerId=(case" suffix="ELSE customerId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('customerId')) or (colPickMode==1 and !item.containsKey('customerId'))">
when a.id=#{item.id} then #{item.customerId}
</when>
<when test="(colPickMode==0 and item.containsKey('customerIdIncrement')) or (colPickMode==1 and !item.containsKey('customerIdIncrement'))">
when a.id=#{item.id} then ifnull(a.customerId,0) + #{item.customerIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
when a.id=#{item.id} then #{item.createUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="createUserName=(case" suffix="ELSE createUserName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createUserName')) or (colPickMode==1 and !item.containsKey('createUserName'))">
when a.id=#{item.id} then #{item.createUserName}
</if>
</foreach>
</trim>
<trim prefix="lastLoginTime=(case" suffix="ELSE lastLoginTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('lastLoginTime')) or (colPickMode==1 and !item.containsKey('lastLoginTime'))">
when a.id=#{item.id} then #{item.lastLoginTime}
</if>
</foreach>
</trim>
<trim prefix="lastLoginAddress=(case" suffix="ELSE lastLoginAddress end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('lastLoginAddress')) or (colPickMode==1 and !item.containsKey('lastLoginAddress'))">
when a.id=#{item.id} then #{item.lastLoginAddress}
</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="UserEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_user as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_user as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_user where id in
<foreach collection="array" item="item" index="index" open="(" separator="," close=")">
#{item}
</foreach>
</delete>
<!-- 根据paramDto删除一批 -->
<delete id="deleteByMap" parameterType="paramDto">
delete a.* from mortals_xhx_user as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="UserEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_user 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_user as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</select>
<!-- 条件映射 -->
<sql id="_condition_">
<if test="condition != null and !condition.isEmpty()">
<!-- 条件映射-普通条件 -->
<include refid="_condition_param_">
<property name="_conditionParam_" value="condition"/>
<property name="_conditionType_" value="and"/>
</include>
<!-- 条件映射-集合之间使用AND，集合中元素使用OR-(list[0].1 or list[0].2) and (list[1].3 or list[1].4) -->
<if test="condition.containsKey('andConditionList') and !condition.andConditionList.isEmpty()">
and
<foreach collection="condition.andConditionList" open="(" close=")" index="index" item="andCondition" separator=" and ">
<trim prefixOverrides="or" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="andCondition"/>
<property name="_conditionType_" value="or"/>
</include>
</trim>
</foreach>
</if>
<!-- 条件映射-集合之间使用OR，集合中元素使用AND-(list[0].1 and list[0].2) or (list[1].3 and list[1].4) -->
<if test="condition.containsKey('orConditionList') and !condition.orConditionList.isEmpty()">
and
<foreach collection="condition.orConditionList" open="(" close=")" index="index" item="orCondition" separator=" or ">
<trim prefixOverrides="and" prefix="(" suffix=")">
<include refid="_condition_param_">
<property name="_conditionParam_" value="orCondition"/>
<property name="_conditionType_" value="and"/>
</include>
</trim>
</foreach>
</if>
</if>
</sql>
<!-- 条件映射-代参数 -->
<sql id="_condition_param_">
<bind name="conditionParamRef" value="${_conditionParam_}"/>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null">
${_conditionType_} a.id=#{${_conditionParam_}.id}
</if>
</if>
<if test="conditionParamRef.containsKey('id')">
<if test="conditionParamRef.id != null ">
${_conditionType_} a.id = #{${_conditionParam_}.id}
</if>
<if test="conditionParamRef.id == null">
${_conditionType_} a.id is null
</if>
</if>
<if test="conditionParamRef.containsKey('idList')">
${_conditionType_} a.id in
<foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
</if>
<if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
</if>
<if test="conditionParamRef.containsKey('loginName')">
<if test="conditionParamRef.loginName != null and conditionParamRef.loginName != ''">
${_conditionType_} a.loginName like #{${_conditionParam_}.loginName}
</if>
<if test="conditionParamRef.loginName == null">
${_conditionType_} a.loginName is null
</if>
</if>
<if test="conditionParamRef.containsKey('loginNameList')">
${_conditionType_} a.loginName in
<foreach collection="conditionParamRef.loginNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('loginPwd')">
<if test="conditionParamRef.loginPwd != null and conditionParamRef.loginPwd != ''">
${_conditionType_} a.loginPwd like #{${_conditionParam_}.loginPwd}
</if>
<if test="conditionParamRef.loginPwd == null">
${_conditionType_} a.loginPwd is null
</if>
</if>
<if test="conditionParamRef.containsKey('loginPwdList')">
${_conditionType_} a.loginPwd in
<foreach collection="conditionParamRef.loginPwdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('loginLimitAddress')">
<if test="conditionParamRef.loginLimitAddress != null and conditionParamRef.loginLimitAddress != ''">
${_conditionType_} a.loginLimitAddress like #{${_conditionParam_}.loginLimitAddress}
</if>
<if test="conditionParamRef.loginLimitAddress == null">
${_conditionType_} a.loginLimitAddress is null
</if>
</if>
<if test="conditionParamRef.containsKey('loginLimitAddressList')">
${_conditionType_} a.loginLimitAddress in
<foreach collection="conditionParamRef.loginLimitAddressList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('realName')">
<if test="conditionParamRef.realName != null and conditionParamRef.realName != ''">
${_conditionType_} a.realName like #{${_conditionParam_}.realName}
</if>
<if test="conditionParamRef.realName == null">
${_conditionType_} a.realName is null
</if>
</if>
<if test="conditionParamRef.containsKey('realNameList')">
${_conditionType_} a.realName in
<foreach collection="conditionParamRef.realNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('mobile')">
<if test="conditionParamRef.mobile != null and conditionParamRef.mobile != ''">
${_conditionType_} a.mobile like #{${_conditionParam_}.mobile}
</if>
<if test="conditionParamRef.mobile == null">
${_conditionType_} a.mobile is null
</if>
</if>
<if test="conditionParamRef.containsKey('mobileList')">
${_conditionType_} a.mobile in
<foreach collection="conditionParamRef.mobileList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('phone')">
<if test="conditionParamRef.phone != null and conditionParamRef.phone != ''">
${_conditionType_} a.phone like #{${_conditionParam_}.phone}
</if>
<if test="conditionParamRef.phone == null">
${_conditionType_} a.phone is null
</if>
</if>
<if test="conditionParamRef.containsKey('phoneList')">
${_conditionType_} a.phone in
<foreach collection="conditionParamRef.phoneList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('email')">
<if test="conditionParamRef.email != null and conditionParamRef.email != ''">
${_conditionType_} a.email like #{${_conditionParam_}.email}
</if>
<if test="conditionParamRef.email == null">
${_conditionType_} a.email is null
</if>
</if>
<if test="conditionParamRef.containsKey('emailList')">
${_conditionType_} a.email in
<foreach collection="conditionParamRef.emailList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('qq')">
<if test="conditionParamRef.qq != null and conditionParamRef.qq != ''">
${_conditionType_} a.qq like #{${_conditionParam_}.qq}
</if>
<if test="conditionParamRef.qq == null">
${_conditionType_} a.qq is null
</if>
</if>
<if test="conditionParamRef.containsKey('qqList')">
${_conditionType_} a.qq in
<foreach collection="conditionParamRef.qqList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('userType')">
<if test="conditionParamRef.userType != null ">
${_conditionType_} a.userType = #{${_conditionParam_}.userType}
</if>
<if test="conditionParamRef.userType == null">
${_conditionType_} a.userType is null
</if>
</if>
<if test="conditionParamRef.containsKey('userTypeList')">
${_conditionType_} a.userType in
<foreach collection="conditionParamRef.userTypeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('userTypeStart') and conditionParamRef.userTypeStart != null">
${_conditionType_} a.userType <![CDATA[ >= ]]> #{${_conditionParam_}.userTypeStart}
</if>
<if test="conditionParamRef.containsKey('userTypeEnd') and conditionParamRef.userTypeEnd != null">
${_conditionType_} a.userType <![CDATA[ <= ]]> #{${_conditionParam_}.userTypeEnd}
</if>
<if test="conditionParamRef.containsKey('siteIds')">
<if test="conditionParamRef.siteIds != null and conditionParamRef.siteIds != ''">
${_conditionType_} a.siteIds like #{${_conditionParam_}.siteIds}
</if>
<if test="conditionParamRef.siteIds == null">
${_conditionType_} a.siteIds is null
</if>
</if>
<if test="conditionParamRef.containsKey('siteIdsList')">
${_conditionType_} a.siteIds in
<foreach collection="conditionParamRef.siteIdsList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('status')">
<if test="conditionParamRef.status != null ">
${_conditionType_} a.status = #{${_conditionParam_}.status}
</if>
<if test="conditionParamRef.status == null">
${_conditionType_} a.status is null
</if>
</if>
<if test="conditionParamRef.containsKey('statusList')">
${_conditionType_} a.status in
<foreach collection="conditionParamRef.statusList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('statusStart') and conditionParamRef.statusStart != null">
${_conditionType_} a.status <![CDATA[ >= ]]> #{${_conditionParam_}.statusStart}
</if>
<if test="conditionParamRef.containsKey('statusEnd') and conditionParamRef.statusEnd != null">
${_conditionType_} a.status <![CDATA[ <= ]]> #{${_conditionParam_}.statusEnd}
</if>
<if test="conditionParamRef.containsKey('customerId')">
<if test="conditionParamRef.customerId != null ">
${_conditionType_} a.customerId = #{${_conditionParam_}.customerId}
</if>
<if test="conditionParamRef.customerId == null">
${_conditionType_} a.customerId is null
</if>
</if>
<if test="conditionParamRef.containsKey('customerIdList')">
${_conditionType_} a.customerId in
<foreach collection="conditionParamRef.customerIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('customerIdStart') and conditionParamRef.customerIdStart != null">
${_conditionType_} a.customerId <![CDATA[ >= ]]> #{${_conditionParam_}.customerIdStart}
</if>
<if test="conditionParamRef.containsKey('customerIdEnd') and conditionParamRef.customerIdEnd != null">
${_conditionType_} a.customerId <![CDATA[ <= ]]> #{${_conditionParam_}.customerIdEnd}
</if>
<if test="conditionParamRef.containsKey('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createUserId')">
<if test="conditionParamRef.createUserId != null ">
${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
</if>
<if test="conditionParamRef.createUserId == null">
${_conditionType_} a.createUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserIdList')">
${_conditionType_} a.createUserId in
<foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
</if>
<if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('createUserName')">
<if test="conditionParamRef.createUserName != null and conditionParamRef.createUserName != ''">
${_conditionType_} a.createUserName like #{${_conditionParam_}.createUserName}
</if>
<if test="conditionParamRef.createUserName == null">
${_conditionType_} a.createUserName is null
</if>
</if>
<if test="conditionParamRef.containsKey('createUserNameList')">
${_conditionType_} a.createUserName in
<foreach collection="conditionParamRef.createUserNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('lastLoginTime')">
<if test="conditionParamRef.lastLoginTime != null ">
${_conditionType_} a.lastLoginTime = #{${_conditionParam_}.lastLoginTime}
</if>
<if test="conditionParamRef.lastLoginTime == null">
${_conditionType_} a.lastLoginTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('lastLoginTimeStart') and conditionParamRef.lastLoginTimeStart != null and conditionParamRef.lastLoginTimeStart!=''">
${_conditionType_} a.lastLoginTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lastLoginTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('lastLoginTimeEnd') and conditionParamRef.lastLoginTimeEnd != null and conditionParamRef.lastLoginTimeEnd!=''">
${_conditionType_} a.lastLoginTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.lastLoginTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('lastLoginAddress')">
<if test="conditionParamRef.lastLoginAddress != null and conditionParamRef.lastLoginAddress != ''">
${_conditionType_} a.lastLoginAddress like #{${_conditionParam_}.lastLoginAddress}
</if>
<if test="conditionParamRef.lastLoginAddress == null">
${_conditionType_} a.lastLoginAddress is null
</if>
</if>
<if test="conditionParamRef.containsKey('lastLoginAddressList')">
${_conditionType_} a.lastLoginAddress in
<foreach collection="conditionParamRef.lastLoginAddressList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('loginName')">
a.loginName
<if test='orderCol.loginName != null and "DESC".equalsIgnoreCase(orderCol.loginName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('loginPwd')">
a.loginPwd
<if test='orderCol.loginPwd != null and "DESC".equalsIgnoreCase(orderCol.loginPwd)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('loginLimitAddress')">
a.loginLimitAddress
<if test='orderCol.loginLimitAddress != null and "DESC".equalsIgnoreCase(orderCol.loginLimitAddress)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('realName')">
a.realName
<if test='orderCol.realName != null and "DESC".equalsIgnoreCase(orderCol.realName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('mobile')">
a.mobile
<if test='orderCol.mobile != null and "DESC".equalsIgnoreCase(orderCol.mobile)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('phone')">
a.phone
<if test='orderCol.phone != null and "DESC".equalsIgnoreCase(orderCol.phone)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('email')">
a.email
<if test='orderCol.email != null and "DESC".equalsIgnoreCase(orderCol.email)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('qq')">
a.qq
<if test='orderCol.qq != null and "DESC".equalsIgnoreCase(orderCol.qq)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('userType')">
a.userType
<if test='orderCol.userType != null and "DESC".equalsIgnoreCase(orderCol.userType)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('siteIds')">
a.siteIds
<if test='orderCol.siteIds != null and "DESC".equalsIgnoreCase(orderCol.siteIds)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('status')">
a.status
<if test='orderCol.status != null and "DESC".equalsIgnoreCase(orderCol.status)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('customerId')">
a.customerId
<if test='orderCol.customerId != null and "DESC".equalsIgnoreCase(orderCol.customerId)'>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('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserName')">
a.createUserName
<if test='orderCol.createUserName != null and "DESC".equalsIgnoreCase(orderCol.createUserName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('lastLoginTime')">
a.lastLoginTime
<if test='orderCol.lastLoginTime != null and "DESC".equalsIgnoreCase(orderCol.lastLoginTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('lastLoginAddress')">
a.lastLoginAddress
<if test='orderCol.lastLoginAddress != null and "DESC".equalsIgnoreCase(orderCol.lastLoginAddress)'>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