Skip to content

F
fill-system
Commit 7255b4fb authored by 赵啸非's avatar 赵啸非
Browse files
Options

添加解析表单参数数据

parent 85479673
Pipeline #2781 failed with stages
      Hide whitespace changes
      Inline Side-by-side
      Showing with 3727 additions and 8 deletions
      fill-manager/db/add.sql
      View file @ 7255b4fb
      ......@@ -12,13 +12,41 @@ ALTER TABLE mortals_xhx_matter_datum_print ADD COLUMN `idName` varchar(64) defau
      ALTER TABLE mortals_xhx_matter_datum_print ADD COLUMN `mobile` varchar(64) default '' COMMENT '手机号码' AFTER idName;
      -- ----------------------------
      2024-04-24
      -- ----------------------------
      DROP TABLE IF EXISTS `mortals_xhx_datum_info_field`;
      CREATE TABLE `mortals_xhx_datum_info_field` (
      `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '序号，主键，自增长',
      `datum_print_id` bigint(20) DEFAULT NULL COMMENT '填单打印id',
      `idCard` varchar(64) DEFAULT '' COMMENT '身份证号',
      `fieldCode` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '字段编码',
      `fieldName` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '字段名称',
      `fieldType` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框）',
      `fieldTypeValue` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT '' COMMENT '字段类型值，当字段类型为多选，单选时候，预设复选值',
      `dataType` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '数据类型（number.数字,string.字符串,arrays.数组,obj.对象）',
      `fieldValue` text CHARACTER SET utf8 COLLATE utf8_general_ci COMMENT '字段值',
      `defaultValue` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT '' COMMENT '字段默认值',
      `fieldLen` int(9) DEFAULT NULL COMMENT '数据长度，默认128',
      `fieldNull` tinyint(2) DEFAULT NULL COMMENT '是否允许为空，(0.否,1.是)',
      `isList` tinyint(2) DEFAULT NULL COMMENT '字段是否列表显示(0.否,1.是)',
      `fieldOrderNo` int(9) DEFAULT NULL COMMENT '排序号',
      `remark` varchar(1024) CHARACTER SET utf8 COLLATE utf8_general_ci DEFAULT NULL COMMENT '备注',
      `createTime` datetime DEFAULT NULL COMMENT '创建时间',
      `createUserId` bigint(20) DEFAULT NULL COMMENT '创建用户',
      `updateTime` datetime DEFAULT NULL COMMENT '修改时间',
      `updateUserId` bigint(20) DEFAULT NULL COMMENT '修改用户',
      PRIMARY KEY (`id`) USING BTREE
      ) ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='填单用户信息字段';
      -- ----------------------------
      2023-03-22
      -- ----------------------------
      INSERT INTO `mortals_xhx_task` (`id`, `name`, `taskKey`, `status`, `excuteService`, `excuteParam`, `excuteHost`, `excuteStrategy`, `excuteDate`, `excuteTime`, `remark`, `lastExcuteHost`, `lastExcuteTime`, `interimExcuteStatus`, `createTime`, `createUserId`, `createUserName`) VALUES ('4', '同步设备', 'SyncSiteDeviceTask', '0', 'SyncSiteDeviceTask', NULL, NULL, '4', '120', '00:00', NULL, '127.0.1.1', '2023-02-26 22:15:59', '0', '2023-02-25 14:34:12', '1', NULL);
      -- ----------------------------
      -- ----------------------------
      2023-06-21
      -- ----------------------------
      ALTER TABLE mortals_xhx_device
      ......
      fill-manager/src/main/java/com/mortals/xhx/common/code/DataTypeEnum.java 0 → 100644
      View file @ 7255b4fb
      package com.mortals.xhx.common.code;
      import java.util.LinkedHashMap;
      import java.util.Map;
      /**
      * 数据类型（number.数字,string.字符串,arrays.数组,obj.对象）枚举类
      *
      * @author zxfei
      */
      public enum DataTypeEnum {
      数字("数字", "number"),
      字符串("字符串", "string"),
      数组("数组", "arrays"),
      对象("对象", "obj");
      private String value;
      private String desc;
      DataTypeEnum(String value, String desc) {
      this.value = value;
      this.desc = desc;
      }
      public String getValue() {
      return this.value;
      }
      public String getDesc() {
      return this.desc;
      }
      public static DataTypeEnum getByValue(String value) {
      for (DataTypeEnum dataTypeEnum : DataTypeEnum.values()) {
      if (dataTypeEnum.getValue() == value) {
      return dataTypeEnum;
      }
      }
      return null;
      }
      /**
      * 获取Map集合
      *
      * @param eItem 不包含项
      * @return
      */
      public static Map<String, String> getEnumMap(String... eItem) {
      Map<String, String> resultMap = new LinkedHashMap<>();
      for (DataTypeEnum item : DataTypeEnum.values()) {
      try {
      boolean hasE = false;
      for (String e : eItem) {
      if (item.getValue() == e) {
      hasE = true;
      break;
      }
      }
      if (!hasE) {
      resultMap.put(item.getValue() + "", item.getDesc());
      }
      } catch (Exception ex) {
      }
      }
      return resultMap;
      }
      }
      \ No newline at end of file
      fill-manager/src/main/java/com/mortals/xhx/common/code/FieldTypeEnum.java 0 → 100644
      View file @ 7255b4fb
      package com.mortals.xhx.common.code;
      import java.util.LinkedHashMap;
      import java.util.Map;
      /**
      * 字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框）枚举类
      *
      * @author zxfei
      */
      public enum FieldTypeEnum {
      单行输入框("单行输入框", "input"),
      多行输入框("多行输入框", "textarea"),
      下拉选项框("下拉选项框", "SELECT"),
      单项选择框("单项选择框", "radio"),
      日期选择框("日期选择框", "date"),
      多项选择框("多项选择框", "checkbox"),
      横向列表("横向列表", "list"),
      表格("表格", "table");
      private String value;
      private String desc;
      FieldTypeEnum(String value, String desc) {
      this.value = value;
      this.desc = desc;
      }
      public String getValue() {
      return this.value;
      }
      public String getDesc() {
      return this.desc;
      }
      public static FieldTypeEnum getByValue(String value) {
      for (FieldTypeEnum fieldTypeEnum : FieldTypeEnum.values()) {
      if (fieldTypeEnum.getValue() == value) {
      return fieldTypeEnum;
      }
      }
      return null;
      }
      /**
      * 获取Map集合
      *
      * @param eItem 不包含项
      * @return
      */
      public static Map<String, String> getEnumMap(String... eItem) {
      Map<String, String> resultMap = new LinkedHashMap<>();
      for (FieldTypeEnum item : FieldTypeEnum.values()) {
      try {
      boolean hasE = false;
      for (String e : eItem) {
      if (item.getValue() == e) {
      hasE = true;
      break;
      }
      }
      if (!hasE) {
      resultMap.put(item.getValue() + "", item.getDesc());
      }
      } catch (Exception ex) {
      }
      }
      return resultMap;
      }
      }
      \ No newline at end of file
      fill-manager/src/main/java/com/mortals/xhx/module/datum/dao/DatumInfoFieldDao.java 0 → 100644
      View file @ 7255b4fb
      package com.mortals.xhx.module.datum.dao;
      import com.mortals.framework.dao.ICRUDDao;
      import com.mortals.xhx.module.datum.model.DatumInfoFieldEntity;
      import java.util.List;
      /**
      * 填单用户信息字段Dao
      * 填单用户信息字段 DAO接口
      *
      * @author zxfei
      * @date 2024-04-23
      */
      public interface DatumInfoFieldDao extends ICRUDDao<DatumInfoFieldEntity,Long>{
      }
      fill-manager/src/main/java/com/mortals/xhx/module/datum/dao/ibatis/DatumInfoFieldDaoImpl.java 0 → 100644
      View file @ 7255b4fb
      package com.mortals.xhx.module.datum.dao.ibatis;
      import org.springframework.stereotype.Repository;
      import com.mortals.xhx.module.datum.dao.DatumInfoFieldDao;
      import com.mortals.xhx.module.datum.model.DatumInfoFieldEntity;
      import java.util.Date;
      import com.mortals.framework.dao.ibatis.BaseCRUDDaoMybatis;
      import java.util.List;
      /**
      * 填单用户信息字段DaoImpl DAO接口
      *
      * @author zxfei
      * @date 2024-04-23
      */
      @Repository("datumInfoFieldDao")
      public class DatumInfoFieldDaoImpl extends BaseCRUDDaoMybatis<DatumInfoFieldEntity,Long> implements DatumInfoFieldDao {
      }
      fill-manager/src/main/java/com/mortals/xhx/module/datum/model/DatumInfoFieldEntity.java 0 → 100644
      View file @ 7255b4fb
      package com.mortals.xhx.module.datum.model;
      import java.util.List;
      import java.util.ArrayList;
      import java.math.BigDecimal;
      import cn.hutool.core.date.DateUtil;
      import java.util.Date;
      import com.fasterxml.jackson.annotation.JsonFormat;
      import com.mortals.framework.annotation.Excel;
      import com.mortals.framework.model.BaseEntityLong;
      import com.mortals.xhx.module.datum.model.vo.DatumInfoFieldVo;
      import lombok.Data;
      /**
      * 填单用户信息字段实体对象
      *
      * @author zxfei
      * @date 2024-04-23
      */
      @Data
      public class DatumInfoFieldEntity extends DatumInfoFieldVo {
      private static final long serialVersionUID = 1L;
      /**
      * 填单打印id
      */
      private Long datumPrintId;
      /**
      * 字段编码
      */
      private String fieldCode;
      /**
      * 字段名称
      */
      private String fieldName;
      /**
      * 字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框）
      */
      private String fieldType;
      /**
      * 字段类型值，当字段类型为多选，单选时候，预设复选值
      */
      private String fieldTypeValue;
      /**
      * 数据类型（number.数字,string.字符串,arrays.数组,obj.对象）
      */
      private String dataType;
      /**
      * 字段值
      */
      private String fieldValue;
      /**
      * 字段默认值
      */
      private String defaultValue;
      /**
      * 数据长度，默认128
      */
      private Integer fieldLen;
      /**
      * 是否允许为空，(0.否,1.是)
      */
      private Integer fieldNull;
      /**
      * 字段是否列表显示(0.否,1.是)
      */
      private Integer isList;
      /**
      * 排序号
      */
      private Integer fieldOrderNo;
      /**
      * 备注
      */
      private String remark;
      /**
      * 身份证号
      */
      private String idCard;
      @Override
      public int hashCode() {
      return this.getId().hashCode();
      }
      @Override
      public boolean equals(Object obj) {
      if (obj == null) return false;
      if (obj instanceof DatumInfoFieldEntity) {
      DatumInfoFieldEntity tmp = (DatumInfoFieldEntity) obj;
      if (this.getId() == tmp.getId()) {
      return true;
      }
      }
      return false;
      }
      public void initAttrValue(){
      this.datumPrintId = null;
      this.fieldCode = "";
      this.fieldName = "";
      this.fieldType = "";
      this.fieldTypeValue = "";
      this.dataType = "";
      this.fieldValue = "";
      this.defaultValue = "";
      this.fieldLen = 0;
      this.fieldNull = 0;
      this.isList = 0;
      this.fieldOrderNo = 0;
      this.remark = "";
      this.idCard = "";
      }
      }
      \ No newline at end of file
      fill-manager/src/main/java/com/mortals/xhx/module/datum/model/DatumInfoFieldQuery.java 0 → 100644
      View file @ 7255b4fb
      package com.mortals.xhx.module.datum.model;
      import java.util.List;
      import com.mortals.xhx.module.datum.model.DatumInfoFieldEntity;
      /**
      * 填单用户信息字段查询对象
      *
      * @author zxfei
      * @date 2024-04-23
      */
      public class DatumInfoFieldQuery extends DatumInfoFieldEntity {
      /** 开始 序号，主键，自增长 */
      private Long idStart;
      /** 结束 序号，主键，自增长 */
      private Long idEnd;
      /** 增加 序号，主键，自增长 */
      private Long idIncrement;
      /** 序号，主键，自增长列表 */
      private List <Long> idList;
      /** 序号，主键，自增长排除列表 */
      private List <Long> idNotList;
      /** 开始 填单打印id */
      private Long datumPrintIdStart;
      /** 结束 填单打印id */
      private Long datumPrintIdEnd;
      /** 增加 填单打印id */
      private Long datumPrintIdIncrement;
      /** 填单打印id列表 */
      private List <Long> datumPrintIdList;
      /** 填单打印id排除列表 */
      private List <Long> datumPrintIdNotList;
      /** 字段编码 */
      private List<String> fieldCodeList;
      /** 字段编码排除列表 */
      private List <String> fieldCodeNotList;
      /** 字段名称 */
      private List<String> fieldNameList;
      /** 字段名称排除列表 */
      private List <String> fieldNameNotList;
      /** 字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框） */
      private List<String> fieldTypeList;
      /** 字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框）排除列表 */
      private List <String> fieldTypeNotList;
      /** 字段类型值，当字段类型为多选，单选时候，预设复选值 */
      private List<String> fieldTypeValueList;
      /** 字段类型值，当字段类型为多选，单选时候，预设复选值排除列表 */
      private List <String> fieldTypeValueNotList;
      /** 数据类型（number.数字,string.字符串,arrays.数组,obj.对象） */
      private List<String> dataTypeList;
      /** 数据类型（number.数字,string.字符串,arrays.数组,obj.对象）排除列表 */
      private List <String> dataTypeNotList;
      /** 字段值 */
      private List<String> fieldValueList;
      /** 字段值排除列表 */
      private List <String> fieldValueNotList;
      /** 字段默认值 */
      private List<String> defaultValueList;
      /** 字段默认值排除列表 */
      private List <String> defaultValueNotList;
      /** 开始 数据长度，默认128 */
      private Integer fieldLenStart;
      /** 结束 数据长度，默认128 */
      private Integer fieldLenEnd;
      /** 增加 数据长度，默认128 */
      private Integer fieldLenIncrement;
      /** 数据长度，默认128列表 */
      private List <Integer> fieldLenList;
      /** 数据长度，默认128排除列表 */
      private List <Integer> fieldLenNotList;
      /** 开始 是否允许为空，(0.否,1.是) */
      private Integer fieldNullStart;
      /** 结束 是否允许为空，(0.否,1.是) */
      private Integer fieldNullEnd;
      /** 增加 是否允许为空，(0.否,1.是) */
      private Integer fieldNullIncrement;
      /** 是否允许为空，(0.否,1.是)列表 */
      private List <Integer> fieldNullList;
      /** 是否允许为空，(0.否,1.是)排除列表 */
      private List <Integer> fieldNullNotList;
      /** 开始 字段是否列表显示(0.否,1.是) */
      private Integer isListStart;
      /** 结束 字段是否列表显示(0.否,1.是) */
      private Integer isListEnd;
      /** 增加 字段是否列表显示(0.否,1.是) */
      private Integer isListIncrement;
      /** 字段是否列表显示(0.否,1.是)列表 */
      private List <Integer> isListList;
      /** 字段是否列表显示(0.否,1.是)排除列表 */
      private List <Integer> isListNotList;
      /** 开始 排序号 */
      private Integer fieldOrderNoStart;
      /** 结束 排序号 */
      private Integer fieldOrderNoEnd;
      /** 增加 排序号 */
      private Integer fieldOrderNoIncrement;
      /** 排序号列表 */
      private List <Integer> fieldOrderNoList;
      /** 排序号排除列表 */
      private List <Integer> fieldOrderNoNotList;
      /** 备注 */
      private List<String> remarkList;
      /** 备注排除列表 */
      private List <String> remarkNotList;
      /** 开始 创建时间 */
      private String createTimeStart;
      /** 结束 创建时间 */
      private String createTimeEnd;
      /** 开始 创建用户 */
      private Long createUserIdStart;
      /** 结束 创建用户 */
      private Long createUserIdEnd;
      /** 增加 创建用户 */
      private Long createUserIdIncrement;
      /** 创建用户列表 */
      private List <Long> createUserIdList;
      /** 创建用户排除列表 */
      private List <Long> createUserIdNotList;
      /** 开始 修改时间 */
      private String updateTimeStart;
      /** 结束 修改时间 */
      private String updateTimeEnd;
      /** 开始 修改用户 */
      private Long updateUserIdStart;
      /** 结束 修改用户 */
      private Long updateUserIdEnd;
      /** 增加 修改用户 */
      private Long updateUserIdIncrement;
      /** 修改用户列表 */
      private List <Long> updateUserIdList;
      /** 修改用户排除列表 */
      private List <Long> updateUserIdNotList;
      /** 身份证号 */
      private List<String> idCardList;
      /** 身份证号排除列表 */
      private List <String> idCardNotList;
      /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
      private List<DatumInfoFieldQuery> orConditionList;
      /** AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4) */
      private List<DatumInfoFieldQuery> andConditionList;
      public DatumInfoFieldQuery(){}
      /**
      * 获取 开始 序号，主键，自增长
      * @return idStart
      */
      public Long getIdStart(){
      return this.idStart;
      }
      /**
      * 设置 开始 序号，主键，自增长
      * @param idStart
      */
      public void setIdStart(Long idStart){
      this.idStart = idStart;
      }
      /**
      * 获取 结束 序号，主键，自增长
      * @return $idEnd
      */
      public Long getIdEnd(){
      return this.idEnd;
      }
      /**
      * 设置 结束 序号，主键，自增长
      * @param idEnd
      */
      public void setIdEnd(Long idEnd){
      this.idEnd = idEnd;
      }
      /**
      * 获取 增加 序号，主键，自增长
      * @return idIncrement
      */
      public Long getIdIncrement(){
      return this.idIncrement;
      }
      /**
      * 设置 增加 序号，主键，自增长
      * @param idIncrement
      */
      public void setIdIncrement(Long idIncrement){
      this.idIncrement = idIncrement;
      }
      /**
      * 获取 序号，主键，自增长
      * @return idList
      */
      public List<Long> getIdList(){
      return this.idList;
      }
      /**
      * 设置 序号，主键，自增长
      * @param idList
      */
      public void setIdList(List<Long> idList){
      this.idList = idList;
      }
      /**
      * 获取 序号，主键，自增长
      * @return idNotList
      */
      public List<Long> getIdNotList(){
      return this.idNotList;
      }
      /**
      * 设置 序号，主键，自增长
      * @param idNotList
      */
      public void setIdNotList(List<Long> idNotList){
      this.idNotList = idNotList;
      }
      /**
      * 获取 开始 填单打印id
      * @return datumPrintIdStart
      */
      public Long getDatumPrintIdStart(){
      return this.datumPrintIdStart;
      }
      /**
      * 设置 开始 填单打印id
      * @param datumPrintIdStart
      */
      public void setDatumPrintIdStart(Long datumPrintIdStart){
      this.datumPrintIdStart = datumPrintIdStart;
      }
      /**
      * 获取 结束 填单打印id
      * @return $datumPrintIdEnd
      */
      public Long getDatumPrintIdEnd(){
      return this.datumPrintIdEnd;
      }
      /**
      * 设置 结束 填单打印id
      * @param datumPrintIdEnd
      */
      public void setDatumPrintIdEnd(Long datumPrintIdEnd){
      this.datumPrintIdEnd = datumPrintIdEnd;
      }
      /**
      * 获取 增加 填单打印id
      * @return datumPrintIdIncrement
      */
      public Long getDatumPrintIdIncrement(){
      return this.datumPrintIdIncrement;
      }
      /**
      * 设置 增加 填单打印id
      * @param datumPrintIdIncrement
      */
      public void setDatumPrintIdIncrement(Long datumPrintIdIncrement){
      this.datumPrintIdIncrement = datumPrintIdIncrement;
      }
      /**
      * 获取 填单打印id
      * @return datumPrintIdList
      */
      public List<Long> getDatumPrintIdList(){
      return this.datumPrintIdList;
      }
      /**
      * 设置 填单打印id
      * @param datumPrintIdList
      */
      public void setDatumPrintIdList(List<Long> datumPrintIdList){
      this.datumPrintIdList = datumPrintIdList;
      }
      /**
      * 获取 填单打印id
      * @return datumPrintIdNotList
      */
      public List<Long> getDatumPrintIdNotList(){
      return this.datumPrintIdNotList;
      }
      /**
      * 设置 填单打印id
      * @param datumPrintIdNotList
      */
      public void setDatumPrintIdNotList(List<Long> datumPrintIdNotList){
      this.datumPrintIdNotList = datumPrintIdNotList;
      }
      /**
      * 获取 字段编码
      * @return fieldCodeList
      */
      public List<String> getFieldCodeList(){
      return this.fieldCodeList;
      }
      /**
      * 设置 字段编码
      * @param fieldCodeList
      */
      public void setFieldCodeList(List<String> fieldCodeList){
      this.fieldCodeList = fieldCodeList;
      }
      /**
      * 获取 字段编码
      * @return fieldCodeNotList
      */
      public List<String> getFieldCodeNotList(){
      return this.fieldCodeNotList;
      }
      /**
      * 设置 字段编码
      * @param fieldCodeNotList
      */
      public void setFieldCodeNotList(List<String> fieldCodeNotList){
      this.fieldCodeNotList = fieldCodeNotList;
      }
      /**
      * 获取 字段名称
      * @return fieldNameList
      */
      public List<String> getFieldNameList(){
      return this.fieldNameList;
      }
      /**
      * 设置 字段名称
      * @param fieldNameList
      */
      public void setFieldNameList(List<String> fieldNameList){
      this.fieldNameList = fieldNameList;
      }
      /**
      * 获取 字段名称
      * @return fieldNameNotList
      */
      public List<String> getFieldNameNotList(){
      return this.fieldNameNotList;
      }
      /**
      * 设置 字段名称
      * @param fieldNameNotList
      */
      public void setFieldNameNotList(List<String> fieldNameNotList){
      this.fieldNameNotList = fieldNameNotList;
      }
      /**
      * 获取 字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框）
      * @return fieldTypeList
      */
      public List<String> getFieldTypeList(){
      return this.fieldTypeList;
      }
      /**
      * 设置 字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框）
      * @param fieldTypeList
      */
      public void setFieldTypeList(List<String> fieldTypeList){
      this.fieldTypeList = fieldTypeList;
      }
      /**
      * 获取 字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框）
      * @return fieldTypeNotList
      */
      public List<String> getFieldTypeNotList(){
      return this.fieldTypeNotList;
      }
      /**
      * 设置 字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框）
      * @param fieldTypeNotList
      */
      public void setFieldTypeNotList(List<String> fieldTypeNotList){
      this.fieldTypeNotList = fieldTypeNotList;
      }
      /**
      * 获取 字段类型值，当字段类型为多选，单选时候，预设复选值
      * @return fieldTypeValueList
      */
      public List<String> getFieldTypeValueList(){
      return this.fieldTypeValueList;
      }
      /**
      * 设置 字段类型值，当字段类型为多选，单选时候，预设复选值
      * @param fieldTypeValueList
      */
      public void setFieldTypeValueList(List<String> fieldTypeValueList){
      this.fieldTypeValueList = fieldTypeValueList;
      }
      /**
      * 获取 字段类型值，当字段类型为多选，单选时候，预设复选值
      * @return fieldTypeValueNotList
      */
      public List<String> getFieldTypeValueNotList(){
      return this.fieldTypeValueNotList;
      }
      /**
      * 设置 字段类型值，当字段类型为多选，单选时候，预设复选值
      * @param fieldTypeValueNotList
      */
      public void setFieldTypeValueNotList(List<String> fieldTypeValueNotList){
      this.fieldTypeValueNotList = fieldTypeValueNotList;
      }
      /**
      * 获取 数据类型（number.数字,string.字符串,arrays.数组,obj.对象）
      * @return dataTypeList
      */
      public List<String> getDataTypeList(){
      return this.dataTypeList;
      }
      /**
      * 设置 数据类型（number.数字,string.字符串,arrays.数组,obj.对象）
      * @param dataTypeList
      */
      public void setDataTypeList(List<String> dataTypeList){
      this.dataTypeList = dataTypeList;
      }
      /**
      * 获取 数据类型（number.数字,string.字符串,arrays.数组,obj.对象）
      * @return dataTypeNotList
      */
      public List<String> getDataTypeNotList(){
      return this.dataTypeNotList;
      }
      /**
      * 设置 数据类型（number.数字,string.字符串,arrays.数组,obj.对象）
      * @param dataTypeNotList
      */
      public void setDataTypeNotList(List<String> dataTypeNotList){
      this.dataTypeNotList = dataTypeNotList;
      }
      /**
      * 获取 字段值
      * @return fieldValueList
      */
      public List<String> getFieldValueList(){
      return this.fieldValueList;
      }
      /**
      * 设置 字段值
      * @param fieldValueList
      */
      public void setFieldValueList(List<String> fieldValueList){
      this.fieldValueList = fieldValueList;
      }
      /**
      * 获取 字段值
      * @return fieldValueNotList
      */
      public List<String> getFieldValueNotList(){
      return this.fieldValueNotList;
      }
      /**
      * 设置 字段值
      * @param fieldValueNotList
      */
      public void setFieldValueNotList(List<String> fieldValueNotList){
      this.fieldValueNotList = fieldValueNotList;
      }
      /**
      * 获取 字段默认值
      * @return defaultValueList
      */
      public List<String> getDefaultValueList(){
      return this.defaultValueList;
      }
      /**
      * 设置 字段默认值
      * @param defaultValueList
      */
      public void setDefaultValueList(List<String> defaultValueList){
      this.defaultValueList = defaultValueList;
      }
      /**
      * 获取 字段默认值
      * @return defaultValueNotList
      */
      public List<String> getDefaultValueNotList(){
      return this.defaultValueNotList;
      }
      /**
      * 设置 字段默认值
      * @param defaultValueNotList
      */
      public void setDefaultValueNotList(List<String> defaultValueNotList){
      this.defaultValueNotList = defaultValueNotList;
      }
      /**
      * 获取 开始 数据长度，默认128
      * @return fieldLenStart
      */
      public Integer getFieldLenStart(){
      return this.fieldLenStart;
      }
      /**
      * 设置 开始 数据长度，默认128
      * @param fieldLenStart
      */
      public void setFieldLenStart(Integer fieldLenStart){
      this.fieldLenStart = fieldLenStart;
      }
      /**
      * 获取 结束 数据长度，默认128
      * @return $fieldLenEnd
      */
      public Integer getFieldLenEnd(){
      return this.fieldLenEnd;
      }
      /**
      * 设置 结束 数据长度，默认128
      * @param fieldLenEnd
      */
      public void setFieldLenEnd(Integer fieldLenEnd){
      this.fieldLenEnd = fieldLenEnd;
      }
      /**
      * 获取 增加 数据长度，默认128
      * @return fieldLenIncrement
      */
      public Integer getFieldLenIncrement(){
      return this.fieldLenIncrement;
      }
      /**
      * 设置 增加 数据长度，默认128
      * @param fieldLenIncrement
      */
      public void setFieldLenIncrement(Integer fieldLenIncrement){
      this.fieldLenIncrement = fieldLenIncrement;
      }
      /**
      * 获取 数据长度，默认128
      * @return fieldLenList
      */
      public List<Integer> getFieldLenList(){
      return this.fieldLenList;
      }
      /**
      * 设置 数据长度，默认128
      * @param fieldLenList
      */
      public void setFieldLenList(List<Integer> fieldLenList){
      this.fieldLenList = fieldLenList;
      }
      /**
      * 获取 数据长度，默认128
      * @return fieldLenNotList
      */
      public List<Integer> getFieldLenNotList(){
      return this.fieldLenNotList;
      }
      /**
      * 设置 数据长度，默认128
      * @param fieldLenNotList
      */
      public void setFieldLenNotList(List<Integer> fieldLenNotList){
      this.fieldLenNotList = fieldLenNotList;
      }
      /**
      * 获取 开始 是否允许为空，(0.否,1.是)
      * @return fieldNullStart
      */
      public Integer getFieldNullStart(){
      return this.fieldNullStart;
      }
      /**
      * 设置 开始 是否允许为空，(0.否,1.是)
      * @param fieldNullStart
      */
      public void setFieldNullStart(Integer fieldNullStart){
      this.fieldNullStart = fieldNullStart;
      }
      /**
      * 获取 结束 是否允许为空，(0.否,1.是)
      * @return $fieldNullEnd
      */
      public Integer getFieldNullEnd(){
      return this.fieldNullEnd;
      }
      /**
      * 设置 结束 是否允许为空，(0.否,1.是)
      * @param fieldNullEnd
      */
      public void setFieldNullEnd(Integer fieldNullEnd){
      this.fieldNullEnd = fieldNullEnd;
      }
      /**
      * 获取 增加 是否允许为空，(0.否,1.是)
      * @return fieldNullIncrement
      */
      public Integer getFieldNullIncrement(){
      return this.fieldNullIncrement;
      }
      /**
      * 设置 增加 是否允许为空，(0.否,1.是)
      * @param fieldNullIncrement
      */
      public void setFieldNullIncrement(Integer fieldNullIncrement){
      this.fieldNullIncrement = fieldNullIncrement;
      }
      /**
      * 获取 是否允许为空，(0.否,1.是)
      * @return fieldNullList
      */
      public List<Integer> getFieldNullList(){
      return this.fieldNullList;
      }
      /**
      * 设置 是否允许为空，(0.否,1.是)
      * @param fieldNullList
      */
      public void setFieldNullList(List<Integer> fieldNullList){
      this.fieldNullList = fieldNullList;
      }
      /**
      * 获取 是否允许为空，(0.否,1.是)
      * @return fieldNullNotList
      */
      public List<Integer> getFieldNullNotList(){
      return this.fieldNullNotList;
      }
      /**
      * 设置 是否允许为空，(0.否,1.是)
      * @param fieldNullNotList
      */
      public void setFieldNullNotList(List<Integer> fieldNullNotList){
      this.fieldNullNotList = fieldNullNotList;
      }
      /**
      * 获取 开始 字段是否列表显示(0.否,1.是)
      * @return isListStart
      */
      public Integer getIsListStart(){
      return this.isListStart;
      }
      /**
      * 设置 开始 字段是否列表显示(0.否,1.是)
      * @param isListStart
      */
      public void setIsListStart(Integer isListStart){
      this.isListStart = isListStart;
      }
      /**
      * 获取 结束 字段是否列表显示(0.否,1.是)
      * @return $isListEnd
      */
      public Integer getIsListEnd(){
      return this.isListEnd;
      }
      /**
      * 设置 结束 字段是否列表显示(0.否,1.是)
      * @param isListEnd
      */
      public void setIsListEnd(Integer isListEnd){
      this.isListEnd = isListEnd;
      }
      /**
      * 获取 增加 字段是否列表显示(0.否,1.是)
      * @return isListIncrement
      */
      public Integer getIsListIncrement(){
      return this.isListIncrement;
      }
      /**
      * 设置 增加 字段是否列表显示(0.否,1.是)
      * @param isListIncrement
      */
      public void setIsListIncrement(Integer isListIncrement){
      this.isListIncrement = isListIncrement;
      }
      /**
      * 获取 字段是否列表显示(0.否,1.是)
      * @return isListList
      */
      public List<Integer> getIsListList(){
      return this.isListList;
      }
      /**
      * 设置 字段是否列表显示(0.否,1.是)
      * @param isListList
      */
      public void setIsListList(List<Integer> isListList){
      this.isListList = isListList;
      }
      /**
      * 获取 字段是否列表显示(0.否,1.是)
      * @return isListNotList
      */
      public List<Integer> getIsListNotList(){
      return this.isListNotList;
      }
      /**
      * 设置 字段是否列表显示(0.否,1.是)
      * @param isListNotList
      */
      public void setIsListNotList(List<Integer> isListNotList){
      this.isListNotList = isListNotList;
      }
      /**
      * 获取 开始 排序号
      * @return fieldOrderNoStart
      */
      public Integer getFieldOrderNoStart(){
      return this.fieldOrderNoStart;
      }
      /**
      * 设置 开始 排序号
      * @param fieldOrderNoStart
      */
      public void setFieldOrderNoStart(Integer fieldOrderNoStart){
      this.fieldOrderNoStart = fieldOrderNoStart;
      }
      /**
      * 获取 结束 排序号
      * @return $fieldOrderNoEnd
      */
      public Integer getFieldOrderNoEnd(){
      return this.fieldOrderNoEnd;
      }
      /**
      * 设置 结束 排序号
      * @param fieldOrderNoEnd
      */
      public void setFieldOrderNoEnd(Integer fieldOrderNoEnd){
      this.fieldOrderNoEnd = fieldOrderNoEnd;
      }
      /**
      * 获取 增加 排序号
      * @return fieldOrderNoIncrement
      */
      public Integer getFieldOrderNoIncrement(){
      return this.fieldOrderNoIncrement;
      }
      /**
      * 设置 增加 排序号
      * @param fieldOrderNoIncrement
      */
      public void setFieldOrderNoIncrement(Integer fieldOrderNoIncrement){
      this.fieldOrderNoIncrement = fieldOrderNoIncrement;
      }
      /**
      * 获取 排序号
      * @return fieldOrderNoList
      */
      public List<Integer> getFieldOrderNoList(){
      return this.fieldOrderNoList;
      }
      /**
      * 设置 排序号
      * @param fieldOrderNoList
      */
      public void setFieldOrderNoList(List<Integer> fieldOrderNoList){
      this.fieldOrderNoList = fieldOrderNoList;
      }
      /**
      * 获取 排序号
      * @return fieldOrderNoNotList
      */
      public List<Integer> getFieldOrderNoNotList(){
      return this.fieldOrderNoNotList;
      }
      /**
      * 设置 排序号
      * @param fieldOrderNoNotList
      */
      public void setFieldOrderNoNotList(List<Integer> fieldOrderNoNotList){
      this.fieldOrderNoNotList = fieldOrderNoNotList;
      }
      /**
      * 获取 备注
      * @return remarkList
      */
      public List<String> getRemarkList(){
      return this.remarkList;
      }
      /**
      * 设置 备注
      * @param remarkList
      */
      public void setRemarkList(List<String> remarkList){
      this.remarkList = remarkList;
      }
      /**
      * 获取 备注
      * @return remarkNotList
      */
      public List<String> getRemarkNotList(){
      return this.remarkNotList;
      }
      /**
      * 设置 备注
      * @param remarkNotList
      */
      public void setRemarkNotList(List<String> remarkNotList){
      this.remarkNotList = remarkNotList;
      }
      /**
      * 获取 开始 创建时间
      * @return createTimeStart
      */
      public String getCreateTimeStart(){
      return this.createTimeStart;
      }
      /**
      * 设置 开始 创建时间
      * @param createTimeStart
      */
      public void setCreateTimeStart(String createTimeStart){
      this.createTimeStart = createTimeStart;
      }
      /**
      * 获取 结束 创建时间
      * @return createTimeEnd
      */
      public String getCreateTimeEnd(){
      return this.createTimeEnd;
      }
      /**
      * 设置 结束 创建时间
      * @param createTimeEnd
      */
      public void setCreateTimeEnd(String createTimeEnd){
      this.createTimeEnd = createTimeEnd;
      }
      /**
      * 获取 开始 创建用户
      * @return createUserIdStart
      */
      public Long getCreateUserIdStart(){
      return this.createUserIdStart;
      }
      /**
      * 设置 开始 创建用户
      * @param createUserIdStart
      */
      public void setCreateUserIdStart(Long createUserIdStart){
      this.createUserIdStart = createUserIdStart;
      }
      /**
      * 获取 结束 创建用户
      * @return $createUserIdEnd
      */
      public Long getCreateUserIdEnd(){
      return this.createUserIdEnd;
      }
      /**
      * 设置 结束 创建用户
      * @param createUserIdEnd
      */
      public void setCreateUserIdEnd(Long createUserIdEnd){
      this.createUserIdEnd = createUserIdEnd;
      }
      /**
      * 获取 增加 创建用户
      * @return createUserIdIncrement
      */
      public Long getCreateUserIdIncrement(){
      return this.createUserIdIncrement;
      }
      /**
      * 设置 增加 创建用户
      * @param createUserIdIncrement
      */
      public void setCreateUserIdIncrement(Long createUserIdIncrement){
      this.createUserIdIncrement = createUserIdIncrement;
      }
      /**
      * 获取 创建用户
      * @return createUserIdList
      */
      public List<Long> getCreateUserIdList(){
      return this.createUserIdList;
      }
      /**
      * 设置 创建用户
      * @param createUserIdList
      */
      public void setCreateUserIdList(List<Long> createUserIdList){
      this.createUserIdList = createUserIdList;
      }
      /**
      * 获取 创建用户
      * @return createUserIdNotList
      */
      public List<Long> getCreateUserIdNotList(){
      return this.createUserIdNotList;
      }
      /**
      * 设置 创建用户
      * @param createUserIdNotList
      */
      public void setCreateUserIdNotList(List<Long> createUserIdNotList){
      this.createUserIdNotList = createUserIdNotList;
      }
      /**
      * 获取 开始 修改时间
      * @return 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;
      }
      /**
      * 获取 开始 修改用户
      * @return updateUserIdStart
      */
      public Long getUpdateUserIdStart(){
      return this.updateUserIdStart;
      }
      /**
      * 设置 开始 修改用户
      * @param updateUserIdStart
      */
      public void setUpdateUserIdStart(Long updateUserIdStart){
      this.updateUserIdStart = updateUserIdStart;
      }
      /**
      * 获取 结束 修改用户
      * @return $updateUserIdEnd
      */
      public Long getUpdateUserIdEnd(){
      return this.updateUserIdEnd;
      }
      /**
      * 设置 结束 修改用户
      * @param updateUserIdEnd
      */
      public void setUpdateUserIdEnd(Long updateUserIdEnd){
      this.updateUserIdEnd = updateUserIdEnd;
      }
      /**
      * 获取 增加 修改用户
      * @return updateUserIdIncrement
      */
      public Long getUpdateUserIdIncrement(){
      return this.updateUserIdIncrement;
      }
      /**
      * 设置 增加 修改用户
      * @param updateUserIdIncrement
      */
      public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
      this.updateUserIdIncrement = updateUserIdIncrement;
      }
      /**
      * 获取 修改用户
      * @return updateUserIdList
      */
      public List<Long> getUpdateUserIdList(){
      return this.updateUserIdList;
      }
      /**
      * 设置 修改用户
      * @param updateUserIdList
      */
      public void setUpdateUserIdList(List<Long> updateUserIdList){
      this.updateUserIdList = updateUserIdList;
      }
      /**
      * 获取 修改用户
      * @return updateUserIdNotList
      */
      public List<Long> getUpdateUserIdNotList(){
      return this.updateUserIdNotList;
      }
      /**
      * 设置 修改用户
      * @param updateUserIdNotList
      */
      public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
      this.updateUserIdNotList = updateUserIdNotList;
      }
      /**
      * 获取 身份证号
      * @return idCardList
      */
      public List<String> getIdCardList(){
      return this.idCardList;
      }
      /**
      * 设置 身份证号
      * @param idCardList
      */
      public void setIdCardList(List<String> idCardList){
      this.idCardList = idCardList;
      }
      /**
      * 获取 身份证号
      * @return idCardNotList
      */
      public List<String> getIdCardNotList(){
      return this.idCardNotList;
      }
      /**
      * 设置 身份证号
      * @param idCardNotList
      */
      public void setIdCardNotList(List<String> idCardNotList){
      this.idCardNotList = idCardNotList;
      }
      /**
      * 设置 序号，主键，自增长
      * @param id
      */
      public DatumInfoFieldQuery id(Long id){
      setId(id);
      return this;
      }
      /**
      * 设置 开始 序号，主键，自增长
      * @param idStart
      */
      public DatumInfoFieldQuery idStart(Long idStart){
      this.idStart = idStart;
      return this;
      }
      /**
      * 设置 结束 序号，主键，自增长
      * @param idEnd
      */
      public DatumInfoFieldQuery idEnd(Long idEnd){
      this.idEnd = idEnd;
      return this;
      }
      /**
      * 设置 增加 序号，主键，自增长
      * @param idIncrement
      */
      public DatumInfoFieldQuery idIncrement(Long idIncrement){
      this.idIncrement = idIncrement;
      return this;
      }
      /**
      * 设置 序号，主键，自增长
      * @param idList
      */
      public DatumInfoFieldQuery idList(List<Long> idList){
      this.idList = idList;
      return this;
      }
      /**
      * 设置 序号，主键，自增长
      * @param idNotList
      */
      public DatumInfoFieldQuery idNotList(List<Long> idNotList){
      this.idNotList = idNotList;
      return this;
      }
      /**
      * 设置 填单打印id
      * @param datumPrintId
      */
      public DatumInfoFieldQuery datumPrintId(Long datumPrintId){
      setDatumPrintId(datumPrintId);
      return this;
      }
      /**
      * 设置 开始 填单打印id
      * @param datumPrintIdStart
      */
      public DatumInfoFieldQuery datumPrintIdStart(Long datumPrintIdStart){
      this.datumPrintIdStart = datumPrintIdStart;
      return this;
      }
      /**
      * 设置 结束 填单打印id
      * @param datumPrintIdEnd
      */
      public DatumInfoFieldQuery datumPrintIdEnd(Long datumPrintIdEnd){
      this.datumPrintIdEnd = datumPrintIdEnd;
      return this;
      }
      /**
      * 设置 增加 填单打印id
      * @param datumPrintIdIncrement
      */
      public DatumInfoFieldQuery datumPrintIdIncrement(Long datumPrintIdIncrement){
      this.datumPrintIdIncrement = datumPrintIdIncrement;
      return this;
      }
      /**
      * 设置 填单打印id
      * @param datumPrintIdList
      */
      public DatumInfoFieldQuery datumPrintIdList(List<Long> datumPrintIdList){
      this.datumPrintIdList = datumPrintIdList;
      return this;
      }
      /**
      * 设置 填单打印id
      * @param datumPrintIdNotList
      */
      public DatumInfoFieldQuery datumPrintIdNotList(List<Long> datumPrintIdNotList){
      this.datumPrintIdNotList = datumPrintIdNotList;
      return this;
      }
      /**
      * 设置 字段编码
      * @param fieldCode
      */
      public DatumInfoFieldQuery fieldCode(String fieldCode){
      setFieldCode(fieldCode);
      return this;
      }
      /**
      * 设置 字段编码
      * @param fieldCodeList
      */
      public DatumInfoFieldQuery fieldCodeList(List<String> fieldCodeList){
      this.fieldCodeList = fieldCodeList;
      return this;
      }
      /**
      * 设置 字段名称
      * @param fieldName
      */
      public DatumInfoFieldQuery fieldName(String fieldName){
      setFieldName(fieldName);
      return this;
      }
      /**
      * 设置 字段名称
      * @param fieldNameList
      */
      public DatumInfoFieldQuery fieldNameList(List<String> fieldNameList){
      this.fieldNameList = fieldNameList;
      return this;
      }
      /**
      * 设置 字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框）
      * @param fieldType
      */
      public DatumInfoFieldQuery fieldType(String fieldType){
      setFieldType(fieldType);
      return this;
      }
      /**
      * 设置 字段类型（input.单行输入框,textarea.多行输入框,SELECT.下拉选项框,date.日期选择框,checkbox.多项选择框）
      * @param fieldTypeList
      */
      public DatumInfoFieldQuery fieldTypeList(List<String> fieldTypeList){
      this.fieldTypeList = fieldTypeList;
      return this;
      }
      /**
      * 设置 字段类型值，当字段类型为多选，单选时候，预设复选值
      * @param fieldTypeValue
      */
      public DatumInfoFieldQuery fieldTypeValue(String fieldTypeValue){
      setFieldTypeValue(fieldTypeValue);
      return this;
      }
      /**
      * 设置 字段类型值，当字段类型为多选，单选时候，预设复选值
      * @param fieldTypeValueList
      */
      public DatumInfoFieldQuery fieldTypeValueList(List<String> fieldTypeValueList){
      this.fieldTypeValueList = fieldTypeValueList;
      return this;
      }
      /**
      * 设置 数据类型（number.数字,string.字符串,arrays.数组,obj.对象）
      * @param dataType
      */
      public DatumInfoFieldQuery dataType(String dataType){
      setDataType(dataType);
      return this;
      }
      /**
      * 设置 数据类型（number.数字,string.字符串,arrays.数组,obj.对象）
      * @param dataTypeList
      */
      public DatumInfoFieldQuery dataTypeList(List<String> dataTypeList){
      this.dataTypeList = dataTypeList;
      return this;
      }
      /**
      * 设置 字段值
      * @param fieldValue
      */
      public DatumInfoFieldQuery fieldValue(String fieldValue){
      setFieldValue(fieldValue);
      return this;
      }
      /**
      * 设置 字段值
      * @param fieldValueList
      */
      public DatumInfoFieldQuery fieldValueList(List<String> fieldValueList){
      this.fieldValueList = fieldValueList;
      return this;
      }
      /**
      * 设置 字段默认值
      * @param defaultValue
      */
      public DatumInfoFieldQuery defaultValue(String defaultValue){
      setDefaultValue(defaultValue);
      return this;
      }
      /**
      * 设置 字段默认值
      * @param defaultValueList
      */
      public DatumInfoFieldQuery defaultValueList(List<String> defaultValueList){
      this.defaultValueList = defaultValueList;
      return this;
      }
      /**
      * 设置 数据长度，默认128
      * @param fieldLen
      */
      public DatumInfoFieldQuery fieldLen(Integer fieldLen){
      setFieldLen(fieldLen);
      return this;
      }
      /**
      * 设置 开始 数据长度，默认128
      * @param fieldLenStart
      */
      public DatumInfoFieldQuery fieldLenStart(Integer fieldLenStart){
      this.fieldLenStart = fieldLenStart;
      return this;
      }
      /**
      * 设置 结束 数据长度，默认128
      * @param fieldLenEnd
      */
      public DatumInfoFieldQuery fieldLenEnd(Integer fieldLenEnd){
      this.fieldLenEnd = fieldLenEnd;
      return this;
      }
      /**
      * 设置 增加 数据长度，默认128
      * @param fieldLenIncrement
      */
      public DatumInfoFieldQuery fieldLenIncrement(Integer fieldLenIncrement){
      this.fieldLenIncrement = fieldLenIncrement;
      return this;
      }
      /**
      * 设置 数据长度，默认128
      * @param fieldLenList
      */
      public DatumInfoFieldQuery fieldLenList(List<Integer> fieldLenList){
      this.fieldLenList = fieldLenList;
      return this;
      }
      /**
      * 设置 数据长度，默认128
      * @param fieldLenNotList
      */
      public DatumInfoFieldQuery fieldLenNotList(List<Integer> fieldLenNotList){
      this.fieldLenNotList = fieldLenNotList;
      return this;
      }
      /**
      * 设置 是否允许为空，(0.否,1.是)
      * @param fieldNull
      */
      public DatumInfoFieldQuery fieldNull(Integer fieldNull){
      setFieldNull(fieldNull);
      return this;
      }
      /**
      * 设置 开始 是否允许为空，(0.否,1.是)
      * @param fieldNullStart
      */
      public DatumInfoFieldQuery fieldNullStart(Integer fieldNullStart){
      this.fieldNullStart = fieldNullStart;
      return this;
      }
      /**
      * 设置 结束 是否允许为空，(0.否,1.是)
      * @param fieldNullEnd
      */
      public DatumInfoFieldQuery fieldNullEnd(Integer fieldNullEnd){
      this.fieldNullEnd = fieldNullEnd;
      return this;
      }
      /**
      * 设置 增加 是否允许为空，(0.否,1.是)
      * @param fieldNullIncrement
      */
      public DatumInfoFieldQuery fieldNullIncrement(Integer fieldNullIncrement){
      this.fieldNullIncrement = fieldNullIncrement;
      return this;
      }
      /**
      * 设置 是否允许为空，(0.否,1.是)
      * @param fieldNullList
      */
      public DatumInfoFieldQuery fieldNullList(List<Integer> fieldNullList){
      this.fieldNullList = fieldNullList;
      return this;
      }
      /**
      * 设置 是否允许为空，(0.否,1.是)
      * @param fieldNullNotList
      */
      public DatumInfoFieldQuery fieldNullNotList(List<Integer> fieldNullNotList){
      this.fieldNullNotList = fieldNullNotList;
      return this;
      }
      /**
      * 设置 字段是否列表显示(0.否,1.是)
      * @param isList
      */
      public DatumInfoFieldQuery isList(Integer isList){
      setIsList(isList);
      return this;
      }
      /**
      * 设置 开始 字段是否列表显示(0.否,1.是)
      * @param isListStart
      */
      public DatumInfoFieldQuery isListStart(Integer isListStart){
      this.isListStart = isListStart;
      return this;
      }
      /**
      * 设置 结束 字段是否列表显示(0.否,1.是)
      * @param isListEnd
      */
      public DatumInfoFieldQuery isListEnd(Integer isListEnd){
      this.isListEnd = isListEnd;
      return this;
      }
      /**
      * 设置 增加 字段是否列表显示(0.否,1.是)
      * @param isListIncrement
      */
      public DatumInfoFieldQuery isListIncrement(Integer isListIncrement){
      this.isListIncrement = isListIncrement;
      return this;
      }
      /**
      * 设置 字段是否列表显示(0.否,1.是)
      * @param isListList
      */
      public DatumInfoFieldQuery isListList(List<Integer> isListList){
      this.isListList = isListList;
      return this;
      }
      /**
      * 设置 字段是否列表显示(0.否,1.是)
      * @param isListNotList
      */
      public DatumInfoFieldQuery isListNotList(List<Integer> isListNotList){
      this.isListNotList = isListNotList;
      return this;
      }
      /**
      * 设置 排序号
      * @param fieldOrderNo
      */
      public DatumInfoFieldQuery fieldOrderNo(Integer fieldOrderNo){
      setFieldOrderNo(fieldOrderNo);
      return this;
      }
      /**
      * 设置 开始 排序号
      * @param fieldOrderNoStart
      */
      public DatumInfoFieldQuery fieldOrderNoStart(Integer fieldOrderNoStart){
      this.fieldOrderNoStart = fieldOrderNoStart;
      return this;
      }
      /**
      * 设置 结束 排序号
      * @param fieldOrderNoEnd
      */
      public DatumInfoFieldQuery fieldOrderNoEnd(Integer fieldOrderNoEnd){
      this.fieldOrderNoEnd = fieldOrderNoEnd;
      return this;
      }
      /**
      * 设置 增加 排序号
      * @param fieldOrderNoIncrement
      */
      public DatumInfoFieldQuery fieldOrderNoIncrement(Integer fieldOrderNoIncrement){
      this.fieldOrderNoIncrement = fieldOrderNoIncrement;
      return this;
      }
      /**
      * 设置 排序号
      * @param fieldOrderNoList
      */
      public DatumInfoFieldQuery fieldOrderNoList(List<Integer> fieldOrderNoList){
      this.fieldOrderNoList = fieldOrderNoList;
      return this;
      }
      /**
      * 设置 排序号
      * @param fieldOrderNoNotList
      */
      public DatumInfoFieldQuery fieldOrderNoNotList(List<Integer> fieldOrderNoNotList){
      this.fieldOrderNoNotList = fieldOrderNoNotList;
      return this;
      }
      /**
      * 设置 备注
      * @param remark
      */
      public DatumInfoFieldQuery remark(String remark){
      setRemark(remark);
      return this;
      }
      /**
      * 设置 备注
      * @param remarkList
      */
      public DatumInfoFieldQuery remarkList(List<String> remarkList){
      this.remarkList = remarkList;
      return this;
      }
      /**
      * 设置 创建用户
      * @param createUserId
      */
      public DatumInfoFieldQuery createUserId(Long createUserId){
      setCreateUserId(createUserId);
      return this;
      }
      /**
      * 设置 开始 创建用户
      * @param createUserIdStart
      */
      public DatumInfoFieldQuery createUserIdStart(Long createUserIdStart){
      this.createUserIdStart = createUserIdStart;
      return this;
      }
      /**
      * 设置 结束 创建用户
      * @param createUserIdEnd
      */
      public DatumInfoFieldQuery createUserIdEnd(Long createUserIdEnd){
      this.createUserIdEnd = createUserIdEnd;
      return this;
      }
      /**
      * 设置 增加 创建用户
      * @param createUserIdIncrement
      */
      public DatumInfoFieldQuery createUserIdIncrement(Long createUserIdIncrement){
      this.createUserIdIncrement = createUserIdIncrement;
      return this;
      }
      /**
      * 设置 创建用户
      * @param createUserIdList
      */
      public DatumInfoFieldQuery createUserIdList(List<Long> createUserIdList){
      this.createUserIdList = createUserIdList;
      return this;
      }
      /**
      * 设置 创建用户
      * @param createUserIdNotList
      */
      public DatumInfoFieldQuery createUserIdNotList(List<Long> createUserIdNotList){
      this.createUserIdNotList = createUserIdNotList;
      return this;
      }
      /**
      * 设置 修改用户
      * @param updateUserId
      */
      public DatumInfoFieldQuery updateUserId(Long updateUserId){
      setUpdateUserId(updateUserId);
      return this;
      }
      /**
      * 设置 开始 修改用户
      * @param updateUserIdStart
      */
      public DatumInfoFieldQuery updateUserIdStart(Long updateUserIdStart){
      this.updateUserIdStart = updateUserIdStart;
      return this;
      }
      /**
      * 设置 结束 修改用户
      * @param updateUserIdEnd
      */
      public DatumInfoFieldQuery updateUserIdEnd(Long updateUserIdEnd){
      this.updateUserIdEnd = updateUserIdEnd;
      return this;
      }
      /**
      * 设置 增加 修改用户
      * @param updateUserIdIncrement
      */
      public DatumInfoFieldQuery updateUserIdIncrement(Long updateUserIdIncrement){
      this.updateUserIdIncrement = updateUserIdIncrement;
      return this;
      }
      /**
      * 设置 修改用户
      * @param updateUserIdList
      */
      public DatumInfoFieldQuery updateUserIdList(List<Long> updateUserIdList){
      this.updateUserIdList = updateUserIdList;
      return this;
      }
      /**
      * 设置 修改用户
      * @param updateUserIdNotList
      */
      public DatumInfoFieldQuery updateUserIdNotList(List<Long> updateUserIdNotList){
      this.updateUserIdNotList = updateUserIdNotList;
      return this;
      }
      /**
      * 设置 身份证号
      * @param idCard
      */
      public DatumInfoFieldQuery idCard(String idCard){
      setIdCard(idCard);
      return this;
      }
      /**
      * 设置 身份证号
      * @param idCardList
      */
      public DatumInfoFieldQuery idCardList(List<String> idCardList){
      this.idCardList = idCardList;
      return this;
      }
      /**
      * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
      * @return orConditionList
      */
      public List<DatumInfoFieldQuery> 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<DatumInfoFieldQuery> 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<DatumInfoFieldQuery> 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<DatumInfoFieldQuery> andConditionList){
      this.andConditionList = andConditionList;
      }
      }
      \ No newline at end of file
      fill-manager/src/main/java/com/mortals/xhx/module/datum/model/vo/DatumInfoFieldVo.java 0 → 100644
      View file @ 7255b4fb
      package com.mortals.xhx.module.datum.model.vo;
      import com.mortals.framework.model.BaseEntityLong;
      import com.mortals.xhx.module.datum.model.DatumInfoFieldEntity;
      import java.util.ArrayList;
      import java.util.List;
      import lombok.Data;
      import com.mortals.framework.annotation.Excel;
      import java.math.BigDecimal;
      import java.util.Date;
      /**
      * 填单用户信息字段视图对象
      *
      * @author zxfei
      * @date 2024-04-23
      */
      @Data
      public class DatumInfoFieldVo extends BaseEntityLong {
      /** 序号，主键，自增长列表 */
      private List <Long> idList;
      }
      \ No newline at end of file
      fill-manager/src/main/java/com/mortals/xhx/module/datum/service/DatumInfoFieldService.java 0 → 100644
      View file @ 7255b4fb
      package com.mortals.xhx.module.datum.service;
      import com.mortals.framework.common.Rest;
      import com.mortals.framework.model.Context;
      import com.mortals.framework.service.ICRUDService;
      import com.mortals.xhx.module.datum.model.DatumInfoFieldEntity;
      import com.mortals.xhx.module.datum.dao.DatumInfoFieldDao;
      import com.mortals.xhx.module.datum.model.DatumInfoFieldQuery;
      import com.mortals.xhx.module.matter.model.MatterDatumPrintEntity;
      import com.mortals.xhx.module.matter.model.MatterDatumPrintQuery;
      import java.util.List;
      /**
      * DatumInfoFieldService
      * <p>
      * 填单用户信息字段 service接口
      *
      * @author zxfei
      * @date 2024-04-23
      */
      public interface DatumInfoFieldService extends ICRUDService<DatumInfoFieldEntity, Long> {
      DatumInfoFieldDao getDao();
      /**
      * 解析保存表单字段
      *
      * @param matterDatumPrintEntity
      * @param context
      * @return
      */
      Rest<List<DatumInfoFieldEntity>> parseFormContent(MatterDatumPrintEntity matterDatumPrintEntity, Context context);
      /**
      * 去除重复列表
      *
      * @param datumInfoFieldQuery
      * @param context
      * @return
      */
      Rest<List<DatumInfoFieldEntity>> distinctList(DatumInfoFieldQuery datumInfoFieldQuery, Context context);
      }
      \ No newline at end of file
      fill-manager/src/main/java/com/mortals/xhx/module/datum/service/impl/DatumInfoFieldServiceImpl.java 0 → 100644
      View file @ 7255b4fb
      package com.mortals.xhx.module.datum.service.impl;
      import cn.hutool.core.util.StrUtil;
      import com.alibaba.fastjson.JSON;
      import com.alibaba.fastjson.JSONObject;
      import com.mortals.framework.common.Rest;
      import com.mortals.framework.model.OrderCol;
      import com.mortals.xhx.common.code.ComponentEnum;
      import com.mortals.xhx.common.code.DataTypeEnum;
      import com.mortals.xhx.common.code.FieldTypeEnum;
      import com.mortals.xhx.module.datum.model.DatumInfoFieldQuery;
      import com.mortals.xhx.module.matter.model.MatterDatumPrintEntity;
      import com.mortals.xhx.module.matter.model.MatterDatumPrintQuery;
      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.datum.dao.DatumInfoFieldDao;
      import com.mortals.xhx.module.datum.model.DatumInfoFieldEntity;
      import com.mortals.xhx.module.datum.service.DatumInfoFieldService;
      import lombok.extern.slf4j.Slf4j;
      import org.springframework.util.ObjectUtils;
      import java.util.ArrayList;
      import java.util.Arrays;
      import java.util.List;
      import java.util.Map;
      import java.util.stream.Collectors;
      /**
      * DatumInfoFieldService
      * 填单用户信息字段 service实现
      *
      * @author zxfei
      * @date 2024-04-23
      */
      @Service("datumInfoFieldService")
      @Slf4j
      public class DatumInfoFieldServiceImpl extends AbstractCRUDServiceImpl<DatumInfoFieldDao, DatumInfoFieldEntity, Long> implements DatumInfoFieldService {
      @Override
      public Rest<List<DatumInfoFieldEntity>> parseFormContent(MatterDatumPrintEntity matterDatumPrintEntity, Context context) {
      JSONObject json = JSON.parseObject(matterDatumPrintEntity.getFormContent());
      List<DatumInfoFieldEntity> infoFieldlist = new ArrayList<DatumInfoFieldEntity>();
      for (String key : json.keySet()) {
      DatumInfoFieldEntity infoField = new DatumInfoFieldEntity();
      infoField.setDatumPrintId(matterDatumPrintEntity.getId());
      infoField.setIdCard(matterDatumPrintEntity.getIdCard());
      //通过key类型判断属性类型
      List<String> split = StrUtil.split(key, "_");
      String value = json.getString(key);
      //单行输入框
      boolean input = StrUtil.startWith(key, ComponentEnum.INPUT.getValue());
      if (input && split.size() > 2) {
      infoField.setFieldCode(split.get(2));
      infoField.setFieldName(split.get(2));
      infoField.setFieldType(FieldTypeEnum.单行输入框.getDesc());
      infoField.setFieldValue(value);
      infoField.setDataType(DataTypeEnum.字符串.getDesc());
      }
      //文本输入框
      boolean texxarea = StrUtil.startWith(key, ComponentEnum.TEXTAREA.getValue());
      if (texxarea && split.size() > 2) {
      infoField.setFieldCode(split.get(2));
      infoField.setFieldName(split.get(2));
      infoField.setFieldType(FieldTypeEnum.多项选择框.getDesc());
      infoField.setFieldValue(value);
      infoField.setDataType(DataTypeEnum.字符串.getDesc());
      }
      //单选框
      boolean radio = StrUtil.startWith(key, ComponentEnum.RADIO.getValue());
      if (radio && split.size() > 2) {
      infoField.setFieldCode(split.get(2));
      infoField.setFieldName(split.get(2));
      infoField.setFieldType(FieldTypeEnum.单项选择框.getDesc());
      infoField.setFieldValue(value);
      infoField.setDataType(DataTypeEnum.字符串.getDesc());
      }
      //下拉选项框
      boolean select = StrUtil.startWith(key, ComponentEnum.SELECT.getValue());
      if (select && split.size() > 2) {
      infoField.setFieldCode(split.get(2));
      infoField.setFieldName(split.get(2));
      infoField.setFieldType(FieldTypeEnum.单项选择框.getDesc());
      infoField.setFieldValue(value);
      infoField.setDataType(DataTypeEnum.字符串.getDesc());
      }
      //复选框
      boolean checkBok = StrUtil.startWith(key, ComponentEnum.CHECKBOX.getValue());
      if (checkBok && split.size() > 2) {
      infoField.setFieldCode(split.get(2));
      infoField.setFieldName(split.get(2));
      infoField.setFieldType(FieldTypeEnum.多项选择框.getDesc());
      infoField.setFieldValue(value);
      infoField.setDataType(DataTypeEnum.数组.getDesc());
      }
      //时间
      boolean date = StrUtil.startWith(key, ComponentEnum.DATE.getValue());
      if (date && split.size() > 2) {
      infoField.setFieldCode(split.get(2));
      infoField.setFieldName(split.get(2));
      infoField.setFieldType(FieldTypeEnum.日期选择框.getDesc());
      infoField.setFieldValue(value);
      infoField.setDataType(DataTypeEnum.字符串.getDesc());
      }
      //横向列表
      boolean list = StrUtil.startWith(key, ComponentEnum.LIST.getValue());
      if (list && split.size() > 2) {
      infoField.setFieldCode(split.get(2));
      infoField.setFieldName(split.get(2));
      infoField.setFieldType(FieldTypeEnum.横向列表.getDesc());
      infoField.setFieldValue(value);
      infoField.setDataType(DataTypeEnum.数组.getDesc());
      }
      //表格
      boolean table = StrUtil.startWith(key, ComponentEnum.DYNAMIC_TABLE.getValue());
      if (table && split.size() > 2) {
      infoField.setFieldCode(split.get(2));
      infoField.setFieldName(split.get(2));
      infoField.setFieldType(FieldTypeEnum.表格.getDesc());
      infoField.setFieldValue(value);
      infoField.setDataType(DataTypeEnum.数组.getDesc());
      }
      infoFieldlist.add(infoField);
      }
      return Rest.ok("解析保存成功！", infoFieldlist);
      }
      @Override
      public Rest<List<DatumInfoFieldEntity>> distinctList(DatumInfoFieldQuery datumInfoFieldQuery, Context context) {
      datumInfoFieldQuery.setOrderColList(Arrays.asList(new OrderCol("createTime", OrderCol.DESCENDING)));
      Map<String, List<DatumInfoFieldEntity>> collect = this.find(datumInfoFieldQuery, context).stream().collect(Collectors.groupingBy(x -> x.getFieldName()));
      List<DatumInfoFieldEntity> distiinctList = collect.entrySet().stream().map(item -> {
      List<DatumInfoFieldEntity> value = item.getValue();
      if (!ObjectUtils.isEmpty(value)) {
      return value.get(0);
      } else {
      return null;
      }
      }).filter(f -> f != null).collect(Collectors.toList());
      return Rest.ok("获取列表成功！",distiinctList);
      }
      public static void main(String[] args) {
      String json = "{\n" +
      " \"ck_1_类别_<新参保登记-暂停登记-注销登记-拆分-合并-分立>\": [\n" +
      " \"新参保登记\"\n" +
      " ],\n" +
      " \"i_2_单位名称\": \"蜻蜓和\",\n" +
      " \"i_3_现统一社会信用代码\": \"34534543\",\n" +
      " \"i_4_姓名\": \"hjs\",\n" +
      " \"i_5_联系电话\": \"18282787877\",\n" +
      " \"i_6_身份证号码\": \"51192319991118605X\",\n" +
      " \"i_7_开户行\": \"1234213123\",\n" +
      " \"i_8_户名\": \"hjg\",\n" +
      " \"i_9_银行账号\": \"6745645645\",\n" +
      " \"i_10_姓名\": \"hjs\",\n" +
      " \"i_11_手机号码\": \"16434534534543\",\n" +
      " \"i_12_联系电话\": \"23423423432\",\n" +
      " \"ck_13_参保险种_<职工基本医疗保险-生育保险-补充医疗保险->其他（___________）\": [\n" +
      " \"职工基本医疗保险\"\n" +
      " ],\n" +
      " \"date_14_参保起始时间\": \"2023 年 02 月 22 日\",\n" +
      " \"date_15_日期\": \"2023 年 02 月 14 日\"\n" +
      "}";
      JSONObject jsonObject = JSON.parseObject(json);
      String string = jsonObject.getString("ck_13_参保险种_<职工基本医疗保险-生育保险-补充医疗保险->其他（___________）");
      System.out.println(string);
      }
      }
      \ No newline at end of file
      fill-manager/src/main/java/com/mortals/xhx/module/datum/web/DatumInfoFieldController.java 0 → 100644
      View file @ 7255b4fb
      package com.mortals.xhx.module.datum.web;
      import com.mortals.framework.annotation.UnAuth;
      import com.mortals.framework.common.Rest;
      import com.mortals.framework.web.BaseCRUDJsonBodyMappingController;
      import com.mortals.xhx.base.system.param.service.ParamService;
      import com.mortals.xhx.module.datum.model.DatumInfoFieldQuery;
      import com.mortals.xhx.module.device.model.DeviceEntity;
      import com.mortals.xhx.module.matter.model.MatterDatumPrintEntity;
      import com.mortals.xhx.module.matter.model.MatterDatumPrintQuery;
      import com.mortals.xhx.module.matter.service.MatterDatumPrintService;
      import org.checkerframework.checker.units.qual.A;
      import org.springframework.beans.factory.annotation.Autowired;
      import org.springframework.util.ObjectUtils;
      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.datum.model.DatumInfoFieldEntity;
      import com.mortals.xhx.module.datum.service.DatumInfoFieldService;
      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.*;
      import com.mortals.xhx.common.code.*;
      /**
      * 填单用户信息字段
      *
      * @author zxfei
      * @date 2024-04-23
      */
      @RestController
      @RequestMapping("datum/info/field")
      public class DatumInfoFieldController extends BaseCRUDJsonBodyMappingController<DatumInfoFieldService, DatumInfoFieldEntity, Long> {
      @Autowired
      private ParamService paramService;
      @Autowired
      private MatterDatumPrintService datumPrintService;
      public DatumInfoFieldController() {
      super.setModuleDesc("填单用户信息字段");
      }
      @Override
      protected void init(Map<String, Object> model, Context context) {
      this.addDict(model, "fieldType", FieldTypeEnum.getEnumMap());
      this.addDict(model, "dataType", DataTypeEnum.getEnumMap());
      this.addDict(model, "fieldNull", FieldNullEnum.getEnumMap());
      this.addDict(model, "isList", IsListEnum.getEnumMap());
      super.init(model, context);
      }
      /**
      * 解析保存用户所有表单
      *
      * @param query
      * @return
      */
      @PostMapping(value = "parseForm")
      @UnAuth
      public Rest<Object> parseForm(@RequestBody DatumInfoFieldEntity query) {
      Map<String, Object> model = new HashMap<>();
      Context context = this.getContext();
      String busiDesc = "解析保存" + this.getModuleDesc();
      try {
      List<MatterDatumPrintEntity> datumPrintEntities = datumPrintService.find(new MatterDatumPrintQuery());
      for (MatterDatumPrintEntity datumPrintEntity : datumPrintEntities) {
      if (!ObjectUtils.isEmpty(datumPrintEntity.getFormContent())) {
      Rest<List<DatumInfoFieldEntity>> rest = this.service.parseFormContent(datumPrintEntity, context);
      if (rest.getCode() == YesNoEnum.YES.getValue() && !ObjectUtils.isEmpty(rest.getData())) {
      this.service.save(rest.getData());
      }
      }
      }
      recordSysLog(request, busiDesc + " 【成功】");
      } catch (Exception e) {
      this.doException(request, busiDesc, model, e);
      return Rest.fail(e.getMessage());
      }
      return Rest.ok(model);
      }
      /**
      * 去重列表
      *
      * @param query
      * @return
      */
      @PostMapping(value = "distinctList")
      @UnAuth
      public Rest<Object> distinctList(@RequestBody DatumInfoFieldQuery query) {
      Map<String, Object> model = new HashMap<>();
      Context context = this.getContext();
      String busiDesc = "查询" + this.getModuleDesc();
      try {
      Rest<List<DatumInfoFieldEntity>> rest = this.service.distinctList(query, context);
      model.put(KEY_RESULT_DATA, rest.getData());
      recordSysLog(request, busiDesc + " 【成功】");
      } catch (Exception e) {
      this.doException(request, busiDesc, model, e);
      return Rest.fail(e.getMessage());
      }
      this.init(model, context);
      return Rest.ok(model);
      }
      }
      \ No newline at end of file
      fill-manager/src/main/java/com/mortals/xhx/module/matter/service/impl/MatterDatumPrintServiceImpl.java
      View file @ 7255b4fb
      package com.mortals.xhx.module.matter.service.impl;
      import cn.hutool.core.util.IdUtil;
      import cn.hutool.core.util.StrUtil;
      import com.alibaba.fastjson.JSON;
      import com.alibaba.fastjson.JSONObject;
      import com.mortals.framework.common.Rest;
      import com.mortals.framework.model.PageInfo;
      import com.mortals.xhx.base.system.upload.service.UploadService;
      import com.mortals.xhx.common.code.DataTypeEnum;
      import com.mortals.xhx.common.code.FieldTypeEnum;
      import com.mortals.xhx.common.code.YesNoEnum;
      import com.mortals.xhx.common.utils.WordUtil;
      import com.mortals.xhx.module.datum.model.DatumInfoFieldEntity;
      import com.mortals.xhx.module.datum.service.DatumInfoFieldService;
      import com.mortals.xhx.module.device.model.DeviceEntity;
      import com.mortals.xhx.module.device.model.DeviceQuery;
      import com.mortals.xhx.module.device.service.DeviceService;
      ......@@ -22,6 +31,7 @@ import com.mortals.xhx.module.matter.model.MatterDatumPrintEntity;
      import com.mortals.xhx.module.matter.service.MatterDatumPrintService;
      import org.springframework.util.ObjectUtils;
      import java.util.ArrayList;
      import java.util.List;
      /**
      ......@@ -40,7 +50,8 @@ public class MatterDatumPrintServiceImpl extends AbstractCRUDServiceImpl<MatterD
      private MatterService matterService;
      @Autowired
      private DeviceService deviceService;
      @Autowired
      private DatumInfoFieldService datumInfoFieldService;
      @Value("${upload.path}")
      private String filePath;
      ......@@ -62,8 +73,8 @@ public class MatterDatumPrintServiceImpl extends AbstractCRUDServiceImpl<MatterD
      }
      entity.setOrderId(IdUtil.simpleUUID());
      String rootPath = this.filePath.endsWith("/") ? this.filePath : this.filePath + "/";
      Integer pageByDoc = WordUtil.getPageByDoc(rootPath + entity.getDocPath());
      entity.setPrintPage(pageByDoc);
      // Integer pageByDoc = WordUtil.getPageByDoc(rootPath + entity.getDocPath());
      entity.setPrintPage(1);
      if (!ObjectUtils.isEmpty(entity.getDeviceCode())) {
      DeviceEntity deviceEntity = deviceService.selectOne(new DeviceQuery().deviceCode(entity.getDeviceCode()));
      ......@@ -88,4 +99,27 @@ public class MatterDatumPrintServiceImpl extends AbstractCRUDServiceImpl<MatterD
      });
      }
      @Override
      protected void saveAfter(MatterDatumPrintEntity entity, Context context) throws AppException {
      super.saveAfter(entity, context);
      //拆解数据
      if (!ObjectUtils.isEmpty(entity.getFormContent())) {
      Rest<List<DatumInfoFieldEntity>> rest = datumInfoFieldService.parseFormContent(entity, context);
      if (rest.getCode() == YesNoEnum.YES.getValue() && !ObjectUtils.isEmpty(rest.getData())) {
      datumInfoFieldService.save(rest.getData());
      }
      }
      }
      public static void main(String[] args) {
      String key="ck_1_类别_<新参保登记-暂停登记-注销登记-拆分-合并-分立>";
      List<String> split = StrUtil.split(key, "_");
      System.out.println(split.size());
      System.out.println(split.get(0));
      }
      }
      \ No newline at end of file
      fill-manager/src/main/resources/sqlmap/module/datum/DatumInfoFieldMapper.xml 0 → 100644
      View file @ 7255b4fb
      <?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.datum.dao.ibatis.DatumInfoFieldDaoImpl">
      <!-- 字段和属性映射 -->
      <resultMap type="DatumInfoFieldEntity" id="DatumInfoFieldEntity-Map">
      <id property="id" column="id" />
      <result property="datumPrintId" column="datum_print_id" />
      <result property="fieldCode" column="fieldCode" />
      <result property="fieldName" column="fieldName" />
      <result property="fieldType" column="fieldType" />
      <result property="fieldTypeValue" column="fieldTypeValue" />
      <result property="dataType" column="dataType" />
      <result property="fieldValue" column="fieldValue" />
      <result property="defaultValue" column="defaultValue" />
      <result property="fieldLen" column="fieldLen" />
      <result property="fieldNull" column="fieldNull" />
      <result property="isList" column="isList" />
      <result property="fieldOrderNo" column="fieldOrderNo" />
      <result property="remark" column="remark" />
      <result property="createTime" column="createTime" />
      <result property="createUserId" column="createUserId" />
      <result property="updateTime" column="updateTime" />
      <result property="updateUserId" column="updateUserId" />
      <result property="idCard" column="idCard" />
      </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('datumPrintId') or colPickMode == 1 and data.containsKey('datumPrintId')))">
      a.datum_print_id,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fieldCode') or colPickMode == 1 and data.containsKey('fieldCode')))">
      a.fieldCode,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fieldName') or colPickMode == 1 and data.containsKey('fieldName')))">
      a.fieldName,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fieldType') or colPickMode == 1 and data.containsKey('fieldType')))">
      a.fieldType,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fieldTypeValue') or colPickMode == 1 and data.containsKey('fieldTypeValue')))">
      a.fieldTypeValue,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('dataType') or colPickMode == 1 and data.containsKey('dataType')))">
      a.dataType,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fieldValue') or colPickMode == 1 and data.containsKey('fieldValue')))">
      a.fieldValue,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('defaultValue') or colPickMode == 1 and data.containsKey('defaultValue')))">
      a.defaultValue,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fieldLen') or colPickMode == 1 and data.containsKey('fieldLen')))">
      a.fieldLen,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fieldNull') or colPickMode == 1 and data.containsKey('fieldNull')))">
      a.fieldNull,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('isList') or colPickMode == 1 and data.containsKey('isList')))">
      a.isList,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('fieldOrderNo') or colPickMode == 1 and data.containsKey('fieldOrderNo')))">
      a.fieldOrderNo,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('remark') or colPickMode == 1 and data.containsKey('remark')))">
      a.remark,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
      a.createTime,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
      a.createUserId,
      </if>
      <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
      a.updateTime,
      </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('idCard') or colPickMode == 1 and data.containsKey('idCard')))">
      a.idCard,
      </if>
      </trim>
      </sql>
      <!-- 新增 区分主键自增加还是业务插入 -->
      <insert id="insert" parameterType="DatumInfoFieldEntity" useGeneratedKeys="true" keyProperty="id">
      insert into mortals_xhx_datum_info_field
      (datum_print_id,fieldCode,fieldName,fieldType,fieldTypeValue,dataType,fieldValue,defaultValue,fieldLen,fieldNull,isList,fieldOrderNo,remark,createTime,createUserId,updateTime,updateUserId,idCard)
      VALUES
      (#{datumPrintId},#{fieldCode},#{fieldName},#{fieldType},#{fieldTypeValue},#{dataType},#{fieldValue},#{defaultValue},#{fieldLen},#{fieldNull},#{isList},#{fieldOrderNo},#{remark},#{createTime},#{createUserId},#{updateTime},#{updateUserId},#{idCard})
      </insert>
      <!-- 批量新增 -->
      <insert id="insertBatch" parameterType="paramDto">
      insert into mortals_xhx_datum_info_field
      (datum_print_id,fieldCode,fieldName,fieldType,fieldTypeValue,dataType,fieldValue,defaultValue,fieldLen,fieldNull,isList,fieldOrderNo,remark,createTime,createUserId,updateTime,updateUserId,idCard)
      VALUES
      <foreach collection="data.dataList" item="item" index="index" separator="," >
      (#{item.datumPrintId},#{item.fieldCode},#{item.fieldName},#{item.fieldType},#{item.fieldTypeValue},#{item.dataType},#{item.fieldValue},#{item.defaultValue},#{item.fieldLen},#{item.fieldNull},#{item.isList},#{item.fieldOrderNo},#{item.remark},#{item.createTime},#{item.createUserId},#{item.updateTime},#{item.updateUserId},#{item.idCard})
      </foreach>
      </insert>
      <!-- 根据ParamDto更新 -->
      <update id="update" parameterType="paramDto">
      update mortals_xhx_datum_info_field as a
      set
      <trim suffixOverrides="," suffix="">
      <if test="(colPickMode==0 and data.containsKey('datumPrintId')) or (colPickMode==1 and !data.containsKey('datumPrintId'))">
      a.datum_print_id=#{data.datumPrintId},
      </if>
      <if test="(colPickMode==0 and data.containsKey('datumPrintIdIncrement')) or (colPickMode==1 and !data.containsKey('datumPrintIdIncrement'))">
      a.datum_print_id=ifnull(a.datum_print_id,0) + #{data.datumPrintIdIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldCode')) or (colPickMode==1 and !data.containsKey('fieldCode'))">
      a.fieldCode=#{data.fieldCode},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldName')) or (colPickMode==1 and !data.containsKey('fieldName'))">
      a.fieldName=#{data.fieldName},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldType')) or (colPickMode==1 and !data.containsKey('fieldType'))">
      a.fieldType=#{data.fieldType},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldTypeValue')) or (colPickMode==1 and !data.containsKey('fieldTypeValue'))">
      a.fieldTypeValue=#{data.fieldTypeValue},
      </if>
      <if test="(colPickMode==0 and data.containsKey('dataType')) or (colPickMode==1 and !data.containsKey('dataType'))">
      a.dataType=#{data.dataType},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldValue')) or (colPickMode==1 and !data.containsKey('fieldValue'))">
      a.fieldValue=#{data.fieldValue},
      </if>
      <if test="(colPickMode==0 and data.containsKey('defaultValue')) or (colPickMode==1 and !data.containsKey('defaultValue'))">
      a.defaultValue=#{data.defaultValue},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldLen')) or (colPickMode==1 and !data.containsKey('fieldLen'))">
      a.fieldLen=#{data.fieldLen},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldLenIncrement')) or (colPickMode==1 and !data.containsKey('fieldLenIncrement'))">
      a.fieldLen=ifnull(a.fieldLen,0) + #{data.fieldLenIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldNull')) or (colPickMode==1 and !data.containsKey('fieldNull'))">
      a.fieldNull=#{data.fieldNull},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldNullIncrement')) or (colPickMode==1 and !data.containsKey('fieldNullIncrement'))">
      a.fieldNull=ifnull(a.fieldNull,0) + #{data.fieldNullIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('isList')) or (colPickMode==1 and !data.containsKey('isList'))">
      a.isList=#{data.isList},
      </if>
      <if test="(colPickMode==0 and data.containsKey('isListIncrement')) or (colPickMode==1 and !data.containsKey('isListIncrement'))">
      a.isList=ifnull(a.isList,0) + #{data.isListIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldOrderNo')) or (colPickMode==1 and !data.containsKey('fieldOrderNo'))">
      a.fieldOrderNo=#{data.fieldOrderNo},
      </if>
      <if test="(colPickMode==0 and data.containsKey('fieldOrderNoIncrement')) or (colPickMode==1 and !data.containsKey('fieldOrderNoIncrement'))">
      a.fieldOrderNo=ifnull(a.fieldOrderNo,0) + #{data.fieldOrderNoIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('remark')) or (colPickMode==1 and !data.containsKey('remark'))">
      a.remark=#{data.remark},
      </if>
      <if test="(colPickMode==0 and data.containsKey('createTime')) or (colPickMode==1 and !data.containsKey('createTime'))">
      a.createTime=#{data.createTime},
      </if>
      <if test="(colPickMode==0 and data.containsKey('createUserId')) or (colPickMode==1 and !data.containsKey('createUserId'))">
      a.createUserId=#{data.createUserId},
      </if>
      <if test="(colPickMode==0 and data.containsKey('createUserIdIncrement')) or (colPickMode==1 and !data.containsKey('createUserIdIncrement'))">
      a.createUserId=ifnull(a.createUserId,0) + #{data.createUserIdIncrement},
      </if>
      <if test="(colPickMode==0 and data.containsKey('updateTime')) or (colPickMode==1 and !data.containsKey('updateTime'))">
      a.updateTime=#{data.updateTime},
      </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('idCard')) or (colPickMode==1 and !data.containsKey('idCard'))">
      a.idCard=#{data.idCard},
      </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_datum_info_field as a
      <trim prefix="set" suffixOverrides=",">
      <trim prefix="datum_print_id=(case" suffix="ELSE datum_print_id end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('datumPrintId')) or (colPickMode==1 and !item.containsKey('datumPrintId'))">
      when a.id=#{item.id} then #{item.datumPrintId}
      </when>
      <when test="(colPickMode==0 and item.containsKey('datumPrintIdIncrement')) or (colPickMode==1 and !item.containsKey('datumPrintIdIncrement'))">
      when a.id=#{item.id} then ifnull(a.datum_print_id,0) + #{item.datumPrintIdIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="fieldCode=(case" suffix="ELSE fieldCode end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('fieldCode')) or (colPickMode==1 and !item.containsKey('fieldCode'))">
      when a.id=#{item.id} then #{item.fieldCode}
      </if>
      </foreach>
      </trim>
      <trim prefix="fieldName=(case" suffix="ELSE fieldName end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('fieldName')) or (colPickMode==1 and !item.containsKey('fieldName'))">
      when a.id=#{item.id} then #{item.fieldName}
      </if>
      </foreach>
      </trim>
      <trim prefix="fieldType=(case" suffix="ELSE fieldType end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('fieldType')) or (colPickMode==1 and !item.containsKey('fieldType'))">
      when a.id=#{item.id} then #{item.fieldType}
      </if>
      </foreach>
      </trim>
      <trim prefix="fieldTypeValue=(case" suffix="ELSE fieldTypeValue end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('fieldTypeValue')) or (colPickMode==1 and !item.containsKey('fieldTypeValue'))">
      when a.id=#{item.id} then #{item.fieldTypeValue}
      </if>
      </foreach>
      </trim>
      <trim prefix="dataType=(case" suffix="ELSE dataType end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('dataType')) or (colPickMode==1 and !item.containsKey('dataType'))">
      when a.id=#{item.id} then #{item.dataType}
      </if>
      </foreach>
      </trim>
      <trim prefix="fieldValue=(case" suffix="ELSE fieldValue end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('fieldValue')) or (colPickMode==1 and !item.containsKey('fieldValue'))">
      when a.id=#{item.id} then #{item.fieldValue}
      </if>
      </foreach>
      </trim>
      <trim prefix="defaultValue=(case" suffix="ELSE defaultValue end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('defaultValue')) or (colPickMode==1 and !item.containsKey('defaultValue'))">
      when a.id=#{item.id} then #{item.defaultValue}
      </if>
      </foreach>
      </trim>
      <trim prefix="fieldLen=(case" suffix="ELSE fieldLen end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('fieldLen')) or (colPickMode==1 and !item.containsKey('fieldLen'))">
      when a.id=#{item.id} then #{item.fieldLen}
      </when>
      <when test="(colPickMode==0 and item.containsKey('fieldLenIncrement')) or (colPickMode==1 and !item.containsKey('fieldLenIncrement'))">
      when a.id=#{item.id} then ifnull(a.fieldLen,0) + #{item.fieldLenIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="fieldNull=(case" suffix="ELSE fieldNull end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('fieldNull')) or (colPickMode==1 and !item.containsKey('fieldNull'))">
      when a.id=#{item.id} then #{item.fieldNull}
      </when>
      <when test="(colPickMode==0 and item.containsKey('fieldNullIncrement')) or (colPickMode==1 and !item.containsKey('fieldNullIncrement'))">
      when a.id=#{item.id} then ifnull(a.fieldNull,0) + #{item.fieldNullIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="isList=(case" suffix="ELSE isList end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('isList')) or (colPickMode==1 and !item.containsKey('isList'))">
      when a.id=#{item.id} then #{item.isList}
      </when>
      <when test="(colPickMode==0 and item.containsKey('isListIncrement')) or (colPickMode==1 and !item.containsKey('isListIncrement'))">
      when a.id=#{item.id} then ifnull(a.isList,0) + #{item.isListIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="fieldOrderNo=(case" suffix="ELSE fieldOrderNo end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('fieldOrderNo')) or (colPickMode==1 and !item.containsKey('fieldOrderNo'))">
      when a.id=#{item.id} then #{item.fieldOrderNo}
      </when>
      <when test="(colPickMode==0 and item.containsKey('fieldOrderNoIncrement')) or (colPickMode==1 and !item.containsKey('fieldOrderNoIncrement'))">
      when a.id=#{item.id} then ifnull(a.fieldOrderNo,0) + #{item.fieldOrderNoIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="remark=(case" suffix="ELSE remark end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('remark')) or (colPickMode==1 and !item.containsKey('remark'))">
      when a.id=#{item.id} then #{item.remark}
      </if>
      </foreach>
      </trim>
      <trim prefix="createTime=(case" suffix="ELSE createTime end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
      when a.id=#{item.id} then #{item.createTime}
      </if>
      </foreach>
      </trim>
      <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <choose>
      <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
      when a.id=#{item.id} then #{item.createUserId}
      </when>
      <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
      when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
      </when>
      </choose>
      </foreach>
      </trim>
      <trim prefix="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="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="idCard=(case" suffix="ELSE idCard end),">
      <foreach collection="data.dataList" item="item" index="index" separator="" >
      <if test="(colPickMode==0 and item.containsKey('idCard')) or (colPickMode==1 and !item.containsKey('idCard'))">
      when a.id=#{item.id} then #{item.idCard}
      </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="DatumInfoFieldEntity-Map">
      select <include refid="_columns"/>
      from mortals_xhx_datum_info_field as a
      where a.id=#{condition.id}
      </select>
      <!-- 根据主健删除 -->
      <delete id="deleteByKey" parameterType="paramDto">
      delete a.* from mortals_xhx_datum_info_field as a where a.id=#{condition.id}
      </delete>
      <!-- 根据主健删除一批，针对单一主健有效 -->
      <delete id="deleteByKeys">
      delete from mortals_xhx_datum_info_field where id in
      <foreach collection="array" item="item" index="index" open="(" separator="," close=")">
      #{item}
      </foreach>
      </delete>
      <!-- 根据主健列表删除一批，针对单一主健有效 -->
      <delete id="deleteByKeyList">
      delete from mortals_xhx_datum_info_field where id in
      <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
      #{item}
      </foreach>
      </delete>
      <!-- 根据对象列表删除一批，针对单一主健有效 -->
      <delete id="deleteByEntityList">
      delete from mortals_xhx_datum_info_field where id in
      <foreach collection="list" item="item" index="index" open="(" separator="," close=")">
      #{item.id}
      </foreach>
      </delete>
      <!-- 根据paramDto删除一批 -->
      <delete id="deleteByMap" parameterType="paramDto">
      delete a.* from mortals_xhx_datum_info_field as a
      <trim suffixOverrides="where" suffix="">
      where
      <trim prefixOverrides="and" prefix="">
      <include refid="_condition_"/>
      </trim>
      </trim>
      </delete>
      <!-- 获取列表 -->
      <select id="getList" parameterType="paramDto" resultMap="DatumInfoFieldEntity-Map">
      select <include refid="_columns"/>
      from mortals_xhx_datum_info_field 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_datum_info_field 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') and conditionParamRef.idList.size() > 0">
      ${_conditionType_} a.id in
      <foreach collection="conditionParamRef.idList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('idNotList') and conditionParamRef.idNotList.size() > 0">
      ${_conditionType_} a.id not in
      <foreach collection="conditionParamRef.idNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
      ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
      </if>
      <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
      ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
      </if>
      <if test="conditionParamRef.containsKey('datumPrintId')">
      <if test="conditionParamRef.datumPrintId != null ">
      ${_conditionType_} a.datum_print_id = #{${_conditionParam_}.datumPrintId}
      </if>
      <if test="conditionParamRef.datumPrintId == null">
      ${_conditionType_} a.datum_print_id is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('datumPrintIdList') and conditionParamRef.datumPrintIdList.size() > 0">
      ${_conditionType_} a.datum_print_id in
      <foreach collection="conditionParamRef.datumPrintIdList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('datumPrintIdNotList') and conditionParamRef.datumPrintIdNotList.size() > 0">
      ${_conditionType_} a.datum_print_id not in
      <foreach collection="conditionParamRef.datumPrintIdNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('datumPrintIdStart') and conditionParamRef.datumPrintIdStart != null">
      ${_conditionType_} a.datum_print_id <![CDATA[ >= ]]> #{${_conditionParam_}.datumPrintIdStart}
      </if>
      <if test="conditionParamRef.containsKey('datumPrintIdEnd') and conditionParamRef.datumPrintIdEnd != null">
      ${_conditionType_} a.datum_print_id <![CDATA[ <= ]]> #{${_conditionParam_}.datumPrintIdEnd}
      </if>
      <if test="conditionParamRef.containsKey('fieldCode')">
      <if test="conditionParamRef.fieldCode != null and conditionParamRef.fieldCode != ''">
      ${_conditionType_} a.fieldCode like #{${_conditionParam_}.fieldCode}
      </if>
      <if test="conditionParamRef.fieldCode == null">
      ${_conditionType_} a.fieldCode is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('fieldCodeList') and conditionParamRef.fieldCodeList.size() > 0">
      ${_conditionType_} a.fieldCode in
      <foreach collection="conditionParamRef.fieldCodeList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldCodeNotList') and conditionParamRef.fieldCodeNotList.size() > 0">
      ${_conditionType_} a.fieldCode not in
      <foreach collection="conditionParamRef.fieldCodeNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldName')">
      <if test="conditionParamRef.fieldName != null and conditionParamRef.fieldName != ''">
      ${_conditionType_} a.fieldName like #{${_conditionParam_}.fieldName}
      </if>
      <if test="conditionParamRef.fieldName == null">
      ${_conditionType_} a.fieldName is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('fieldNameList') and conditionParamRef.fieldNameList.size() > 0">
      ${_conditionType_} a.fieldName in
      <foreach collection="conditionParamRef.fieldNameList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldNameNotList') and conditionParamRef.fieldNameNotList.size() > 0">
      ${_conditionType_} a.fieldName not in
      <foreach collection="conditionParamRef.fieldNameNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldType')">
      <if test="conditionParamRef.fieldType != null and conditionParamRef.fieldType != ''">
      ${_conditionType_} a.fieldType like #{${_conditionParam_}.fieldType}
      </if>
      <if test="conditionParamRef.fieldType == null">
      ${_conditionType_} a.fieldType is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('fieldTypeList') and conditionParamRef.fieldTypeList.size() > 0">
      ${_conditionType_} a.fieldType in
      <foreach collection="conditionParamRef.fieldTypeList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldTypeNotList') and conditionParamRef.fieldTypeNotList.size() > 0">
      ${_conditionType_} a.fieldType not in
      <foreach collection="conditionParamRef.fieldTypeNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldTypeValue')">
      <if test="conditionParamRef.fieldTypeValue != null and conditionParamRef.fieldTypeValue != ''">
      ${_conditionType_} a.fieldTypeValue like #{${_conditionParam_}.fieldTypeValue}
      </if>
      <if test="conditionParamRef.fieldTypeValue == null">
      ${_conditionType_} a.fieldTypeValue is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('fieldTypeValueList') and conditionParamRef.fieldTypeValueList.size() > 0">
      ${_conditionType_} a.fieldTypeValue in
      <foreach collection="conditionParamRef.fieldTypeValueList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldTypeValueNotList') and conditionParamRef.fieldTypeValueNotList.size() > 0">
      ${_conditionType_} a.fieldTypeValue not in
      <foreach collection="conditionParamRef.fieldTypeValueNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('dataType')">
      <if test="conditionParamRef.dataType != null and conditionParamRef.dataType != ''">
      ${_conditionType_} a.dataType like #{${_conditionParam_}.dataType}
      </if>
      <if test="conditionParamRef.dataType == null">
      ${_conditionType_} a.dataType is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('dataTypeList') and conditionParamRef.dataTypeList.size() > 0">
      ${_conditionType_} a.dataType in
      <foreach collection="conditionParamRef.dataTypeList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('dataTypeNotList') and conditionParamRef.dataTypeNotList.size() > 0">
      ${_conditionType_} a.dataType not in
      <foreach collection="conditionParamRef.dataTypeNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldValue')">
      <if test="conditionParamRef.fieldValue != null and conditionParamRef.fieldValue != ''">
      ${_conditionType_} a.fieldValue like #{${_conditionParam_}.fieldValue}
      </if>
      <if test="conditionParamRef.fieldValue == null">
      ${_conditionType_} a.fieldValue is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('fieldValueList') and conditionParamRef.fieldValueList.size() > 0">
      ${_conditionType_} a.fieldValue in
      <foreach collection="conditionParamRef.fieldValueList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldValueNotList') and conditionParamRef.fieldValueNotList.size() > 0">
      ${_conditionType_} a.fieldValue not in
      <foreach collection="conditionParamRef.fieldValueNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('defaultValue')">
      <if test="conditionParamRef.defaultValue != null and conditionParamRef.defaultValue != ''">
      ${_conditionType_} a.defaultValue like #{${_conditionParam_}.defaultValue}
      </if>
      <if test="conditionParamRef.defaultValue == null">
      ${_conditionType_} a.defaultValue is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('defaultValueList') and conditionParamRef.defaultValueList.size() > 0">
      ${_conditionType_} a.defaultValue in
      <foreach collection="conditionParamRef.defaultValueList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('defaultValueNotList') and conditionParamRef.defaultValueNotList.size() > 0">
      ${_conditionType_} a.defaultValue not in
      <foreach collection="conditionParamRef.defaultValueNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldLen')">
      <if test="conditionParamRef.fieldLen != null ">
      ${_conditionType_} a.fieldLen = #{${_conditionParam_}.fieldLen}
      </if>
      <if test="conditionParamRef.fieldLen == null">
      ${_conditionType_} a.fieldLen is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('fieldLenList') and conditionParamRef.fieldLenList.size() > 0">
      ${_conditionType_} a.fieldLen in
      <foreach collection="conditionParamRef.fieldLenList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldLenNotList') and conditionParamRef.fieldLenNotList.size() > 0">
      ${_conditionType_} a.fieldLen not in
      <foreach collection="conditionParamRef.fieldLenNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldLenStart') and conditionParamRef.fieldLenStart != null">
      ${_conditionType_} a.fieldLen <![CDATA[ >= ]]> #{${_conditionParam_}.fieldLenStart}
      </if>
      <if test="conditionParamRef.containsKey('fieldLenEnd') and conditionParamRef.fieldLenEnd != null">
      ${_conditionType_} a.fieldLen <![CDATA[ <= ]]> #{${_conditionParam_}.fieldLenEnd}
      </if>
      <if test="conditionParamRef.containsKey('fieldNull')">
      <if test="conditionParamRef.fieldNull != null ">
      ${_conditionType_} a.fieldNull = #{${_conditionParam_}.fieldNull}
      </if>
      <if test="conditionParamRef.fieldNull == null">
      ${_conditionType_} a.fieldNull is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('fieldNullList') and conditionParamRef.fieldNullList.size() > 0">
      ${_conditionType_} a.fieldNull in
      <foreach collection="conditionParamRef.fieldNullList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldNullNotList') and conditionParamRef.fieldNullNotList.size() > 0">
      ${_conditionType_} a.fieldNull not in
      <foreach collection="conditionParamRef.fieldNullNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldNullStart') and conditionParamRef.fieldNullStart != null">
      ${_conditionType_} a.fieldNull <![CDATA[ >= ]]> #{${_conditionParam_}.fieldNullStart}
      </if>
      <if test="conditionParamRef.containsKey('fieldNullEnd') and conditionParamRef.fieldNullEnd != null">
      ${_conditionType_} a.fieldNull <![CDATA[ <= ]]> #{${_conditionParam_}.fieldNullEnd}
      </if>
      <if test="conditionParamRef.containsKey('isList')">
      <if test="conditionParamRef.isList != null ">
      ${_conditionType_} a.isList = #{${_conditionParam_}.isList}
      </if>
      <if test="conditionParamRef.isList == null">
      ${_conditionType_} a.isList is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('isListList') and conditionParamRef.isListList.size() > 0">
      ${_conditionType_} a.isList in
      <foreach collection="conditionParamRef.isListList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('isListNotList') and conditionParamRef.isListNotList.size() > 0">
      ${_conditionType_} a.isList not in
      <foreach collection="conditionParamRef.isListNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('isListStart') and conditionParamRef.isListStart != null">
      ${_conditionType_} a.isList <![CDATA[ >= ]]> #{${_conditionParam_}.isListStart}
      </if>
      <if test="conditionParamRef.containsKey('isListEnd') and conditionParamRef.isListEnd != null">
      ${_conditionType_} a.isList <![CDATA[ <= ]]> #{${_conditionParam_}.isListEnd}
      </if>
      <if test="conditionParamRef.containsKey('fieldOrderNo')">
      <if test="conditionParamRef.fieldOrderNo != null ">
      ${_conditionType_} a.fieldOrderNo = #{${_conditionParam_}.fieldOrderNo}
      </if>
      <if test="conditionParamRef.fieldOrderNo == null">
      ${_conditionType_} a.fieldOrderNo is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('fieldOrderNoList') and conditionParamRef.fieldOrderNoList.size() > 0">
      ${_conditionType_} a.fieldOrderNo in
      <foreach collection="conditionParamRef.fieldOrderNoList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldOrderNoNotList') and conditionParamRef.fieldOrderNoNotList.size() > 0">
      ${_conditionType_} a.fieldOrderNo not in
      <foreach collection="conditionParamRef.fieldOrderNoNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('fieldOrderNoStart') and conditionParamRef.fieldOrderNoStart != null">
      ${_conditionType_} a.fieldOrderNo <![CDATA[ >= ]]> #{${_conditionParam_}.fieldOrderNoStart}
      </if>
      <if test="conditionParamRef.containsKey('fieldOrderNoEnd') and conditionParamRef.fieldOrderNoEnd != null">
      ${_conditionType_} a.fieldOrderNo <![CDATA[ <= ]]> #{${_conditionParam_}.fieldOrderNoEnd}
      </if>
      <if test="conditionParamRef.containsKey('remark')">
      <if test="conditionParamRef.remark != null and conditionParamRef.remark != ''">
      ${_conditionType_} a.remark like #{${_conditionParam_}.remark}
      </if>
      <if test="conditionParamRef.remark == null">
      ${_conditionType_} a.remark is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('remarkList') and conditionParamRef.remarkList.size() > 0">
      ${_conditionType_} a.remark in
      <foreach collection="conditionParamRef.remarkList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('remarkNotList') and conditionParamRef.remarkNotList.size() > 0">
      ${_conditionType_} a.remark not in
      <foreach collection="conditionParamRef.remarkNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('createTime')">
      <if test="conditionParamRef.createTime != null ">
      ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
      </if>
      <if test="conditionParamRef.createTime == null">
      ${_conditionType_} a.createTime is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
      ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
      </if>
      <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
      ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
      </if>
      <if test="conditionParamRef.containsKey('createUserId')">
      <if test="conditionParamRef.createUserId != null ">
      ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
      </if>
      <if test="conditionParamRef.createUserId == null">
      ${_conditionType_} a.createUserId is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
      ${_conditionType_} a.createUserId in
      <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('createUserIdNotList') and conditionParamRef.createUserIdNotList.size() > 0">
      ${_conditionType_} a.createUserId not in
      <foreach collection="conditionParamRef.createUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('createUserIdStart') and conditionParamRef.createUserIdStart != null">
      ${_conditionType_} a.createUserId <![CDATA[ >= ]]> #{${_conditionParam_}.createUserIdStart}
      </if>
      <if test="conditionParamRef.containsKey('createUserIdEnd') and conditionParamRef.createUserIdEnd != null">
      ${_conditionType_} a.createUserId <![CDATA[ <= ]]> #{${_conditionParam_}.createUserIdEnd}
      </if>
      <if test="conditionParamRef.containsKey('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('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') and conditionParamRef.updateUserIdList.size() > 0">
      ${_conditionType_} a.updateUserId in
      <foreach collection="conditionParamRef.updateUserIdList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('updateUserIdNotList') and conditionParamRef.updateUserIdNotList.size() > 0">
      ${_conditionType_} a.updateUserId not in
      <foreach collection="conditionParamRef.updateUserIdNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('updateUserIdStart') and conditionParamRef.updateUserIdStart != null">
      ${_conditionType_} a.updateUserId <![CDATA[ >= ]]> #{${_conditionParam_}.updateUserIdStart}
      </if>
      <if test="conditionParamRef.containsKey('updateUserIdEnd') and conditionParamRef.updateUserIdEnd != null">
      ${_conditionType_} a.updateUserId <![CDATA[ <= ]]> #{${_conditionParam_}.updateUserIdEnd}
      </if>
      <if test="conditionParamRef.containsKey('idCard')">
      <if test="conditionParamRef.idCard != null and conditionParamRef.idCard != ''">
      ${_conditionType_} a.idCard like #{${_conditionParam_}.idCard}
      </if>
      <if test="conditionParamRef.idCard == null">
      ${_conditionType_} a.idCard is null
      </if>
      </if>
      <if test="conditionParamRef.containsKey('idCardList') and conditionParamRef.idCardList.size() > 0">
      ${_conditionType_} a.idCard in
      <foreach collection="conditionParamRef.idCardList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      <if test="conditionParamRef.containsKey('idCardNotList') and conditionParamRef.idCardNotList.size() > 0">
      ${_conditionType_} a.idCard not in
      <foreach collection="conditionParamRef.idCardNotList" open="(" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      </if>
      </sql>
      <sql id="_orderCols_">
      <if test="orderColList != null and !orderColList.isEmpty()">
      order by
      <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
      field(a.id,
      <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('datumPrintIdList') and conditionParamRef.datumPrintIdList.size() > 0">
      field(a.datumPrintId,
      <foreach collection="conditionParamRef.datumPrintIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('fieldLenList') and conditionParamRef.fieldLenList.size() > 0">
      field(a.fieldLen,
      <foreach collection="conditionParamRef.fieldLenList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('fieldNullList') and conditionParamRef.fieldNullList.size() > 0">
      field(a.fieldNull,
      <foreach collection="conditionParamRef.fieldNullList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('isListList') and conditionParamRef.isListList.size() > 0">
      field(a.isList,
      <foreach collection="conditionParamRef.isListList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('fieldOrderNoList') and conditionParamRef.fieldOrderNoList.size() > 0">
      field(a.fieldOrderNo,
      <foreach collection="conditionParamRef.fieldOrderNoList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
      field(a.createUserId,
      <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
      field(a.updateUserId,
      <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <trim suffixOverrides="," suffix="">
      <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
      a.${item.colName} ${item.sortKind}
      </foreach>
      </trim>
      </if>
      <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
      order by
      <if test="conditionParamRef.containsKey('idList') and conditionParamRef.idList.size() > 0">
      field(a.id,
      <foreach collection="conditionParamRef.idList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('datumPrintIdList') and conditionParamRef.datumPrintIdList.size() > 0">
      field(a.datumPrintId,
      <foreach collection="conditionParamRef.datumPrintIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('fieldLenList') and conditionParamRef.fieldLenList.size() > 0">
      field(a.fieldLen,
      <foreach collection="conditionParamRef.fieldLenList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('fieldNullList') and conditionParamRef.fieldNullList.size() > 0">
      field(a.fieldNull,
      <foreach collection="conditionParamRef.fieldNullList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('isListList') and conditionParamRef.isListList.size() > 0">
      field(a.isList,
      <foreach collection="conditionParamRef.isListList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('fieldOrderNoList') and conditionParamRef.fieldOrderNoList.size() > 0">
      field(a.fieldOrderNo,
      <foreach collection="conditionParamRef.fieldOrderNoList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
      field(a.createUserId,
      <foreach collection="conditionParamRef.createUserIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <if test="conditionParamRef.containsKey('updateUserIdList') and conditionParamRef.updateUserIdList.size() > 0">
      field(a.updateUserId,
      <foreach collection="conditionParamRef.updateUserIdList" open="" close=")" index="index" item="item" separator=",">
      #{item}
      </foreach>
      ,
      </if>
      <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('datumPrintId')">
      a.datum_print_id
      <if test='orderCol.datumPrintId != null and "DESC".equalsIgnoreCase(orderCol.datumPrintId)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('fieldCode')">
      a.fieldCode
      <if test='orderCol.fieldCode != null and "DESC".equalsIgnoreCase(orderCol.fieldCode)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('fieldName')">
      a.fieldName
      <if test='orderCol.fieldName != null and "DESC".equalsIgnoreCase(orderCol.fieldName)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('fieldType')">
      a.fieldType
      <if test='orderCol.fieldType != null and "DESC".equalsIgnoreCase(orderCol.fieldType)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('fieldTypeValue')">
      a.fieldTypeValue
      <if test='orderCol.fieldTypeValue != null and "DESC".equalsIgnoreCase(orderCol.fieldTypeValue)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('dataType')">
      a.dataType
      <if test='orderCol.dataType != null and "DESC".equalsIgnoreCase(orderCol.dataType)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('fieldValue')">
      a.fieldValue
      <if test='orderCol.fieldValue != null and "DESC".equalsIgnoreCase(orderCol.fieldValue)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('defaultValue')">
      a.defaultValue
      <if test='orderCol.defaultValue != null and "DESC".equalsIgnoreCase(orderCol.defaultValue)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('fieldLen')">
      a.fieldLen
      <if test='orderCol.fieldLen != null and "DESC".equalsIgnoreCase(orderCol.fieldLen)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('fieldNull')">
      a.fieldNull
      <if test='orderCol.fieldNull != null and "DESC".equalsIgnoreCase(orderCol.fieldNull)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('isList')">
      a.isList
      <if test='orderCol.isList != null and "DESC".equalsIgnoreCase(orderCol.isList)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('fieldOrderNo')">
      a.fieldOrderNo
      <if test='orderCol.fieldOrderNo != null and "DESC".equalsIgnoreCase(orderCol.fieldOrderNo)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('remark')">
      a.remark
      <if test='orderCol.remark != null and "DESC".equalsIgnoreCase(orderCol.remark)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('createTime')">
      a.createTime
      <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('createUserId')">
      a.createUserId
      <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
      ,
      </if>
      <if test="orderCol.containsKey('updateTime')">
      a.updateTime
      <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>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('idCard')">
      a.idCard
      <if test='orderCol.idCard != null and "DESC".equalsIgnoreCase(orderCol.idCard)'>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
      fill-manager/src/test/java/com/mortals/httpclient/http-client.env.json
      View file @ 7255b4fb
      ......@@ -11,6 +11,11 @@
      "baseUrl": "http://192.168.0.98:11078/fm",
      "baseLogin": "http://192.168.0.98:11078/fm"
      },
      "test-remote": {
      "baseUrl": "http://8.136.255.30:11078/fm",
      "baseLogin": "http://8.136.255.30:11078/fm"
      },
      "portal": {
      "baseUrl": "http://192.168.0.98:11072/zwfw",
      "baseLogin": "http://192.168.0.98:11078/base"
      ......
      fill-manager/src/test/java/com/mortals/httpclient/system.http
      View file @ 7255b4fb
      ......@@ -54,15 +54,16 @@ Content-Type: application/json
      }
      ###通知列表
      POST {{baseUrl}}/param/list
      ###解析
      POST {{baseUrl}}/datum/info/field/parseForm
      Content-Type: application/json
      {
      "page": 1,
      "size": 10
      }
      ###通知详细
      GET {{baseUrl}}/home/notice/info?id=14
      Authorization: {{authToken}}
      ......
      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