Merge branch 'master' of http://gitlab.scsmile.cn/zxf/enterprise-platform

db/add.sql

@@ -116,3 +116,7 @@ PRIMARY KEY  (`id`)
 ALTER TABLE mortals_xhx_company ADD COLUMN   `background` varchar(256)   default ''  COMMENT '背景图片';
 ALTER TABLE `mortals_xhx_favorites_businesscard` CHANGE `staffId` `bussinesscardId` bigint(20) NOT NULL     COMMENT '名片ID, 关联到名片表中的ID，表示这是哪个名片的收藏';
 
+-- ----------------------------
+-- 2024-12-26
+-- ----------------------------
+ALTER TABLE `mortals_xhx_product` ADD COLUMN `shelves` tinyint(1)    DEFAULT '1'  COMMENT '是否上架(0.否,1.是)';

enterprise-manager/src/main/java/com/mortals/xhx/busiz/applets/web/ProductApiController.java

@@ -85,6 +85,7 @@ public class ProductApiController extends AbstractBaseController<ProductReq>{
                 query.setCategoryId(String.valueOf(productReq.getCategoryId()));
             }
             query.setHot(productReq.getHot());
+            query.setShelves(1);
             query.setOrderColList(Arrays.asList(new OrderCol("publishTime", OrderCol.DESCENDING)));
             Result<ProductEntity> result = productService.find(query, pageInfo, context);
             List<ProductEntity> collect = result.getList().stream().map(item -> {

enterprise-manager/src/main/java/com/mortals/xhx/module/product/model/ProductEntity.java

@@ -13,70 +13,74 @@ import com.mortals.xhx.module.product.model.vo.ProductVo;
 import com.mortals.xhx.module.product.model.ProductQuestionEntity;
 import lombok.Data;
 /**
-* 产品实体对象
-*
-* @author zxfei
-* @date 2023-09-18
-*/
+ * 产品实体对象
+ *
+ * @author zxfei
+ * @date 2024-12-26
+ */
 @Data
 public class ProductEntity extends ProductVo {
     private static final long serialVersionUID = 1L;
 
     /**
-    * 产品名称，名称唯一
-    */
+     * 产品名称，名称唯一
+     */
     @Excel(name = "产品名称，名称唯一")
     private String productName;
     /**
-    * 产品编码
-    */
+     * 产品编码
+     */
     private String productCode;
     /**
-    * 产品slogan
-    */
+     * 产品slogan
+     */
     private String productSlogan;
     /**
-    * 产品图标
-    */
+     * 产品图标
+     */
     private String productLogoPath;
     /**
-    * 产品封面图片
-    */
+     * 产品封面图片
+     */
     private String productFacePath;
     /**
-    * 产品视频,多个视频逗号分割
-    */
+     * 产品视频,多个视频逗号分割
+     */
     private String productVideoPath;
     /**
-    * 产品宣传图片,多个视频逗号分割
-    */
+     * 产品宣传图片,多个视频逗号分割
+     */
     private String productPicPath;
     /**
-    * 产品介绍
-    */
+     * 产品介绍
+     */
     private String productIntroduction;
     /**
-    * 产品详情
-    */
+     * 产品详情
+     */
     private String productDetail;
     /**
-    * 发布时间
-    */
+     * 发布时间
+     */
     private Date publishTime;
     /**
-    * 是否热门(0.否,1.是)
-    */
+     * 是否热门(0.否,1.是)
+     */
     private Integer hot;
     /**
-    * 备注
-    */
+     * 备注
+     */
     private String productRemark;
     /**
-    * 产品常见问题信息
-    */
+     * 是否上架(0.否,1.是)
+     */
+    private Integer shelves;
+    /**
+     * 产品常见问题信息
+     */
     private List<ProductQuestionEntity> productQuestionList=new ArrayList<>();;
     public List<ProductQuestionEntity> getProductQuestionList(){
-      return productQuestionList;
+        return productQuestionList;
     }
 
     public void setProductQuestionList(List<ProductQuestionEntity> productQuestionList){
@@ -84,7 +88,7 @@ public class ProductEntity extends ProductVo {
     }
     @Override
     public int hashCode() {
-         return this.getId().hashCode();
+        return this.getId().hashCode();
     }
     @Override
     public boolean equals(Object obj) {
@@ -92,24 +96,25 @@ public class ProductEntity extends ProductVo {
         if (obj instanceof ProductEntity) {
             ProductEntity tmp = (ProductEntity) obj;
             if (this.getId() == tmp.getId()) {
-                 return true;
+                return true;
             }
         }
         return false;
     }
 
     public void initAttrValue(){
-            this.productName = "";
-            this.productCode = "";
-            this.productSlogan = "";
-            this.productLogoPath = "";
-            this.productFacePath = "";
-            this.productVideoPath = "";
-            this.productPicPath = "";
-            this.productIntroduction = "";
-            this.productDetail = "";
-            this.publishTime = new Date();
-            this.hot = 0;
-            this.productRemark = "";
+        this.productName = "";
+        this.productCode = "";
+        this.productSlogan = "";
+        this.productLogoPath = "";
+        this.productFacePath = "";
+        this.productVideoPath = "";
+        this.productPicPath = "";
+        this.productIntroduction = "";
+        this.productDetail = "";
+        this.publishTime = new Date();
+        this.hot = 0;
+        this.productRemark = "";
+        this.shelves = 1;
     }
 }
\ No newline at end of file

enterprise-manager/src/main/java/com/mortals/xhx/module/product/model/ProductQuery.java

@@ -5,11 +5,11 @@ import java.util.Date;
 import java.util.List;
 import com.mortals.xhx.module.product.model.ProductEntity;
 /**
-* 产品查询对象
-*
-* @author zxfei
-* @date 2023-09-18
-*/
+ * 产品查询对象
+ *
+ * @author zxfei
+ * @date 2024-12-26
+ */
 public class ProductQuery extends ProductEntity {
     /** 开始 主键ID，主键，自增长 */
     private Long idStart;
@@ -139,6 +139,21 @@ public class ProductQuery extends ProductEntity {
     /** 结束 更新时间 */
     private String updateTimeEnd;
 
+    /** 开始 是否上架(0.否,1.是) */
+    private Integer shelvesStart;
+
+    /** 结束 是否上架(0.否,1.是) */
+    private Integer shelvesEnd;
+
+    /** 增加 是否上架(0.否,1.是) */
+    private Integer shelvesIncrement;
+
+    /** 是否上架(0.否,1.是)列表 */
+    private List <Integer> shelvesList;
+
+    /** 是否上架(0.否,1.是)排除列表 */
+    private List <Integer> shelvesNotList;
+
     /** OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4) */
     private List<ProductQuery> orConditionList;
 
@@ -148,1182 +163,1317 @@ public class ProductQuery extends ProductEntity {
     public ProductQuery(){}
 
     /**
-    * 获取 开始 主键ID，主键，自增长
-    * @return idStart
-    */
+     * 获取 开始 主键ID，主键，自增长
+     * @return idStart
+     */
     public Long getIdStart(){
         return this.idStart;
     }
 
     /**
-    * 设置 开始 主键ID，主键，自增长
-    * @param idStart
-    */
+     * 设置 开始 主键ID，主键，自增长
+     * @param idStart
+     */
     public void setIdStart(Long idStart){
         this.idStart = idStart;
     }
 
     /**
-    * 获取 结束 主键ID，主键，自增长
-    * @return $idEnd
-    */
+     * 获取 结束 主键ID，主键，自增长
+     * @return $idEnd
+     */
     public Long getIdEnd(){
         return this.idEnd;
     }
 
     /**
-    * 设置 结束 主键ID，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 主键ID，主键，自增长
+     * @param idEnd
+     */
     public void setIdEnd(Long idEnd){
         this.idEnd = idEnd;
     }
 
     /**
-    * 获取 增加 主键ID，主键，自增长
-    * @return idIncrement
-    */
+     * 获取 增加 主键ID，主键，自增长
+     * @return idIncrement
+     */
     public Long getIdIncrement(){
         return this.idIncrement;
     }
 
     /**
-    * 设置 增加 主键ID，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 主键ID，主键，自增长
+     * @param idIncrement
+     */
     public void setIdIncrement(Long idIncrement){
         this.idIncrement = idIncrement;
     }
 
     /**
-    * 获取 主键ID，主键，自增长
-    * @return idList
-    */
+     * 获取 主键ID，主键，自增长
+     * @return idList
+     */
     public List<Long> getIdList(){
         return this.idList;
     }
 
     /**
-    * 设置 主键ID，主键，自增长
-    * @param idList
-    */
+     * 设置 主键ID，主键，自增长
+     * @param idList
+     */
     public void setIdList(List<Long> idList){
         this.idList = idList;
     }
 
     /**
-    * 获取 主键ID，主键，自增长
-    * @return idNotList
-    */
+     * 获取 主键ID，主键，自增长
+     * @return idNotList
+     */
     public List<Long> getIdNotList(){
         return this.idNotList;
     }
 
     /**
-    * 设置 主键ID，主键，自增长
-    * @param idNotList
-    */
+     * 设置 主键ID，主键，自增长
+     * @param idNotList
+     */
     public void setIdNotList(List<Long> idNotList){
         this.idNotList = idNotList;
     }
 
 
     /**
-    * 获取 产品名称，名称唯一
-    * @return productNameList
-    */
+     * 获取 产品名称，名称唯一
+     * @return productNameList
+     */
     public List<String> getProductNameList(){
         return this.productNameList;
     }
 
     /**
-    * 设置 产品名称，名称唯一
-    * @param productNameList
-    */
+     * 设置 产品名称，名称唯一
+     * @param productNameList
+     */
     public void setProductNameList(List<String> productNameList){
         this.productNameList = productNameList;
     }
 
     /**
-    * 获取 产品名称，名称唯一
-    * @return productNameNotList
-    */
+     * 获取 产品名称，名称唯一
+     * @return productNameNotList
+     */
     public List<String> getProductNameNotList(){
         return this.productNameNotList;
     }
 
     /**
-    * 设置 产品名称，名称唯一
-    * @param productNameNotList
-    */
+     * 设置 产品名称，名称唯一
+     * @param productNameNotList
+     */
     public void setProductNameNotList(List<String> productNameNotList){
         this.productNameNotList = productNameNotList;
     }
 
     /**
-    * 获取 产品编码
-    * @return productCodeList
-    */
+     * 获取 产品编码
+     * @return productCodeList
+     */
     public List<String> getProductCodeList(){
         return this.productCodeList;
     }
 
     /**
-    * 设置 产品编码
-    * @param productCodeList
-    */
+     * 设置 产品编码
+     * @param productCodeList
+     */
     public void setProductCodeList(List<String> productCodeList){
         this.productCodeList = productCodeList;
     }
 
     /**
-    * 获取 产品编码
-    * @return productCodeNotList
-    */
+     * 获取 产品编码
+     * @return productCodeNotList
+     */
     public List<String> getProductCodeNotList(){
         return this.productCodeNotList;
     }
 
     /**
-    * 设置 产品编码
-    * @param productCodeNotList
-    */
+     * 设置 产品编码
+     * @param productCodeNotList
+     */
     public void setProductCodeNotList(List<String> productCodeNotList){
         this.productCodeNotList = productCodeNotList;
     }
 
     /**
-    * 获取 产品slogan
-    * @return productSloganList
-    */
+     * 获取 产品slogan
+     * @return productSloganList
+     */
     public List<String> getProductSloganList(){
         return this.productSloganList;
     }
 
     /**
-    * 设置 产品slogan
-    * @param productSloganList
-    */
+     * 设置 产品slogan
+     * @param productSloganList
+     */
     public void setProductSloganList(List<String> productSloganList){
         this.productSloganList = productSloganList;
     }
 
     /**
-    * 获取 产品slogan
-    * @return productSloganNotList
-    */
+     * 获取 产品slogan
+     * @return productSloganNotList
+     */
     public List<String> getProductSloganNotList(){
         return this.productSloganNotList;
     }
 
     /**
-    * 设置 产品slogan
-    * @param productSloganNotList
-    */
+     * 设置 产品slogan
+     * @param productSloganNotList
+     */
     public void setProductSloganNotList(List<String> productSloganNotList){
         this.productSloganNotList = productSloganNotList;
     }
 
     /**
-    * 获取 产品图标
-    * @return productLogoPathList
-    */
+     * 获取 产品图标
+     * @return productLogoPathList
+     */
     public List<String> getProductLogoPathList(){
         return this.productLogoPathList;
     }
 
     /**
-    * 设置 产品图标
-    * @param productLogoPathList
-    */
+     * 设置 产品图标
+     * @param productLogoPathList
+     */
     public void setProductLogoPathList(List<String> productLogoPathList){
         this.productLogoPathList = productLogoPathList;
     }
 
     /**
-    * 获取 产品图标
-    * @return productLogoPathNotList
-    */
+     * 获取 产品图标
+     * @return productLogoPathNotList
+     */
     public List<String> getProductLogoPathNotList(){
         return this.productLogoPathNotList;
     }
 
     /**
-    * 设置 产品图标
-    * @param productLogoPathNotList
-    */
+     * 设置 产品图标
+     * @param productLogoPathNotList
+     */
     public void setProductLogoPathNotList(List<String> productLogoPathNotList){
         this.productLogoPathNotList = productLogoPathNotList;
     }
 
     /**
-    * 获取 产品封面图片
-    * @return productFacePathList
-    */
+     * 获取 产品封面图片
+     * @return productFacePathList
+     */
     public List<String> getProductFacePathList(){
         return this.productFacePathList;
     }
 
     /**
-    * 设置 产品封面图片
-    * @param productFacePathList
-    */
+     * 设置 产品封面图片
+     * @param productFacePathList
+     */
     public void setProductFacePathList(List<String> productFacePathList){
         this.productFacePathList = productFacePathList;
     }
 
     /**
-    * 获取 产品封面图片
-    * @return productFacePathNotList
-    */
+     * 获取 产品封面图片
+     * @return productFacePathNotList
+     */
     public List<String> getProductFacePathNotList(){
         return this.productFacePathNotList;
     }
 
     /**
-    * 设置 产品封面图片
-    * @param productFacePathNotList
-    */
+     * 设置 产品封面图片
+     * @param productFacePathNotList
+     */
     public void setProductFacePathNotList(List<String> productFacePathNotList){
         this.productFacePathNotList = productFacePathNotList;
     }
 
     /**
-    * 获取 产品视频,多个视频逗号分割
-    * @return productVideoPathList
-    */
+     * 获取 产品视频,多个视频逗号分割
+     * @return productVideoPathList
+     */
     public List<String> getProductVideoPathList(){
         return this.productVideoPathList;
     }
 
     /**
-    * 设置 产品视频,多个视频逗号分割
-    * @param productVideoPathList
-    */
+     * 设置 产品视频,多个视频逗号分割
+     * @param productVideoPathList
+     */
     public void setProductVideoPathList(List<String> productVideoPathList){
         this.productVideoPathList = productVideoPathList;
     }
 
     /**
-    * 获取 产品视频,多个视频逗号分割
-    * @return productVideoPathNotList
-    */
+     * 获取 产品视频,多个视频逗号分割
+     * @return productVideoPathNotList
+     */
     public List<String> getProductVideoPathNotList(){
         return this.productVideoPathNotList;
     }
 
     /**
-    * 设置 产品视频,多个视频逗号分割
-    * @param productVideoPathNotList
-    */
+     * 设置 产品视频,多个视频逗号分割
+     * @param productVideoPathNotList
+     */
     public void setProductVideoPathNotList(List<String> productVideoPathNotList){
         this.productVideoPathNotList = productVideoPathNotList;
     }
 
     /**
-    * 获取 产品宣传图片,多个视频逗号分割
-    * @return productPicPathList
-    */
+     * 获取 产品宣传图片,多个视频逗号分割
+     * @return productPicPathList
+     */
     public List<String> getProductPicPathList(){
         return this.productPicPathList;
     }
 
     /**
-    * 设置 产品宣传图片,多个视频逗号分割
-    * @param productPicPathList
-    */
+     * 设置 产品宣传图片,多个视频逗号分割
+     * @param productPicPathList
+     */
     public void setProductPicPathList(List<String> productPicPathList){
         this.productPicPathList = productPicPathList;
     }
 
     /**
-    * 获取 产品宣传图片,多个视频逗号分割
-    * @return productPicPathNotList
-    */
+     * 获取 产品宣传图片,多个视频逗号分割
+     * @return productPicPathNotList
+     */
     public List<String> getProductPicPathNotList(){
         return this.productPicPathNotList;
     }
 
     /**
-    * 设置 产品宣传图片,多个视频逗号分割
-    * @param productPicPathNotList
-    */
+     * 设置 产品宣传图片,多个视频逗号分割
+     * @param productPicPathNotList
+     */
     public void setProductPicPathNotList(List<String> productPicPathNotList){
         this.productPicPathNotList = productPicPathNotList;
     }
 
     /**
-    * 获取 产品介绍
-    * @return productIntroductionList
-    */
+     * 获取 产品介绍
+     * @return productIntroductionList
+     */
     public List<String> getProductIntroductionList(){
         return this.productIntroductionList;
     }
 
     /**
-    * 设置 产品介绍
-    * @param productIntroductionList
-    */
+     * 设置 产品介绍
+     * @param productIntroductionList
+     */
     public void setProductIntroductionList(List<String> productIntroductionList){
         this.productIntroductionList = productIntroductionList;
     }
 
     /**
-    * 获取 产品介绍
-    * @return productIntroductionNotList
-    */
+     * 获取 产品介绍
+     * @return productIntroductionNotList
+     */
     public List<String> getProductIntroductionNotList(){
         return this.productIntroductionNotList;
     }
 
     /**
-    * 设置 产品介绍
-    * @param productIntroductionNotList
-    */
+     * 设置 产品介绍
+     * @param productIntroductionNotList
+     */
     public void setProductIntroductionNotList(List<String> productIntroductionNotList){
         this.productIntroductionNotList = productIntroductionNotList;
     }
 
     /**
-    * 获取 产品详情
-    * @return productDetailList
-    */
+     * 获取 产品详情
+     * @return productDetailList
+     */
     public List<String> getProductDetailList(){
         return this.productDetailList;
     }
 
     /**
-    * 设置 产品详情
-    * @param productDetailList
-    */
+     * 设置 产品详情
+     * @param productDetailList
+     */
     public void setProductDetailList(List<String> productDetailList){
         this.productDetailList = productDetailList;
     }
 
     /**
-    * 获取 产品详情
-    * @return productDetailNotList
-    */
+     * 获取 产品详情
+     * @return productDetailNotList
+     */
     public List<String> getProductDetailNotList(){
         return this.productDetailNotList;
     }
 
     /**
-    * 设置 产品详情
-    * @param productDetailNotList
-    */
+     * 设置 产品详情
+     * @param productDetailNotList
+     */
     public void setProductDetailNotList(List<String> productDetailNotList){
         this.productDetailNotList = productDetailNotList;
     }
 
     /**
-    * 获取 开始 发布时间
-    * @return publishTimeStart
-    */
+     * 获取 开始 发布时间
+     * @return publishTimeStart
+     */
     public String getPublishTimeStart(){
         return this.publishTimeStart;
     }
 
     /**
-    * 设置 开始 发布时间
-    * @param publishTimeStart
-    */
+     * 设置 开始 发布时间
+     * @param publishTimeStart
+     */
     public void setPublishTimeStart(String publishTimeStart){
         this.publishTimeStart = publishTimeStart;
     }
 
     /**
-    * 获取 结束 发布时间
-    * @return publishTimeEnd
-    */
+     * 获取 结束 发布时间
+     * @return publishTimeEnd
+     */
     public String getPublishTimeEnd(){
         return this.publishTimeEnd;
     }
 
     /**
-    * 设置 结束 发布时间
-    * @param publishTimeEnd
-    */
+     * 设置 结束 发布时间
+     * @param publishTimeEnd
+     */
     public void setPublishTimeEnd(String publishTimeEnd){
         this.publishTimeEnd = publishTimeEnd;
     }
 
     /**
-    * 获取 开始 是否热门(0.否,1.是)
-    * @return hotStart
-    */
+     * 获取 开始 是否热门(0.否,1.是)
+     * @return hotStart
+     */
     public Integer getHotStart(){
         return this.hotStart;
     }
 
     /**
-    * 设置 开始 是否热门(0.否,1.是)
-    * @param hotStart
-    */
+     * 设置 开始 是否热门(0.否,1.是)
+     * @param hotStart
+     */
     public void setHotStart(Integer hotStart){
         this.hotStart = hotStart;
     }
 
     /**
-    * 获取 结束 是否热门(0.否,1.是)
-    * @return $hotEnd
-    */
+     * 获取 结束 是否热门(0.否,1.是)
+     * @return $hotEnd
+     */
     public Integer getHotEnd(){
         return this.hotEnd;
     }
 
     /**
-    * 设置 结束 是否热门(0.否,1.是)
-    * @param hotEnd
-    */
+     * 设置 结束 是否热门(0.否,1.是)
+     * @param hotEnd
+     */
     public void setHotEnd(Integer hotEnd){
         this.hotEnd = hotEnd;
     }
 
     /**
-    * 获取 增加 是否热门(0.否,1.是)
-    * @return hotIncrement
-    */
+     * 获取 增加 是否热门(0.否,1.是)
+     * @return hotIncrement
+     */
     public Integer getHotIncrement(){
         return this.hotIncrement;
     }
 
     /**
-    * 设置 增加 是否热门(0.否,1.是)
-    * @param hotIncrement
-    */
+     * 设置 增加 是否热门(0.否,1.是)
+     * @param hotIncrement
+     */
     public void setHotIncrement(Integer hotIncrement){
         this.hotIncrement = hotIncrement;
     }
 
     /**
-    * 获取 是否热门(0.否,1.是)
-    * @return hotList
-    */
+     * 获取 是否热门(0.否,1.是)
+     * @return hotList
+     */
     public List<Integer> getHotList(){
         return this.hotList;
     }
 
     /**
-    * 设置 是否热门(0.否,1.是)
-    * @param hotList
-    */
+     * 设置 是否热门(0.否,1.是)
+     * @param hotList
+     */
     public void setHotList(List<Integer> hotList){
         this.hotList = hotList;
     }
 
     /**
-    * 获取 是否热门(0.否,1.是)
-    * @return hotNotList
-    */
+     * 获取 是否热门(0.否,1.是)
+     * @return hotNotList
+     */
     public List<Integer> getHotNotList(){
         return this.hotNotList;
     }
 
     /**
-    * 设置 是否热门(0.否,1.是)
-    * @param hotNotList
-    */
+     * 设置 是否热门(0.否,1.是)
+     * @param hotNotList
+     */
     public void setHotNotList(List<Integer> hotNotList){
         this.hotNotList = hotNotList;
     }
 
 
     /**
-    * 获取 备注
-    * @return productRemarkList
-    */
+     * 获取 备注
+     * @return productRemarkList
+     */
     public List<String> getProductRemarkList(){
         return this.productRemarkList;
     }
 
     /**
-    * 设置 备注
-    * @param productRemarkList
-    */
+     * 设置 备注
+     * @param productRemarkList
+     */
     public void setProductRemarkList(List<String> productRemarkList){
         this.productRemarkList = productRemarkList;
     }
 
     /**
-    * 获取 备注
-    * @return productRemarkNotList
-    */
+     * 获取 备注
+     * @return productRemarkNotList
+     */
     public List<String> getProductRemarkNotList(){
         return this.productRemarkNotList;
     }
 
     /**
-    * 设置 备注
-    * @param productRemarkNotList
-    */
+     * 设置 备注
+     * @param productRemarkNotList
+     */
     public void setProductRemarkNotList(List<String> productRemarkNotList){
         this.productRemarkNotList = productRemarkNotList;
     }
 
     /**
-    * 获取 开始 创建用户
-    * @return createUserIdStart
-    */
+     * 获取 开始 创建用户
+     * @return createUserIdStart
+     */
     public Long getCreateUserIdStart(){
         return this.createUserIdStart;
     }
 
     /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public void setCreateUserIdStart(Long createUserIdStart){
         this.createUserIdStart = createUserIdStart;
     }
 
     /**
-    * 获取 结束 创建用户
-    * @return $createUserIdEnd
-    */
+     * 获取 结束 创建用户
+     * @return $createUserIdEnd
+     */
     public Long getCreateUserIdEnd(){
         return this.createUserIdEnd;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public void setCreateUserIdEnd(Long createUserIdEnd){
         this.createUserIdEnd = createUserIdEnd;
     }
 
     /**
-    * 获取 增加 创建用户
-    * @return createUserIdIncrement
-    */
+     * 获取 增加 创建用户
+     * @return createUserIdIncrement
+     */
     public Long getCreateUserIdIncrement(){
         return this.createUserIdIncrement;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public void setCreateUserIdIncrement(Long createUserIdIncrement){
         this.createUserIdIncrement = createUserIdIncrement;
     }
 
     /**
-    * 获取 创建用户
-    * @return createUserIdList
-    */
+     * 获取 创建用户
+     * @return createUserIdList
+     */
     public List<Long> getCreateUserIdList(){
         return this.createUserIdList;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public void setCreateUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
     }
 
     /**
-    * 获取 创建用户
-    * @return createUserIdNotList
-    */
+     * 获取 创建用户
+     * @return createUserIdNotList
+     */
     public List<Long> getCreateUserIdNotList(){
         return this.createUserIdNotList;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdNotList
-    */
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
     public void setCreateUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
     }
 
 
     /**
-    * 获取 开始 创建时间
-    * @return createTimeStart
-    */
+     * 获取 开始 创建时间
+     * @return createTimeStart
+     */
     public String getCreateTimeStart(){
         return this.createTimeStart;
     }
 
     /**
-    * 设置 开始 创建时间
-    * @param createTimeStart
-    */
+     * 设置 开始 创建时间
+     * @param createTimeStart
+     */
     public void setCreateTimeStart(String createTimeStart){
         this.createTimeStart = createTimeStart;
     }
 
     /**
-    * 获取 结束 创建时间
-    * @return createTimeEnd
-    */
+     * 获取 结束 创建时间
+     * @return createTimeEnd
+     */
     public String getCreateTimeEnd(){
         return this.createTimeEnd;
     }
 
     /**
-    * 设置 结束 创建时间
-    * @param createTimeEnd
-    */
+     * 设置 结束 创建时间
+     * @param createTimeEnd
+     */
     public void setCreateTimeEnd(String createTimeEnd){
         this.createTimeEnd = createTimeEnd;
     }
 
     /**
-    * 获取 开始 更新用户
-    * @return updateUserIdStart
-    */
+     * 获取 开始 更新用户
+     * @return updateUserIdStart
+     */
     public Long getUpdateUserIdStart(){
         return this.updateUserIdStart;
     }
 
     /**
-    * 设置 开始 更新用户
-    * @param updateUserIdStart
-    */
+     * 设置 开始 更新用户
+     * @param updateUserIdStart
+     */
     public void setUpdateUserIdStart(Long updateUserIdStart){
         this.updateUserIdStart = updateUserIdStart;
     }
 
     /**
-    * 获取 结束 更新用户
-    * @return $updateUserIdEnd
-    */
+     * 获取 结束 更新用户
+     * @return $updateUserIdEnd
+     */
     public Long getUpdateUserIdEnd(){
         return this.updateUserIdEnd;
     }
 
     /**
-    * 设置 结束 更新用户
-    * @param updateUserIdEnd
-    */
+     * 设置 结束 更新用户
+     * @param updateUserIdEnd
+     */
     public void setUpdateUserIdEnd(Long updateUserIdEnd){
         this.updateUserIdEnd = updateUserIdEnd;
     }
 
     /**
-    * 获取 增加 更新用户
-    * @return updateUserIdIncrement
-    */
+     * 获取 增加 更新用户
+     * @return updateUserIdIncrement
+     */
     public Long getUpdateUserIdIncrement(){
         return this.updateUserIdIncrement;
     }
 
     /**
-    * 设置 增加 更新用户
-    * @param updateUserIdIncrement
-    */
+     * 设置 增加 更新用户
+     * @param updateUserIdIncrement
+     */
     public void setUpdateUserIdIncrement(Long updateUserIdIncrement){
         this.updateUserIdIncrement = updateUserIdIncrement;
     }
 
     /**
-    * 获取 更新用户
-    * @return updateUserIdList
-    */
+     * 获取 更新用户
+     * @return updateUserIdList
+     */
     public List<Long> getUpdateUserIdList(){
         return this.updateUserIdList;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdList
-    */
+     * 设置 更新用户
+     * @param updateUserIdList
+     */
     public void setUpdateUserIdList(List<Long> updateUserIdList){
         this.updateUserIdList = updateUserIdList;
     }
 
     /**
-    * 获取 更新用户
-    * @return updateUserIdNotList
-    */
+     * 获取 更新用户
+     * @return updateUserIdNotList
+     */
     public List<Long> getUpdateUserIdNotList(){
         return this.updateUserIdNotList;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdNotList
-    */
+     * 设置 更新用户
+     * @param updateUserIdNotList
+     */
     public void setUpdateUserIdNotList(List<Long> updateUserIdNotList){
         this.updateUserIdNotList = updateUserIdNotList;
     }
 
 
     /**
-    * 获取 开始 更新时间
-    * @return updateTimeStart
-    */
+     * 获取 开始 更新时间
+     * @return updateTimeStart
+     */
     public String getUpdateTimeStart(){
         return this.updateTimeStart;
     }
 
     /**
-    * 设置 开始 更新时间
-    * @param updateTimeStart
-    */
+     * 设置 开始 更新时间
+     * @param updateTimeStart
+     */
     public void setUpdateTimeStart(String updateTimeStart){
         this.updateTimeStart = updateTimeStart;
     }
 
     /**
-    * 获取 结束 更新时间
-    * @return updateTimeEnd
-    */
+     * 获取 结束 更新时间
+     * @return updateTimeEnd
+     */
     public String getUpdateTimeEnd(){
         return this.updateTimeEnd;
     }
 
     /**
-    * 设置 结束 更新时间
-    * @param updateTimeEnd
-    */
+     * 设置 结束 更新时间
+     * @param updateTimeEnd
+     */
     public void setUpdateTimeEnd(String updateTimeEnd){
         this.updateTimeEnd = updateTimeEnd;
     }
 
     /**
-    * 设置  主键ID，主键，自增长
-    * @param id
-    */
+     * 获取 开始 是否上架(0.否,1.是)
+     * @return shelvesStart
+     */
+    public Integer getShelvesStart(){
+        return this.shelvesStart;
+    }
+
+    /**
+     * 设置 开始 是否上架(0.否,1.是)
+     * @param shelvesStart
+     */
+    public void setShelvesStart(Integer shelvesStart){
+        this.shelvesStart = shelvesStart;
+    }
+
+    /**
+     * 获取 结束 是否上架(0.否,1.是)
+     * @return $shelvesEnd
+     */
+    public Integer getShelvesEnd(){
+        return this.shelvesEnd;
+    }
+
+    /**
+     * 设置 结束 是否上架(0.否,1.是)
+     * @param shelvesEnd
+     */
+    public void setShelvesEnd(Integer shelvesEnd){
+        this.shelvesEnd = shelvesEnd;
+    }
+
+    /**
+     * 获取 增加 是否上架(0.否,1.是)
+     * @return shelvesIncrement
+     */
+    public Integer getShelvesIncrement(){
+        return this.shelvesIncrement;
+    }
+
+    /**
+     * 设置 增加 是否上架(0.否,1.是)
+     * @param shelvesIncrement
+     */
+    public void setShelvesIncrement(Integer shelvesIncrement){
+        this.shelvesIncrement = shelvesIncrement;
+    }
+
+    /**
+     * 获取 是否上架(0.否,1.是)
+     * @return shelvesList
+     */
+    public List<Integer> getShelvesList(){
+        return this.shelvesList;
+    }
+
+    /**
+     * 设置 是否上架(0.否,1.是)
+     * @param shelvesList
+     */
+    public void setShelvesList(List<Integer> shelvesList){
+        this.shelvesList = shelvesList;
+    }
+
+    /**
+     * 获取 是否上架(0.否,1.是)
+     * @return shelvesNotList
+     */
+    public List<Integer> getShelvesNotList(){
+        return this.shelvesNotList;
+    }
+
+    /**
+     * 设置 是否上架(0.否,1.是)
+     * @param shelvesNotList
+     */
+    public void setShelvesNotList(List<Integer> shelvesNotList){
+        this.shelvesNotList = shelvesNotList;
+    }
+
+
+    /**
+     * 设置  主键ID，主键，自增长
+     * @param id
+     */
     public ProductQuery id(Long id){
-	    setId(id);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 主键ID，主键，自增长
-    * @param idStart
-    */
+        setId(id);
+        return this;
+    }
+
+    /**
+     * 设置 开始 主键ID，主键，自增长
+     * @param idStart
+     */
     public ProductQuery idStart(Long idStart){
-		this.idStart = idStart;
-		return this;
+        this.idStart = idStart;
+        return this;
     }
 
     /**
-    * 设置 结束 主键ID，主键，自增长
-    * @param idEnd
-    */
+     * 设置 结束 主键ID，主键，自增长
+     * @param idEnd
+     */
     public ProductQuery idEnd(Long idEnd){
-		this.idEnd = idEnd;
-		return this;
+        this.idEnd = idEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 主键ID，主键，自增长
-    * @param idIncrement
-    */
+     * 设置 增加 主键ID，主键，自增长
+     * @param idIncrement
+     */
     public ProductQuery idIncrement(Long idIncrement){
-		this.idIncrement = idIncrement;
-		return this;
+        this.idIncrement = idIncrement;
+        return this;
     }
 
     /**
-    * 设置 主键ID，主键，自增长
-    * @param idList
-    */
+     * 设置 主键ID，主键，自增长
+     * @param idList
+     */
     public ProductQuery idList(List<Long> idList){
         this.idList = idList;
-		return this;
-        }
-
-        /**
-        * 设置 主键ID，主键，自增长
-        * @param idNotList
-        */
-        public ProductQuery idNotList(List<Long> idNotList){
+        return this;
+    }
+
+    /**
+     * 设置 主键ID，主键，自增长
+     * @param idNotList
+     */
+    public ProductQuery idNotList(List<Long> idNotList){
         this.idNotList = idNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 产品名称，名称唯一
-    * @param productName
-    */
+    /**
+     * 设置 产品名称，名称唯一
+     * @param productName
+     */
     public ProductQuery productName(String productName){
         setProductName(productName);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品名称，名称唯一
-    * @param productNameList
-    */
+     * 设置 产品名称，名称唯一
+     * @param productNameList
+     */
     public ProductQuery productNameList(List<String> productNameList){
         this.productNameList = productNameList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 产品编码
-    * @param productCode
-    */
+    /**
+     * 设置 产品编码
+     * @param productCode
+     */
     public ProductQuery productCode(String productCode){
         setProductCode(productCode);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品编码
-    * @param productCodeList
-    */
+     * 设置 产品编码
+     * @param productCodeList
+     */
     public ProductQuery productCodeList(List<String> productCodeList){
         this.productCodeList = productCodeList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 产品slogan
-    * @param productSlogan
-    */
+    /**
+     * 设置 产品slogan
+     * @param productSlogan
+     */
     public ProductQuery productSlogan(String productSlogan){
         setProductSlogan(productSlogan);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品slogan
-    * @param productSloganList
-    */
+     * 设置 产品slogan
+     * @param productSloganList
+     */
     public ProductQuery productSloganList(List<String> productSloganList){
         this.productSloganList = productSloganList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 产品图标
-    * @param productLogoPath
-    */
+    /**
+     * 设置 产品图标
+     * @param productLogoPath
+     */
     public ProductQuery productLogoPath(String productLogoPath){
         setProductLogoPath(productLogoPath);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品图标
-    * @param productLogoPathList
-    */
+     * 设置 产品图标
+     * @param productLogoPathList
+     */
     public ProductQuery productLogoPathList(List<String> productLogoPathList){
         this.productLogoPathList = productLogoPathList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 产品封面图片
-    * @param productFacePath
-    */
+    /**
+     * 设置 产品封面图片
+     * @param productFacePath
+     */
     public ProductQuery productFacePath(String productFacePath){
         setProductFacePath(productFacePath);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品封面图片
-    * @param productFacePathList
-    */
+     * 设置 产品封面图片
+     * @param productFacePathList
+     */
     public ProductQuery productFacePathList(List<String> productFacePathList){
         this.productFacePathList = productFacePathList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 产品视频,多个视频逗号分割
-    * @param productVideoPath
-    */
+    /**
+     * 设置 产品视频,多个视频逗号分割
+     * @param productVideoPath
+     */
     public ProductQuery productVideoPath(String productVideoPath){
         setProductVideoPath(productVideoPath);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品视频,多个视频逗号分割
-    * @param productVideoPathList
-    */
+     * 设置 产品视频,多个视频逗号分割
+     * @param productVideoPathList
+     */
     public ProductQuery productVideoPathList(List<String> productVideoPathList){
         this.productVideoPathList = productVideoPathList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 产品宣传图片,多个视频逗号分割
-    * @param productPicPath
-    */
+    /**
+     * 设置 产品宣传图片,多个视频逗号分割
+     * @param productPicPath
+     */
     public ProductQuery productPicPath(String productPicPath){
         setProductPicPath(productPicPath);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品宣传图片,多个视频逗号分割
-    * @param productPicPathList
-    */
+     * 设置 产品宣传图片,多个视频逗号分割
+     * @param productPicPathList
+     */
     public ProductQuery productPicPathList(List<String> productPicPathList){
         this.productPicPathList = productPicPathList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 产品介绍
-    * @param productIntroduction
-    */
+    /**
+     * 设置 产品介绍
+     * @param productIntroduction
+     */
     public ProductQuery productIntroduction(String productIntroduction){
         setProductIntroduction(productIntroduction);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品介绍
-    * @param productIntroductionList
-    */
+     * 设置 产品介绍
+     * @param productIntroductionList
+     */
     public ProductQuery productIntroductionList(List<String> productIntroductionList){
         this.productIntroductionList = productIntroductionList;
-		return this;
+        return this;
     }
 
 
-	/**
-    * 设置 产品详情
-    * @param productDetail
-    */
+    /**
+     * 设置 产品详情
+     * @param productDetail
+     */
     public ProductQuery productDetail(String productDetail){
         setProductDetail(productDetail);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 产品详情
-    * @param productDetailList
-    */
+     * 设置 产品详情
+     * @param productDetailList
+     */
     public ProductQuery productDetailList(List<String> productDetailList){
         this.productDetailList = productDetailList;
-		return this;
+        return this;
     }
 
 
     /**
-    * 设置  是否热门(0.否,1.是)
-    * @param hot
-    */
+     * 设置  是否热门(0.否,1.是)
+     * @param hot
+     */
     public ProductQuery hot(Integer hot){
-	    setHot(hot);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 是否热门(0.否,1.是)
-    * @param hotStart
-    */
+        setHot(hot);
+        return this;
+    }
+
+    /**
+     * 设置 开始 是否热门(0.否,1.是)
+     * @param hotStart
+     */
     public ProductQuery hotStart(Integer hotStart){
-		this.hotStart = hotStart;
-		return this;
+        this.hotStart = hotStart;
+        return this;
     }
 
     /**
-    * 设置 结束 是否热门(0.否,1.是)
-    * @param hotEnd
-    */
+     * 设置 结束 是否热门(0.否,1.是)
+     * @param hotEnd
+     */
     public ProductQuery hotEnd(Integer hotEnd){
-		this.hotEnd = hotEnd;
-		return this;
+        this.hotEnd = hotEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 是否热门(0.否,1.是)
-    * @param hotIncrement
-    */
+     * 设置 增加 是否热门(0.否,1.是)
+     * @param hotIncrement
+     */
     public ProductQuery hotIncrement(Integer hotIncrement){
-		this.hotIncrement = hotIncrement;
-		return this;
+        this.hotIncrement = hotIncrement;
+        return this;
     }
 
     /**
-    * 设置 是否热门(0.否,1.是)
-    * @param hotList
-    */
+     * 设置 是否热门(0.否,1.是)
+     * @param hotList
+     */
     public ProductQuery hotList(List<Integer> hotList){
         this.hotList = hotList;
-		return this;
-        }
-
-        /**
-        * 设置 是否热门(0.否,1.是)
-        * @param hotNotList
-        */
-        public ProductQuery hotNotList(List<Integer> hotNotList){
+        return this;
+    }
+
+    /**
+     * 设置 是否热门(0.否,1.是)
+     * @param hotNotList
+     */
+    public ProductQuery hotNotList(List<Integer> hotNotList){
         this.hotNotList = hotNotList;
         return this;
-        }
+    }
 
 
-	/**
-    * 设置 备注
-    * @param productRemark
-    */
+    /**
+     * 设置 备注
+     * @param productRemark
+     */
     public ProductQuery productRemark(String productRemark){
         setProductRemark(productRemark);
-		return this;
+        return this;
     }
 
     /**
-    * 设置 备注
-    * @param productRemarkList
-    */
+     * 设置 备注
+     * @param productRemarkList
+     */
     public ProductQuery productRemarkList(List<String> productRemarkList){
         this.productRemarkList = productRemarkList;
-		return this;
+        return this;
     }
 
     /**
-    * 设置  创建用户
-    * @param createUserId
-    */
+     * 设置  创建用户
+     * @param createUserId
+     */
     public ProductQuery createUserId(Long createUserId){
-	    setCreateUserId(createUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 创建用户
-    * @param createUserIdStart
-    */
+        setCreateUserId(createUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 创建用户
+     * @param createUserIdStart
+     */
     public ProductQuery createUserIdStart(Long createUserIdStart){
-		this.createUserIdStart = createUserIdStart;
-		return this;
+        this.createUserIdStart = createUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 创建用户
-    * @param createUserIdEnd
-    */
+     * 设置 结束 创建用户
+     * @param createUserIdEnd
+     */
     public ProductQuery createUserIdEnd(Long createUserIdEnd){
-		this.createUserIdEnd = createUserIdEnd;
-		return this;
+        this.createUserIdEnd = createUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 创建用户
-    * @param createUserIdIncrement
-    */
+     * 设置 增加 创建用户
+     * @param createUserIdIncrement
+     */
     public ProductQuery createUserIdIncrement(Long createUserIdIncrement){
-		this.createUserIdIncrement = createUserIdIncrement;
-		return this;
+        this.createUserIdIncrement = createUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 创建用户
-    * @param createUserIdList
-    */
+     * 设置 创建用户
+     * @param createUserIdList
+     */
     public ProductQuery createUserIdList(List<Long> createUserIdList){
         this.createUserIdList = createUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 创建用户
-        * @param createUserIdNotList
-        */
-        public ProductQuery createUserIdNotList(List<Long> createUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 创建用户
+     * @param createUserIdNotList
+     */
+    public ProductQuery createUserIdNotList(List<Long> createUserIdNotList){
         this.createUserIdNotList = createUserIdNotList;
         return this;
-        }
+    }
 
 
     /**
-    * 设置  更新用户
-    * @param updateUserId
-    */
+     * 设置  更新用户
+     * @param updateUserId
+     */
     public ProductQuery updateUserId(Long updateUserId){
-	    setUpdateUserId(updateUserId);
-		return this;
-    }
-	
-	 /**
-    * 设置 开始 更新用户
-    * @param updateUserIdStart
-    */
+        setUpdateUserId(updateUserId);
+        return this;
+    }
+
+    /**
+     * 设置 开始 更新用户
+     * @param updateUserIdStart
+     */
     public ProductQuery updateUserIdStart(Long updateUserIdStart){
-		this.updateUserIdStart = updateUserIdStart;
-		return this;
+        this.updateUserIdStart = updateUserIdStart;
+        return this;
     }
 
     /**
-    * 设置 结束 更新用户
-    * @param updateUserIdEnd
-    */
+     * 设置 结束 更新用户
+     * @param updateUserIdEnd
+     */
     public ProductQuery updateUserIdEnd(Long updateUserIdEnd){
-		this.updateUserIdEnd = updateUserIdEnd;
-		return this;
+        this.updateUserIdEnd = updateUserIdEnd;
+        return this;
     }
 
     /**
-    * 设置 增加 更新用户
-    * @param updateUserIdIncrement
-    */
+     * 设置 增加 更新用户
+     * @param updateUserIdIncrement
+     */
     public ProductQuery updateUserIdIncrement(Long updateUserIdIncrement){
-		this.updateUserIdIncrement = updateUserIdIncrement;
-		return this;
+        this.updateUserIdIncrement = updateUserIdIncrement;
+        return this;
     }
 
     /**
-    * 设置 更新用户
-    * @param updateUserIdList
-    */
+     * 设置 更新用户
+     * @param updateUserIdList
+     */
     public ProductQuery updateUserIdList(List<Long> updateUserIdList){
         this.updateUserIdList = updateUserIdList;
-		return this;
-        }
-
-        /**
-        * 设置 更新用户
-        * @param updateUserIdNotList
-        */
-        public ProductQuery updateUserIdNotList(List<Long> updateUserIdNotList){
+        return this;
+    }
+
+    /**
+     * 设置 更新用户
+     * @param updateUserIdNotList
+     */
+    public ProductQuery updateUserIdNotList(List<Long> updateUserIdNotList){
         this.updateUserIdNotList = updateUserIdNotList;
         return this;
-        }
+    }
 
 
     /**
-    * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @return orConditionList
-    */
+     * 设置  是否上架(0.否,1.是)
+     * @param shelves
+     */
+    public ProductQuery shelves(Integer shelves){
+        setShelves(shelves);
+        return this;
+    }
+
+    /**
+     * 设置 开始 是否上架(0.否,1.是)
+     * @param shelvesStart
+     */
+    public ProductQuery shelvesStart(Integer shelvesStart){
+        this.shelvesStart = shelvesStart;
+        return this;
+    }
+
+    /**
+     * 设置 结束 是否上架(0.否,1.是)
+     * @param shelvesEnd
+     */
+    public ProductQuery shelvesEnd(Integer shelvesEnd){
+        this.shelvesEnd = shelvesEnd;
+        return this;
+    }
+
+    /**
+     * 设置 增加 是否上架(0.否,1.是)
+     * @param shelvesIncrement
+     */
+    public ProductQuery shelvesIncrement(Integer shelvesIncrement){
+        this.shelvesIncrement = shelvesIncrement;
+        return this;
+    }
+
+    /**
+     * 设置 是否上架(0.否,1.是)
+     * @param shelvesList
+     */
+    public ProductQuery shelvesList(List<Integer> shelvesList){
+        this.shelvesList = shelvesList;
+        return this;
+    }
+
+    /**
+     * 设置 是否上架(0.否,1.是)
+     * @param shelvesNotList
+     */
+    public ProductQuery shelvesNotList(List<Integer> shelvesNotList){
+        this.shelvesNotList = shelvesNotList;
+        return this;
+    }
+
+    /**
+     * 获取 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @return orConditionList
+     */
     public List<ProductQuery> getOrConditionList(){
-    return this.orConditionList;
+        return this.orConditionList;
     }
 
     /**
-    * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
-    * @param orConditionList
-    */
+     * 设置 OR条件集合，列表项之间是OR，项内容之间是AND，如：(list[0].1 and list[0].2) or (list[1].3 and list[1].4)
+     * @param orConditionList
+     */
     public void setOrConditionList(List<ProductQuery> orConditionList){
         this.orConditionList = orConditionList;
     }
 
     /**
-    * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @return andConditionList
-    */
+     * 获取 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @return andConditionList
+     */
     public List<ProductQuery> getAndConditionList(){
         return this.andConditionList;
     }
 
     /**
-    * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
-    * @param andConditionList
-    */
+     * 设置 AND条件集合，列表项之间是AND，项内容之间是OR，如：(list[0].1 or list[0].2) and (list[1].3 or list[1].4)
+     * @param andConditionList
+     */
     public void setAndConditionList(List<ProductQuery> andConditionList){
         this.andConditionList = andConditionList;
     }

enterprise-manager/src/main/java/com/mortals/xhx/module/product/service/impl/ProductServiceImpl.java

@@ -76,7 +76,9 @@ public class ProductServiceImpl extends AbstractCRUDCacheServiceImpl<ProductDao,
                     //过滤热门与非热门
                     productList = productList.stream().filter(f -> f.getHot() == hot).collect(Collectors.toList());
                 }
-
+                productList = productList.stream().filter(f -> f.getShelves() == 1).collect(Collectors.toList());
+                productList = productList.stream().sorted(Comparator.comparing(ProductEntity::getPublishTime).reversed())
+                        .collect(Collectors.toList());
                 productEntityResult.setList(productList);
                 productEntityResult.setPageInfo(productCategoryResult.getPageInfo());
                 productEntityResult.setDict(productCategoryResult.getDict());
@@ -90,6 +92,9 @@ public class ProductServiceImpl extends AbstractCRUDCacheServiceImpl<ProductDao,
                     //过滤热门与非热门
                     productList = productList.stream().filter(f -> f.getHot() == hot).collect(Collectors.toList());
                 }
+                productList = productList.stream().filter(f -> f.getShelves() == 1).collect(Collectors.toList());
+                productList = productList.stream().sorted(Comparator.comparing(ProductEntity::getPublishTime).reversed())
+                        .collect(Collectors.toList());
                 productEntityResult.setList(productList);
                 productEntityResult.setPageInfo(companyProductEntityResult.getPageInfo());
                 productEntityResult.setDict(companyProductEntityResult.getDict());
@@ -108,6 +113,9 @@ public class ProductServiceImpl extends AbstractCRUDCacheServiceImpl<ProductDao,
                     //过滤热门与非热门
                     collect = collect.stream().filter(f -> f.getHot() == hot).collect(Collectors.toList());
                 }
+                collect = collect.stream().filter(f -> f.getShelves() == 1).collect(Collectors.toList());
+                collect = collect.stream().sorted(Comparator.comparing(ProductEntity::getPublishTime).reversed())
+                        .collect(Collectors.toList());
                 productEntityResult.setList(collect);
                 pageInfo.setTotalResult(collect.size());
                 productEntityResult.setPageInfo(pageInfo);
@@ -150,6 +158,7 @@ public class ProductServiceImpl extends AbstractCRUDCacheServiceImpl<ProductDao,
                 }
             });
         }
+        productList = productList.stream().filter(f -> f.getShelves() == 1).collect(Collectors.toList());
         productList = productList.stream().sorted(Comparator.comparing(ProductEntity::getPublishTime).reversed())
                 .collect(Collectors.toList());
         return productList;

enterprise-manager/src/main/java/com/mortals/xhx/module/product/web/ProductController.java

@@ -74,6 +74,7 @@ public class ProductController extends BaseCRUDJsonBodyMappingController<Product
         this.addDict(model, "hot", YesNoEnum.getEnumMap());
         this.addDict(model, "categoryId", categoryService.find(new CategoryQuery()).stream().collect(Collectors.toMap(x -> x.getId().toString(), y -> y.getName(), (o, n) -> n)));
         this.addDict(model, "companyId", companyService.find(new CompanyQuery()).stream().collect(Collectors.toMap(x -> x.getId().toString(), y -> y.getCompanyName(), (o, n) -> n)));
+        this.addDict(model, "shelves", YesNoEnum.getEnumMap());
         super.init(model, context);
     }
 

enterprise-manager/src/main/resources/sqlmap/module/product/ProductMapper.xml

 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
-"mybatis-3-mapper.dtd">
+        "mybatis-3-mapper.dtd">
 <mapper namespace="com.mortals.xhx.module.product.dao.ibatis.ProductDaoImpl">
 
     <!-- 字段和属性映射 -->
     <resultMap type="ProductEntity" id="ProductEntity-Map">
-            <id  property="id" column="id" />
-            <result property="productName" column="productName" />
-            <result property="productCode" column="productCode" />
-            <result property="productSlogan" column="productSlogan" />
-            <result property="productLogoPath" column="productLogoPath" />
-            <result property="productFacePath" column="productFacePath" />
-            <result property="productVideoPath" column="productVideoPath" />
-            <result property="productPicPath" column="productPicPath" />
-            <result property="productIntroduction" column="productIntroduction" />
-            <result property="productDetail" column="productDetail" />
-            <result property="publishTime" column="publishTime" />
-            <result property="hot" column="hot" />
-            <result property="productRemark" column="productRemark" />
-            <result property="createUserId" column="createUserId" />
-            <result property="createTime" column="createTime" />
-            <result property="updateUserId" column="updateUserId" />
-            <result property="updateTime" column="updateTime" />
-            <collection property="productQuestionList" column="id" ofType="ProductQuestionEntity" javaType="ArrayList" select="getProductQuestionByProductId"></collection>
+        <id  property="id" column="id" />
+        <result property="productName" column="productName" />
+        <result property="productCode" column="productCode" />
+        <result property="productSlogan" column="productSlogan" />
+        <result property="productLogoPath" column="productLogoPath" />
+        <result property="productFacePath" column="productFacePath" />
+        <result property="productVideoPath" column="productVideoPath" />
+        <result property="productPicPath" column="productPicPath" />
+        <result property="productIntroduction" column="productIntroduction" />
+        <result property="productDetail" column="productDetail" />
+        <result property="publishTime" column="publishTime" />
+        <result property="hot" column="hot" />
+        <result property="productRemark" column="productRemark" />
+        <result property="createUserId" column="createUserId" />
+        <result property="createTime" column="createTime" />
+        <result property="updateUserId" column="updateUserId" />
+        <result property="updateTime" column="updateTime" />
+        <result property="shelves" column="shelves" />
     </resultMap>
-    <resultMap type="ProductQuestionEntity" id="ProductQuestionEntity-Map">
-            <result property="id" column="id" />
-            <result property="productId" column="productId" />
-            <result property="productName" column="productName" />
-            <result property="question" column="question" />
-            <result property="answer" column="answer" />
-            <result property="createTime" column="createTime" />
-            <result property="createUserId" column="createUserId" />
-            <result property="updateTime" column="updateTime" />
-    </resultMap>
-
 
     <!-- 表所有列 -->
     <sql id="_columns">
         <trim suffixOverrides="," suffix="">
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
-                    a.id,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productName') or colPickMode == 1 and data.containsKey('productName')))">
-                    a.productName,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productCode') or colPickMode == 1 and data.containsKey('productCode')))">
-                    a.productCode,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productSlogan') or colPickMode == 1 and data.containsKey('productSlogan')))">
-                    a.productSlogan,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productLogoPath') or colPickMode == 1 and data.containsKey('productLogoPath')))">
-                    a.productLogoPath,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productFacePath') or colPickMode == 1 and data.containsKey('productFacePath')))">
-                    a.productFacePath,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productVideoPath') or colPickMode == 1 and data.containsKey('productVideoPath')))">
-                    a.productVideoPath,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productPicPath') or colPickMode == 1 and data.containsKey('productPicPath')))">
-                    a.productPicPath,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productIntroduction') or colPickMode == 1 and data.containsKey('productIntroduction')))">
-                    a.productIntroduction,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productDetail') or colPickMode == 1 and data.containsKey('productDetail')))">
-                    a.productDetail,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('publishTime') or colPickMode == 1 and data.containsKey('publishTime')))">
-                    a.publishTime,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hot') or colPickMode == 1 and data.containsKey('hot')))">
-                    a.hot,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productRemark') or colPickMode == 1 and data.containsKey('productRemark')))">
-                    a.productRemark,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
-                    a.createUserId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
-                    a.createTime,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
-                    a.updateUserId,
-                </if>
-                <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
-                    a.updateTime,
-                </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('id') or colPickMode == 1 and data.containsKey('id')))">
+                a.id,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productName') or colPickMode == 1 and data.containsKey('productName')))">
+                a.productName,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productCode') or colPickMode == 1 and data.containsKey('productCode')))">
+                a.productCode,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productSlogan') or colPickMode == 1 and data.containsKey('productSlogan')))">
+                a.productSlogan,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productLogoPath') or colPickMode == 1 and data.containsKey('productLogoPath')))">
+                a.productLogoPath,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productFacePath') or colPickMode == 1 and data.containsKey('productFacePath')))">
+                a.productFacePath,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productVideoPath') or colPickMode == 1 and data.containsKey('productVideoPath')))">
+                a.productVideoPath,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productPicPath') or colPickMode == 1 and data.containsKey('productPicPath')))">
+                a.productPicPath,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productIntroduction') or colPickMode == 1 and data.containsKey('productIntroduction')))">
+                a.productIntroduction,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productDetail') or colPickMode == 1 and data.containsKey('productDetail')))">
+                a.productDetail,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('publishTime') or colPickMode == 1 and data.containsKey('publishTime')))">
+                a.publishTime,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('hot') or colPickMode == 1 and data.containsKey('hot')))">
+                a.hot,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('productRemark') or colPickMode == 1 and data.containsKey('productRemark')))">
+                a.productRemark,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createUserId') or colPickMode == 1 and data.containsKey('createUserId')))">
+                a.createUserId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('createTime') or colPickMode == 1 and data.containsKey('createTime')))">
+                a.createTime,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateUserId') or colPickMode == 1 and data.containsKey('updateUserId')))">
+                a.updateUserId,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('updateTime') or colPickMode == 1 and data.containsKey('updateTime')))">
+                a.updateTime,
+            </if>
+            <if test="(data == null) or (data != null and ( colPickMode == 0 and !data.containsKey('shelves') or colPickMode == 1 and data.containsKey('shelves')))">
+                a.shelves,
+            </if>
         </trim>
     </sql>
     <!-- 子表所有列 -->
@@ -101,18 +93,18 @@
     <!-- 新增 区分主键自增加还是业务插入 -->
     <insert id="insert" parameterType="ProductEntity"  useGeneratedKeys="true" keyProperty="id">
         insert into mortals_xhx_product
-        (productName,productCode,productSlogan,productLogoPath,productFacePath,productVideoPath,productPicPath,productIntroduction,productDetail,publishTime,hot,productRemark,createUserId,createTime,updateUserId,updateTime)
+        (productName,productCode,productSlogan,productLogoPath,productFacePath,productVideoPath,productPicPath,productIntroduction,productDetail,publishTime,hot,productRemark,createUserId,createTime,updateUserId,updateTime,shelves)
         VALUES
-        (#{productName},#{productCode},#{productSlogan},#{productLogoPath},#{productFacePath},#{productVideoPath},#{productPicPath},#{productIntroduction},#{productDetail},#{publishTime},#{hot},#{productRemark},#{createUserId},#{createTime},#{updateUserId},#{updateTime})
+        (#{productName},#{productCode},#{productSlogan},#{productLogoPath},#{productFacePath},#{productVideoPath},#{productPicPath},#{productIntroduction},#{productDetail},#{publishTime},#{hot},#{productRemark},#{createUserId},#{createTime},#{updateUserId},#{updateTime},#{shelves})
     </insert>
 
     <!-- 批量新增 -->
     <insert id="insertBatch" parameterType="paramDto">
         insert into mortals_xhx_product
-        (productName,productCode,productSlogan,productLogoPath,productFacePath,productVideoPath,productPicPath,productIntroduction,productDetail,publishTime,hot,productRemark,createUserId,createTime,updateUserId,updateTime)
+        (productName,productCode,productSlogan,productLogoPath,productFacePath,productVideoPath,productPicPath,productIntroduction,productDetail,publishTime,hot,productRemark,createUserId,createTime,updateUserId,updateTime,shelves)
         VALUES
         <foreach collection="data.dataList" item="item" index="index" separator="," >
-            (#{item.productName},#{item.productCode},#{item.productSlogan},#{item.productLogoPath},#{item.productFacePath},#{item.productVideoPath},#{item.productPicPath},#{item.productIntroduction},#{item.productDetail},#{item.publishTime},#{item.hot},#{item.productRemark},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime})
+            (#{item.productName},#{item.productCode},#{item.productSlogan},#{item.productLogoPath},#{item.productFacePath},#{item.productVideoPath},#{item.productPicPath},#{item.productIntroduction},#{item.productDetail},#{item.publishTime},#{item.hot},#{item.productRemark},#{item.createUserId},#{item.createTime},#{item.updateUserId},#{item.updateTime},#{item.shelves})
         </foreach>
     </insert>
 
@@ -179,6 +171,12 @@
             <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('shelves')) or (colPickMode==1 and !data.containsKey('shelves'))">
+                a.shelves=#{data.shelves},
+            </if>
+            <if test="(colPickMode==0 and data.containsKey('shelvesIncrement')) or (colPickMode==1 and !data.containsKey('shelvesIncrement'))">
+                a.shelves=ifnull(a.shelves,0) + #{data.shelvesIncrement},
+            </if>
         </trim>
         <trim suffixOverrides="where" suffix="">
             where
@@ -191,133 +189,145 @@
     <update id="updateBatch" parameterType="paramDto">
         update mortals_xhx_product as a
         <trim prefix="set" suffixOverrides=",">
-                <trim prefix="productName=(case" suffix="ELSE productName end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('productName')) or (colPickMode==1 and !item.containsKey('productName'))">
-                            when a.id=#{item.id} then #{item.productName}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="productCode=(case" suffix="ELSE productCode end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('productCode')) or (colPickMode==1 and !item.containsKey('productCode'))">
-                            when a.id=#{item.id} then #{item.productCode}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="productSlogan=(case" suffix="ELSE productSlogan end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('productSlogan')) or (colPickMode==1 and !item.containsKey('productSlogan'))">
-                            when a.id=#{item.id} then #{item.productSlogan}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="productLogoPath=(case" suffix="ELSE productLogoPath end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('productLogoPath')) or (colPickMode==1 and !item.containsKey('productLogoPath'))">
-                            when a.id=#{item.id} then #{item.productLogoPath}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="productFacePath=(case" suffix="ELSE productFacePath end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('productFacePath')) or (colPickMode==1 and !item.containsKey('productFacePath'))">
-                            when a.id=#{item.id} then #{item.productFacePath}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="productVideoPath=(case" suffix="ELSE productVideoPath end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('productVideoPath')) or (colPickMode==1 and !item.containsKey('productVideoPath'))">
-                            when a.id=#{item.id} then #{item.productVideoPath}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="productPicPath=(case" suffix="ELSE productPicPath end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('productPicPath')) or (colPickMode==1 and !item.containsKey('productPicPath'))">
-                            when a.id=#{item.id} then #{item.productPicPath}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="productIntroduction=(case" suffix="ELSE productIntroduction end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('productIntroduction')) or (colPickMode==1 and !item.containsKey('productIntroduction'))">
-                            when a.id=#{item.id} then #{item.productIntroduction}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="productDetail=(case" suffix="ELSE productDetail end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('productDetail')) or (colPickMode==1 and !item.containsKey('productDetail'))">
-                            when a.id=#{item.id} then #{item.productDetail}
-                        </if>
-                    </foreach>
-                </trim>
-                <trim prefix="publishTime=(case" suffix="ELSE publishTime end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('publishTime')) or (colPickMode==1 and !item.containsKey('publishTime'))">
-                            when a.id=#{item.id} then #{item.publishTime}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="hot=(case" suffix="ELSE hot end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('hot')) or (colPickMode==1 and !item.containsKey('hot'))">
-                                        when a.id=#{item.id} then #{item.hot}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('hotIncrement')) or (colPickMode==1 and !item.containsKey('hotIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.hot,0) + #{item.hotIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="productRemark=(case" suffix="ELSE productRemark end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('productRemark')) or (colPickMode==1 and !item.containsKey('productRemark'))">
-                            when a.id=#{item.id} then #{item.productRemark}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
-                                        when a.id=#{item.id} then #{item.createUserId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="createTime=(case" suffix="ELSE createTime end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
-                            when a.id=#{item.id} then #{item.createTime}
-                        </if>
-                    </foreach>
-                </trim>
-                        <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
-                            <foreach collection="data.dataList" item="item" index="index" separator="" >
-                                <choose>
-                                    <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
-                                        when a.id=#{item.id} then #{item.updateUserId}
-                                    </when>
-                                    <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
-                                        when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
-                                    </when>
-                                </choose>
-                            </foreach>
-                        </trim>
-                <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
-                    <foreach collection="data.dataList" item="item" index="index" separator="" >
-                        <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
-                            when a.id=#{item.id} then #{item.updateTime}
-                        </if>
-                    </foreach>
-                </trim>
+            <trim prefix="productName=(case" suffix="ELSE productName end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('productName')) or (colPickMode==1 and !item.containsKey('productName'))">
+                        when a.id=#{item.id} then #{item.productName}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="productCode=(case" suffix="ELSE productCode end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('productCode')) or (colPickMode==1 and !item.containsKey('productCode'))">
+                        when a.id=#{item.id} then #{item.productCode}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="productSlogan=(case" suffix="ELSE productSlogan end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('productSlogan')) or (colPickMode==1 and !item.containsKey('productSlogan'))">
+                        when a.id=#{item.id} then #{item.productSlogan}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="productLogoPath=(case" suffix="ELSE productLogoPath end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('productLogoPath')) or (colPickMode==1 and !item.containsKey('productLogoPath'))">
+                        when a.id=#{item.id} then #{item.productLogoPath}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="productFacePath=(case" suffix="ELSE productFacePath end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('productFacePath')) or (colPickMode==1 and !item.containsKey('productFacePath'))">
+                        when a.id=#{item.id} then #{item.productFacePath}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="productVideoPath=(case" suffix="ELSE productVideoPath end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('productVideoPath')) or (colPickMode==1 and !item.containsKey('productVideoPath'))">
+                        when a.id=#{item.id} then #{item.productVideoPath}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="productPicPath=(case" suffix="ELSE productPicPath end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('productPicPath')) or (colPickMode==1 and !item.containsKey('productPicPath'))">
+                        when a.id=#{item.id} then #{item.productPicPath}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="productIntroduction=(case" suffix="ELSE productIntroduction end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('productIntroduction')) or (colPickMode==1 and !item.containsKey('productIntroduction'))">
+                        when a.id=#{item.id} then #{item.productIntroduction}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="productDetail=(case" suffix="ELSE productDetail end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('productDetail')) or (colPickMode==1 and !item.containsKey('productDetail'))">
+                        when a.id=#{item.id} then #{item.productDetail}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="publishTime=(case" suffix="ELSE publishTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('publishTime')) or (colPickMode==1 and !item.containsKey('publishTime'))">
+                        when a.id=#{item.id} then #{item.publishTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="hot=(case" suffix="ELSE hot end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('hot')) or (colPickMode==1 and !item.containsKey('hot'))">
+                            when a.id=#{item.id} then #{item.hot}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('hotIncrement')) or (colPickMode==1 and !item.containsKey('hotIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.hot,0) + #{item.hotIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="productRemark=(case" suffix="ELSE productRemark end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('productRemark')) or (colPickMode==1 and !item.containsKey('productRemark'))">
+                        when a.id=#{item.id} then #{item.productRemark}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="createUserId=(case" suffix="ELSE createUserId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('createUserId')) or (colPickMode==1 and !item.containsKey('createUserId'))">
+                            when a.id=#{item.id} then #{item.createUserId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('createUserIdIncrement')) or (colPickMode==1 and !item.containsKey('createUserIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.createUserId,0) + #{item.createUserIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="createTime=(case" suffix="ELSE createTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('createTime')) or (colPickMode==1 and !item.containsKey('createTime'))">
+                        when a.id=#{item.id} then #{item.createTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="updateUserId=(case" suffix="ELSE updateUserId end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('updateUserId')) or (colPickMode==1 and !item.containsKey('updateUserId'))">
+                            when a.id=#{item.id} then #{item.updateUserId}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('updateUserIdIncrement')) or (colPickMode==1 and !item.containsKey('updateUserIdIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.updateUserId,0) + #{item.updateUserIdIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
+            <trim prefix="updateTime=(case" suffix="ELSE updateTime end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <if test="(colPickMode==0 and item.containsKey('updateTime')) or (colPickMode==1 and !item.containsKey('updateTime'))">
+                        when a.id=#{item.id} then #{item.updateTime}
+                    </if>
+                </foreach>
+            </trim>
+            <trim prefix="shelves=(case" suffix="ELSE shelves end),">
+                <foreach collection="data.dataList" item="item" index="index" separator="" >
+                    <choose>
+                        <when test="(colPickMode==0 and item.containsKey('shelves')) or (colPickMode==1 and !item.containsKey('shelves'))">
+                            when a.id=#{item.id} then #{item.shelves}
+                        </when>
+                        <when test="(colPickMode==0 and item.containsKey('shelvesIncrement')) or (colPickMode==1 and !item.containsKey('shelvesIncrement'))">
+                            when a.id=#{item.id} then ifnull(a.shelves,0) + #{item.shelvesIncrement}
+                        </when>
+                    </choose>
+                </foreach>
+            </trim>
         </trim>
         where id in
         <foreach collection="data.dataList" item="item" index="index" open="(" separator="," close=")">
@@ -379,13 +389,6 @@
         <include refid="_orderCols_"/>
     </select>
     <!-- 获取子列表 -->
-    <select id="getProductQuestionByProductId" parameterType="java.lang.Long" resultMap="ProductQuestionEntity-Map">
-        select <include refid="_columns_sub"/>
-        from mortals_xhx_product_question as b
-        <trim suffixOverrides="where" suffix="">
-            where b.productId = #{id}
-        </trim>
-    </select>
 
 
 
@@ -437,474 +440,582 @@
     <!-- 条件映射-代参数 -->
     <sql id="_condition_param_">
         <bind name="conditionParamRef" value="${_conditionParam_}"/>
+        <if test="permissionSql != null and permissionSql != ''">
+            ${permissionSql}
+        </if>
+
         <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 test="conditionParamRef.containsKey('id')">
+            <if test="conditionParamRef.id != null ">
+                ${_conditionType_} a.id = #{${_conditionParam_}.id}
             </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 test="conditionParamRef.id == null">
+                ${_conditionType_} a.id is null
             </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('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('productName')">
+            <if test="conditionParamRef.productName != null and conditionParamRef.productName != ''">
+                ${_conditionType_} a.productName like #{${_conditionParam_}.productName}
             </if>
-            <if test="conditionParamRef.containsKey('idStart') and conditionParamRef.idStart != null">
-                ${_conditionType_} a.id <![CDATA[ >= ]]> #{${_conditionParam_}.idStart}
+            <if test="conditionParamRef.productName == null">
+                ${_conditionType_} a.productName is null
             </if>
-            <if test="conditionParamRef.containsKey('idEnd') and conditionParamRef.idEnd != null">
-                ${_conditionType_} a.id <![CDATA[ <= ]]> #{${_conditionParam_}.idEnd}
+        </if>
+        <if test="conditionParamRef.containsKey('productNameList') and conditionParamRef.productNameList.size() > 0">
+            ${_conditionType_} a.productName in
+            <foreach collection="conditionParamRef.productNameList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productNameNotList') and conditionParamRef.productNameNotList.size() > 0">
+            ${_conditionType_} a.productName not in
+            <foreach collection="conditionParamRef.productNameNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('productCode')">
+            <if test="conditionParamRef.productCode != null and conditionParamRef.productCode != ''">
+                ${_conditionType_} a.productCode like #{${_conditionParam_}.productCode}
+            </if>
+            <if test="conditionParamRef.productCode == null">
+                ${_conditionType_} a.productCode is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('productCodeList') and conditionParamRef.productCodeList.size() > 0">
+            ${_conditionType_} a.productCode in
+            <foreach collection="conditionParamRef.productCodeList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productCodeNotList') and conditionParamRef.productCodeNotList.size() > 0">
+            ${_conditionType_} a.productCode not in
+            <foreach collection="conditionParamRef.productCodeNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
+        <if test="conditionParamRef.containsKey('productSlogan')">
+            <if test="conditionParamRef.productSlogan != null and conditionParamRef.productSlogan != ''">
+                ${_conditionType_} a.productSlogan like #{${_conditionParam_}.productSlogan}
+            </if>
+            <if test="conditionParamRef.productSlogan == null">
+                ${_conditionType_} a.productSlogan is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('productSloganList') and conditionParamRef.productSloganList.size() > 0">
+            ${_conditionType_} a.productSlogan in
+            <foreach collection="conditionParamRef.productSloganList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productSloganNotList') and conditionParamRef.productSloganNotList.size() > 0">
+            ${_conditionType_} a.productSlogan not in
+            <foreach collection="conditionParamRef.productSloganNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('productName')">
-                <if test="conditionParamRef.productName != null and conditionParamRef.productName != ''">
-                    ${_conditionType_} a.productName like #{${_conditionParam_}.productName}
-                </if>
-                <if test="conditionParamRef.productName == null">
-                    ${_conditionType_} a.productName is null
-                </if>
+        <if test="conditionParamRef.containsKey('productLogoPath')">
+            <if test="conditionParamRef.productLogoPath != null and conditionParamRef.productLogoPath != ''">
+                ${_conditionType_} a.productLogoPath like #{${_conditionParam_}.productLogoPath}
             </if>
-            <if test="conditionParamRef.containsKey('productNameList') and conditionParamRef.productNameList.size() > 0">
-                ${_conditionType_} a.productName in
-                <foreach collection="conditionParamRef.productNameList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.productLogoPath == null">
+                ${_conditionType_} a.productLogoPath is null
             </if>
-            <if test="conditionParamRef.containsKey('productNameNotList') and conditionParamRef.productNameNotList.size() > 0">
-                ${_conditionType_} a.productName not in
-                <foreach collection="conditionParamRef.productNameNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productLogoPathList') and conditionParamRef.productLogoPathList.size() > 0">
+            ${_conditionType_} a.productLogoPath in
+            <foreach collection="conditionParamRef.productLogoPathList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productLogoPathNotList') and conditionParamRef.productLogoPathNotList.size() > 0">
+            ${_conditionType_} a.productLogoPath not in
+            <foreach collection="conditionParamRef.productLogoPathNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('productFacePath')">
+            <if test="conditionParamRef.productFacePath != null and conditionParamRef.productFacePath != ''">
+                ${_conditionType_} a.productFacePath like #{${_conditionParam_}.productFacePath}
+            </if>
+            <if test="conditionParamRef.productFacePath == null">
+                ${_conditionType_} a.productFacePath is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('productFacePathList') and conditionParamRef.productFacePathList.size() > 0">
+            ${_conditionType_} a.productFacePath in
+            <foreach collection="conditionParamRef.productFacePathList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productFacePathNotList') and conditionParamRef.productFacePathNotList.size() > 0">
+            ${_conditionType_} a.productFacePath not in
+            <foreach collection="conditionParamRef.productFacePathNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('productCode')">
-                <if test="conditionParamRef.productCode != null and conditionParamRef.productCode != ''">
-                    ${_conditionType_} a.productCode like #{${_conditionParam_}.productCode}
-                </if>
-                <if test="conditionParamRef.productCode == null">
-                    ${_conditionType_} a.productCode is null
-                </if>
+        <if test="conditionParamRef.containsKey('productVideoPath')">
+            <if test="conditionParamRef.productVideoPath != null and conditionParamRef.productVideoPath != ''">
+                ${_conditionType_} a.productVideoPath like #{${_conditionParam_}.productVideoPath}
             </if>
-            <if test="conditionParamRef.containsKey('productCodeList') and conditionParamRef.productCodeList.size() > 0">
-                ${_conditionType_} a.productCode in
-                <foreach collection="conditionParamRef.productCodeList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.productVideoPath == null">
+                ${_conditionType_} a.productVideoPath is null
             </if>
-            <if test="conditionParamRef.containsKey('productCodeNotList') and conditionParamRef.productCodeNotList.size() > 0">
-                ${_conditionType_} a.productCode not in
-                <foreach collection="conditionParamRef.productCodeNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productVideoPathList') and conditionParamRef.productVideoPathList.size() > 0">
+            ${_conditionType_} a.productVideoPath in
+            <foreach collection="conditionParamRef.productVideoPathList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productVideoPathNotList') and conditionParamRef.productVideoPathNotList.size() > 0">
+            ${_conditionType_} a.productVideoPath not in
+            <foreach collection="conditionParamRef.productVideoPathNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('productPicPath')">
+            <if test="conditionParamRef.productPicPath != null and conditionParamRef.productPicPath != ''">
+                ${_conditionType_} a.productPicPath like #{${_conditionParam_}.productPicPath}
             </if>
+            <if test="conditionParamRef.productPicPath == null">
+                ${_conditionType_} a.productPicPath is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('productPicPathList') and conditionParamRef.productPicPathList.size() > 0">
+            ${_conditionType_} a.productPicPath in
+            <foreach collection="conditionParamRef.productPicPathList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productPicPathNotList') and conditionParamRef.productPicPathNotList.size() > 0">
+            ${_conditionType_} a.productPicPath not in
+            <foreach collection="conditionParamRef.productPicPathNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('productSlogan')">
-                <if test="conditionParamRef.productSlogan != null and conditionParamRef.productSlogan != ''">
-                    ${_conditionType_} a.productSlogan like #{${_conditionParam_}.productSlogan}
-                </if>
-                <if test="conditionParamRef.productSlogan == null">
-                    ${_conditionType_} a.productSlogan is null
-                </if>
+        <if test="conditionParamRef.containsKey('productIntroduction')">
+            <if test="conditionParamRef.productIntroduction != null and conditionParamRef.productIntroduction != ''">
+                ${_conditionType_} a.productIntroduction like #{${_conditionParam_}.productIntroduction}
             </if>
-            <if test="conditionParamRef.containsKey('productSloganList') and conditionParamRef.productSloganList.size() > 0">
-                ${_conditionType_} a.productSlogan in
-                <foreach collection="conditionParamRef.productSloganList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.productIntroduction == null">
+                ${_conditionType_} a.productIntroduction is null
             </if>
-            <if test="conditionParamRef.containsKey('productSloganNotList') and conditionParamRef.productSloganNotList.size() > 0">
-                ${_conditionType_} a.productSlogan not in
-                <foreach collection="conditionParamRef.productSloganNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productIntroductionList') and conditionParamRef.productIntroductionList.size() > 0">
+            ${_conditionType_} a.productIntroduction in
+            <foreach collection="conditionParamRef.productIntroductionList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productIntroductionNotList') and conditionParamRef.productIntroductionNotList.size() > 0">
+            ${_conditionType_} a.productIntroduction not in
+            <foreach collection="conditionParamRef.productIntroductionNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+
+        <if test="conditionParamRef.containsKey('productDetail')">
+            <if test="conditionParamRef.productDetail != null and conditionParamRef.productDetail != ''">
+                ${_conditionType_} a.productDetail like #{${_conditionParam_}.productDetail}
             </if>
+            <if test="conditionParamRef.productDetail == null">
+                ${_conditionType_} a.productDetail is null
+            </if>
+        </if>
+        <if test="conditionParamRef.containsKey('productDetailList') and conditionParamRef.productDetailList.size() > 0">
+            ${_conditionType_} a.productDetail in
+            <foreach collection="conditionParamRef.productDetailList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productDetailNotList') and conditionParamRef.productDetailNotList.size() > 0">
+            ${_conditionType_} a.productDetail not in
+            <foreach collection="conditionParamRef.productDetailNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
 
-            <if test="conditionParamRef.containsKey('productLogoPath')">
-                <if test="conditionParamRef.productLogoPath != null and conditionParamRef.productLogoPath != ''">
-                    ${_conditionType_} a.productLogoPath like #{${_conditionParam_}.productLogoPath}
-                </if>
-                <if test="conditionParamRef.productLogoPath == null">
-                    ${_conditionType_} a.productLogoPath is null
-                </if>
+        <if test="conditionParamRef.containsKey('publishTime')">
+            <if test="conditionParamRef.publishTime != null ">
+                ${_conditionType_} a.publishTime = #{${_conditionParam_}.publishTime}
             </if>
-            <if test="conditionParamRef.containsKey('productLogoPathList') and conditionParamRef.productLogoPathList.size() > 0">
-                ${_conditionType_} a.productLogoPath in
-                <foreach collection="conditionParamRef.productLogoPathList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.publishTime == null">
+                ${_conditionType_} a.publishTime is null
             </if>
-            <if test="conditionParamRef.containsKey('productLogoPathNotList') and conditionParamRef.productLogoPathNotList.size() > 0">
-                ${_conditionType_} a.productLogoPath not in
-                <foreach collection="conditionParamRef.productLogoPathNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('publishTimeStart') and conditionParamRef.publishTimeStart != null and conditionParamRef.publishTimeStart!=''">
+            ${_conditionType_} a.publishTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.publishTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('publishTimeEnd') and conditionParamRef.publishTimeEnd != null and conditionParamRef.publishTimeEnd!=''">
+            ${_conditionType_} a.publishTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.publishTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('hot')">
+            <if test="conditionParamRef.hot != null ">
+                ${_conditionType_} a.hot = #{${_conditionParam_}.hot}
+            </if>
+            <if test="conditionParamRef.hot == null">
+                ${_conditionType_} a.hot is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('hotList') and conditionParamRef.hotList.size() > 0">
+            ${_conditionType_} a.hot in
+            <foreach collection="conditionParamRef.hotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('hotNotList') and conditionParamRef.hotNotList.size() > 0">
+            ${_conditionType_} a.hot not in
+            <foreach collection="conditionParamRef.hotNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('hotStart') and conditionParamRef.hotStart != null">
+            ${_conditionType_} a.hot <![CDATA[ >= ]]> #{${_conditionParam_}.hotStart}
+        </if>
+        <if test="conditionParamRef.containsKey('hotEnd') and conditionParamRef.hotEnd != null">
+            ${_conditionType_} a.hot <![CDATA[ <= ]]> #{${_conditionParam_}.hotEnd}
+        </if>
 
-            <if test="conditionParamRef.containsKey('productFacePath')">
-                <if test="conditionParamRef.productFacePath != null and conditionParamRef.productFacePath != ''">
-                    ${_conditionType_} a.productFacePath like #{${_conditionParam_}.productFacePath}
-                </if>
-                <if test="conditionParamRef.productFacePath == null">
-                    ${_conditionType_} a.productFacePath is null
-                </if>
+
+        <if test="conditionParamRef.containsKey('productRemark')">
+            <if test="conditionParamRef.productRemark != null and conditionParamRef.productRemark != ''">
+                ${_conditionType_} a.productRemark like #{${_conditionParam_}.productRemark}
             </if>
-            <if test="conditionParamRef.containsKey('productFacePathList') and conditionParamRef.productFacePathList.size() > 0">
-                ${_conditionType_} a.productFacePath in
-                <foreach collection="conditionParamRef.productFacePathList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.productRemark == null">
+                ${_conditionType_} a.productRemark is null
             </if>
-            <if test="conditionParamRef.containsKey('productFacePathNotList') and conditionParamRef.productFacePathNotList.size() > 0">
-                ${_conditionType_} a.productFacePath not in
-                <foreach collection="conditionParamRef.productFacePathNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productRemarkList') and conditionParamRef.productRemarkList.size() > 0">
+            ${_conditionType_} a.productRemark in
+            <foreach collection="conditionParamRef.productRemarkList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('productRemarkNotList') and conditionParamRef.productRemarkNotList.size() > 0">
+            ${_conditionType_} a.productRemark not in
+            <foreach collection="conditionParamRef.productRemarkNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserId')">
+            <if test="conditionParamRef.createUserId != null ">
+                ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
+            </if>
+            <if test="conditionParamRef.createUserId == null">
+                ${_conditionType_} a.createUserId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('createUserIdList') 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('productVideoPath')">
-                <if test="conditionParamRef.productVideoPath != null and conditionParamRef.productVideoPath != ''">
-                    ${_conditionType_} a.productVideoPath like #{${_conditionParam_}.productVideoPath}
-                </if>
-                <if test="conditionParamRef.productVideoPath == null">
-                    ${_conditionType_} a.productVideoPath is null
-                </if>
+
+        <if test="conditionParamRef.containsKey('createTime')">
+            <if test="conditionParamRef.createTime != null ">
+                ${_conditionType_} a.createTime = #{${_conditionParam_}.createTime}
             </if>
-            <if test="conditionParamRef.containsKey('productVideoPathList') and conditionParamRef.productVideoPathList.size() > 0">
-                ${_conditionType_} a.productVideoPath in
-                <foreach collection="conditionParamRef.productVideoPathList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.createTime == null">
+                ${_conditionType_} a.createTime is null
             </if>
-            <if test="conditionParamRef.containsKey('productVideoPathNotList') and conditionParamRef.productVideoPathNotList.size() > 0">
-                ${_conditionType_} a.productVideoPath not in
-                <foreach collection="conditionParamRef.productVideoPathNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
+            ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
+            ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserId')">
+            <if test="conditionParamRef.updateUserId != null ">
+                ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
+            </if>
+            <if test="conditionParamRef.updateUserId == null">
+                ${_conditionType_} a.updateUserId is null
             </if>
+        </if>
+        <if test="conditionParamRef.containsKey('updateUserIdList') 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('productPicPath')">
-                <if test="conditionParamRef.productPicPath != null and conditionParamRef.productPicPath != ''">
-                    ${_conditionType_} a.productPicPath like #{${_conditionParam_}.productPicPath}
-                </if>
-                <if test="conditionParamRef.productPicPath == null">
-                    ${_conditionType_} a.productPicPath is null
-                </if>
+
+        <if test="conditionParamRef.containsKey('updateTime')">
+            <if test="conditionParamRef.updateTime != null ">
+                ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
             </if>
-            <if test="conditionParamRef.containsKey('productPicPathList') and conditionParamRef.productPicPathList.size() > 0">
-                ${_conditionType_} a.productPicPath in
-                <foreach collection="conditionParamRef.productPicPathList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+            <if test="conditionParamRef.updateTime == null">
+                ${_conditionType_} a.updateTime is null
             </if>
-            <if test="conditionParamRef.containsKey('productPicPathNotList') and conditionParamRef.productPicPathNotList.size() > 0">
-                ${_conditionType_} a.productPicPath not in
-                <foreach collection="conditionParamRef.productPicPathNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
-                </foreach>
+        </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('shelves')">
+            <if test="conditionParamRef.shelves != null ">
+                ${_conditionType_} a.shelves = #{${_conditionParam_}.shelves}
             </if>
-
-            <if test="conditionParamRef.containsKey('productIntroduction')">
-                <if test="conditionParamRef.productIntroduction != null and conditionParamRef.productIntroduction != ''">
-                    ${_conditionType_} a.productIntroduction like #{${_conditionParam_}.productIntroduction}
-                </if>
-                <if test="conditionParamRef.productIntroduction == null">
-                    ${_conditionType_} a.productIntroduction is null
-                </if>
+            <if test="conditionParamRef.shelves == null">
+                ${_conditionType_} a.shelves is null
             </if>
-            <if test="conditionParamRef.containsKey('productIntroductionList') and conditionParamRef.productIntroductionList.size() > 0">
-                ${_conditionType_} a.productIntroduction in
-                <foreach collection="conditionParamRef.productIntroductionList" open="(" close=")" index="index" item="item" separator=",">
+        </if>
+        <if test="conditionParamRef.containsKey('shelvesList') and conditionParamRef.shelvesList.size() > 0">
+            ${_conditionType_} a.shelves in
+            <foreach collection="conditionParamRef.shelvesList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('shelvesNotList') and conditionParamRef.shelvesNotList.size() > 0">
+            ${_conditionType_} a.shelves not in
+            <foreach collection="conditionParamRef.shelvesNotList" open="(" close=")" index="index" item="item" separator=",">
+                #{item}
+            </foreach>
+        </if>
+        <if test="conditionParamRef.containsKey('shelvesStart') and conditionParamRef.shelvesStart != null">
+            ${_conditionType_} a.shelves <![CDATA[ >= ]]> #{${_conditionParam_}.shelvesStart}
+        </if>
+        <if test="conditionParamRef.containsKey('shelvesEnd') and conditionParamRef.shelvesEnd != null">
+            ${_conditionType_} a.shelves <![CDATA[ <= ]]> #{${_conditionParam_}.shelvesEnd}
+        </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('productIntroductionNotList') and conditionParamRef.productIntroductionNotList.size() > 0">
-                ${_conditionType_} a.productIntroduction not in
-                <foreach collection="conditionParamRef.productIntroductionNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('hotList') and conditionParamRef.hotList.size() > 0">
+                field(a.hot,
+                <foreach collection="conditionParamRef.hotList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-
-            <if test="conditionParamRef.containsKey('productDetail')">
-                <if test="conditionParamRef.productDetail != null and conditionParamRef.productDetail != ''">
-                    ${_conditionType_} a.productDetail like #{${_conditionParam_}.productDetail}
-                </if>
-                <if test="conditionParamRef.productDetail == null">
-                    ${_conditionType_} a.productDetail is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('productDetailList') and conditionParamRef.productDetailList.size() > 0">
-                ${_conditionType_} a.productDetail in
-                <foreach collection="conditionParamRef.productDetailList" open="(" close=")" index="index" item="item" separator=",">
+            <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('productDetailNotList') and conditionParamRef.productDetailNotList.size() > 0">
-                ${_conditionType_} a.productDetail not in
-                <foreach collection="conditionParamRef.productDetailNotList" open="(" close=")" index="index" item="item" separator=",">
+            <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>
-
-            <if test="conditionParamRef.containsKey('publishTime')">
-                <if test="conditionParamRef.publishTime != null ">
-                    ${_conditionType_} a.publishTime = #{${_conditionParam_}.publishTime}
-                </if>
-                <if test="conditionParamRef.publishTime == null">
-                    ${_conditionType_} a.publishTime is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('publishTimeStart') and conditionParamRef.publishTimeStart != null and conditionParamRef.publishTimeStart!=''">
-                ${_conditionType_} a.publishTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.publishTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
-            </if>
-            <if test="conditionParamRef.containsKey('publishTimeEnd') and conditionParamRef.publishTimeEnd != null and conditionParamRef.publishTimeEnd!=''">
-                ${_conditionType_} a.publishTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.publishTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
-            </if>
-            <if test="conditionParamRef.containsKey('hot')">
-                <if test="conditionParamRef.hot != null ">
-                    ${_conditionType_} a.hot = #{${_conditionParam_}.hot}
-                </if>
-                <if test="conditionParamRef.hot == null">
-                    ${_conditionType_} a.hot is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('hotList') and conditionParamRef.hotList.size() > 0">
-                ${_conditionType_} a.hot in
-                <foreach collection="conditionParamRef.hotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('shelvesList') and conditionParamRef.shelvesList.size() > 0">
+                field(a.shelves,
+                <foreach collection="conditionParamRef.shelvesList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
+                ,
             </if>
-            <if test="conditionParamRef.containsKey('hotNotList') and conditionParamRef.hotNotList.size() > 0">
-                ${_conditionType_} a.hot not in
-                <foreach collection="conditionParamRef.hotNotList" open="(" close=")" index="index" item="item" separator=",">
-                    #{item}
+            <trim suffixOverrides=","  suffix="">
+                <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
+                    a.${item.colName} ${item.sortKind}
                 </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('hotStart') and conditionParamRef.hotStart != null">
-                ${_conditionType_} a.hot <![CDATA[ >= ]]> #{${_conditionParam_}.hotStart}
-            </if>
-            <if test="conditionParamRef.containsKey('hotEnd') and conditionParamRef.hotEnd != null">
-                ${_conditionType_} a.hot <![CDATA[ <= ]]> #{${_conditionParam_}.hotEnd}
-            </if>
-
-
-            <if test="conditionParamRef.containsKey('productRemark')">
-                <if test="conditionParamRef.productRemark != null and conditionParamRef.productRemark != ''">
-                    ${_conditionType_} a.productRemark like #{${_conditionParam_}.productRemark}
-                </if>
-                <if test="conditionParamRef.productRemark == null">
-                    ${_conditionType_} a.productRemark is null
-                </if>
-            </if>
-            <if test="conditionParamRef.containsKey('productRemarkList') and conditionParamRef.productRemarkList.size() > 0">
-                ${_conditionType_} a.productRemark in
-                <foreach collection="conditionParamRef.productRemarkList" open="(" close=")" index="index" item="item" separator=",">
+            </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('productRemarkNotList') and conditionParamRef.productRemarkNotList.size() > 0">
-                ${_conditionType_} a.productRemark not in
-                <foreach collection="conditionParamRef.productRemarkNotList" open="(" close=")" index="index" item="item" separator=",">
+            <if test="conditionParamRef.containsKey('hotList') and conditionParamRef.hotList.size() > 0">
+                field(a.hot,
+                <foreach collection="conditionParamRef.hotList" open="" close=")" index="index" item="item" separator=",">
                     #{item}
                 </foreach>
-            </if>
-            <if test="conditionParamRef.containsKey('createUserId')">
-                <if test="conditionParamRef.createUserId != null ">
-                    ${_conditionType_} a.createUserId = #{${_conditionParam_}.createUserId}
-                </if>
-                <if test="conditionParamRef.createUserId == null">
-                    ${_conditionType_} a.createUserId is null
-                </if>
+                ,
             </if>
             <if test="conditionParamRef.containsKey('createUserIdList') and conditionParamRef.createUserIdList.size() > 0">
-                ${_conditionType_} a.createUserId in
-                <foreach collection="conditionParamRef.createUserIdList" open="(" close=")" index="index" item="item" separator=",">
+                field(a.createUserId,
+                <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=",">
+            <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>
-            <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 test="conditionParamRef.containsKey('shelvesList') and conditionParamRef.shelvesList.size() > 0">
+                field(a.shelves,
+                <foreach collection="conditionParamRef.shelvesList" 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}
+            <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="conditionParamRef.createTime == null">
-                    ${_conditionType_} a.createTime is null
+                <if test="orderCol.containsKey('productName')">
+                    a.productName
+                    <if test='orderCol.productName != null and "DESC".equalsIgnoreCase(orderCol.productName)'>DESC</if>
+                    ,
                 </if>
-            </if>
-            <if test="conditionParamRef.containsKey('createTimeStart') and conditionParamRef.createTimeStart != null and conditionParamRef.createTimeStart!=''">
-                ${_conditionType_} a.createTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
-            </if>
-            <if test="conditionParamRef.containsKey('createTimeEnd') and conditionParamRef.createTimeEnd != null and conditionParamRef.createTimeEnd!=''">
-                ${_conditionType_} a.createTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.createTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
-            </if>
-            <if test="conditionParamRef.containsKey('updateUserId')">
-                <if test="conditionParamRef.updateUserId != null ">
-                    ${_conditionType_} a.updateUserId = #{${_conditionParam_}.updateUserId}
+                <if test="orderCol.containsKey('productCode')">
+                    a.productCode
+                    <if test='orderCol.productCode != null and "DESC".equalsIgnoreCase(orderCol.productCode)'>DESC</if>
+                    ,
                 </if>
-                <if test="conditionParamRef.updateUserId == null">
-                    ${_conditionType_} a.updateUserId is null
+                <if test="orderCol.containsKey('productSlogan')">
+                    a.productSlogan
+                    <if test='orderCol.productSlogan != null and "DESC".equalsIgnoreCase(orderCol.productSlogan)'>DESC</if>
+                    ,
                 </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('updateTime')">
-                <if test="conditionParamRef.updateTime != null ">
-                    ${_conditionType_} a.updateTime = #{${_conditionParam_}.updateTime}
+                <if test="orderCol.containsKey('productLogoPath')">
+                    a.productLogoPath
+                    <if test='orderCol.productLogoPath != null and "DESC".equalsIgnoreCase(orderCol.productLogoPath)'>DESC</if>
+                    ,
                 </if>
-                <if test="conditionParamRef.updateTime == null">
-                    ${_conditionType_} a.updateTime is null
+                <if test="orderCol.containsKey('productFacePath')">
+                    a.productFacePath
+                    <if test='orderCol.productFacePath != null and "DESC".equalsIgnoreCase(orderCol.productFacePath)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('productVideoPath')">
+                    a.productVideoPath
+                    <if test='orderCol.productVideoPath != null and "DESC".equalsIgnoreCase(orderCol.productVideoPath)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('productPicPath')">
+                    a.productPicPath
+                    <if test='orderCol.productPicPath != null and "DESC".equalsIgnoreCase(orderCol.productPicPath)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('productIntroduction')">
+                    a.productIntroduction
+                    <if test='orderCol.productIntroduction != null and "DESC".equalsIgnoreCase(orderCol.productIntroduction)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('productDetail')">
+                    a.productDetail
+                    <if test='orderCol.productDetail != null and "DESC".equalsIgnoreCase(orderCol.productDetail)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('publishTime')">
+                    a.publishTime
+                    <if test='orderCol.publishTime != null and "DESC".equalsIgnoreCase(orderCol.publishTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('hot')">
+                    a.hot
+                    <if test='orderCol.hot != null and "DESC".equalsIgnoreCase(orderCol.hot)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('productRemark')">
+                    a.productRemark
+                    <if test='orderCol.productRemark != null and "DESC".equalsIgnoreCase(orderCol.productRemark)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('createUserId')">
+                    a.createUserId
+                    <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('createTime')">
+                    a.createTime
+                    <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('updateUserId')">
+                    a.updateUserId
+                    <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('updateTime')">
+                    a.updateTime
+                    <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
+                    ,
+                </if>
+                <if test="orderCol.containsKey('shelves')">
+                    a.shelves
+                    <if test='orderCol.shelves != null and "DESC".equalsIgnoreCase(orderCol.shelves)'>DESC</if>
+                    ,
                 </if>
-            </if>
-            <if test="conditionParamRef.containsKey('updateTimeStart') and conditionParamRef.updateTimeStart != null and conditionParamRef.updateTimeStart!=''">
-                ${_conditionType_} a.updateTime <![CDATA[ >= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeStart},' 00:00:00'),19),'%Y-%m-%d %k:%i:%s')
-            </if>
-            <if test="conditionParamRef.containsKey('updateTimeEnd') and conditionParamRef.updateTimeEnd != null and conditionParamRef.updateTimeEnd!=''">
-                ${_conditionType_} a.updateTime <![CDATA[ <= ]]> STR_TO_DATE(left(concat(#{${_conditionParam_}.updateTimeEnd},' 23:59:59'),19),'%Y-%m-%d %k:%i:%s')
-            </if>
-    </sql>
-    <sql id="_orderCols_">
-        <if test="orderColList != null and !orderColList.isEmpty()">
-            order by
-            <trim suffixOverrides=","  suffix="">
-                <foreach collection="orderColList" open="" close="" index="index" item="item" separator=",">
-                     ${item.colName} ${item.sortKind}
-                </foreach>
-            </trim>
-        </if>
-        <if test="(orderColList == null or orderColList.isEmpty()) and orderCol != null and !orderCol.isEmpty()">
-            order by
-            <trim suffixOverrides=","  suffix="">
-                    <if test="orderCol.containsKey('id')">
-                        a.id
-                        <if test='orderCol.id != null and "DESC".equalsIgnoreCase(orderCol.id)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('productName')">
-                        a.productName
-                        <if test='orderCol.productName != null and "DESC".equalsIgnoreCase(orderCol.productName)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('productCode')">
-                        a.productCode
-                        <if test='orderCol.productCode != null and "DESC".equalsIgnoreCase(orderCol.productCode)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('productSlogan')">
-                        a.productSlogan
-                        <if test='orderCol.productSlogan != null and "DESC".equalsIgnoreCase(orderCol.productSlogan)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('productLogoPath')">
-                        a.productLogoPath
-                        <if test='orderCol.productLogoPath != null and "DESC".equalsIgnoreCase(orderCol.productLogoPath)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('productFacePath')">
-                        a.productFacePath
-                        <if test='orderCol.productFacePath != null and "DESC".equalsIgnoreCase(orderCol.productFacePath)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('productVideoPath')">
-                        a.productVideoPath
-                        <if test='orderCol.productVideoPath != null and "DESC".equalsIgnoreCase(orderCol.productVideoPath)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('productPicPath')">
-                        a.productPicPath
-                        <if test='orderCol.productPicPath != null and "DESC".equalsIgnoreCase(orderCol.productPicPath)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('productIntroduction')">
-                        a.productIntroduction
-                        <if test='orderCol.productIntroduction != null and "DESC".equalsIgnoreCase(orderCol.productIntroduction)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('productDetail')">
-                        a.productDetail
-                        <if test='orderCol.productDetail != null and "DESC".equalsIgnoreCase(orderCol.productDetail)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('publishTime')">
-                        a.publishTime
-                        <if test='orderCol.publishTime != null and "DESC".equalsIgnoreCase(orderCol.publishTime)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('hot')">
-                        a.hot
-                        <if test='orderCol.hot != null and "DESC".equalsIgnoreCase(orderCol.hot)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('productRemark')">
-                        a.productRemark
-                        <if test='orderCol.productRemark != null and "DESC".equalsIgnoreCase(orderCol.productRemark)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('createUserId')">
-                        a.createUserId
-                        <if test='orderCol.createUserId != null and "DESC".equalsIgnoreCase(orderCol.createUserId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('createTime')">
-                        a.createTime
-                        <if test='orderCol.createTime != null and "DESC".equalsIgnoreCase(orderCol.createTime)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('updateUserId')">
-                        a.updateUserId
-                        <if test='orderCol.updateUserId != null and "DESC".equalsIgnoreCase(orderCol.updateUserId)'>DESC</if>
-                        ,
-                    </if>
-                    <if test="orderCol.containsKey('updateTime')">
-                        a.updateTime
-                        <if test='orderCol.updateTime != null and "DESC".equalsIgnoreCase(orderCol.updateTime)'>DESC</if>
-                        ,
-                    </if>
             </trim>
         </if>
+
+
     </sql>
     <sql id="_group_by_">
         <if test="groupList != null and !groupList.isEmpty()">