Skip to content

C
certificate-print
Commit 72852fec authored by 廖旭伟's avatar 廖旭伟
Browse files
Options

打印服务配置功能，API新加接口

parent b4a28fa7
Hide whitespace changes
Inline Side-by-side
Showing with 4175 additions and 89 deletions
certificate-manager/doc/api.md
View file @ 72852fec
......@@ -3073,9 +3073,480 @@ dict|object|字典对象
"msg": "保存打印记录成功",
"dict": null
}
```
## 证照打印服务配置
### 查询证照打印服务配置列表
**请求URL:** print/service/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询证照打印服务配置
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
page|Integer|否|当前页
size|Integer|否|每页条数，值为-1，查询所有记录
**请求样例:**
```
{
"page":1,
"size":10
}
```
**响应参数:**
参数名称|参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
 per_page|Integer|每页条数
 total|Integer|总条数
 last_page|Integer|总页数
 current_page|Integer|当前页
 data|array|结果集列表|数组
  id|Long|序号，主键，自增长
  serviceName|String|配置名称
  serviceUrl|String|服务访问地址
  createUserId|Long|创建用户
  createTime|Date|创建时间
  updateUserId|Long|更新用户
  updateTime|Date|更新时间
dict|object|字典对象
**响应消息样例:**
```
{
"code":1,
"data":{
}
}
```
### 查看证照打印服务配置
**请求URL:** print/service/info
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 查看证照打印服务配置，返回实例详细信息
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|Long|是|ID
**请求样例:**
```
http://localhost/print/service/info?id=549
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:-------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
 id|Long|序号，主键，自增长
 serviceName|String|配置名称
 serviceUrl|String|服务访问地址
 createUserId|Long|创建用户
 createTime|Date|创建时间
 updateUserId|Long|更新用户
 updateTime|Date|更新时间
dict|object|字典对象
**响应消息样例:**
```
{
"code": 1,
"data": {
"id":9223,
"serviceName":"rua637",
"serviceUrl":"zlhmk9",
"createUserId":1323,
"createTime":"2022-11-21",
"updateUserId":435,
"updateTime":"2022-11-21"
}
}
```
### 保存更新证照打印服务配置
**请求URL:** print/service/save
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 保存或更新证照打印服务配置：id为空时为新增保存，否则为更新提交
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
id|Long|否|序号，主键，自增长
serviceUrl|String|是|服务访问地址
createUserId|Long|否|创建用户
createTime|Date|否|创建时间
updateUserId|Long|否|更新用户
updateTime|Date|否|更新时间
**请求样例:**
```
{
"serviceName":"4cro3g",
"serviceUrl":"pg1h0s",
}
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
 id|Long|保存后主键id
 entity|object|保存更新实体
  id|Long|序号，主键，自增长
  serviceName|String|配置名称
  serviceUrl|String|服务访问地址
  createUserId|Long|创建用户
  createTime|Date|创建时间
  updateUserId|Long|更新用户
  updateTime|Date|更新时间
**响应消息样例:**
```
{
"msg":"新增模块成功",
"code":1,
"data":{}
}
}
```
### 删除证照打印服务配置
**请求URL:** print/service/delete
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 删除证照打印服务配置
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|String|是|数组
**请求样例:**
```
http://localhost:8080/print/service/delete?id=1&id=2'
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
## 证照目录打印配置
### 查询证照目录打印配置列表
**请求URL:** print/catalog/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询证照目录打印配置
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
page|Integer|否|当前页
size|Integer|否|每页条数，值为-1，查询所有记录
**请求样例:**
```
{
"page":1,
"size":10
}
```
**响应参数:**
参数名称|参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
 per_page|Integer|每页条数
 total|Integer|总条数
 last_page|Integer|总页数
 current_page|Integer|当前页
 data|array|结果集列表|数组
  id|Long|序号，主键，自增长
  catalogId|Long|证照目录ID
  catalogCode|String|证照目录编号
  catalogName|String|目录名称
  printerName|String|打印机名称
  printerIp|String|打印机网络地址
  paperSource|String|打印机纸盒
  createUserId|Long|创建用户
  createTime|Date|创建时间
  updateUserId|Long|更新用户
  updateTime|Date|更新时间
  serviceId|Long|打印服务配置ID
dict|object|字典对象
**响应消息样例:**
```
{
"code":1,
"data":{
}
}
```
### 查看证照目录打印配置
**请求URL:** print/catalog/info
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 查看证照目录打印配置，返回实例详细信息
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|Long|是|ID
**请求样例:**
```
http://localhost/print/catalog/info?id=549
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:-------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
 id|Long|序号，主键，自增长
 catalogId|Long|证照目录ID
 catalogCode|String|证照目录编号
 catalogName|String|目录名称
 printerName|String|打印机名称
 printerIp|String|打印机网络地址
 paperSource|String|打印机纸盒
 createUserId|Long|创建用户
 createTime|Date|创建时间
 updateUserId|Long|更新用户
 updateTime|Date|更新时间
 serviceId|Long|打印服务配置ID
dict|object|字典对象
**响应消息样例:**
```
{
"code": 1,
"data": {
"id":1020,
"catalogId":9717,
"catalogCode":"wfdqdb",
"catalogName":"hqpbes",
"printerName":"u2piww",
"printerIp":"ijxnnr",
"paperSource":"2dj30z",
"createUserId":2515,
"createTime":"2022-11-21",
"updateUserId":6574,
"updateTime":"2022-11-21",
"serviceId":9081
}
}
```
### 保存更新证照目录打印配置
**请求URL:** print/catalog/save
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 保存或更新证照目录打印配置：id为空时为新增保存，否则为更新提交
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
id|Long|否|序号，主键，自增长
catalogCode|String|是|证照目录编号
catalogName|String|是|目录名称
createUserId|Long|否|创建用户
createTime|Date|否|创建时间
updateUserId|Long|否|更新用户
updateTime|Date|否|更新时间
**请求样例:**
```
{
"catalogId":534,
"catalogCode":"b1bl71",
"catalogName":"2qmefy",
"printerName":"1bflus",
"printerIp":"mmyral",
"paperSource":"edj16g",
"serviceId":7228
}
```
**响应参数:**
参数名称 |参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
data|object|数据对象
 id|Long|保存后主键id
 entity|object|保存更新实体
  id|Long|序号，主键，自增长
  catalogId|Long|证照目录ID
  catalogCode|String|证照目录编号
  catalogName|String|目录名称
  printerName|String|打印机名称
  printerIp|String|打印机网络地址
  paperSource|String|打印机纸盒
  createUserId|Long|创建用户
  createTime|Date|创建时间
  updateUserId|Long|更新用户
  updateTime|Date|更新时间
  serviceId|Long|打印服务配置ID
**响应消息样例:**
```
{
"msg":"新增模块成功",
"code":1,
"data":{}
}
}
```
### 删除证照目录打印配置
**请求URL:** print/catalog/delete
**请求方式:** GET
**内容类型:** application/json;charset=utf-8
**简要描述:** 删除证照目录打印配置
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:------
id|String|是|数组
**请求样例:**
```
http://localhost:8080/print/catalog/delete?id=1&id=2'
```
**响应参数:**
参数名称 |参数类型|备注|其它
---|---|---|---
code|Integer|结果码（-1.失败，1.成功）|-
msg|String|消息|-
**响应消息样例:**
```
{
"code":1,
"msg":"成功"
}
```
## API接口
### 查询打印服务配置列表
**请求URL:** api/print/service/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询打印服务配置列表
**请求样例:**
```
{
}
```
**响应参数:**
参数名称|参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
 data|array|结果集列表|数组
  id|Long|序号，主键，自增长
  serviceName|String|服务名称
  serviceUrl|String|服务地址
**响应消息样例:**
```
{
"msg": "获取打印服务配置列表成功",
"code": 1,
"data": [
{
"id": 1,
"serviceName": "测试站点",
"serviceUrl":"http://169.254.218.130:8037/api/print/GetHardWareInfo"
}
]
}
```
### 查询证照目录
**请求URL:** api/catalog/list
......@@ -3180,4 +3651,85 @@ msg|String|消息
}
```
### 查询待打印证件
**请求URL:** api/print/certificate/list
**请求方式:** POST
**内容类型:** application/json;charset=utf-8
**简要描述:** 查询待打印证件
**请求参数:**
参数名称|类型|必填|描述
:---|:---|:---|:-------
serviceId|Long|是|打印服务配置id
idCard|String|是|证件编号
**请求样例:**
```
{
"serviceId":1,
"idCard":"510001199208090721"
}
```
**响应参数:**
参数名称|参数类型|描述
:---|:---|:------
code|Integer|结果码（-1.失败，1.成功）
msg|String|消息
 data|array|结果集列表|数组
  waitQueueId|Long|待打印队列主键，自增长
  catalogId|Long|证照目录ID
  catalogCode|String|证照目录编号
  catalogName|String|目录名称
  certificateCode|String|证件编号
  certificateName|String|证件名称
  pickerName|String|取件人姓名
  pickerIDCardNo|String|取件人证件号码
  holderName|String|持有者名称
  holderIDCardNo|String|持有者证件号码
  enterpriseName|String|企业名称
  certificateUrl|String|证件附件地址
  previewUrl|String|证件预览地址
  serviceUrl|String|打印机名称服务地址
  printerName|String|打印机名称
  printerIp|String|打印机网络地址
  paperSource|String|打印机纸盒
**响应消息样例:**
```
{
"data": {
"data": [
{
"waitQueueId": 10,
"catalogId": 1,
"catalogCode": "ck4h3r",
"catalogName": "大型户外广告许可证",
"certificateName": "测试证照",
"certificateCode": "ZZBH20221011",
"enterpriseName": "测试企业名称",
"holderName": "测试人员",
"holderIDCardNo": "510001199208090721",
"pickerName": "测试人员",
"pickerIDCardNo": "510001199208090721",
"previewUrl": "/preview/653041520304.jpg",
"certificateUrl": "/mergedoc/1668158764395.docx",
"serviceUrl": "http://169.254.218.130:8037/api/print/GetHardWareInfo",
"printerName": "printerName",
"printerIp": "printerIp",
"paperSource": "paperSource"
}
]
},
"code": 1,
"msg": "API接口查询待打印证件成功",
"dict": null
}
```
## 字典附录
certificate-manager/src/main/java/com/mortals/xhx/module/api/CertificateApi.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.api;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.common.Rest;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.web.BaseJsonBodyController;
import com.mortals.xhx.common.code.YesNoEnum;
import com.mortals.xhx.module.certificate.model.CertificateCatalogEntity;
import com.mortals.xhx.module.certificate.model.CertificateCatalogQuery;
import com.mortals.xhx.module.certificate.pdu.ApplyLogPdu;
import com.mortals.xhx.module.certificate.pdu.PrintListPdu;
import com.mortals.xhx.module.certificate.pdu.PrintLogPdu;
import com.mortals.xhx.module.certificate.service.CertificateCatalogService;
import com.mortals.xhx.module.print.model.PrintCatalogEntity;
import com.mortals.xhx.module.print.model.PrintCatalogQuery;
import com.mortals.xhx.module.print.model.PrintServiceEntity;
import com.mortals.xhx.module.print.service.PrintCatalogService;
import com.mortals.xhx.module.print.service.PrintServiceService;
import com.mortals.xhx.module.record.model.PrintWaitQueueEntity;
import com.mortals.xhx.module.record.model.PrintWaitQueueQuery;
import com.mortals.xhx.module.record.service.ApplyLogService;
import com.mortals.xhx.module.record.service.PrintWaitQueueService;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("api")
public class CertificateApi extends BaseJsonBodyController {
@Autowired
private CertificateCatalogService certificateCatalogService;
@Autowired
private ApplyLogService applyLogService;
@Autowired
private PrintServiceService printServiceService;
@Autowired
private PrintCatalogService printCatalogService;
@Autowired
private PrintWaitQueueService printWaitQueueService;
@PostMapping({"catalog/list"})
@UnAuth
public String getCatalogList(){
JSONObject ret = new JSONObject();
Map<String, Object> model = new HashMap();
String busiDesc = "API接口查询证照目录列表";
byte code = 1;
try {
List<CertificateCatalogEntity> list = certificateCatalogService.find(new CertificateCatalogQuery());
if(CollectionUtils.isNotEmpty(list)){
List<CatalogVO> catalogList = new ArrayList<>();
for(CertificateCatalogEntity entity:list){
CatalogVO catalogVO = new CatalogVO(entity.getId(),entity.getCatalogName(),entity.getCatalogCode());
JSONObject formContent = JSONObject.parseObject(entity.getFormContent());
JSONArray formList = formContent.getJSONArray("list");
JSONObject json = new JSONObject();
for (int j = 0; j < formList.size(); j++) {
JSONObject jsonObject = formList.getJSONObject(j);
json.put(jsonObject.getString("id"),"");
}
catalogVO.setFormContent(json.toJSONString());
catalogList.add(catalogVO);
}
model.put("message_info", "获取证照目录成功");
ret.put("data", catalogList);
}else {
code = 0;
model.put("message_info", "没有数据");
}
this.recordSysLog(this.request, busiDesc + " 【成功】");
}catch (Exception e){
code = -1;
model.put("message_info", "系统发生异常,请稍后再试");
this.doException(this.request, busiDesc, model, e);
}
ret.put("code", Integer.valueOf(code));
ret.put("msg", model.remove("message_info"));
return ret.toJSONString();
}
@PostMapping({"certificate/submit"})
@UnAuth
public String postA(@RequestBody ApplyLogPdu applyLogPdu){
JSONObject ret = new JSONObject();
Map<String, Object> model = new HashMap();
byte code = 1;
String busiDesc = "API接口生成证照";
try {
applyLogService.apiSaveApplyLog(applyLogPdu);
model.put("message_info", "生成证照成功");
this.recordSysLog(this.request, busiDesc + " 【成功】");
}catch (Exception e){
code = -1;
model.put("message_info", "生成证照发生异常");
if(e instanceof AppException){
model.put("message_info", e.getMessage());
}
this.doException(this.request, busiDesc, model, e);
}
ret.put("code", Integer.valueOf(code));
ret.put("msg", model.remove("message_info"));
return ret.toJSONString();
}
@PostMapping({"print/service/list"})
@UnAuth
public String printServiceList(){
JSONObject ret = new JSONObject();
Map<String, Object> model = new HashMap();
String busiDesc = "API接口查询打印服务配置列表";
byte code = 1;
try {
List<PrintServiceEntity> list = printServiceService.find(new PrintServiceEntity());
if(CollectionUtils.isNotEmpty(list)){
List<PrintServiceVO> serviceList = new ArrayList<>();
for(PrintServiceEntity entity:list){
PrintServiceVO printServiceVO = new PrintServiceVO(entity.getId(),entity.getServiceName(),entity.getServiceUrl());
serviceList.add(printServiceVO);
}
model.put("message_info", "获取打印服务配置列表成功");
ret.put("data", serviceList);
}else {
code = 0;
model.put("message_info", "没有数据");
}
this.recordSysLog(this.request, busiDesc + " 【成功】");
}catch (Exception e){
code = -1;
model.put("message_info", "系统发生异常,请稍后再试");
this.doException(this.request, busiDesc, model, e);
}
ret.put("code", Integer.valueOf(code));
ret.put("msg", model.remove("message_info"));
return ret.toJSONString();
}
@PostMapping({"print/catalog/service"})
@UnAuth
public String printCatalogService(@RequestBody PrintServicePdu printServicePdu){
JSONObject ret = new JSONObject();
Map<String, Object> model = new HashMap();
String busiDesc = "API接口查询目录打印配置";
byte code = 1;
try {
if(printServicePdu.getServiceId()==null){
throw new AppException("打印服务配置ID不能为空");
}
if(printServicePdu.getCatalogId()==null){
throw new AppException("证照目录ID不能为空");
}
PrintCatalogQuery query = new PrintCatalogQuery();
query.setServiceId(printServicePdu.getServiceId());
query.setCatalogId(printServicePdu.getCatalogId());
PrintCatalogVO printCatalogVO = null;
List<PrintCatalogEntity> list = printCatalogService.find(query);
if(CollectionUtils.isNotEmpty(list)&&list.size()>0){
printCatalogVO = new PrintCatalogVO(list.get(0).getPrinterName(),list.get(0).getPrinterIp(),list.get(0).getPaperSource());
model.put("message_info", "获取目录打印配置成功");
ret.put("data", printCatalogVO);
}else {
code = 0;
model.put("message_info", "没有数据");
}
this.recordSysLog(this.request, busiDesc + " 【成功】");
}catch (Exception e){
code = -1;
model.put("message_info", "系统发生异常,请稍后再试");
this.doException(this.request, busiDesc, model, e);
}
ret.put("code", Integer.valueOf(code));
ret.put("msg", model.remove("message_info"));
return ret.toJSONString();
}
/**
* 获取打印文件
*/
@PostMapping({"print/certificate/list"})
@UnAuth
public Rest<Object> listByIDCard(@RequestBody PrintListPdu pdu) {
Rest<Object> ret = new Rest();
Map<String, Object> model = new HashMap();
String busiDesc = "API接口查询待打印证件";
int code=1;
try {
if(pdu.getServiceId()==null){
throw new AppException("打印服务配置ID不能为空");
}
PrintWaitQueueQuery query = new PrintWaitQueueQuery();
query.setPrintStatus(YesNoEnum.NO.getValue());
query.setPickerIDCardNo(pdu.getIdCard());
List<PrintWaitQueueEntity> list = printWaitQueueService.find(query);
if(CollectionUtils.isNotEmpty(list)){
List<PrintWaitQueueVO> waitQueueVOList = new ArrayList<>();
for(PrintWaitQueueEntity printWaitQueueEntity:list){
PrintCatalogEntity printCatalogEntity = printCatalogService.getPrintCatalogByService(pdu.getServiceId(),printWaitQueueEntity.getCatalogId());
PrintWaitQueueVO printWaitQueueVO = new PrintWaitQueueVO();
printWaitQueueVO.setCatalogId(printWaitQueueEntity.getCatalogId());
printWaitQueueVO.setCatalogCode(printWaitQueueEntity.getCatalogCode());
printWaitQueueVO.setCatalogName(printWaitQueueEntity.getCatalogName());
printWaitQueueVO.setWaitQueueId(printWaitQueueEntity.getId());
printWaitQueueVO.setCertificateCode(printWaitQueueEntity.getCertificateCode());
printWaitQueueVO.setCertificateName(printWaitQueueEntity.getCertificateName());
printWaitQueueVO.setCertificateUrl(printWaitQueueEntity.getCertificateUrl());
printWaitQueueVO.setEnterpriseName(printWaitQueueEntity.getEnterpriseName());
printWaitQueueVO.setHolderIDCardNo(printWaitQueueEntity.getHolderIDCardNo());
printWaitQueueVO.setHolderName(printWaitQueueEntity.getHolderName());
printWaitQueueVO.setPickerIDCardNo(printWaitQueueEntity.getPickerIDCardNo());
printWaitQueueVO.setPickerName(printWaitQueueEntity.getPickerName());
printWaitQueueVO.setPreviewUrl(printWaitQueueEntity.getPreviewUrl());
printWaitQueueVO.setServiceUrl(printCatalogEntity.getServiceUrl());
printWaitQueueVO.setPrinterIp(printCatalogEntity.getPrinterIp());
printWaitQueueVO.setPrinterName(printCatalogEntity.getPrinterName());
printWaitQueueVO.setPaperSource(printCatalogEntity.getPaperSource());
waitQueueVOList.add(printWaitQueueVO);
}
model.put("data", waitQueueVOList);
model.put("message_info", busiDesc + "成功");
}else {
code = 0;
model.put("message_info", "没有数据");
}
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var9) {
code = -1;
this.doException(this.request, busiDesc, model, var9);
}
ret.setCode(code);
ret.setData(model);
ret.setDict(model.get("dict"));
ret.setMsg(model.get("message_info") == null ? "" : model.remove("message_info").toString());
return ret;
}
/**
* 打印文件
*/
@RequestMapping(value = {"print/certificate/log"},method = {RequestMethod.POST, RequestMethod.GET})
@UnAuth
public Rest<Object> print(@RequestBody PrintLogPdu printLogPdu) {
Rest<Object> ret = new Rest();
Map<String, Object> model = new HashMap();
String busiDesc = "API接口保存打印记录";
int code=1;
try {
printWaitQueueService.doPrint(printLogPdu.getWaitQueueId(),printLogPdu.getPrintStatus(),printLogPdu.getStatusRemark());
model.put("message_info", busiDesc + "成功");
this.recordSysLog(this.request, busiDesc + " 【成功】");
} catch (Exception var9) {
code = -1;
this.doException(this.request, busiDesc, model, var9);
}
ret.setCode(code);
ret.setData(model);
ret.setDict(model.get("dict"));
ret.setMsg(model.get("message_info") == null ? "" : model.remove("message_info").toString());
return ret;
}
}
certificate-manager/src/main/java/com/mortals/xhx/module/api/PrintCatalogVO.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.api;
import lombok.Data;
@Data
public class PrintCatalogVO {
/**
* 打印机名称
*/
private String printerName;
/**
* 打印机网络地址
*/
private String printerIp;
/**
* 打印机纸盒
*/
private String paperSource;
public PrintCatalogVO(String printerName, String printerIp, String paperSource) {
this.printerName = printerName;
this.printerIp = printerIp;
this.paperSource = paperSource;
}
}
certificate-manager/src/main/java/com/mortals/xhx/module/api/PrintServicePdu.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.api;
import lombok.Data;
@Data
public class PrintServicePdu {
/**
* 证照目录ID
*/
private Long catalogId;
/**
* 打印服务配置ID
*/
private Long serviceId;
}
certificate-manager/src/main/java/com/mortals/xhx/module/api/PrintServiceVO.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.api;
import lombok.Data;
@Data
public class PrintServiceVO {
/**
* 主键
*/
private Long id;
/**
* 配置名称
*/
private String serviceName;
/**
* 服务访问地址
*/
private String serviceUrl;
public PrintServiceVO(Long id, String serviceName, String serviceUrl) {
this.id = id;
this.serviceName = serviceName;
this.serviceUrl = serviceUrl;
}
}
certificate-manager/src/main/java/com/mortals/xhx/module/api/PrintWaitQueueVO.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.api;
import lombok.Data;
@Data
public class PrintWaitQueueVO {
/** 打印队列id */
private Long waitQueueId;
/**
* 证照目录ID
*/
private Long catalogId;
/**
* 证照目录编号
*/
private String catalogCode;
/**
* 目录名称
*/
private String catalogName;
/**
* 证照名称
*/
private String certificateName;
/**
* 证照编号
*/
private String certificateCode;
/**
* 企业名称
*/
private String enterpriseName;
/**
* 持有者姓名
*/
private String holderName;
/**
* 持有者证件号码
*/
private String holderIDCardNo;
/**
* 取件人姓名
*/
private String pickerName;
/**
* 取件人证件号码
*/
private String pickerIDCardNo;
/**
* 证件预览地址
*/
private String previewUrl;
/**
* 证件附件地址
*/
private String certificateUrl;
/**
* 打印服务访问地址
*/
private String serviceUrl;
/**
* 打印机名称
*/
private String printerName;
/**
* 打印机网络地址
*/
private String printerIp;
/**
* 打印机纸盒
*/
private String paperSource;
}
certificate-manager/src/main/java/com/mortals/xhx/module/certificate/pdu/PrintListPdu.java
View file @ 72852fec
......@@ -8,5 +8,7 @@ public class PrintListPdu {
private String idCard;
/** 证件分类 */
private Long classifyId;
/** 打印服务ID */
private Long serviceId;
}
certificate-manager/src/main/java/com/mortals/xhx/module/certificate/web/CertificateApi.java deleted 100644 → 0
View file @ b4a28fa7
package com.mortals.xhx.module.certificate.web;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.mortals.framework.annotation.UnAuth;
import com.mortals.framework.exception.AppException;
import com.mortals.xhx.module.certificate.model.CertificateCatalogEntity;
import com.mortals.xhx.module.certificate.model.CertificateCatalogQuery;
import com.mortals.xhx.module.certificate.pdu.ApplyLogPdu;
import com.mortals.xhx.module.certificate.pdu.CatalogVO;
import com.mortals.xhx.module.certificate.service.CertificateCatalogService;
import com.mortals.xhx.module.record.service.ApplyLogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@RestController
@RequestMapping("api")
public class CertificateApi {
@Autowired
private CertificateCatalogService certificateCatalogService;
@Autowired
private ApplyLogService applyLogService;
@PostMapping({"catalog/list"})
@UnAuth
public String getCatalogList(){
JSONObject ret = new JSONObject();
Map<String, Object> model = new HashMap();
byte code = 1;
try {
List<CertificateCatalogEntity> list = certificateCatalogService.find(new CertificateCatalogQuery());
List<CatalogVO> catalogList = new ArrayList<>();
for(CertificateCatalogEntity entity:list){
CatalogVO catalogVO = new CatalogVO(entity.getId(),entity.getCatalogName(),entity.getCatalogCode());
JSONObject formContent = JSONObject.parseObject(entity.getFormContent());
JSONArray formList = formContent.getJSONArray("list");
JSONObject json = new JSONObject();
for (int j = 0; j < formList.size(); j++) {
JSONObject jsonObject = formList.getJSONObject(j);
json.put(jsonObject.getString("id"),"");
}
catalogVO.setFormContent(json.toJSONString());
catalogList.add(catalogVO);
}
model.put("message_info", "获取证照目录成功");
ret.put("data", catalogList);
}catch (Exception e){
code = -1;
model.put("message_info", "系统发生异常,请稍后再试");
}
ret.put("code", Integer.valueOf(code));
ret.put("msg", model.remove("message_info"));
return ret.toJSONString();
}
@PostMapping({"certificate/submit"})
@UnAuth
public String postA(@RequestBody ApplyLogPdu applyLogPdu){
JSONObject ret = new JSONObject();
Map<String, Object> model = new HashMap();
byte code = 1;
try {
applyLogService.apiSaveApplyLog(applyLogPdu);
model.put("message_info", "生成证照成功");
}catch (Exception e){
code = -1;
model.put("message_info", "生成证照发生异常");
if(e instanceof AppException){
model.put("message_info", e.getMessage());
}
}
ret.put("code", Integer.valueOf(code));
ret.put("msg", model.remove("message_info"));
return ret.toJSONString();
}
}
certificate-manager/src/main/java/com/mortals/xhx/module/print/dao/PrintCatalogDao.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.print.model.PrintCatalogEntity;
import java.util.List;
/**
* 证照目录打印配置Dao
* 证照目录打印配置 DAO接口
*
* @author zxfei
* @date 2022-11-21
*/
public interface PrintCatalogDao extends ICRUDDao<PrintCatalogEntity,Long>{
}
certificate-manager/src/main/java/com/mortals/xhx/module/print/dao/PrintServiceDao.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.dao;
import com.mortals.framework.dao.ICRUDDao;
import com.mortals.xhx.module.print.model.PrintServiceEntity;
import java.util.List;
/**
* 证照打印服务配置Dao
* 证照打印服务配置 DAO接口
*
* @author zxfei
* @date 2022-11-21
*/
public interface PrintServiceDao extends ICRUDDao<PrintServiceEntity,Long>{
}
certificate-manager/src/main/java/com/mortals/xhx/module/print/dao/ibatis/PrintCatalogDaoImpl.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.print.dao.PrintCatalogDao;
import com.mortals.xhx.module.print.model.PrintCatalogEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 证照目录打印配置DaoImpl DAO接口
*
* @author zxfei
* @date 2022-11-21
*/
@Repository("printCatalogDao")
public class PrintCatalogDaoImpl extends BaseCRUDDaoMybatis<PrintCatalogEntity,Long> implements PrintCatalogDao {
}
certificate-manager/src/main/java/com/mortals/xhx/module/print/dao/ibatis/PrintServiceDaoImpl.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.dao.ibatis;
import org.springframework.stereotype.Repository;
import com.mortals.xhx.module.print.dao.PrintServiceDao;
import com.mortals.xhx.module.print.model.PrintServiceEntity;
import java.util.Date;
import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
import java.util.List;
/**
* 证照打印服务配置DaoImpl DAO接口
*
* @author zxfei
* @date 2022-11-21
*/
@Repository("printServiceDao")
public class PrintServiceDaoImpl extends BaseCRUDDaoMybatis<PrintServiceEntity,Long> implements PrintServiceDao {
}
certificate-manager/src/main/java/com/mortals/xhx/module/print/model/PrintCatalogEntity.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.model;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.print.model.vo.PrintCatalogVo;
/**
* 证照目录打印配置实体对象
*
* @author zxfei
* @date 2022-11-21
*/
public class PrintCatalogEntity extends PrintCatalogVo {
private static final long serialVersionUID = 1L;
/**
* 证照目录ID
*/
private Long catalogId;
/**
* 证照目录编号
*/
private String catalogCode;
/**
* 目录名称
*/
private String catalogName;
/**
* 打印机名称
*/
private String printerName;
/**
* 打印机网络地址
*/
private String printerIp;
/**
* 打印机纸盒
*/
private String paperSource;
/**
* 打印服务配置ID
*/
private Long serviceId;
public PrintCatalogEntity(){}
/**
* 获取 证照目录ID
* @return Long
*/
public Long getCatalogId(){
return catalogId;
}
/**
* 设置 证照目录ID
* @param catalogId
*/
public void setCatalogId(Long catalogId){
this.catalogId = catalogId;
}
/**
* 获取 证照目录编号
* @return String
*/
public String getCatalogCode(){
return catalogCode;
}
/**
* 设置 证照目录编号
* @param catalogCode
*/
public void setCatalogCode(String catalogCode){
this.catalogCode = catalogCode;
}
/**
* 获取 目录名称
* @return String
*/
public String getCatalogName(){
return catalogName;
}
/**
* 设置 目录名称
* @param catalogName
*/
public void setCatalogName(String catalogName){
this.catalogName = catalogName;
}
/**
* 获取 打印机名称
* @return String
*/
public String getPrinterName(){
return printerName;
}
/**
* 设置 打印机名称
* @param printerName
*/
public void setPrinterName(String printerName){
this.printerName = printerName;
}
/**
* 获取 打印机网络地址
* @return String
*/
public String getPrinterIp(){
return printerIp;
}
/**
* 设置 打印机网络地址
* @param printerIp
*/
public void setPrinterIp(String printerIp){
this.printerIp = printerIp;
}
/**
* 获取 打印机纸盒
* @return String
*/
public String getPaperSource(){
return paperSource;
}
/**
* 设置 打印机纸盒
* @param paperSource
*/
public void setPaperSource(String paperSource){
this.paperSource = paperSource;
}
/**
* 获取 打印服务配置ID
* @return Long
*/
public Long getServiceId(){
return serviceId;
}
/**
* 设置 打印服务配置ID
* @param serviceId
*/
public void setServiceId(Long serviceId){
this.serviceId = serviceId;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof PrintCatalogEntity) {
PrintCatalogEntity tmp = (PrintCatalogEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",catalogId:").append(getCatalogId());
sb.append(",catalogCode:").append(getCatalogCode());
sb.append(",catalogName:").append(getCatalogName());
sb.append(",printerName:").append(getPrinterName());
sb.append(",printerIp:").append(getPrinterIp());
sb.append(",paperSource:").append(getPaperSource());
sb.append(",serviceId:").append(getServiceId());
return sb.toString();
}
public void initAttrValue(){
this.catalogId = null;
this.catalogCode = "";
this.catalogName = "";
this.printerName = "";
this.printerIp = "";
this.paperSource = "";
this.serviceId = null;
}
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/model/PrintCatalogQuery.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.model;
import java.util.List;
import com.mortals.xhx.module.print.model.PrintCatalogEntity;
/**
* 证照目录打印配置查询对象
*
* @author zxfei
* @date 2022-11-21
*/
public class PrintCatalogQuery extends PrintCatalogEntity {
/** 开始 序号，主键，自增长 */
private Long idStart;
/** 结束 序号，主键，自增长 */
private Long idEnd;
/** 增加 序号，主键，自增长 */
private Long idIncrement;
/** 序号，主键，自增长列表 */
private List <Long> idList;
/** 开始 证照目录ID */
private Long catalogIdStart;
/** 结束 证照目录ID */
private Long catalogIdEnd;
/** 增加 证照目录ID */
private Long catalogIdIncrement;
/** 证照目录ID列表 */
private List <Long> catalogIdList;
/** 证照目录编号 */
private List<String> catalogCodeList;
/** 目录名称 */
private List<String> catalogNameList;
/** 打印机名称 */
private List<String> printerNameList;
/** 打印机网络地址 */
private List<String> printerIpList;
/** 打印机纸盒 */
private List<String> paperSourceList;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 结束 更新用户 */
private Long updateUserIdEnd;
/** 增加 更新用户 */
private Long updateUserIdIncrement;
/** 更新用户列表 */
private List <Long> updateUserIdList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** 开始 打印服务配置ID */
private Long serviceIdStart;
/** 结束 打印服务配置ID */
private Long serviceIdEnd;
/** 增加 打印服务配置ID */
private Long serviceIdIncrement;
/** 打印服务配置ID列表 */
private List <Long> serviceIdList;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<PrintCatalogQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<PrintCatalogQuery> andConditionList;
public PrintCatalogQuery(){}
/**
* 获取 开始 序号，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 开始 证照目录ID
* @return catalogIdStart
*/
public Long getCatalogIdStart(){
return this.catalogIdStart;
}
/**
* 设置 开始 证照目录ID
* @param catalogIdStart
*/
public void setCatalogIdStart(Long catalogIdStart){
this.catalogIdStart = catalogIdStart;
}
/**
* 获取 结束 证照目录ID
* @return $catalogIdEnd
*/
public Long getCatalogIdEnd(){
return this.catalogIdEnd;
}
/**
* 设置 结束 证照目录ID
* @param catalogIdEnd
*/
public void setCatalogIdEnd(Long catalogIdEnd){
this.catalogIdEnd = catalogIdEnd;
}
/**
* 获取 增加 证照目录ID
* @return catalogIdIncrement
*/
public Long getCatalogIdIncrement(){
return this.catalogIdIncrement;
}
/**
* 设置 增加 证照目录ID
* @param catalogIdIncrement
*/
public void setCatalogIdIncrement(Long catalogIdIncrement){
this.catalogIdIncrement = catalogIdIncrement;
}
/**
* 获取 证照目录ID
* @return catalogIdList
*/
public List<Long> getCatalogIdList(){
return this.catalogIdList;
}
/**
* 设置 证照目录ID
* @param catalogIdList
*/
public void setCatalogIdList(List<Long> catalogIdList){
this.catalogIdList = catalogIdList;
}
/**
* 获取 证照目录编号
* @return catalogCodeList
*/
public List<String> getCatalogCodeList(){
return this.catalogCodeList;
}
/**
* 设置 证照目录编号
* @param catalogCodeList
*/
public void setCatalogCodeList(List<String> catalogCodeList){
this.catalogCodeList = catalogCodeList;
}
/**
* 获取 目录名称
* @return catalogNameList
*/
public List<String> getCatalogNameList(){
return this.catalogNameList;
}
/**
* 设置 目录名称
* @param catalogNameList
*/
public void setCatalogNameList(List<String> catalogNameList){
this.catalogNameList = catalogNameList;
}
/**
* 获取 打印机名称
* @return printerNameList
*/
public List<String> getPrinterNameList(){
return this.printerNameList;
}
/**
* 设置 打印机名称
* @param printerNameList
*/
public void setPrinterNameList(List<String> printerNameList){
this.printerNameList = printerNameList;
}
/**
* 获取 打印机网络地址
* @return printerIpList
*/
public List<String> getPrinterIpList(){
return this.printerIpList;
}
/**
* 设置 打印机网络地址
* @param printerIpList
*/
public void setPrinterIpList(List<String> printerIpList){
this.printerIpList = printerIpList;
}
/**
* 获取 打印机纸盒
* @return paperSourceList
*/
public List<String> getPaperSourceList(){
return this.paperSourceList;
}
/**
* 设置 打印机纸盒
* @param paperSourceList
*/
public void setPaperSourceList(List<String> paperSourceList){
this.paperSourceList = paperSourceList;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 更新用户
* @return updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 获取 开始 打印服务配置ID
* @return serviceIdStart
*/
public Long getServiceIdStart(){
return this.serviceIdStart;
}
/**
* 设置 开始 打印服务配置ID
* @param serviceIdStart
*/
public void setServiceIdStart(Long serviceIdStart){
this.serviceIdStart = serviceIdStart;
}
/**
* 获取 结束 打印服务配置ID
* @return $serviceIdEnd
*/
public Long getServiceIdEnd(){
return this.serviceIdEnd;
}
/**
* 设置 结束 打印服务配置ID
* @param serviceIdEnd
*/
public void setServiceIdEnd(Long serviceIdEnd){
this.serviceIdEnd = serviceIdEnd;
}
/**
* 获取 增加 打印服务配置ID
* @return serviceIdIncrement
*/
public Long getServiceIdIncrement(){
return this.serviceIdIncrement;
}
/**
* 设置 增加 打印服务配置ID
* @param serviceIdIncrement
*/
public void setServiceIdIncrement(Long serviceIdIncrement){
this.serviceIdIncrement = serviceIdIncrement;
}
/**
* 获取 打印服务配置ID
* @return serviceIdList
*/
public List<Long> getServiceIdList(){
return this.serviceIdList;
}
/**
* 设置 打印服务配置ID
* @param serviceIdList
*/
public void setServiceIdList(List<Long> serviceIdList){
this.serviceIdList = serviceIdList;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public PrintCatalogQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public PrintCatalogQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public PrintCatalogQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public PrintCatalogQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public PrintCatalogQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 证照目录ID
* @param catalogId
*/
public PrintCatalogQuery catalogId(Long catalogId){
setCatalogId(catalogId);
return this;
}
/**
* 设置 开始 证照目录ID
* @param catalogIdStart
*/
public PrintCatalogQuery catalogIdStart(Long catalogIdStart){
this.catalogIdStart = catalogIdStart;
return this;
}
/**
* 设置 结束 证照目录ID
* @param catalogIdEnd
*/
public PrintCatalogQuery catalogIdEnd(Long catalogIdEnd){
this.catalogIdEnd = catalogIdEnd;
return this;
}
/**
* 设置 增加 证照目录ID
* @param catalogIdIncrement
*/
public PrintCatalogQuery catalogIdIncrement(Long catalogIdIncrement){
this.catalogIdIncrement = catalogIdIncrement;
return this;
}
/**
* 设置 证照目录ID
* @param catalogIdList
*/
public PrintCatalogQuery catalogIdList(List<Long> catalogIdList){
this.catalogIdList = catalogIdList;
return this;
}
/**
* 设置 证照目录编号
* @param catalogCode
*/
public PrintCatalogQuery catalogCode(String catalogCode){
setCatalogCode(catalogCode);
return this;
}
/**
* 设置 证照目录编号
* @param catalogCodeList
*/
public PrintCatalogQuery catalogCodeList(List<String> catalogCodeList){
this.catalogCodeList = catalogCodeList;
return this;
}
/**
* 设置 目录名称
* @param catalogName
*/
public PrintCatalogQuery catalogName(String catalogName){
setCatalogName(catalogName);
return this;
}
/**
* 设置 目录名称
* @param catalogNameList
*/
public PrintCatalogQuery catalogNameList(List<String> catalogNameList){
this.catalogNameList = catalogNameList;
return this;
}
/**
* 设置 打印机名称
* @param printerName
*/
public PrintCatalogQuery printerName(String printerName){
setPrinterName(printerName);
return this;
}
/**
* 设置 打印机名称
* @param printerNameList
*/
public PrintCatalogQuery printerNameList(List<String> printerNameList){
this.printerNameList = printerNameList;
return this;
}
/**
* 设置 打印机网络地址
* @param printerIp
*/
public PrintCatalogQuery printerIp(String printerIp){
setPrinterIp(printerIp);
return this;
}
/**
* 设置 打印机网络地址
* @param printerIpList
*/
public PrintCatalogQuery printerIpList(List<String> printerIpList){
this.printerIpList = printerIpList;
return this;
}
/**
* 设置 打印机纸盒
* @param paperSource
*/
public PrintCatalogQuery paperSource(String paperSource){
setPaperSource(paperSource);
return this;
}
/**
* 设置 打印机纸盒
* @param paperSourceList
*/
public PrintCatalogQuery paperSourceList(List<String> paperSourceList){
this.paperSourceList = paperSourceList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public PrintCatalogQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public PrintCatalogQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public PrintCatalogQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public PrintCatalogQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public PrintCatalogQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public PrintCatalogQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public PrintCatalogQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public PrintCatalogQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public PrintCatalogQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public PrintCatalogQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 设置 打印服务配置ID
* @param serviceId
*/
public PrintCatalogQuery serviceId(Long serviceId){
setServiceId(serviceId);
return this;
}
/**
* 设置 开始 打印服务配置ID
* @param serviceIdStart
*/
public PrintCatalogQuery serviceIdStart(Long serviceIdStart){
this.serviceIdStart = serviceIdStart;
return this;
}
/**
* 设置 结束 打印服务配置ID
* @param serviceIdEnd
*/
public PrintCatalogQuery serviceIdEnd(Long serviceIdEnd){
this.serviceIdEnd = serviceIdEnd;
return this;
}
/**
* 设置 增加 打印服务配置ID
* @param serviceIdIncrement
*/
public PrintCatalogQuery serviceIdIncrement(Long serviceIdIncrement){
this.serviceIdIncrement = serviceIdIncrement;
return this;
}
/**
* 设置 打印服务配置ID
* @param serviceIdList
*/
public PrintCatalogQuery serviceIdList(List<Long> serviceIdList){
this.serviceIdList = serviceIdList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<PrintCatalogQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<PrintCatalogQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<PrintCatalogQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<PrintCatalogQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/model/PrintServiceEntity.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.model;
import java.util.List;
import java.util.ArrayList;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.mortals.framework.annotation.Excel;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.print.model.vo.PrintServiceVo;
/**
* 证照打印服务配置实体对象
*
* @author zxfei
* @date 2022-11-21
*/
public class PrintServiceEntity extends PrintServiceVo {
private static final long serialVersionUID = 1L;
/**
* 配置名称
*/
private String serviceName;
/**
* 服务访问地址
*/
private String serviceUrl;
public PrintServiceEntity(){}
/**
* 获取 配置名称
* @return String
*/
public String getServiceName(){
return serviceName;
}
/**
* 设置 配置名称
* @param serviceName
*/
public void setServiceName(String serviceName){
this.serviceName = serviceName;
}
/**
* 获取 服务访问地址
* @return String
*/
public String getServiceUrl(){
return serviceUrl;
}
/**
* 设置 服务访问地址
* @param serviceUrl
*/
public void setServiceUrl(String serviceUrl){
this.serviceUrl = serviceUrl;
}
@Override
public int hashCode() {
return this.getId().hashCode();
}
@Override
public boolean equals(Object obj) {
if (obj == null) return false;
if (obj instanceof PrintServiceEntity) {
PrintServiceEntity tmp = (PrintServiceEntity) obj;
if (this.getId() == tmp.getId()) {
return true;
}
}
return false;
}
public String toString(){
StringBuilder sb = new StringBuilder("");
sb.append(",serviceName:").append(getServiceName());
sb.append(",serviceUrl:").append(getServiceUrl());
return sb.toString();
}
public void initAttrValue(){
this.serviceName = "";
this.serviceUrl = "";
}
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/model/PrintServiceQuery.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.model;
import java.util.List;
import com.mortals.xhx.module.print.model.PrintServiceEntity;
/**
* 证照打印服务配置查询对象
*
* @author zxfei
* @date 2022-11-21
*/
public class PrintServiceQuery extends PrintServiceEntity {
/** 开始 序号，主键，自增长 */
private Long idStart;
/** 结束 序号，主键，自增长 */
private Long idEnd;
/** 增加 序号，主键，自增长 */
private Long idIncrement;
/** 序号，主键，自增长列表 */
private List <Long> idList;
/** 配置名称 */
private List<String> serviceNameList;
/** 服务访问地址 */
private List<String> serviceUrlList;
/** 开始 创建用户 */
private Long createUserIdStart;
/** 结束 创建用户 */
private Long createUserIdEnd;
/** 增加 创建用户 */
private Long createUserIdIncrement;
/** 创建用户列表 */
private List <Long> createUserIdList;
/** 开始 创建时间 */
private String createTimeStart;
/** 结束 创建时间 */
private String createTimeEnd;
/** 开始 更新用户 */
private Long updateUserIdStart;
/** 结束 更新用户 */
private Long updateUserIdEnd;
/** 增加 更新用户 */
private Long updateUserIdIncrement;
/** 更新用户列表 */
private List <Long> updateUserIdList;
/** 开始 更新时间 */
private String updateTimeStart;
/** 结束 更新时间 */
private String updateTimeEnd;
/** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
private List<PrintServiceQuery> orConditionList;
/** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
private List<PrintServiceQuery> andConditionList;
public PrintServiceQuery(){}
/**
* 获取 开始 序号，主键，自增长
* @return idStart
*/
public Long getIdStart(){
return this.idStart;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public void setIdStart(Long idStart){
this.idStart = idStart;
}
/**
* 获取 结束 序号，主键，自增长
* @return $idEnd
*/
public Long getIdEnd(){
return this.idEnd;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public void setIdEnd(Long idEnd){
this.idEnd = idEnd;
}
/**
* 获取 增加 序号，主键，自增长
* @return idIncrement
*/
public Long getIdIncrement(){
return this.idIncrement;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public void setIdIncrement(Long idIncrement){
this.idIncrement = idIncrement;
}
/**
* 获取 序号，主键，自增长
* @return idList
*/
public List<Long> getIdList(){
return this.idList;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public void setIdList(List<Long> idList){
this.idList = idList;
}
/**
* 获取 配置名称
* @return serviceNameList
*/
public List<String> getServiceNameList(){
return this.serviceNameList;
}
/**
* 设置 配置名称
* @param serviceNameList
*/
public void setServiceNameList(List<String> serviceNameList){
this.serviceNameList = serviceNameList;
}
/**
* 获取 服务访问地址
* @return serviceUrlList
*/
public List<String> getServiceUrlList(){
return this.serviceUrlList;
}
/**
* 设置 服务访问地址
* @param serviceUrlList
*/
public void setServiceUrlList(List<String> serviceUrlList){
this.serviceUrlList = serviceUrlList;
}
/**
* 获取 开始 创建用户
* @return createUserIdStart
*/
public Long getCreateUserIdStart(){
return this.createUserIdStart;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public void setCreateUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
}
/**
* 获取 结束 创建用户
* @return $createUserIdEnd
*/
public Long getCreateUserIdEnd(){
return this.createUserIdEnd;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public void setCreateUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
}
/**
* 获取 增加 创建用户
* @return createUserIdIncrement
*/
public Long getCreateUserIdIncrement(){
return this.createUserIdIncrement;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public void setCreateUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
}
/**
* 获取 创建用户
* @return createUserIdList
*/
public List<Long> getCreateUserIdList(){
return this.createUserIdList;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public void setCreateUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
}
/**
* 获取 开始 创建时间
* @return createTimeStart
*/
public String getCreateTimeStart(){
return this.createTimeStart;
}
/**
* 设置 开始 创建时间
* @param createTimeStart
*/
public void setCreateTimeStart(String createTimeStart){
this.createTimeStart = createTimeStart;
}
/**
* 获取 结束 创建时间
* @return createTimeEnd
*/
public String getCreateTimeEnd(){
return this.createTimeEnd;
}
/**
* 设置 结束 创建时间
* @param createTimeEnd
*/
public void setCreateTimeEnd(String createTimeEnd){
this.createTimeEnd = createTimeEnd;
}
/**
* 获取 开始 更新用户
* @return updateUserIdStart
*/
public Long getUpdateUserIdStart(){
return this.updateUserIdStart;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public void setUpdateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
}
/**
* 获取 结束 更新用户
* @return $updateUserIdEnd
*/
public Long getUpdateUserIdEnd(){
return this.updateUserIdEnd;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public void setUpdateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
}
/**
* 获取 增加 更新用户
* @return updateUserIdIncrement
*/
public Long getUpdateUserIdIncrement(){
return this.updateUserIdIncrement;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
}
/**
* 获取 更新用户
* @return updateUserIdList
*/
public List<Long> getUpdateUserIdList(){
return this.updateUserIdList;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public void setUpdateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
}
/**
* 获取 开始 更新时间
* @return updateTimeStart
*/
public String getUpdateTimeStart(){
return this.updateTimeStart;
}
/**
* 设置 开始 更新时间
* @param updateTimeStart
*/
public void setUpdateTimeStart(String updateTimeStart){
this.updateTimeStart = updateTimeStart;
}
/**
* 获取 结束 更新时间
* @return updateTimeEnd
*/
public String getUpdateTimeEnd(){
return this.updateTimeEnd;
}
/**
* 设置 结束 更新时间
* @param updateTimeEnd
*/
public void setUpdateTimeEnd(String updateTimeEnd){
this.updateTimeEnd = updateTimeEnd;
}
/**
* 设置 序号，主键，自增长
* @param id
*/
public PrintServiceQuery id(Long id){
setId(id);
return this;
}
/**
* 设置 开始 序号，主键，自增长
* @param idStart
*/
public PrintServiceQuery idStart(Long idStart){
this.idStart = idStart;
return this;
}
/**
* 设置 结束 序号，主键，自增长
* @param idEnd
*/
public PrintServiceQuery idEnd(Long idEnd){
this.idEnd = idEnd;
return this;
}
/**
* 设置 增加 序号，主键，自增长
* @param idIncrement
*/
public PrintServiceQuery idIncrement(Long idIncrement){
this.idIncrement = idIncrement;
return this;
}
/**
* 设置 序号，主键，自增长
* @param idList
*/
public PrintServiceQuery idList(List<Long> idList){
this.idList = idList;
return this;
}
/**
* 设置 配置名称
* @param serviceName
*/
public PrintServiceQuery serviceName(String serviceName){
setServiceName(serviceName);
return this;
}
/**
* 设置 配置名称
* @param serviceNameList
*/
public PrintServiceQuery serviceNameList(List<String> serviceNameList){
this.serviceNameList = serviceNameList;
return this;
}
/**
* 设置 服务访问地址
* @param serviceUrl
*/
public PrintServiceQuery serviceUrl(String serviceUrl){
setServiceUrl(serviceUrl);
return this;
}
/**
* 设置 服务访问地址
* @param serviceUrlList
*/
public PrintServiceQuery serviceUrlList(List<String> serviceUrlList){
this.serviceUrlList = serviceUrlList;
return this;
}
/**
* 设置 创建用户
* @param createUserId
*/
public PrintServiceQuery createUserId(Long createUserId){
setCreateUserId(createUserId);
return this;
}
/**
* 设置 开始 创建用户
* @param createUserIdStart
*/
public PrintServiceQuery createUserIdStart(Long createUserIdStart){
this.createUserIdStart = createUserIdStart;
return this;
}
/**
* 设置 结束 创建用户
* @param createUserIdEnd
*/
public PrintServiceQuery createUserIdEnd(Long createUserIdEnd){
this.createUserIdEnd = createUserIdEnd;
return this;
}
/**
* 设置 增加 创建用户
* @param createUserIdIncrement
*/
public PrintServiceQuery createUserIdIncrement(Long createUserIdIncrement){
this.createUserIdIncrement = createUserIdIncrement;
return this;
}
/**
* 设置 创建用户
* @param createUserIdList
*/
public PrintServiceQuery createUserIdList(List<Long> createUserIdList){
this.createUserIdList = createUserIdList;
return this;
}
/**
* 设置 更新用户
* @param updateUserId
*/
public PrintServiceQuery updateUserId(Long updateUserId){
setUpdateUserId(updateUserId);
return this;
}
/**
* 设置 开始 更新用户
* @param updateUserIdStart
*/
public PrintServiceQuery updateUserIdStart(Long updateUserIdStart){
this.updateUserIdStart = updateUserIdStart;
return this;
}
/**
* 设置 结束 更新用户
* @param updateUserIdEnd
*/
public PrintServiceQuery updateUserIdEnd(Long updateUserIdEnd){
this.updateUserIdEnd = updateUserIdEnd;
return this;
}
/**
* 设置 增加 更新用户
* @param updateUserIdIncrement
*/
public PrintServiceQuery updateUserIdIncrement(Long updateUserIdIncrement){
this.updateUserIdIncrement = updateUserIdIncrement;
return this;
}
/**
* 设置 更新用户
* @param updateUserIdList
*/
public PrintServiceQuery updateUserIdList(List<Long> updateUserIdList){
this.updateUserIdList = updateUserIdList;
return this;
}
/**
* 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @return orConditionList
*/
public List<PrintServiceQuery> getOrConditionList(){
return this.orConditionList;
}
/**
* 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
* @param orConditionList
*/
public void setOrConditionList(List<PrintServiceQuery> orConditionList){
this.orConditionList = orConditionList;
}
/**
* 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @return andConditionList
*/
public List<PrintServiceQuery> getAndConditionList(){
return this.andConditionList;
}
/**
* 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
* @param andConditionList
*/
public void setAndConditionList(List<PrintServiceQuery> andConditionList){
this.andConditionList = andConditionList;
}
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/model/vo/PrintCatalogVo.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.print.model.PrintCatalogEntity;
import lombok.Data;
import java.util.ArrayList;
import java.util.List;
/**
* 证照目录打印配置视图对象
*
* @author zxfei
* @date 2022-11-21
*/
@Data
public class PrintCatalogVo extends BaseEntityLong {
/**
* 服务访问地址
*/
private String serviceUrl;
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/model/vo/PrintServiceVo.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.model.vo;
import com.mortals.framework.model.BaseEntityLong;
import com.mortals.xhx.module.print.model.PrintServiceEntity;
import java.util.ArrayList;
import java.util.List;
/**
* 证照打印服务配置视图对象
*
* @author zxfei
* @date 2022-11-21
*/
public class PrintServiceVo extends BaseEntityLong {
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/service/PrintCatalogService.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.service;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.print.model.PrintCatalogEntity;
/**
* PrintCatalogService
*
* 证照目录打印配置 service接口
*
* @author zxfei
* @date 2022-11-21
*/
public interface PrintCatalogService extends ICRUDService<PrintCatalogEntity,Long>{
/**
* 根据打印服务id和目录id获取打印相关配置
* @param serviceId
* @param catalogId
* @return
*/
PrintCatalogEntity getPrintCatalogByService(Long serviceId,Long catalogId) throws AppException;
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/service/PrintServiceService.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.service;
import com.mortals.framework.service.ICRUDService;
import com.mortals.xhx.module.print.model.PrintServiceEntity;
/**
* PrintServiceService
*
* 证照打印服务配置 service接口
*
* @author zxfei
* @date 2022-11-21
*/
public interface PrintServiceService extends ICRUDService<PrintServiceEntity,Long>{
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/service/impl/PrintCatalogServiceImpl.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.service.impl;
import com.mortals.xhx.module.certificate.model.CertificateCatalogEntity;
import com.mortals.xhx.module.certificate.service.CertificateCatalogService;
import com.mortals.xhx.module.print.model.PrintCatalogQuery;
import com.mortals.xhx.module.print.model.PrintServiceEntity;
import com.mortals.xhx.module.print.service.PrintServiceService;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.print.dao.PrintCatalogDao;
import com.mortals.xhx.module.print.model.PrintCatalogEntity;
import com.mortals.xhx.module.print.service.PrintCatalogService;
import java.util.List;
/**
* PrintCatalogService
* 证照目录打印配置 service实现
*
* @author zxfei
* @date 2022-11-21
*/
@Service("printCatalogService")
public class PrintCatalogServiceImpl extends AbstractCRUDServiceImpl<PrintCatalogDao, PrintCatalogEntity, Long> implements PrintCatalogService {
@Autowired
private CertificateCatalogService certificateCatalogService;
@Autowired
private PrintServiceService printServiceService;
@Override
protected void validData(PrintCatalogEntity entity, Context context) throws AppException {
if(entity.getServiceId()==null){
throw new AppException("打印服务id不能为空");
}
if(entity.getCatalogId()==null){
throw new AppException("证照目录id不能为空");
}
}
@Override
protected void saveBefore(PrintCatalogEntity entity, Context context) throws AppException {
super.saveBefore(entity,context);
CertificateCatalogEntity catalogEntity = certificateCatalogService.get(entity.getCatalogId());
if(catalogEntity == null){
throw new AppException("证照目录id不正确");
}
entity.setCatalogCode(catalogEntity.getCatalogCode());
entity.setCatalogName(catalogEntity.getCatalogName());
}
@Override
public PrintCatalogEntity getPrintCatalogByService(Long serviceId, Long catalogId) throws AppException {
PrintServiceEntity printServiceEntity = printServiceService.get(serviceId);
if(printServiceEntity == null){
throw new AppException("打印服务id不正确");
}
PrintCatalogEntity data = null;
PrintCatalogQuery query = new PrintCatalogQuery();
query.setCatalogId(catalogId);
query.setServiceId(serviceId);
List<PrintCatalogEntity> printCatalogEntityList = this.find(query);
if(CollectionUtils.isNotEmpty(printCatalogEntityList)){
data = printCatalogEntityList.get(0);
data.setServiceUrl(printServiceEntity.getServiceUrl());
}else {
CertificateCatalogEntity catalogEntity = certificateCatalogService.get(catalogId);
if(catalogEntity == null){
throw new AppException("证照目录id不正确");
}
data = new PrintCatalogEntity();
data.setServiceUrl(printServiceEntity.getServiceUrl());
data.setCatalogCode(catalogEntity.getCatalogCode());
data.setCatalogName(catalogEntity.getCatalogName());
data.setCatalogId(catalogEntity.getId());
data.setPrinterIp(catalogEntity.getPrinterIp());
data.setPrinterName(catalogEntity.getPrinterName());
data.setPaperSource(catalogEntity.getPaperSource());
}
return data;
}
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/service/impl/PrintServiceServiceImpl.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.service.impl;
import org.springframework.stereotype.Service;
import com.mortals.framework.service.impl.AbstractCRUDServiceImpl;
import com.mortals.framework.exception.AppException;
import com.mortals.framework.model.Context;
import com.mortals.xhx.module.print.dao.PrintServiceDao;
import com.mortals.xhx.module.print.model.PrintServiceEntity;
import com.mortals.xhx.module.print.service.PrintServiceService;
/**
* PrintServiceService
* 证照打印服务配置 service实现
*
* @author zxfei
* @date 2022-11-21
*/
@Service("printServiceService")
public class PrintServiceServiceImpl extends AbstractCRUDServiceImpl<PrintServiceDao, PrintServiceEntity, Long> implements PrintServiceService {
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/web/PrintCatalogController.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.web;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.print.model.PrintCatalogEntity;
import com.mortals.xhx.module.print.service.PrintCatalogService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 证照目录打印配置
*
* @author zxfei
* @date 2022-11-21
*/
@RestController
@RequestMapping("print/catalog")
public class PrintCatalogController extends BaseCRUDJsonBodyMappingController<PrintCatalogService,PrintCatalogEntity,Long> {
@Autowired
private ParamService paramService;
public PrintCatalogController(){
super.setModuleDesc( "证照目录打印配置");
}
@Override
protected void init(Map<String, Object> model, Context context) {
super.init(model, context);
}
}
\ No newline at end of file
certificate-manager/src/main/java/com/mortals/xhx/module/print/web/PrintServiceController.java 0 → 100644
View file @ 72852fec
package com.mortals.xhx.module.print.web;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.base.system.param.service.ParamService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.*;
import com.mortals.framework.model.Context;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
import com.mortals.xhx.module.print.model.PrintServiceEntity;
import com.mortals.xhx.module.print.service.PrintServiceService;
import org.apache.commons.lang3.ArrayUtils;
import com.mortals.framework.util.StringUtils;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.alibaba.fastjson.JSONObject;
import java.util.Arrays;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import static com.mortals.framework.ap.SysConstains.*;
/**
*
* 证照打印服务配置
*
* @author zxfei
* @date 2022-11-21
*/
@RestController
@RequestMapping("print/service")
public class PrintServiceController extends BaseCRUDJsonBodyMappingController<PrintServiceService,PrintServiceEntity,Long> {
@Autowired
private ParamService paramService;
public PrintServiceController(){
super.setModuleDesc( "证照打印服务配置");
}
@Override
protected void init(Map<String, Object> model, Context context) {
super.init(model, context);
}
}
\ No newline at end of file
certificate-manager/src/main/resources/sqlmap/module/print/PrintCatalogMapper.xml 0 → 100644
View file @ 72852fec
<?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.print.dao.ibatis.PrintCatalogDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="PrintCatalogEntity" id="PrintCatalogEntity-Map">
<id property="id" column="id" />
<result property="catalogId" column="catalogId" />
<result property="catalogCode" column="catalogCode" />
<result property="catalogName" column="catalogName" />
<result property="printerName" column="printerName" />
<result property="printerIp" column="printerIp" />
<result property="paperSource" column="paperSource" />
<result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" />
<result property="serviceId" column="serviceId" />
</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('catalogId') or colPickMode == 1 and data.containsKey('catalogId')))">
a.catalogId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('catalogCode') or colPickMode == 1 and data.containsKey('catalogCode')))">
a.catalogCode,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('catalogName') or colPickMode == 1 and data.containsKey('catalogName')))">
a.catalogName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('printerName') or colPickMode == 1 and data.containsKey('printerName')))">
a.printerName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('printerIp') or colPickMode == 1 and data.containsKey('printerIp')))">
a.printerIp,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('paperSource') or colPickMode == 1 and data.containsKey('paperSource')))">
a.paperSource,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('serviceId') or colPickMode == 1 and data.containsKey('serviceId')))">
a.serviceId,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="PrintCatalogEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_print_catalog
(catalogId,catalogCode,catalogName,printerName,printerIp,paperSource,createUserId,createTime,updateUserId,updateTime,serviceId)
VALUES
(#{catalogId},#{catalogCode},#{catalogName},#{printerName},#{printerIp},#{paperSource},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{serviceId})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_print_catalog
(catalogId,catalogCode,catalogName,printerName,printerIp,paperSource,createUserId,createTime,updateUserId,updateTime,serviceId)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.catalogId},#{item.catalogCode},#{item.catalogName},#{item.printerName},#{item.printerIp},#{item.paperSource},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.serviceId})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_print_catalog as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('catalogId')) or (colPickMode==1 and !data.containsKey('catalogId'))">
a.catalogId=#{data.catalogId},
</if>
<if test="(colPickMode==0 and data.containsKey('catalogIdIncrement')) or (colPickMode==1 and !data.containsKey('catalogIdIncrement'))">
a.catalogId=ifnull(a.catalogId,0) + #{data.catalogIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('catalogCode')) or (colPickMode==1 and !data.containsKey('catalogCode'))">
a.catalogCode=#{data.catalogCode},
</if>
<if test="(colPickMode==0 and data.containsKey('catalogName')) or (colPickMode==1 and !data.containsKey('catalogName'))">
a.catalogName=#{data.catalogName},
</if>
<if test="(colPickMode==0 and data.containsKey('printerName')) or (colPickMode==1 and !data.containsKey('printerName'))">
a.printerName=#{data.printerName},
</if>
<if test="(colPickMode==0 and data.containsKey('printerIp')) or (colPickMode==1 and !data.containsKey('printerIp'))">
a.printerIp=#{data.printerIp},
</if>
<if test="(colPickMode==0 and data.containsKey('paperSource')) or (colPickMode==1 and !data.containsKey('paperSource'))">
a.paperSource=#{data.paperSource},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
<if test="(colPickMode==0 and data.containsKey('serviceId')) or (colPickMode==1 and !data.containsKey('serviceId'))">
a.serviceId=#{data.serviceId},
</if>
<if test="(colPickMode==0 and data.containsKey('serviceIdIncrement')) or (colPickMode==1 and !data.containsKey('serviceIdIncrement'))">
a.serviceId=ifnull(a.serviceId,0) + #{data.serviceIdIncrement},
</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_print_catalog as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="catalogId=(case" suffix="ELSE catalogId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('catalogId')) or (colPickMode==1 and !item.containsKey('catalogId'))">
when a.id=#{item.id} then #{item.catalogId}
</when>
<when test="(colPickMode==0 and item.containsKey('catalogIdIncrement')) or (colPickMode==1 and !item.containsKey('catalogIdIncrement'))">
when a.id=#{item.id} then ifnull(a.catalogId,0) + #{item.catalogIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="catalogCode=(case" suffix="ELSE catalogCode end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('catalogCode')) or (colPickMode==1 and !item.containsKey('catalogCode'))">
when a.id=#{item.id} then #{item.catalogCode}
</if>
</foreach>
</trim>
<trim prefix="catalogName=(case" suffix="ELSE catalogName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('catalogName')) or (colPickMode==1 and !item.containsKey('catalogName'))">
when a.id=#{item.id} then #{item.catalogName}
</if>
</foreach>
</trim>
<trim prefix="printerName=(case" suffix="ELSE printerName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('printerName')) or (colPickMode==1 and !item.containsKey('printerName'))">
when a.id=#{item.id} then #{item.printerName}
</if>
</foreach>
</trim>
<trim prefix="printerIp=(case" suffix="ELSE printerIp end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('printerIp')) or (colPickMode==1 and !item.containsKey('printerIp'))">
when a.id=#{item.id} then #{item.printerIp}
</if>
</foreach>
</trim>
<trim prefix="paperSource=(case" suffix="ELSE paperSource end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('paperSource')) or (colPickMode==1 and !item.containsKey('paperSource'))">
when a.id=#{item.id} then #{item.paperSource}
</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="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
<trim prefix="serviceId=(case" suffix="ELSE serviceId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('serviceId')) or (colPickMode==1 and !item.containsKey('serviceId'))">
when a.id=#{item.id} then #{item.serviceId}
</when>
<when test="(colPickMode==0 and item.containsKey('serviceIdIncrement')) or (colPickMode==1 and !item.containsKey('serviceIdIncrement'))">
when a.id=#{item.id} then ifnull(a.serviceId,0) + #{item.serviceIdIncrement}
</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="PrintCatalogEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_print_catalog as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_print_catalog as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_print_catalog 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_print_catalog as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="PrintCatalogEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_print_catalog 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_print_catalog 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('catalogId')">
<if test="conditionParamRef.catalogId != null ">
${_conditionType_} a.catalogId = #{${_conditionParam_}.catalogId}
</if>
<if test="conditionParamRef.catalogId == null">
${_conditionType_} a.catalogId is null
</if>
</if>
<if test="conditionParamRef.containsKey('catalogIdList')">
${_conditionType_} a.catalogId in
<foreach collection="conditionParamRef.catalogIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('catalogIdStart') and conditionParamRef.catalogIdStart != null">
${_conditionType_} a.catalogId <![CDATA[ >= ]]> #{${_conditionParam_}.catalogIdStart}
</if>
<if test="conditionParamRef.containsKey('catalogIdEnd') and conditionParamRef.catalogIdEnd != null">
${_conditionType_} a.catalogId <![CDATA[ <= ]]> #{${_conditionParam_}.catalogIdEnd}
</if>
<if test="conditionParamRef.containsKey('catalogCode')">
<if test="conditionParamRef.catalogCode != null and conditionParamRef.catalogCode != ''">
${_conditionType_} a.catalogCode like #{${_conditionParam_}.catalogCode}
</if>
<if test="conditionParamRef.catalogCode == null">
${_conditionType_} a.catalogCode is null
</if>
</if>
<if test="conditionParamRef.containsKey('catalogCodeList')">
${_conditionType_} a.catalogCode in
<foreach collection="conditionParamRef.catalogCodeList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('catalogName')">
<if test="conditionParamRef.catalogName != null and conditionParamRef.catalogName != ''">
${_conditionType_} a.catalogName like #{${_conditionParam_}.catalogName}
</if>
<if test="conditionParamRef.catalogName == null">
${_conditionType_} a.catalogName is null
</if>
</if>
<if test="conditionParamRef.containsKey('catalogNameList')">
${_conditionType_} a.catalogName in
<foreach collection="conditionParamRef.catalogNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('printerName')">
<if test="conditionParamRef.printerName != null and conditionParamRef.printerName != ''">
${_conditionType_} a.printerName like #{${_conditionParam_}.printerName}
</if>
<if test="conditionParamRef.printerName == null">
${_conditionType_} a.printerName is null
</if>
</if>
<if test="conditionParamRef.containsKey('printerNameList')">
${_conditionType_} a.printerName in
<foreach collection="conditionParamRef.printerNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('printerIp')">
<if test="conditionParamRef.printerIp != null and conditionParamRef.printerIp != ''">
${_conditionType_} a.printerIp like #{${_conditionParam_}.printerIp}
</if>
<if test="conditionParamRef.printerIp == null">
${_conditionType_} a.printerIp is null
</if>
</if>
<if test="conditionParamRef.containsKey('printerIpList')">
${_conditionType_} a.printerIp in
<foreach collection="conditionParamRef.printerIpList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('paperSource')">
<if test="conditionParamRef.paperSource != null and conditionParamRef.paperSource != ''">
${_conditionType_} a.paperSource like #{${_conditionParam_}.paperSource}
</if>
<if test="conditionParamRef.paperSource == null">
${_conditionType_} a.paperSource is null
</if>
</if>
<if test="conditionParamRef.containsKey('paperSourceList')">
${_conditionType_} a.paperSource in
<foreach collection="conditionParamRef.paperSourceList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</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('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList')">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('serviceId')">
<if test="conditionParamRef.serviceId != null ">
${_conditionType_} a.serviceId = #{${_conditionParam_}.serviceId}
</if>
<if test="conditionParamRef.serviceId == null">
${_conditionType_} a.serviceId is null
</if>
</if>
<if test="conditionParamRef.containsKey('serviceIdList')">
${_conditionType_} a.serviceId in
<foreach collection="conditionParamRef.serviceIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('serviceIdStart') and conditionParamRef.serviceIdStart != null">
${_conditionType_} a.serviceId <![CDATA[ >= ]]> #{${_conditionParam_}.serviceIdStart}
</if>
<if test="conditionParamRef.containsKey('serviceIdEnd') and conditionParamRef.serviceIdEnd != null">
${_conditionType_} a.serviceId <![CDATA[ <= ]]> #{${_conditionParam_}.serviceIdEnd}
</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('catalogId')">
a.catalogId
<if test='orderCol.catalogId != null and "DESC".equalsIgnoreCase(orderCol.catalogId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('catalogCode')">
a.catalogCode
<if test='orderCol.catalogCode != null and "DESC".equalsIgnoreCase(orderCol.catalogCode)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('catalogName')">
a.catalogName
<if test='orderCol.catalogName != null and "DESC".equalsIgnoreCase(orderCol.catalogName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('printerName')">
a.printerName
<if test='orderCol.printerName != null and "DESC".equalsIgnoreCase(orderCol.printerName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('printerIp')">
a.printerIp
<if test='orderCol.printerIp != null and "DESC".equalsIgnoreCase(orderCol.printerIp)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('paperSource')">
a.paperSource
<if test='orderCol.paperSource != null and "DESC".equalsIgnoreCase(orderCol.paperSource)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('serviceId')">
a.serviceId
<if test='orderCol.serviceId != null and "DESC".equalsIgnoreCase(orderCol.serviceId)'>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
certificate-manager/src/main/resources/sqlmap/module/print/PrintServiceMapper.xml 0 → 100644
View file @ 72852fec
<?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.print.dao.ibatis.PrintServiceDaoImpl">
<!-- 字段和属性映射 -->
<resultMap type="PrintServiceEntity" id="PrintServiceEntity-Map">
<id property="id" column="id" />
<result property="serviceName" column="serviceName" />
<result property="serviceUrl" column="serviceUrl" />
<result property="createUserId" column="createUserId" />
<result property="createTime" column="createTime" />
<result property="updateUserId" column="updateUserId" />
<result property="updateTime" column="updateTime" />
</resultMap>
<!-- 表所有列 -->
<sql id="_columns">
<trim suffixOverrides="," suffix="">
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
a.id,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('serviceName') or colPickMode == 1 and data.containsKey('serviceName')))">
a.serviceName,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('serviceUrl') or colPickMode == 1 and data.containsKey('serviceUrl')))">
a.serviceUrl,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
a.createUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
a.createTime,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
a.updateUserId,
</if>
<if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
a.updateTime,
</if>
</trim>
</sql>
<!-- 新增 区分主键自增加还是业务插入 -->
<insert id="insert" parameterType="PrintServiceEntity" useGeneratedKeys="true" keyProperty="id">
insert into mortals_xhx_print_service
(serviceName,serviceUrl,createUserId,createTime,updateUserId,updateTime)
VALUES
(#{serviceName},#{serviceUrl},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
</insert>
<!-- 批量新增 -->
<insert id="insertBatch" parameterType="paramDto">
insert into mortals_xhx_print_service
(serviceName,serviceUrl,createUserId,createTime,updateUserId,updateTime)
VALUES
<foreach collection="data.dataList" item="item" index="index" separator="," >
(#{item.serviceName},#{item.serviceUrl},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
</foreach>
</insert>
<!-- 根据ParamDto更新 -->
<update id="update" parameterType="paramDto">
update mortals_xhx_print_service as a
set
<trim suffixOverrides="," suffix="">
<if test="(colPickMode==0 and data.containsKey('serviceName')) or (colPickMode==1 and !data.containsKey('serviceName'))">
a.serviceName=#{data.serviceName},
</if>
<if test="(colPickMode==0 and data.containsKey('serviceUrl')) or (colPickMode==1 and !data.containsKey('serviceUrl'))">
a.serviceUrl=#{data.serviceUrl},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
a.createUserId=#{data.createUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
a.createTime=#{data.createTime},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserId')) or (colPickMode==1 and !data.containsKey('updateUserId'))">
a.updateUserId=#{data.updateUserId},
</if>
<if test="(colPickMode==0 and data.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !data.containsKey('updateUserIdIncrement'))">
a.updateUserId=ifnull(a.updateUserId,0) + #{data.updateUserIdIncrement},
</if>
<if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
a.updateTime=#{data.updateTime},
</if>
</trim>
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</update>
<!-- 批量更新 -->
<update id="updateBatch" parameterType="paramDto">
update mortals_xhx_print_service as a
<trim prefix="set" suffixOverrides=",">
<trim prefix="serviceName=(case" suffix="ELSE serviceName end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('serviceName')) or (colPickMode==1 and !item.containsKey('serviceName'))">
when a.id=#{item.id} then #{item.serviceName}
</if>
</foreach>
</trim>
<trim prefix="serviceUrl=(case" suffix="ELSE serviceUrl end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('serviceUrl')) or (colPickMode==1 and !item.containsKey('serviceUrl'))">
when a.id=#{item.id} then #{item.serviceUrl}
</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="createTime=(case" suffix="ELSE createTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
when a.id=#{item.id} then #{item.createTime}
</if>
</foreach>
</trim>
<trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<choose>
<when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
when a.id=#{item.id} then #{item.updateUserId}
</when>
<when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
</when>
</choose>
</foreach>
</trim>
<trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
<foreach collection="data.dataList" item="item" index="index" separator="" >
<if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
when a.id=#{item.id} then #{item.updateTime}
</if>
</foreach>
</trim>
</trim>
where id in
<foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
#{item.id}
</foreach>
</update>
<!-- 根据主健查询 -->
<select id="getByKey" parameterType="paramDto" resultMap="PrintServiceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_print_service as a
where a.id=#{condition.id}
</select>
<!-- 根据主健删除 -->
<delete id="deleteByKey" parameterType="paramDto">
delete a.* from mortals_xhx_print_service as a where a.id=#{condition.id}
</delete>
<!-- 根据主健删除一批，针对单一主健有效 -->
<delete id="deleteByKeys">
delete from mortals_xhx_print_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_print_service as a
<trim suffixOverrides="where" suffix="">
where
<trim prefixOverrides="and" prefix="">
<include refid="_condition_"/>
</trim>
</trim>
</delete>
<!-- 获取列表 -->
<select id="getList" parameterType="paramDto" resultMap="PrintServiceEntity-Map">
select <include refid="_columns"/>
from mortals_xhx_print_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_print_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('serviceName')">
<if test="conditionParamRef.serviceName != null and conditionParamRef.serviceName != ''">
${_conditionType_} a.serviceName like #{${_conditionParam_}.serviceName}
</if>
<if test="conditionParamRef.serviceName == null">
${_conditionType_} a.serviceName is null
</if>
</if>
<if test="conditionParamRef.containsKey('serviceNameList')">
${_conditionType_} a.serviceName in
<foreach collection="conditionParamRef.serviceNameList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('serviceUrl')">
<if test="conditionParamRef.serviceUrl != null and conditionParamRef.serviceUrl != ''">
${_conditionType_} a.serviceUrl like #{${_conditionParam_}.serviceUrl}
</if>
<if test="conditionParamRef.serviceUrl == null">
${_conditionType_} a.serviceUrl is null
</if>
</if>
<if test="conditionParamRef.containsKey('serviceUrlList')">
${_conditionType_} a.serviceUrl in
<foreach collection="conditionParamRef.serviceUrlList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</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('createTime')">
<if test="conditionParamRef.createTime != null ">
${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
</if>
<if test="conditionParamRef.createTime == null">
${_conditionType_} a.createTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateUserId')">
<if test="conditionParamRef.updateUserId != null ">
${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
</if>
<if test="conditionParamRef.updateUserId == null">
${_conditionType_} a.updateUserId is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateUserIdList')">
${_conditionType_} a.updateUserId in
<foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
#{item}
</foreach>
</if>
<if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
</if>
<if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
</if>
<if test="conditionParamRef.containsKey('updateTime')">
<if test="conditionParamRef.updateTime != null ">
${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
</if>
<if test="conditionParamRef.updateTime == null">
${_conditionType_} a.updateTime is null
</if>
</if>
<if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
</if>
<if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
</if>
</sql>
<sql id="_orderCols_">
<if test="orderColList != null and !orderColList.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
${item.colName} ${item.sortKind}
</foreach>
</trim>
</if>
<if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
order by
<trim suffixOverrides="," suffix="">
<if test="orderCol.containsKey('id')">
a.id
<if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('serviceName')">
a.serviceName
<if test='orderCol.serviceName != null and "DESC".equalsIgnoreCase(orderCol.serviceName)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('serviceUrl')">
a.serviceUrl
<if test='orderCol.serviceUrl != null and "DESC".equalsIgnoreCase(orderCol.serviceUrl)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createUserId')">
a.createUserId
<if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('createTime')">
a.createTime
<if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateUserId')">
a.updateUserId
<if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
,
</if>
<if test="orderCol.containsKey('updateTime')">
a.updateTime
<if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
,
</if>
</trim>
</if>
</sql>
<sql id="_group_by_">
<if test="groupList != null and !groupList.isEmpty()">
GROUP BY
<trim suffixOverrides="," suffix="">
<foreach collection="groupList" open="" close="" index="index" item="item" separator=",">
${item}
</foreach>
</trim>
</if>
</sql>
</mapper>
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment