diff --git a/src/main/java/com/xmomen/module/order/entity/TbOrder.java b/src/main/java/com/xmomen/module/order/entity/TbOrder.java
index 1536fe4..a933628 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbOrder.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbOrder.java
@@ -14,7 +14,7 @@ import javax.persistence.Version;
 @Table(name = "tb_order")
 public class TbOrder extends BaseMybatisModel {
     /**
-     * 
+     *  订单ID
      */
     private Integer id;
 
diff --git a/src/main/java/com/xmomen/module/order/entity/TbOrderExample.java b/src/main/java/com/xmomen/module/order/entity/TbOrderExample.java
index 3bf4ad2..9b132d1 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbOrderExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbOrderExample.java
@@ -6,47 +6,60 @@ import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
-public class TbOrderExample extends BaseMybatisExample {
+public class
+TbOrderExample extends BaseMybatisExample {
+    // 排序字段
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化查询条件
     public TbOrderExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置排序字段
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序字段
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否去重
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取是否去重
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 添加查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -55,37 +68,46 @@ public class TbOrderExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // GeneratedCriteria 类，用于生成查询条件
     protected abstract static class GeneratedCriteria {
+        // 查询条件列表
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化查询条件列表
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -93,6 +115,7 @@ public class TbOrderExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -100,6 +123,7 @@ public class TbOrderExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -107,747 +131,897 @@ public class TbOrderExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 添加查询条件，ID为空
         public Criteria andIdIsNull() {
             addCriterion("ID is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID不为空
         public Criteria andIdIsNotNull() {
             addCriterion("ID is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID等于某个值
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID在某个值列表中
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID不在某个值列表中
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID在某个值范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ID不在某个值范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO为空
         public Criteria andOrderNoIsNull() {
             addCriterion("ORDER_NO is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO不为空
         public Criteria andOrderNoIsNotNull() {
             addCriterion("ORDER_NO is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO等于某个值
         public Criteria andOrderNoEqualTo(String value) {
             addCriterion("ORDER_NO =", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO不等于某个值
         public Criteria andOrderNoNotEqualTo(String value) {
             addCriterion("ORDER_NO <>", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO大于某个值
         public Criteria andOrderNoGreaterThan(String value) {
             addCriterion("ORDER_NO >", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO大于等于某个值
         public Criteria andOrderNoGreaterThanOrEqualTo(String value) {
             addCriterion("ORDER_NO >=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO小于某个值
         public Criteria andOrderNoLessThan(String value) {
             addCriterion("ORDER_NO <", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO小于等于某个值
         public Criteria andOrderNoLessThanOrEqualTo(String value) {
             addCriterion("ORDER_NO <=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO包含某个值
         public Criteria andOrderNoLike(String value) {
             addCriterion("ORDER_NO like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO不包含某个值
         public Criteria andOrderNoNotLike(String value) {
             addCriterion("ORDER_NO not like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO在某个值列表中
         public Criteria andOrderNoIn(List<String> values) {
             addCriterion("ORDER_NO in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO不在某个值列表中
         public Criteria andOrderNoNotIn(List<String> values) {
             addCriterion("ORDER_NO not in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO在某个值范围内
         public Criteria andOrderNoBetween(String value1, String value2) {
             addCriterion("ORDER_NO between", value1, value2, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_NO不在某个值范围内
         public Criteria andOrderNoNotBetween(String value1, String value2) {
             addCriterion("ORDER_NO not between", value1, value2, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE为空
         public Criteria andOrderTypeIsNull() {
             addCriterion("ORDER_TYPE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE不为空
         public Criteria andOrderTypeIsNotNull() {
             addCriterion("ORDER_TYPE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE等于某个值
         public Criteria andOrderTypeEqualTo(Integer value) {
             addCriterion("ORDER_TYPE =", value, "orderType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE不等于某个值
         public Criteria andOrderTypeNotEqualTo(Integer value) {
             addCriterion("ORDER_TYPE <>", value, "orderType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE大于某个值
         public Criteria andOrderTypeGreaterThan(Integer value) {
             addCriterion("ORDER_TYPE >", value, "orderType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE大于等于某个值
         public Criteria andOrderTypeGreaterThanOrEqualTo(Integer value) {
             addCriterion("ORDER_TYPE >=", value, "orderType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE小于某个值
         public Criteria andOrderTypeLessThan(Integer value) {
             addCriterion("ORDER_TYPE <", value, "orderType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE小于等于某个值
         public Criteria andOrderTypeLessThanOrEqualTo(Integer value) {
             addCriterion("ORDER_TYPE <=", value, "orderType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE在某个值列表中
         public Criteria andOrderTypeIn(List<Integer> values) {
             addCriterion("ORDER_TYPE in", values, "orderType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE不在某个值列表中
         public Criteria andOrderTypeNotIn(List<Integer> values) {
             addCriterion("ORDER_TYPE not in", values, "orderType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE在某个值范围内
         public Criteria andOrderTypeBetween(Integer value1, Integer value2) {
             addCriterion("ORDER_TYPE between", value1, value2, "orderType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_TYPE不在某个值范围内
         public Criteria andOrderTypeNotBetween(Integer value1, Integer value2) {
             addCriterion("ORDER_TYPE not between", value1, value2, "orderType");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE为空
         public Criteria andOrderSourceIsNull() {
             addCriterion("ORDER_SOURCE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE不为空
         public Criteria andOrderSourceIsNotNull() {
             addCriterion("ORDER_SOURCE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE等于某个值
         public Criteria andOrderSourceEqualTo(Integer value) {
             addCriterion("ORDER_SOURCE =", value, "orderSource");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE不等于某个值
         public Criteria andOrderSourceNotEqualTo(Integer value) {
             addCriterion("ORDER_SOURCE <>", value, "orderSource");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE大于某个值
         public Criteria andOrderSourceGreaterThan(Integer value) {
             addCriterion("ORDER_SOURCE >", value, "orderSource");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE大于等于某个值
         public Criteria andOrderSourceGreaterThanOrEqualTo(Integer value) {
             addCriterion("ORDER_SOURCE >=", value, "orderSource");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE小于某个值
         public Criteria andOrderSourceLessThan(Integer value) {
             addCriterion("ORDER_SOURCE <", value, "orderSource");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE小于等于某个值
         public Criteria andOrderSourceLessThanOrEqualTo(Integer value) {
             addCriterion("ORDER_SOURCE <=", value, "orderSource");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE在某个值列表中
         public Criteria andOrderSourceIn(List<Integer> values) {
             addCriterion("ORDER_SOURCE in", values, "orderSource");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE不在某个值列表中
         public Criteria andOrderSourceNotIn(List<Integer> values) {
             addCriterion("ORDER_SOURCE not in", values, "orderSource");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE在某个值范围内
         public Criteria andOrderSourceBetween(Integer value1, Integer value2) {
             addCriterion("ORDER_SOURCE between", value1, value2, "orderSource");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_SOURCE不在某个值范围内
         public Criteria andOrderSourceNotBetween(Integer value1, Integer value2) {
             addCriterion("ORDER_SOURCE not between", value1, value2, "orderSource");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE为空
         public Criteria andPaymentModeIsNull() {
             addCriterion("PAYMENT_MODE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE不为空
         public Criteria andPaymentModeIsNotNull() {
             addCriterion("PAYMENT_MODE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE等于某个值
         public Criteria andPaymentModeEqualTo(Integer value) {
             addCriterion("PAYMENT_MODE =", value, "paymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE不等于某个值
         public Criteria andPaymentModeNotEqualTo(Integer value) {
             addCriterion("PAYMENT_MODE <>", value, "paymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE大于某个值
         public Criteria andPaymentModeGreaterThan(Integer value) {
             addCriterion("PAYMENT_MODE >", value, "paymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE大于等于某个值
         public Criteria andPaymentModeGreaterThanOrEqualTo(Integer value) {
             addCriterion("PAYMENT_MODE >=", value, "paymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE小于某个值
         public Criteria andPaymentModeLessThan(Integer value) {
             addCriterion("PAYMENT_MODE <", value, "paymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE小于等于某个值
         public Criteria andPaymentModeLessThanOrEqualTo(Integer value) {
             addCriterion("PAYMENT_MODE <=", value, "paymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE在某个值列表中
         public Criteria andPaymentModeIn(List<Integer> values) {
             addCriterion("PAYMENT_MODE in", values, "paymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE不在某个值列表中
         public Criteria andPaymentModeNotIn(List<Integer> values) {
             addCriterion("PAYMENT_MODE not in", values, "paymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE在某个值范围内
         public Criteria andPaymentModeBetween(Integer value1, Integer value2) {
             addCriterion("PAYMENT_MODE between", value1, value2, "paymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAYMENT_MODE不在某个值范围内
         public Criteria andPaymentModeNotBetween(Integer value1, Integer value2) {
             addCriterion("PAYMENT_MODE not between", value1, value2, "paymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE为空
         public Criteria andOtherPaymentModeIsNull() {
             addCriterion("OTHER_PAYMENT_MODE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE不为空
         public Criteria andOtherPaymentModeIsNotNull() {
             addCriterion("OTHER_PAYMENT_MODE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE等于某个值
         public Criteria andOtherPaymentModeEqualTo(Integer value) {
             addCriterion("OTHER_PAYMENT_MODE =", value, "otherPaymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE不等于某个值
         public Criteria andOtherPaymentModeNotEqualTo(Integer value) {
             addCriterion("OTHER_PAYMENT_MODE <>", value, "otherPaymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE大于某个值
         public Criteria andOtherPaymentModeGreaterThan(Integer value) {
             addCriterion("OTHER_PAYMENT_MODE >", value, "otherPaymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE大于等于某个值
         public Criteria andOtherPaymentModeGreaterThanOrEqualTo(Integer value) {
             addCriterion("OTHER_PAYMENT_MODE >=", value, "otherPaymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE小于某个值
         public Criteria andOtherPaymentModeLessThan(Integer value) {
             addCriterion("OTHER_PAYMENT_MODE <", value, "otherPaymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE小于等于某个值
         public Criteria andOtherPaymentModeLessThanOrEqualTo(Integer value) {
             addCriterion("OTHER_PAYMENT_MODE <=", value, "otherPaymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE在某个值列表中
         public Criteria andOtherPaymentModeIn(List<Integer> values) {
             addCriterion("OTHER_PAYMENT_MODE in", values, "otherPaymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE不在某个值列表中
         public Criteria andOtherPaymentModeNotIn(List<Integer> values) {
             addCriterion("OTHER_PAYMENT_MODE not in", values, "otherPaymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE在某个值范围内
         public Criteria andOtherPaymentModeBetween(Integer value1, Integer value2) {
             addCriterion("OTHER_PAYMENT_MODE between", value1, value2, "otherPaymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，OTHER_PAYMENT_MODE不在某个值范围内
         public Criteria andOtherPaymentModeNotBetween(Integer value1, Integer value2) {
             addCriterion("OTHER_PAYMENT_MODE not between", value1, value2, "otherPaymentMode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE为空
         public Criteria andMemberCodeIsNull() {
             addCriterion("MEMBER_CODE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE不为空
         public Criteria andMemberCodeIsNotNull() {
             addCriterion("MEMBER_CODE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE等于某个值
         public Criteria andMemberCodeEqualTo(String value) {
             addCriterion("MEMBER_CODE =", value, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE不等于某个值
         public Criteria andMemberCodeNotEqualTo(String value) {
             addCriterion("MEMBER_CODE <>", value, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE大于某个值
         public Criteria andMemberCodeGreaterThan(String value) {
             addCriterion("MEMBER_CODE >", value, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE大于等于某个值
         public Criteria andMemberCodeGreaterThanOrEqualTo(String value) {
             addCriterion("MEMBER_CODE >=", value, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE小于某个值
         public Criteria andMemberCodeLessThan(String value) {
             addCriterion("MEMBER_CODE <", value, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE小于等于某个值
         public Criteria andMemberCodeLessThanOrEqualTo(String value) {
             addCriterion("MEMBER_CODE <=", value, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE包含某个值
         public Criteria andMemberCodeLike(String value) {
             addCriterion("MEMBER_CODE like", value, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE不包含某个值
         public Criteria andMemberCodeNotLike(String value) {
             addCriterion("MEMBER_CODE not like", value, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE在某个值列表中
         public Criteria andMemberCodeIn(List<String> values) {
             addCriterion("MEMBER_CODE in", values, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE不在某个值列表中
         public Criteria andMemberCodeNotIn(List<String> values) {
             addCriterion("MEMBER_CODE not in", values, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE在某个值范围内
         public Criteria andMemberCodeBetween(String value1, String value2) {
             addCriterion("MEMBER_CODE between", value1, value2, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，MEMBER_CODE不在某个值范围内
         public Criteria andMemberCodeNotBetween(String value1, String value2) {
             addCriterion("MEMBER_CODE not between", value1, value2, "memberCode");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS为空
         public Criteria andOrderStatusIsNull() {
             addCriterion("ORDER_STATUS is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS不为空
         public Criteria andOrderStatusIsNotNull() {
             addCriterion("ORDER_STATUS is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS等于某个值
         public Criteria andOrderStatusEqualTo(String value) {
             addCriterion("ORDER_STATUS =", value, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS不等于某个值
         public Criteria andOrderStatusNotEqualTo(String value) {
             addCriterion("ORDER_STATUS <>", value, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS大于某个值
         public Criteria andOrderStatusGreaterThan(String value) {
             addCriterion("ORDER_STATUS >", value, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS大于等于某个值
         public Criteria andOrderStatusGreaterThanOrEqualTo(String value) {
             addCriterion("ORDER_STATUS >=", value, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS小于某个值
         public Criteria andOrderStatusLessThan(String value) {
             addCriterion("ORDER_STATUS <", value, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS小于等于某个值
         public Criteria andOrderStatusLessThanOrEqualTo(String value) {
             addCriterion("ORDER_STATUS <=", value, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS包含某个值
         public Criteria andOrderStatusLike(String value) {
             addCriterion("ORDER_STATUS like", value, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS不包含某个值
         public Criteria andOrderStatusNotLike(String value) {
             addCriterion("ORDER_STATUS not like", value, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS在某个值列表中
         public Criteria andOrderStatusIn(List<String> values) {
             addCriterion("ORDER_STATUS in", values, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS不在某个值列表中
         public Criteria andOrderStatusNotIn(List<String> values) {
             addCriterion("ORDER_STATUS not in", values, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS在某个值范围内
         public Criteria andOrderStatusBetween(String value1, String value2) {
             addCriterion("ORDER_STATUS between", value1, value2, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，ORDER_STATUS不在某个值范围内
         public Criteria andOrderStatusNotBetween(String value1, String value2) {
             addCriterion("ORDER_STATUS not between", value1, value2, "orderStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS为空
         public Criteria andPayStatusIsNull() {
             addCriterion("PAY_STATUS is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS不为空
         public Criteria andPayStatusIsNotNull() {
             addCriterion("PAY_STATUS is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS等于某个值
         public Criteria andPayStatusEqualTo(Integer value) {
             addCriterion("PAY_STATUS =", value, "payStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS不等于某个值
         public Criteria andPayStatusNotEqualTo(Integer value) {
             addCriterion("PAY_STATUS <>", value, "payStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS大于某个值
         public Criteria andPayStatusGreaterThan(Integer value) {
             addCriterion("PAY_STATUS >", value, "payStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS大于等于某个值
         public Criteria andPayStatusGreaterThanOrEqualTo(Integer value) {
             addCriterion("PAY_STATUS >=", value, "payStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS小于某个值
         public Criteria andPayStatusLessThan(Integer value) {
             addCriterion("PAY_STATUS <", value, "payStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS小于等于某个值
         public Criteria andPayStatusLessThanOrEqualTo(Integer value) {
             addCriterion("PAY_STATUS <=", value, "payStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS在某个值列表中
         public Criteria andPayStatusIn(List<Integer> values) {
             addCriterion("PAY_STATUS in", values, "payStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS不在某个值列表中
         public Criteria andPayStatusNotIn(List<Integer> values) {
             addCriterion("PAY_STATUS not in", values, "payStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS在某个值范围内
         public Criteria andPayStatusBetween(Integer value1, Integer value2) {
             addCriterion("PAY_STATUS between", value1, value2, "payStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，PAY_STATUS不在某个值范围内
         public Criteria andPayStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("PAY_STATUS not between", value1, value2, "payStatus");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE为空
         public Criteria andConsigneePhoneIsNull() {
             addCriterion("CONSIGNEE_PHONE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE不为空
         public Criteria andConsigneePhoneIsNotNull() {
             addCriterion("CONSIGNEE_PHONE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE等于某个值
         public Criteria andConsigneePhoneEqualTo(String value) {
             addCriterion("CONSIGNEE_PHONE =", value, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE不等于某个值
         public Criteria andConsigneePhoneNotEqualTo(String value) {
             addCriterion("CONSIGNEE_PHONE <>", value, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE大于某个值
         public Criteria andConsigneePhoneGreaterThan(String value) {
             addCriterion("CONSIGNEE_PHONE >", value, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE大于等于某个值
         public Criteria andConsigneePhoneGreaterThanOrEqualTo(String value) {
             addCriterion("CONSIGNEE_PHONE >=", value, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE小于某个值
         public Criteria andConsigneePhoneLessThan(String value) {
             addCriterion("CONSIGNEE_PHONE <", value, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE小于等于某个值
         public Criteria andConsigneePhoneLessThanOrEqualTo(String value) {
             addCriterion("CONSIGNEE_PHONE <=", value, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE包含某个值
         public Criteria andConsigneePhoneLike(String value) {
             addCriterion("CONSIGNEE_PHONE like", value, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE不包含某个值
         public Criteria andConsigneePhoneNotLike(String value) {
             addCriterion("CONSIGNEE_PHONE not like", value, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE在某个值列表中
         public Criteria andConsigneePhoneIn(List<String> values) {
             addCriterion("CONSIGNEE_PHONE in", values, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE不在某个值列表中
         public Criteria andConsigneePhoneNotIn(List<String> values) {
             addCriterion("CONSIGNEE_PHONE not in", values, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE在某个值范围内
         public Criteria andConsigneePhoneBetween(String value1, String value2) {
             addCriterion("CONSIGNEE_PHONE between", value1, value2, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_PHONE不在某个值范围内
         public Criteria andConsigneePhoneNotBetween(String value1, String value2) {
             addCriterion("CONSIGNEE_PHONE not between", value1, value2, "consigneePhone");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME为空
         public Criteria andConsigneeNameIsNull() {
             addCriterion("CONSIGNEE_NAME is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME不为空
         public Criteria andConsigneeNameIsNotNull() {
             addCriterion("CONSIGNEE_NAME is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME等于某个值
         public Criteria andConsigneeNameEqualTo(String value) {
             addCriterion("CONSIGNEE_NAME =", value, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME不等于某个值
         public Criteria andConsigneeNameNotEqualTo(String value) {
             addCriterion("CONSIGNEE_NAME <>", value, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME大于某个值
         public Criteria andConsigneeNameGreaterThan(String value) {
             addCriterion("CONSIGNEE_NAME >", value, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME大于等于某个值
         public Criteria andConsigneeNameGreaterThanOrEqualTo(String value) {
             addCriterion("CONSIGNEE_NAME >=", value, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME小于某个值
         public Criteria andConsigneeNameLessThan(String value) {
             addCriterion("CONSIGNEE_NAME <", value, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME小于等于某个值
         public Criteria andConsigneeNameLessThanOrEqualTo(String value) {
             addCriterion("CONSIGNEE_NAME <=", value, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME包含某个值
         public Criteria andConsigneeNameLike(String value) {
             addCriterion("CONSIGNEE_NAME like", value, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME不包含某个值
         public Criteria andConsigneeNameNotLike(String value) {
             addCriterion("CONSIGNEE_NAME not like", value, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME在某个值列表中
         public Criteria andConsigneeNameIn(List<String> values) {
             addCriterion("CONSIGNEE_NAME in", values, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME不在某个值列表中
         public Criteria andConsigneeNameNotIn(List<String> values) {
             addCriterion("CONSIGNEE_NAME not in", values, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME在某个值范围内
         public Criteria andConsigneeNameBetween(String value1, String value2) {
             addCriterion("CONSIGNEE_NAME between", value1, value2, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_NAME不在某个值范围内
         public Criteria andConsigneeNameNotBetween(String value1, String value2) {
             addCriterion("CONSIGNEE_NAME not between", value1, value2, "consigneeName");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_ADDRESS为空
         public Criteria andConsigneeAddressIsNull() {
             addCriterion("CONSIGNEE_ADDRESS is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_ADDRESS不为空
         public Criteria andConsigneeAddressIsNotNull() {
             addCriterion("CONSIGNEE_ADDRESS is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_ADDRESS等于某个值
         public Criteria andConsigneeAddressEqualTo(String value) {
             addCriterion("CONSIGNEE_ADDRESS =", value, "consigneeAddress");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_ADDRESS不等于某个值
         public Criteria andConsigneeAddressNotEqualTo(String value) {
             addCriterion("CONSIGNEE_ADDRESS <>", value, "consigneeAddress");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_ADDRESS大于某个值
         public Criteria andConsigneeAddressGreaterThan(String value) {
             addCriterion("CONSIGNEE_ADDRESS >", value, "consigneeAddress");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_ADDRESS大于等于某个值
         public Criteria andConsigneeAddressGreaterThanOrEqualTo(String value) {
             addCriterion("CONSIGNEE_ADDRESS >=", value, "consigneeAddress");
             return (Criteria) this;
         }
 
+        // 添加查询条件，CONSIGNEE_ADDRESS小于某个值
         public Criteria andConsigneeAddressLessThan(String value) {
+            // 添加查询条件，CONSIGNEE_ADDRESS小于value
             addCriterion("CONSIGNEE_ADDRESS <", value, "consigneeAddress");
             return (Criteria) this;
         }
diff --git a/src/main/java/com/xmomen/module/order/entity/TbOrderItemExample.java b/src/main/java/com/xmomen/module/order/entity/TbOrderItemExample.java
index 68a1963..8b75ed2 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbOrderItemExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbOrderItemExample.java
@@ -6,47 +6,60 @@ import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
+// 订单项示例类
 public class TbOrderItemExample extends BaseMybatisExample {
+    // 排序字段
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数
     public TbOrderItemExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置排序字段
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序字段
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否去重
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取是否去重
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -55,37 +68,46 @@ public class TbOrderItemExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 生成查询条件
     protected abstract static class GeneratedCriteria {
+        // 查询条件列表
         protected List<Criterion> criteria;
 
+        // 构造函数
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -93,6 +115,7 @@ public class TbOrderItemExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -100,6 +123,7 @@ public class TbOrderItemExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -107,371 +131,445 @@ public class TbOrderItemExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 添加ID为空的查询条件
         public Criteria andIdIsNull() {
             addCriterion("ID is null");
             return (Criteria) this;
         }
 
+        // 添加ID不为空的查询条件
         public Criteria andIdIsNotNull() {
             addCriterion("ID is not null");
             return (Criteria) this;
         }
 
+        // 添加ID等于指定值的查询条件
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 添加ID不等于指定值的查询条件
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 添加ID大于指定值的查询条件
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 添加ID大于等于指定值的查询条件
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加ID小于指定值的查询条件
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 添加ID小于等于指定值的查询条件
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加ID在指定值列表中的查询条件
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加ID不在指定值列表中的查询条件
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加ID在指定值之间的查询条件
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加ID不在指定值之间的查询条件
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加订单号为空的查询条件
         public Criteria andOrderNoIsNull() {
             addCriterion("ORDER_NO is null");
             return (Criteria) this;
         }
 
+        // 添加订单号不为空的查询条件
         public Criteria andOrderNoIsNotNull() {
             addCriterion("ORDER_NO is not null");
             return (Criteria) this;
         }
 
+        // 添加订单号等于指定值的查询条件
         public Criteria andOrderNoEqualTo(String value) {
             addCriterion("ORDER_NO =", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号不等于指定值的查询条件
         public Criteria andOrderNoNotEqualTo(String value) {
             addCriterion("ORDER_NO <>", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号大于指定值的查询条件
         public Criteria andOrderNoGreaterThan(String value) {
             addCriterion("ORDER_NO >", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号大于等于指定值的查询条件
         public Criteria andOrderNoGreaterThanOrEqualTo(String value) {
             addCriterion("ORDER_NO >=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号小于指定值的查询条件
         public Criteria andOrderNoLessThan(String value) {
             addCriterion("ORDER_NO <", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号小于等于指定值的查询条件
         public Criteria andOrderNoLessThanOrEqualTo(String value) {
             addCriterion("ORDER_NO <=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号包含指定值的查询条件
         public Criteria andOrderNoLike(String value) {
             addCriterion("ORDER_NO like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号不包含指定值的查询条件
         public Criteria andOrderNoNotLike(String value) {
             addCriterion("ORDER_NO not like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号在指定值列表中的查询条件
         public Criteria andOrderNoIn(List<String> values) {
             addCriterion("ORDER_NO in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号不在指定值列表中的查询条件
         public Criteria andOrderNoNotIn(List<String> values) {
             addCriterion("ORDER_NO not in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号在指定值之间的查询条件
         public Criteria andOrderNoBetween(String value1, String value2) {
             addCriterion("ORDER_NO between", value1, value2, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加订单号不在指定值之间的查询条件
         public Criteria andOrderNoNotBetween(String value1, String value2) {
             addCriterion("ORDER_NO not between", value1, value2, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加商品ID为空的查询条件
         public Criteria andItemIdIsNull() {
             addCriterion("ITEM_ID is null");
             return (Criteria) this;
         }
 
+        // 添加商品ID不为空的查询条件
         public Criteria andItemIdIsNotNull() {
             addCriterion("ITEM_ID is not null");
             return (Criteria) this;
         }
 
+        // 添加商品ID等于指定值的查询条件
         public Criteria andItemIdEqualTo(Integer value) {
             addCriterion("ITEM_ID =", value, "itemId");
             return (Criteria) this;
         }
 
+        // 添加商品ID不等于指定值的查询条件
         public Criteria andItemIdNotEqualTo(Integer value) {
             addCriterion("ITEM_ID <>", value, "itemId");
             return (Criteria) this;
         }
 
+        // 添加商品ID大于指定值的查询条件
         public Criteria andItemIdGreaterThan(Integer value) {
             addCriterion("ITEM_ID >", value, "itemId");
             return (Criteria) this;
         }
 
+        // 添加商品ID大于等于指定值的查询条件
         public Criteria andItemIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ITEM_ID >=", value, "itemId");
             return (Criteria) this;
         }
 
+        // 添加商品ID小于指定值的查询条件
         public Criteria andItemIdLessThan(Integer value) {
             addCriterion("ITEM_ID <", value, "itemId");
             return (Criteria) this;
         }
 
+        // 添加商品ID小于等于指定值的查询条件
         public Criteria andItemIdLessThanOrEqualTo(Integer value) {
             addCriterion("ITEM_ID <=", value, "itemId");
             return (Criteria) this;
         }
 
+        // 添加商品ID在指定值列表中的查询条件
         public Criteria andItemIdIn(List<Integer> values) {
             addCriterion("ITEM_ID in", values, "itemId");
             return (Criteria) this;
         }
 
+        // 添加商品ID不在指定值列表中的查询条件
         public Criteria andItemIdNotIn(List<Integer> values) {
             addCriterion("ITEM_ID not in", values, "itemId");
             return (Criteria) this;
         }
 
+        // 添加商品ID在指定值之间的查询条件
         public Criteria andItemIdBetween(Integer value1, Integer value2) {
             addCriterion("ITEM_ID between", value1, value2, "itemId");
             return (Criteria) this;
         }
 
+        // 添加商品ID不在指定值之间的查询条件
         public Criteria andItemIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ITEM_ID not between", value1, value2, "itemId");
             return (Criteria) this;
         }
 
+        // 添加商品编码为空的查询条件
         public Criteria andItemCodeIsNull() {
             addCriterion("ITEM_CODE is null");
             return (Criteria) this;
         }
 
+        // 添加商品编码不为空的查询条件
         public Criteria andItemCodeIsNotNull() {
             addCriterion("ITEM_CODE is not null");
             return (Criteria) this;
         }
 
+        // 添加商品编码等于指定值的查询条件
         public Criteria andItemCodeEqualTo(String value) {
             addCriterion("ITEM_CODE =", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码不等于指定值的查询条件
         public Criteria andItemCodeNotEqualTo(String value) {
             addCriterion("ITEM_CODE <>", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码大于指定值的查询条件
         public Criteria andItemCodeGreaterThan(String value) {
             addCriterion("ITEM_CODE >", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码大于等于指定值的查询条件
         public Criteria andItemCodeGreaterThanOrEqualTo(String value) {
             addCriterion("ITEM_CODE >=", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码小于指定值的查询条件
         public Criteria andItemCodeLessThan(String value) {
             addCriterion("ITEM_CODE <", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码小于等于指定值的查询条件
         public Criteria andItemCodeLessThanOrEqualTo(String value) {
             addCriterion("ITEM_CODE <=", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码包含指定值的查询条件
         public Criteria andItemCodeLike(String value) {
             addCriterion("ITEM_CODE like", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码不包含指定值的查询条件
         public Criteria andItemCodeNotLike(String value) {
             addCriterion("ITEM_CODE not like", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码在指定值列表中的查询条件
         public Criteria andItemCodeIn(List<String> values) {
             addCriterion("ITEM_CODE in", values, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码不在指定值列表中的查询条件
         public Criteria andItemCodeNotIn(List<String> values) {
             addCriterion("ITEM_CODE not in", values, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码在指定值之间的查询条件
         public Criteria andItemCodeBetween(String value1, String value2) {
             addCriterion("ITEM_CODE between", value1, value2, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品编码不在指定值之间的查询条件
         public Criteria andItemCodeNotBetween(String value1, String value2) {
             addCriterion("ITEM_CODE not between", value1, value2, "itemCode");
             return (Criteria) this;
         }
 
+        // 添加商品名称为空的查询条件
         public Criteria andItemNameIsNull() {
             addCriterion("ITEM_NAME is null");
             return (Criteria) this;
         }
 
+        // 添加商品名称不为空的查询条件
         public Criteria andItemNameIsNotNull() {
             addCriterion("ITEM_NAME is not null");
             return (Criteria) this;
         }
 
+        // 添加商品名称等于指定值的查询条件
         public Criteria andItemNameEqualTo(String value) {
             addCriterion("ITEM_NAME =", value, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称不等于指定值的查询条件
         public Criteria andItemNameNotEqualTo(String value) {
             addCriterion("ITEM_NAME <>", value, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称大于指定值的查询条件
         public Criteria andItemNameGreaterThan(String value) {
             addCriterion("ITEM_NAME >", value, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称大于等于指定值的查询条件
         public Criteria andItemNameGreaterThanOrEqualTo(String value) {
             addCriterion("ITEM_NAME >=", value, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称小于指定值的查询条件
         public Criteria andItemNameLessThan(String value) {
             addCriterion("ITEM_NAME <", value, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称小于等于指定值的查询条件
         public Criteria andItemNameLessThanOrEqualTo(String value) {
             addCriterion("ITEM_NAME <=", value, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称包含指定值的查询条件
         public Criteria andItemNameLike(String value) {
             addCriterion("ITEM_NAME like", value, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称不包含指定值的查询条件
         public Criteria andItemNameNotLike(String value) {
             addCriterion("ITEM_NAME not like", value, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称在指定值列表中的查询条件
         public Criteria andItemNameIn(List<String> values) {
             addCriterion("ITEM_NAME in", values, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称不在指定值列表中的查询条件
         public Criteria andItemNameNotIn(List<String> values) {
             addCriterion("ITEM_NAME not in", values, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称在指定值之间的查询条件
         public Criteria andItemNameBetween(String value1, String value2) {
             addCriterion("ITEM_NAME between", value1, value2, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品名称不在指定值之间的查询条件
         public Criteria andItemNameNotBetween(String value1, String value2) {
             addCriterion("ITEM_NAME not between", value1, value2, "itemName");
             return (Criteria) this;
         }
 
+        // 添加商品价格为空的查询条件
         public Criteria andItemPriceIsNull() {
             addCriterion("ITEM_PRICE is null");
             return (Criteria) this;
         }
 
+        // 添加商品价格不为空的查询条件
         public Criteria andItemPriceIsNotNull() {
             addCriterion("ITEM_PRICE is not null");
             return (Criteria) this;
         }
 
+        // 添加商品价格等于指定值的查询条件
         public Criteria andItemPriceEqualTo(BigDecimal value) {
             addCriterion("ITEM_PRICE =", value, "itemPrice");
             return (Criteria) this;
         }
 
+        // 添加商品价格不等于指定值的查询条件
         public Criteria andItemPriceNotEqualTo(BigDecimal value) {
             addCriterion("ITEM_PRICE <>", value, "itemPrice");
             return (Criteria) this;
         }
 
+        // 添加商品价格大于指定值的查询条件
         public Criteria andItemPriceGreaterThan(BigDecimal value) {
             addCriterion("ITEM_PRICE >", value, "itemPrice");
             return (Criteria) this;
         }
 
+        // 添加商品价格大于等于指定值的查询条件
         public Criteria andItemPriceGreaterThanOrEqualTo(BigDecimal value) {
             addCriterion("ITEM_PRICE >=", value, "itemPrice");
             return (Criteria) this;
         }
 
+        // 添加商品价格小于指定值的查询条件
         public Criteria andItemPriceLessThan(BigDecimal value) {
             addCriterion("ITEM_PRICE <", value, "itemPrice");
             return (Criteria) this;
         }
 
+        // 添加商品价格小于等于指定值的查询条件
         public Criteria andItemPriceLessThanOrEqualTo(BigDecimal value) {
             addCriterion("ITEM_PRICE <=", value, "itemPrice");
             return (Criteria) this;
diff --git a/src/main/java/com/xmomen/module/order/entity/TbOrderRefExample.java b/src/main/java/com/xmomen/module/order/entity/TbOrderRefExample.java
index e851fe7..5586ecd 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbOrderRefExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbOrderRefExample.java
@@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
 import java.util.ArrayList;
 import java.util.List;
 
+// 定义一个TbOrderRefExample类，继承自BaseMybatisExample类
 public class TbOrderRefExample extends BaseMybatisExample {
+    // 定义一个orderByClause变量，用于存储排序的子句
     protected String orderByClause;
 
+    // 定义一个distinct变量，用于存储是否去重的标志
     protected boolean distinct;
 
+    // 定义一个oredCriteria变量，用于存储查询条件的列表
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria变量
     public TbOrderRefExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置orderByClause变量的值
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取orderByClause变量的值
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置distinct变量的值
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取distinct变量的值
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取oredCriteria变量的值
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加一个查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建一个新的查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建一个新的查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -53,37 +66,46 @@ public class TbOrderRefExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建一个新的查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空oredCriteria变量和orderByClause变量以及distinct变量的值
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 定义一个GeneratedCriteria内部类，用于生成查询条件
     protected abstract static class GeneratedCriteria {
+        // 定义一个criteria变量，用于存储查询条件的列表
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria变量
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有的查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加一个查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -91,6 +113,7 @@ public class TbOrderRefExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加一个查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -98,6 +121,7 @@ public class TbOrderRefExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加一个查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -105,277 +129,332 @@ public class TbOrderRefExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 判断ID是否为空
         public Criteria andIdIsNull() {
             addCriterion("ID is null");
             return (Criteria) this;
         }
 
+        // 判断ID是否不为空
         public Criteria andIdIsNotNull() {
             addCriterion("ID is not null");
             return (Criteria) this;
         }
 
+        // 判断ID是否等于某个值
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否为空
         public Criteria andRefTypeIsNull() {
             addCriterion("REF_TYPE is null");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否不为空
         public Criteria andRefTypeIsNotNull() {
             addCriterion("REF_TYPE is not null");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否等于某个值
         public Criteria andRefTypeEqualTo(String value) {
             addCriterion("REF_TYPE =", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否不等于某个值
         public Criteria andRefTypeNotEqualTo(String value) {
             addCriterion("REF_TYPE <>", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否大于某个值
         public Criteria andRefTypeGreaterThan(String value) {
             addCriterion("REF_TYPE >", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否大于等于某个值
         public Criteria andRefTypeGreaterThanOrEqualTo(String value) {
             addCriterion("REF_TYPE >=", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否小于某个值
         public Criteria andRefTypeLessThan(String value) {
             addCriterion("REF_TYPE <", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否小于等于某个值
         public Criteria andRefTypeLessThanOrEqualTo(String value) {
             addCriterion("REF_TYPE <=", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否包含某个值
         public Criteria andRefTypeLike(String value) {
             addCriterion("REF_TYPE like", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否不包含某个值
         public Criteria andRefTypeNotLike(String value) {
             addCriterion("REF_TYPE not like", value, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否在某个范围内
         public Criteria andRefTypeIn(List<String> values) {
             addCriterion("REF_TYPE in", values, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否不在某个范围内
         public Criteria andRefTypeNotIn(List<String> values) {
             addCriterion("REF_TYPE not in", values, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否在某个范围内
         public Criteria andRefTypeBetween(String value1, String value2) {
             addCriterion("REF_TYPE between", value1, value2, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_TYPE是否不在某个范围内
         public Criteria andRefTypeNotBetween(String value1, String value2) {
             addCriterion("REF_TYPE not between", value1, value2, "refType");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否为空
         public Criteria andRefValueIsNull() {
             addCriterion("REF_VALUE is null");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否不为空
         public Criteria andRefValueIsNotNull() {
             addCriterion("REF_VALUE is not null");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否等于某个值
         public Criteria andRefValueEqualTo(String value) {
             addCriterion("REF_VALUE =", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否不等于某个值
         public Criteria andRefValueNotEqualTo(String value) {
             addCriterion("REF_VALUE <>", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否大于某个值
         public Criteria andRefValueGreaterThan(String value) {
             addCriterion("REF_VALUE >", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否大于等于某个值
         public Criteria andRefValueGreaterThanOrEqualTo(String value) {
             addCriterion("REF_VALUE >=", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否小于某个值
         public Criteria andRefValueLessThan(String value) {
             addCriterion("REF_VALUE <", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否小于等于某个值
         public Criteria andRefValueLessThanOrEqualTo(String value) {
             addCriterion("REF_VALUE <=", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否包含某个值
         public Criteria andRefValueLike(String value) {
             addCriterion("REF_VALUE like", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否不包含某个值
         public Criteria andRefValueNotLike(String value) {
             addCriterion("REF_VALUE not like", value, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否在某个范围内
         public Criteria andRefValueIn(List<String> values) {
             addCriterion("REF_VALUE in", values, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否不在某个范围内
         public Criteria andRefValueNotIn(List<String> values) {
             addCriterion("REF_VALUE not in", values, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否在某个范围内
         public Criteria andRefValueBetween(String value1, String value2) {
             addCriterion("REF_VALUE between", value1, value2, "refValue");
             return (Criteria) this;
         }
 
+        // 判断REF_VALUE是否不在某个范围内
         public Criteria andRefValueNotBetween(String value1, String value2) {
             addCriterion("REF_VALUE not between", value1, value2, "refValue");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否为空
         public Criteria andOrderNoIsNull() {
             addCriterion("ORDER_NO is null");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否不为空
         public Criteria andOrderNoIsNotNull() {
             addCriterion("ORDER_NO is not null");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否等于某个值
         public Criteria andOrderNoEqualTo(String value) {
             addCriterion("ORDER_NO =", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否不等于某个值
         public Criteria andOrderNoNotEqualTo(String value) {
             addCriterion("ORDER_NO <>", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否大于某个值
         public Criteria andOrderNoGreaterThan(String value) {
             addCriterion("ORDER_NO >", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否大于等于某个值
         public Criteria andOrderNoGreaterThanOrEqualTo(String value) {
             addCriterion("ORDER_NO >=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否小于某个值
         public Criteria andOrderNoLessThan(String value) {
             addCriterion("ORDER_NO <", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否小于等于某个值
         public Criteria andOrderNoLessThanOrEqualTo(String value) {
             addCriterion("ORDER_NO <=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否包含某个值
         public Criteria andOrderNoLike(String value) {
             addCriterion("ORDER_NO like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否不包含某个值
         public Criteria andOrderNoNotLike(String value) {
             addCriterion("ORDER_NO not like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否在某个范围内
         public Criteria andOrderNoIn(List<String> values) {
             addCriterion("ORDER_NO in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否不在某个范围内
         public Criteria andOrderNoNotIn(List<String> values) {
             addCriterion("ORDER_NO not in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否在某个范围内
         public Criteria andOrderNoBetween(String value1, String value2) {
             addCriterion("ORDER_NO between", value1, value2, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断ORDER_NO是否不在某个范围内
         public Criteria andOrderNoNotBetween(String value1, String value2) {
             addCriterion("ORDER_NO not between", value1, value2, "orderNo");
             return (Criteria) this;
         }
     }
 
+    // 定义一个Criteria内部类，继承自GeneratedCriteria类
     public static class Criteria extends GeneratedCriteria {
 
         protected Criteria() {
@@ -383,6 +462,7 @@ public class TbOrderRefExample extends BaseMybatisExample {
         }
     }
 
+    // 定义一个Criterion内部类，用于存储查询条件的详细信息
     public static class Criterion {
         private String condition;
 
@@ -400,38 +480,47 @@ public class TbOrderRefExample extends BaseMybatisExample {
 
         private String typeHandler;
 
+        // 获取查询条件的condition
         public String getCondition() {
             return condition;
         }
 
+        // 获取查询条件的value
         public Object getValue() {
             return value;
         }
 
+        // 获取查询条件的secondValue
         public Object getSecondValue() {
             return secondValue;
         }
 
+        // 判断查询条件是否没有值
         public boolean isNoValue() {
             return noValue;
         }
 
+        // 判断查询条件是否只有一个值
         public boolean isSingleValue() {
             return singleValue;
         }
 
+        // 判断查询条件是否在某个范围内
         public boolean isBetweenValue() {
             return betweenValue;
         }
 
+        // 判断查询条件是否在某个范围内
         public boolean isListValue() {
             return listValue;
         }
 
+        // 获取查询条件的typeHandler
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 构造函数，初始化condition变量
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -439,6 +528,7 @@ public class TbOrderRefExample extends BaseMybatisExample {
             this.noValue = true;
         }
 
+        // 构造函数，初始化condition、value和typeHandler变量
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -451,10 +541,12 @@ public class TbOrderRefExample extends BaseMybatisExample {
             }
         }
 
+        // 构造函数，初始化condition和value变量
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 构造函数，初始化condition、value、secondValue和typeHandler变量
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -464,6 +556,7 @@ public class TbOrderRefExample extends BaseMybatisExample {
             this.betweenValue = true;
         }
 
+        // 构造函数，初始化condition、value和secondValue变量
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }
diff --git a/src/main/java/com/xmomen/module/order/entity/TbOrderRelationExample.java b/src/main/java/com/xmomen/module/order/entity/TbOrderRelationExample.java
index 5dad5a2..2356814 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbOrderRelationExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbOrderRelationExample.java
@@ -5,46 +5,57 @@ import java.util.ArrayList;
 import java.util.List;
 
 public class TbOrderRelationExample extends BaseMybatisExample {
+    // 排序字段
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 查询条件
     protected List<Criteria> oredCriteria;
 
     public TbOrderRelationExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置排序字段
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序字段
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否去重
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取是否去重
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -53,17 +64,20 @@ public class TbOrderRelationExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 生成查询条件
     protected abstract static class GeneratedCriteria {
         protected List<Criterion> criteria;
 
@@ -72,18 +86,22 @@ public class TbOrderRelationExample extends BaseMybatisExample {
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -91,6 +109,7 @@ public class TbOrderRelationExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -98,6 +117,7 @@ public class TbOrderRelationExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -105,277 +125,332 @@ public class TbOrderRelationExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 添加查询条件
         public Criteria andIdIsNull() {
             addCriterion("ID is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdIsNotNull() {
             addCriterion("ID is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeIsNull() {
             addCriterion("REF_TYPE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeIsNotNull() {
             addCriterion("REF_TYPE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeEqualTo(String value) {
             addCriterion("REF_TYPE =", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeNotEqualTo(String value) {
             addCriterion("REF_TYPE <>", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeGreaterThan(String value) {
             addCriterion("REF_TYPE >", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeGreaterThanOrEqualTo(String value) {
             addCriterion("REF_TYPE >=", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeLessThan(String value) {
             addCriterion("REF_TYPE <", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeLessThanOrEqualTo(String value) {
             addCriterion("REF_TYPE <=", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeLike(String value) {
             addCriterion("REF_TYPE like", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeNotLike(String value) {
             addCriterion("REF_TYPE not like", value, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeIn(List<String> values) {
             addCriterion("REF_TYPE in", values, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeNotIn(List<String> values) {
             addCriterion("REF_TYPE not in", values, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeBetween(String value1, String value2) {
             addCriterion("REF_TYPE between", value1, value2, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefTypeNotBetween(String value1, String value2) {
             addCriterion("REF_TYPE not between", value1, value2, "refType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueIsNull() {
             addCriterion("REF_VALUE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueIsNotNull() {
             addCriterion("REF_VALUE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueEqualTo(String value) {
             addCriterion("REF_VALUE =", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueNotEqualTo(String value) {
             addCriterion("REF_VALUE <>", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueGreaterThan(String value) {
             addCriterion("REF_VALUE >", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueGreaterThanOrEqualTo(String value) {
             addCriterion("REF_VALUE >=", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueLessThan(String value) {
             addCriterion("REF_VALUE <", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueLessThanOrEqualTo(String value) {
             addCriterion("REF_VALUE <=", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueLike(String value) {
             addCriterion("REF_VALUE like", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueNotLike(String value) {
             addCriterion("REF_VALUE not like", value, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueIn(List<String> values) {
             addCriterion("REF_VALUE in", values, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueNotIn(List<String> values) {
             addCriterion("REF_VALUE not in", values, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueBetween(String value1, String value2) {
             addCriterion("REF_VALUE between", value1, value2, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRefValueNotBetween(String value1, String value2) {
             addCriterion("REF_VALUE not between", value1, value2, "refValue");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoIsNull() {
             addCriterion("ORDER_NO is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoIsNotNull() {
             addCriterion("ORDER_NO is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoEqualTo(String value) {
             addCriterion("ORDER_NO =", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoNotEqualTo(String value) {
             addCriterion("ORDER_NO <>", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoGreaterThan(String value) {
             addCriterion("ORDER_NO >", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoGreaterThanOrEqualTo(String value) {
             addCriterion("ORDER_NO >=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoLessThan(String value) {
             addCriterion("ORDER_NO <", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoLessThanOrEqualTo(String value) {
             addCriterion("ORDER_NO <=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoLike(String value) {
             addCriterion("ORDER_NO like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoNotLike(String value) {
             addCriterion("ORDER_NO not like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoIn(List<String> values) {
             addCriterion("ORDER_NO in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoNotIn(List<String> values) {
             addCriterion("ORDER_NO not in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoBetween(String value1, String value2) {
             addCriterion("ORDER_NO between", value1, value2, "orderNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderNoNotBetween(String value1, String value2) {
             addCriterion("ORDER_NO not between", value1, value2, "orderNo");
             return (Criteria) this;
         }
     }
 
+    // 查询条件
     public static class Criteria extends GeneratedCriteria {
 
         protected Criteria() {
@@ -383,6 +458,7 @@ public class TbOrderRelationExample extends BaseMybatisExample {
         }
     }
 
+    // 查询条件
     public static class Criterion {
         private String condition;
 
@@ -400,38 +476,47 @@ public class TbOrderRelationExample extends BaseMybatisExample {
 
         private String typeHandler;
 
+        // 获取查询条件
         public String getCondition() {
             return condition;
         }
 
+        // 获取查询条件
         public Object getValue() {
             return value;
         }
 
+        // 获取查询条件
         public Object getSecondValue() {
             return secondValue;
         }
 
+        // 判断查询条件是否为空
         public boolean isNoValue() {
             return noValue;
         }
 
+        // 判断查询条件是否为单个值
         public boolean isSingleValue() {
             return singleValue;
         }
 
+        // 判断查询条件是否为范围值
         public boolean isBetweenValue() {
             return betweenValue;
         }
 
+        // 判断查询条件是否为列表值
         public boolean isListValue() {
             return listValue;
         }
 
+        // 获取查询条件
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 创建查询条件
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -439,6 +524,7 @@ public class TbOrderRelationExample extends BaseMybatisExample {
             this.noValue = true;
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -451,10 +537,12 @@ public class TbOrderRelationExample extends BaseMybatisExample {
             }
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -464,6 +552,7 @@ public class TbOrderRelationExample extends BaseMybatisExample {
             this.betweenValue = true;
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }
diff --git a/src/main/java/com/xmomen/module/order/entity/TbOrderSendLogExample.java b/src/main/java/com/xmomen/module/order/entity/TbOrderSendLogExample.java
index 10efd31..29dee51 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbOrderSendLogExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbOrderSendLogExample.java
@@ -6,46 +6,57 @@ import java.util.Date;
 import java.util.List;
 
 public class TbOrderSendLogExample extends BaseMybatisExample {
+    // 排序字段
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 查询条件
     protected List<Criteria> oredCriteria;
 
     public TbOrderSendLogExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置排序字段
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序字段
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否去重
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取是否去重
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -54,18 +65,22 @@ public class TbOrderSendLogExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 查询条件内部类
     protected abstract static class GeneratedCriteria {
+        // 查询条件列表
         protected List<Criterion> criteria;
 
         protected GeneratedCriteria() {
@@ -73,18 +88,22 @@ public class TbOrderSendLogExample extends BaseMybatisExample {
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -92,6 +111,7 @@ public class TbOrderSendLogExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -99,6 +119,7 @@ public class TbOrderSendLogExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -106,41 +127,49 @@ public class TbOrderSendLogExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 判断id是否为空
         public Criteria andIdIsNull() {
             addCriterion("id is null");
             return (Criteria) this;
         }
 
+        // 判断id是否不为空
         public Criteria andIdIsNotNull() {
             addCriterion("id is not null");
             return (Criteria) this;
         }
 
+        // 判断id是否等于某个值
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("id =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("id <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("id >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("id >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("id <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断id是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("id <=", value, "id");
             return (Criteria) this;
diff --git a/src/main/java/com/xmomen/module/order/entity/TbPacking.java b/src/main/java/com/xmomen/module/order/entity/TbPacking.java
index 86fb1a4..1ff6145 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbPacking.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbPacking.java
@@ -13,7 +13,7 @@ import javax.persistence.Version;
 @Table(name = "tb_packing")
 public class TbPacking extends BaseMybatisModel {
     /**
-     * 
+     *  主键ID
      */
     private Integer id;
 
diff --git a/src/main/java/com/xmomen/module/order/entity/TbPackingExample.java b/src/main/java/com/xmomen/module/order/entity/TbPackingExample.java
index d94d9ab..85c0c7e 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbPackingExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbPackingExample.java
@@ -6,46 +6,57 @@ import java.util.Date;
 import java.util.List;
 
 public class TbPackingExample extends BaseMybatisExample {
+    // 排序字段
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 查询条件
     protected List<Criteria> oredCriteria;
 
     public TbPackingExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置排序字段
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序字段
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否去重
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取是否去重
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -54,17 +65,20 @@ public class TbPackingExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 生成查询条件
     protected abstract static class GeneratedCriteria {
         protected List<Criterion> criteria;
 
@@ -73,18 +87,22 @@ public class TbPackingExample extends BaseMybatisExample {
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -92,6 +110,7 @@ public class TbPackingExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -99,6 +118,7 @@ public class TbPackingExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -106,257 +126,308 @@ public class TbPackingExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 判断ID是否为空
         public Criteria andIdIsNull() {
             addCriterion("ID is null");
             return (Criteria) this;
         }
 
+        // 判断ID是否不为空
         public Criteria andIdIsNotNull() {
             addCriterion("ID is not null");
             return (Criteria) this;
         }
 
+        // 判断ID是否等于某个值
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否为空
         public Criteria andPackingNoIsNull() {
             addCriterion("PACKING_NO is null");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否不为空
         public Criteria andPackingNoIsNotNull() {
             addCriterion("PACKING_NO is not null");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否等于某个值
         public Criteria andPackingNoEqualTo(String value) {
             addCriterion("PACKING_NO =", value, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否不等于某个值
         public Criteria andPackingNoNotEqualTo(String value) {
             addCriterion("PACKING_NO <>", value, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否大于某个值
         public Criteria andPackingNoGreaterThan(String value) {
             addCriterion("PACKING_NO >", value, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否大于等于某个值
         public Criteria andPackingNoGreaterThanOrEqualTo(String value) {
             addCriterion("PACKING_NO >=", value, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否小于某个值
         public Criteria andPackingNoLessThan(String value) {
             addCriterion("PACKING_NO <", value, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否小于等于某个值
         public Criteria andPackingNoLessThanOrEqualTo(String value) {
             addCriterion("PACKING_NO <=", value, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否包含某个值
         public Criteria andPackingNoLike(String value) {
             addCriterion("PACKING_NO like", value, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否不包含某个值
         public Criteria andPackingNoNotLike(String value) {
             addCriterion("PACKING_NO not like", value, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否在某个范围内
         public Criteria andPackingNoIn(List<String> values) {
             addCriterion("PACKING_NO in", values, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否不在某个范围内
         public Criteria andPackingNoNotIn(List<String> values) {
             addCriterion("PACKING_NO not in", values, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否在某个范围内
         public Criteria andPackingNoBetween(String value1, String value2) {
             addCriterion("PACKING_NO between", value1, value2, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_NO是否不在某个范围内
         public Criteria andPackingNoNotBetween(String value1, String value2) {
             addCriterion("PACKING_NO not between", value1, value2, "packingNo");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否为空
         public Criteria andPackingTimeIsNull() {
             addCriterion("PACKING_TIME is null");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否不为空
         public Criteria andPackingTimeIsNotNull() {
             addCriterion("PACKING_TIME is not null");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否等于某个值
         public Criteria andPackingTimeEqualTo(Date value) {
             addCriterion("PACKING_TIME =", value, "packingTime");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否不等于某个值
         public Criteria andPackingTimeNotEqualTo(Date value) {
             addCriterion("PACKING_TIME <>", value, "packingTime");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否大于某个值
         public Criteria andPackingTimeGreaterThan(Date value) {
             addCriterion("PACKING_TIME >", value, "packingTime");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否大于等于某个值
         public Criteria andPackingTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("PACKING_TIME >=", value, "packingTime");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否小于某个值
         public Criteria andPackingTimeLessThan(Date value) {
             addCriterion("PACKING_TIME <", value, "packingTime");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否小于等于某个值
         public Criteria andPackingTimeLessThanOrEqualTo(Date value) {
             addCriterion("PACKING_TIME <=", value, "packingTime");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否在某个范围内
         public Criteria andPackingTimeIn(List<Date> values) {
             addCriterion("PACKING_TIME in", values, "packingTime");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否不在某个范围内
         public Criteria andPackingTimeNotIn(List<Date> values) {
             addCriterion("PACKING_TIME not in", values, "packingTime");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否在某个范围内
         public Criteria andPackingTimeBetween(Date value1, Date value2) {
             addCriterion("PACKING_TIME between", value1, value2, "packingTime");
             return (Criteria) this;
         }
 
+        // 判断PACKING_TIME是否不在某个范围内
         public Criteria andPackingTimeNotBetween(Date value1, Date value2) {
             addCriterion("PACKING_TIME not between", value1, value2, "packingTime");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否为空
         public Criteria andPackingStatusIsNull() {
             addCriterion("PACKING_STATUS is null");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否不为空
         public Criteria andPackingStatusIsNotNull() {
             addCriterion("PACKING_STATUS is not null");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否等于某个值
         public Criteria andPackingStatusEqualTo(Integer value) {
             addCriterion("PACKING_STATUS =", value, "packingStatus");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否不等于某个值
         public Criteria andPackingStatusNotEqualTo(Integer value) {
             addCriterion("PACKING_STATUS <>", value, "packingStatus");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否大于某个值
         public Criteria andPackingStatusGreaterThan(Integer value) {
             addCriterion("PACKING_STATUS >", value, "packingStatus");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否大于等于某个值
         public Criteria andPackingStatusGreaterThanOrEqualTo(Integer value) {
             addCriterion("PACKING_STATUS >=", value, "packingStatus");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否小于某个值
         public Criteria andPackingStatusLessThan(Integer value) {
             addCriterion("PACKING_STATUS <", value, "packingStatus");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否小于等于某个值
         public Criteria andPackingStatusLessThanOrEqualTo(Integer value) {
             addCriterion("PACKING_STATUS <=", value, "packingStatus");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否在某个范围内
         public Criteria andPackingStatusIn(List<Integer> values) {
             addCriterion("PACKING_STATUS in", values, "packingStatus");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否不在某个范围内
         public Criteria andPackingStatusNotIn(List<Integer> values) {
             addCriterion("PACKING_STATUS not in", values, "packingStatus");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否在某个范围内
         public Criteria andPackingStatusBetween(Integer value1, Integer value2) {
             addCriterion("PACKING_STATUS between", value1, value2, "packingStatus");
             return (Criteria) this;
         }
 
+        // 判断PACKING_STATUS是否不在某个范围内
         public Criteria andPackingStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("PACKING_STATUS not between", value1, value2, "packingStatus");
             return (Criteria) this;
         }
     }
 
+    // 查询条件
     public static class Criteria extends GeneratedCriteria {
 
         protected Criteria() {
@@ -364,6 +435,7 @@ public class TbPackingExample extends BaseMybatisExample {
         }
     }
 
+    // 查询条件
     public static class Criterion {
         private String condition;
 
@@ -381,38 +453,47 @@ public class TbPackingExample extends BaseMybatisExample {
 
         private String typeHandler;
 
+        // 获取查询条件
         public String getCondition() {
             return condition;
         }
 
+        // 获取查询条件
         public Object getValue() {
             return value;
         }
 
+        // 获取查询条件
         public Object getSecondValue() {
             return secondValue;
         }
 
+        // 判断查询条件是否为空
         public boolean isNoValue() {
             return noValue;
         }
 
+        // 判断查询条件是否为单个值
         public boolean isSingleValue() {
             return singleValue;
         }
 
+        // 判断查询条件是否在某个范围内
         public boolean isBetweenValue() {
             return betweenValue;
         }
 
+        // 判断查询条件是否在某个范围内
         public boolean isListValue() {
             return listValue;
         }
 
+        // 获取查询条件
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 创建查询条件
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -420,6 +501,7 @@ public class TbPackingExample extends BaseMybatisExample {
             this.noValue = true;
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -432,10 +514,12 @@ public class TbPackingExample extends BaseMybatisExample {
             }
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -445,6 +529,7 @@ public class TbPackingExample extends BaseMybatisExample {
             this.betweenValue = true;
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }
diff --git a/src/main/java/com/xmomen/module/order/entity/TbPackingRecord.java b/src/main/java/com/xmomen/module/order/entity/TbPackingRecord.java
index 7311d54..38bb881 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbPackingRecord.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbPackingRecord.java
@@ -13,7 +13,7 @@ import javax.persistence.Version;
 @Table(name = "tb_packing_record")
 public class TbPackingRecord extends BaseMybatisModel {
     /**
-     * 
+     *  主键ID
      */
     private Integer id;
 
diff --git a/src/main/java/com/xmomen/module/order/entity/TbPackingRecordExample.java b/src/main/java/com/xmomen/module/order/entity/TbPackingRecordExample.java
index fdee8c2..8064ec4 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbPackingRecordExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbPackingRecordExample.java
@@ -6,46 +6,57 @@ import java.util.Date;
 import java.util.List;
 
 public class TbPackingRecordExample extends BaseMybatisExample {
+    // 排序字段
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 查询条件
     protected List<Criteria> oredCriteria;
 
     public TbPackingRecordExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置排序字段
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序字段
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否去重
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取是否去重
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -54,17 +65,20 @@ public class TbPackingRecordExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 生成查询条件
     protected abstract static class GeneratedCriteria {
         protected List<Criterion> criteria;
 
@@ -73,18 +87,22 @@ public class TbPackingRecordExample extends BaseMybatisExample {
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -92,6 +110,7 @@ public class TbPackingRecordExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -99,6 +118,7 @@ public class TbPackingRecordExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -106,317 +126,380 @@ public class TbPackingRecordExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 添加查询条件
         public Criteria andIdIsNull() {
             addCriterion("ID is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdIsNotNull() {
             addCriterion("ID is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcIsNull() {
             addCriterion("UPC is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcIsNotNull() {
             addCriterion("UPC is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcEqualTo(String value) {
             addCriterion("UPC =", value, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcNotEqualTo(String value) {
             addCriterion("UPC <>", value, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcGreaterThan(String value) {
             addCriterion("UPC >", value, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcGreaterThanOrEqualTo(String value) {
             addCriterion("UPC >=", value, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcLessThan(String value) {
             addCriterion("UPC <", value, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcLessThanOrEqualTo(String value) {
             addCriterion("UPC <=", value, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcLike(String value) {
             addCriterion("UPC like", value, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcNotLike(String value) {
             addCriterion("UPC not like", value, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcIn(List<String> values) {
             addCriterion("UPC in", values, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcNotIn(List<String> values) {
             addCriterion("UPC not in", values, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcBetween(String value1, String value2) {
             addCriterion("UPC between", value1, value2, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andUpcNotBetween(String value1, String value2) {
             addCriterion("UPC not between", value1, value2, "upc");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdIsNull() {
             addCriterion("ORDER_ITEM_ID is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdIsNotNull() {
             addCriterion("ORDER_ITEM_ID is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdEqualTo(Integer value) {
             addCriterion("ORDER_ITEM_ID =", value, "orderItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdNotEqualTo(Integer value) {
             addCriterion("ORDER_ITEM_ID <>", value, "orderItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdGreaterThan(Integer value) {
             addCriterion("ORDER_ITEM_ID >", value, "orderItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ORDER_ITEM_ID >=", value, "orderItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdLessThan(Integer value) {
             addCriterion("ORDER_ITEM_ID <", value, "orderItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdLessThanOrEqualTo(Integer value) {
             addCriterion("ORDER_ITEM_ID <=", value, "orderItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdIn(List<Integer> values) {
             addCriterion("ORDER_ITEM_ID in", values, "orderItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdNotIn(List<Integer> values) {
             addCriterion("ORDER_ITEM_ID not in", values, "orderItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdBetween(Integer value1, Integer value2) {
             addCriterion("ORDER_ITEM_ID between", value1, value2, "orderItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andOrderItemIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ORDER_ITEM_ID not between", value1, value2, "orderItemId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeIsNull() {
             addCriterion("SCAN_TIME is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeIsNotNull() {
             addCriterion("SCAN_TIME is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeEqualTo(Date value) {
             addCriterion("SCAN_TIME =", value, "scanTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeNotEqualTo(Date value) {
             addCriterion("SCAN_TIME <>", value, "scanTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeGreaterThan(Date value) {
             addCriterion("SCAN_TIME >", value, "scanTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("SCAN_TIME >=", value, "scanTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeLessThan(Date value) {
             addCriterion("SCAN_TIME <", value, "scanTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeLessThanOrEqualTo(Date value) {
             addCriterion("SCAN_TIME <=", value, "scanTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeIn(List<Date> values) {
             addCriterion("SCAN_TIME in", values, "scanTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeNotIn(List<Date> values) {
             addCriterion("SCAN_TIME not in", values, "scanTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeBetween(Date value1, Date value2) {
             addCriterion("SCAN_TIME between", value1, value2, "scanTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andScanTimeNotBetween(Date value1, Date value2) {
             addCriterion("SCAN_TIME not between", value1, value2, "scanTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdIsNull() {
             addCriterion("PACKING_ID is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdIsNotNull() {
             addCriterion("PACKING_ID is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdEqualTo(Integer value) {
             addCriterion("PACKING_ID =", value, "packingId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdNotEqualTo(Integer value) {
             addCriterion("PACKING_ID <>", value, "packingId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdGreaterThan(Integer value) {
             addCriterion("PACKING_ID >", value, "packingId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("PACKING_ID >=", value, "packingId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdLessThan(Integer value) {
             addCriterion("PACKING_ID <", value, "packingId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdLessThanOrEqualTo(Integer value) {
             addCriterion("PACKING_ID <=", value, "packingId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdIn(List<Integer> values) {
             addCriterion("PACKING_ID in", values, "packingId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdNotIn(List<Integer> values) {
             addCriterion("PACKING_ID not in", values, "packingId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdBetween(Integer value1, Integer value2) {
             addCriterion("PACKING_ID between", value1, value2, "packingId");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andPackingIdNotBetween(Integer value1, Integer value2) {
             addCriterion("PACKING_ID not between", value1, value2, "packingId");
             return (Criteria) this;
         }
     }
 
+    // 生成查询条件
     public static class Criteria extends GeneratedCriteria {
 
         protected Criteria() {
@@ -424,6 +507,7 @@ public class TbPackingRecordExample extends BaseMybatisExample {
         }
     }
 
+    // 生成查询条件
     public static class Criterion {
         private String condition;
 
@@ -441,38 +525,47 @@ public class TbPackingRecordExample extends BaseMybatisExample {
 
         private String typeHandler;
 
+        // 获取查询条件
         public String getCondition() {
             return condition;
         }
 
+        // 获取查询条件
         public Object getValue() {
             return value;
         }
 
+        // 获取查询条件
         public Object getSecondValue() {
             return secondValue;
         }
 
+        // 判断查询条件是否为空
         public boolean isNoValue() {
             return noValue;
         }
 
+        // 判断查询条件是否为单个值
         public boolean isSingleValue() {
             return singleValue;
         }
 
+        // 判断查询条件是否为范围值
         public boolean isBetweenValue() {
             return betweenValue;
         }
 
+        // 判断查询条件是否为列表值
         public boolean isListValue() {
             return listValue;
         }
 
+        // 获取查询条件
         public String getTypeHandler() {
             return typeHandler;
         }
 
+        // 创建查询条件
         protected Criterion(String condition) {
             super();
             this.condition = condition;
@@ -480,6 +573,7 @@ public class TbPackingRecordExample extends BaseMybatisExample {
             this.noValue = true;
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value, String typeHandler) {
             super();
             this.condition = condition;
@@ -492,10 +586,12 @@ public class TbPackingRecordExample extends BaseMybatisExample {
             }
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value) {
             this(condition, value, null);
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value, Object secondValue, String typeHandler) {
             super();
             this.condition = condition;
@@ -505,6 +601,7 @@ public class TbPackingRecordExample extends BaseMybatisExample {
             this.betweenValue = true;
         }
 
+        // 创建查询条件
         protected Criterion(String condition, Object value, Object secondValue) {
             this(condition, value, secondValue, null);
         }
diff --git a/src/main/java/com/xmomen/module/order/entity/TbPurchaseExample.java b/src/main/java/com/xmomen/module/order/entity/TbPurchaseExample.java
index 4f15d2a..91f3a52 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbPurchaseExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbPurchaseExample.java
@@ -7,46 +7,57 @@ import java.util.Date;
 import java.util.List;
 
 public class TbPurchaseExample extends BaseMybatisExample {
+    // 排序字段
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 查询条件
     protected List<Criteria> oredCriteria;
 
     public TbPurchaseExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置排序字段
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序字段
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否去重
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取是否去重
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -55,17 +66,20 @@ public class TbPurchaseExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 生成查询条件
     protected abstract static class GeneratedCriteria {
         protected List<Criterion> criteria;
 
@@ -74,18 +88,22 @@ public class TbPurchaseExample extends BaseMybatisExample {
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -93,6 +111,7 @@ public class TbPurchaseExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -100,6 +119,7 @@ public class TbPurchaseExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -107,386 +127,463 @@ public class TbPurchaseExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 判断ID是否为空
         public Criteria andIdIsNull() {
             addCriterion("ID is null");
             return (Criteria) this;
         }
 
+        // 判断ID是否不为空
         public Criteria andIdIsNotNull() {
             addCriterion("ID is not null");
             return (Criteria) this;
         }
 
+        // 判断ID是否等于某个值
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否为空
         public Criteria andPurchaseCodeIsNull() {
             addCriterion("PURCHASE_CODE is null");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否不为空
         public Criteria andPurchaseCodeIsNotNull() {
             addCriterion("PURCHASE_CODE is not null");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否等于某个值
         public Criteria andPurchaseCodeEqualTo(String value) {
             addCriterion("PURCHASE_CODE =", value, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否不等于某个值
         public Criteria andPurchaseCodeNotEqualTo(String value) {
             addCriterion("PURCHASE_CODE <>", value, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否大于某个值
         public Criteria andPurchaseCodeGreaterThan(String value) {
             addCriterion("PURCHASE_CODE >", value, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否大于等于某个值
         public Criteria andPurchaseCodeGreaterThanOrEqualTo(String value) {
             addCriterion("PURCHASE_CODE >=", value, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否小于某个值
         public Criteria andPurchaseCodeLessThan(String value) {
             addCriterion("PURCHASE_CODE <", value, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否小于等于某个值
         public Criteria andPurchaseCodeLessThanOrEqualTo(String value) {
             addCriterion("PURCHASE_CODE <=", value, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否包含某个值
         public Criteria andPurchaseCodeLike(String value) {
             addCriterion("PURCHASE_CODE like", value, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否不包含某个值
         public Criteria andPurchaseCodeNotLike(String value) {
             addCriterion("PURCHASE_CODE not like", value, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否在某个范围内
         public Criteria andPurchaseCodeIn(List<String> values) {
             addCriterion("PURCHASE_CODE in", values, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否不在某个范围内
         public Criteria andPurchaseCodeNotIn(List<String> values) {
             addCriterion("PURCHASE_CODE not in", values, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否在某个范围内
         public Criteria andPurchaseCodeBetween(String value1, String value2) {
             addCriterion("PURCHASE_CODE between", value1, value2, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断PURCHASE_CODE是否不在某个范围内
         public Criteria andPurchaseCodeNotBetween(String value1, String value2) {
             addCriterion("PURCHASE_CODE not between", value1, value2, "purchaseCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否为空
         public Criteria andItemCodeIsNull() {
             addCriterion("ITEM_CODE is null");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否不为空
         public Criteria andItemCodeIsNotNull() {
             addCriterion("ITEM_CODE is not null");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否等于某个值
         public Criteria andItemCodeEqualTo(String value) {
             addCriterion("ITEM_CODE =", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否不等于某个值
         public Criteria andItemCodeNotEqualTo(String value) {
             addCriterion("ITEM_CODE <>", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否大于某个值
         public Criteria andItemCodeGreaterThan(String value) {
             addCriterion("ITEM_CODE >", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否大于等于某个值
         public Criteria andItemCodeGreaterThanOrEqualTo(String value) {
             addCriterion("ITEM_CODE >=", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否小于某个值
         public Criteria andItemCodeLessThan(String value) {
             addCriterion("ITEM_CODE <", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否小于等于某个值
         public Criteria andItemCodeLessThanOrEqualTo(String value) {
             addCriterion("ITEM_CODE <=", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否包含某个值
         public Criteria andItemCodeLike(String value) {
             addCriterion("ITEM_CODE like", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否不包含某个值
         public Criteria andItemCodeNotLike(String value) {
             addCriterion("ITEM_CODE not like", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否在某个范围内
         public Criteria andItemCodeIn(List<String> values) {
             addCriterion("ITEM_CODE in", values, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否不在某个范围内
         public Criteria andItemCodeNotIn(List<String> values) {
             addCriterion("ITEM_CODE not in", values, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否在某个范围内
         public Criteria andItemCodeBetween(String value1, String value2) {
             addCriterion("ITEM_CODE between", value1, value2, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否不在某个范围内
         public Criteria andItemCodeNotBetween(String value1, String value2) {
             addCriterion("ITEM_CODE not between", value1, value2, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否为空
         public Criteria andTotalIsNull() {
             addCriterion("TOTAL is null");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否不为空
         public Criteria andTotalIsNotNull() {
             addCriterion("TOTAL is not null");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否等于某个值
         public Criteria andTotalEqualTo(BigDecimal value) {
             addCriterion("TOTAL =", value, "total");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否不等于某个值
         public Criteria andTotalNotEqualTo(BigDecimal value) {
             addCriterion("TOTAL <>", value, "total");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否大于某个值
         public Criteria andTotalGreaterThan(BigDecimal value) {
             addCriterion("TOTAL >", value, "total");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否大于等于某个值
         public Criteria andTotalGreaterThanOrEqualTo(BigDecimal value) {
             addCriterion("TOTAL >=", value, "total");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否小于某个值
         public Criteria andTotalLessThan(BigDecimal value) {
             addCriterion("TOTAL <", value, "total");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否小于等于某个值
         public Criteria andTotalLessThanOrEqualTo(BigDecimal value) {
             addCriterion("TOTAL <=", value, "total");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否在某个范围内
         public Criteria andTotalIn(List<BigDecimal> values) {
             addCriterion("TOTAL in", values, "total");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否不在某个范围内
         public Criteria andTotalNotIn(List<BigDecimal> values) {
             addCriterion("TOTAL not in", values, "total");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否在某个范围内
         public Criteria andTotalBetween(BigDecimal value1, BigDecimal value2) {
             addCriterion("TOTAL between", value1, value2, "total");
             return (Criteria) this;
         }
 
+        // 判断TOTAL是否不在某个范围内
         public Criteria andTotalNotBetween(BigDecimal value1, BigDecimal value2) {
             addCriterion("TOTAL not between", value1, value2, "total");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否为空
         public Criteria andCreateDateIsNull() {
             addCriterion("CREATE_DATE is null");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否不为空
         public Criteria andCreateDateIsNotNull() {
             addCriterion("CREATE_DATE is not null");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否等于某个值
         public Criteria andCreateDateEqualTo(Date value) {
             addCriterion("CREATE_DATE =", value, "createDate");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否不等于某个值
         public Criteria andCreateDateNotEqualTo(Date value) {
             addCriterion("CREATE_DATE <>", value, "createDate");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否大于某个值
         public Criteria andCreateDateGreaterThan(Date value) {
             addCriterion("CREATE_DATE >", value, "createDate");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否大于等于某个值
         public Criteria andCreateDateGreaterThanOrEqualTo(Date value) {
             addCriterion("CREATE_DATE >=", value, "createDate");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否小于某个值
         public Criteria andCreateDateLessThan(Date value) {
             addCriterion("CREATE_DATE <", value, "createDate");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否小于等于某个值
         public Criteria andCreateDateLessThanOrEqualTo(Date value) {
             addCriterion("CREATE_DATE <=", value, "createDate");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否在某个范围内
         public Criteria andCreateDateIn(List<Date> values) {
             addCriterion("CREATE_DATE in", values, "createDate");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否不在某个范围内
         public Criteria andCreateDateNotIn(List<Date> values) {
             addCriterion("CREATE_DATE not in", values, "createDate");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否在某个范围内
         public Criteria andCreateDateBetween(Date value1, Date value2) {
             addCriterion("CREATE_DATE between", value1, value2, "createDate");
             return (Criteria) this;
         }
 
+        // 判断CREATE_DATE是否不在某个范围内
         public Criteria andCreateDateNotBetween(Date value1, Date value2) {
             addCriterion("CREATE_DATE not between", value1, value2, "createDate");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否为空
         public Criteria andBuyerIdIsNull() {
             addCriterion("BUYER_ID is null");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否不为空
         public Criteria andBuyerIdIsNotNull() {
             addCriterion("BUYER_ID is not null");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否等于某个值
         public Criteria andBuyerIdEqualTo(Integer value) {
             addCriterion("BUYER_ID =", value, "buyerId");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否不等于某个值
         public Criteria andBuyerIdNotEqualTo(Integer value) {
             addCriterion("BUYER_ID <>", value, "buyerId");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否大于某个值
         public Criteria andBuyerIdGreaterThan(Integer value) {
             addCriterion("BUYER_ID >", value, "buyerId");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否大于等于某个值
         public Criteria andBuyerIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("BUYER_ID >=", value, "buyerId");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否小于某个值
         public Criteria andBuyerIdLessThan(Integer value) {
             addCriterion("BUYER_ID <", value, "buyerId");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否小于等于某个值
         public Criteria andBuyerIdLessThanOrEqualTo(Integer value) {
             addCriterion("BUYER_ID <=", value, "buyerId");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否在某个范围内
         public Criteria andBuyerIdIn(List<Integer> values) {
             addCriterion("BUYER_ID in", values, "buyerId");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否不在某个范围内
         public Criteria andBuyerIdNotIn(List<Integer> values) {
             addCriterion("BUYER_ID not in", values, "buyerId");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否在某个范围内
         public Criteria andBuyerIdBetween(Integer value1, Integer value2) {
             addCriterion("BUYER_ID between", value1, value2, "buyerId");
             return (Criteria) this;
         }
 
+        // 判断BUYER_ID是否不在某个范围内
         public Criteria andBuyerIdNotBetween(Integer value1, Integer value2) {
             addCriterion("BUYER_ID not between", value1, value2, "buyerId");
             return (Criteria) this;
         }
 
+        // 判断TOTAL_WEIGHT是否为空
         public Criteria andTotalWeightIsNull() {
             addCriterion("TOTAL_WEIGHT is null");
             return (Criteria) this;
diff --git a/src/main/java/com/xmomen/module/order/entity/TbReturnOrderExample.java b/src/main/java/com/xmomen/module/order/entity/TbReturnOrderExample.java
index 3193964..5ab0275 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbReturnOrderExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbReturnOrderExample.java
@@ -6,47 +6,59 @@ import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
-public class TbReturnOrderExample extends BaseMybatisExample {
+public class
+TbReturnOrderExample extends BaseMybatisExample {
+    // 排序字段
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 查询条件
     protected List<Criteria> oredCriteria;
 
     public TbReturnOrderExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置排序字段
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序字段
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否去重
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取是否去重
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -54,18 +66,22 @@ public class TbReturnOrderExample extends BaseMybatisExample {
         }
         return criteria;
     }
+    // 创建查询条件
 
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
+    // 清空查询条件
 
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
+    // 查询条件内部类
 
+        // 查询条件列表
     protected abstract static class GeneratedCriteria {
         protected List<Criterion> criteria;
 
@@ -73,18 +89,22 @@ public class TbReturnOrderExample extends BaseMybatisExample {
             super();
             criteria = new ArrayList<Criterion>();
         }
+        // 判断查询条件是否有效
 
         public boolean isValid() {
             return criteria.size() > 0;
         }
+        // 获取所有查询条件
 
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
+        // 获取查询条件
 
         public List<Criterion> getCriteria() {
             return criteria;
         }
+        // 添加查询条件
 
         protected void addCriterion(String condition) {
             if (condition == null) {
@@ -92,6 +112,7 @@ public class TbReturnOrderExample extends BaseMybatisExample {
             }
             criteria.add(new Criterion(condition));
         }
+        // 添加查询条件
 
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
@@ -99,6 +120,7 @@ public class TbReturnOrderExample extends BaseMybatisExample {
             }
             criteria.add(new Criterion(condition, value));
         }
+        // 添加查询条件
 
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
@@ -106,381 +128,457 @@ public class TbReturnOrderExample extends BaseMybatisExample {
             }
             criteria.add(new Criterion(condition, value1, value2));
         }
+        // 判断ID是否为空
 
         public Criteria andIdIsNull() {
             addCriterion("ID is null");
             return (Criteria) this;
         }
+        // 判断ID是否不为空
 
         public Criteria andIdIsNotNull() {
             addCriterion("ID is not null");
             return (Criteria) this;
         }
+        // 判断ID是否等于某个值
 
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
+        // 判断ID是否不等于某个值
 
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
+        // 判断ID是否大于某个值
 
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
+        // 判断ID是否大于等于某个值
 
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
+        // 判断ID是否小于某个值
 
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
+        // 判断ID是否小于等于某个值
 
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
+        // 判断ID是否在某个范围内
 
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
+        // 判断ID是否不在某个范围内
 
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
+        // 判断ID是否在某个范围内
 
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
+        // 判断ID是否不在某个范围内
 
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否为空
 
         public Criteria andOrderNoIsNull() {
             addCriterion("ORDER_NO is null");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否不为空
 
         public Criteria andOrderNoIsNotNull() {
             addCriterion("ORDER_NO is not null");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否等于某个值
 
         public Criteria andOrderNoEqualTo(String value) {
             addCriterion("ORDER_NO =", value, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否不等于某个值
 
         public Criteria andOrderNoNotEqualTo(String value) {
             addCriterion("ORDER_NO <>", value, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否大于某个值
 
         public Criteria andOrderNoGreaterThan(String value) {
             addCriterion("ORDER_NO >", value, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否大于等于某个值
 
         public Criteria andOrderNoGreaterThanOrEqualTo(String value) {
             addCriterion("ORDER_NO >=", value, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否小于某个值
 
         public Criteria andOrderNoLessThan(String value) {
             addCriterion("ORDER_NO <", value, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否小于等于某个值
 
         public Criteria andOrderNoLessThanOrEqualTo(String value) {
             addCriterion("ORDER_NO <=", value, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否包含某个值
 
         public Criteria andOrderNoLike(String value) {
             addCriterion("ORDER_NO like", value, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否不包含某个值
 
         public Criteria andOrderNoNotLike(String value) {
             addCriterion("ORDER_NO not like", value, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否在某个范围内
 
         public Criteria andOrderNoIn(List<String> values) {
             addCriterion("ORDER_NO in", values, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否不在某个范围内
 
         public Criteria andOrderNoNotIn(List<String> values) {
             addCriterion("ORDER_NO not in", values, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否在某个范围内
 
         public Criteria andOrderNoBetween(String value1, String value2) {
             addCriterion("ORDER_NO between", value1, value2, "orderNo");
             return (Criteria) this;
         }
+        // 判断ORDER_NO是否不在某个范围内
 
         public Criteria andOrderNoNotBetween(String value1, String value2) {
             addCriterion("ORDER_NO not between", value1, value2, "orderNo");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否为空
 
         public Criteria andReturnTimeIsNull() {
             addCriterion("RETURN_TIME is null");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否不为空
 
         public Criteria andReturnTimeIsNotNull() {
             addCriterion("RETURN_TIME is not null");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否等于某个值
 
         public Criteria andReturnTimeEqualTo(Date value) {
             addCriterion("RETURN_TIME =", value, "returnTime");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否不等于某个值
 
         public Criteria andReturnTimeNotEqualTo(Date value) {
             addCriterion("RETURN_TIME <>", value, "returnTime");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否大于某个值
 
         public Criteria andReturnTimeGreaterThan(Date value) {
             addCriterion("RETURN_TIME >", value, "returnTime");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否大于等于某个值
 
         public Criteria andReturnTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("RETURN_TIME >=", value, "returnTime");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否小于某个值
 
         public Criteria andReturnTimeLessThan(Date value) {
             addCriterion("RETURN_TIME <", value, "returnTime");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否小于等于某个值
 
         public Criteria andReturnTimeLessThanOrEqualTo(Date value) {
             addCriterion("RETURN_TIME <=", value, "returnTime");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否在某个范围内
 
         public Criteria andReturnTimeIn(List<Date> values) {
             addCriterion("RETURN_TIME in", values, "returnTime");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否不在某个范围内
 
         public Criteria andReturnTimeNotIn(List<Date> values) {
             addCriterion("RETURN_TIME not in", values, "returnTime");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否在某个范围内
 
         public Criteria andReturnTimeBetween(Date value1, Date value2) {
             addCriterion("RETURN_TIME between", value1, value2, "returnTime");
             return (Criteria) this;
         }
+        // 判断RETURN_TIME是否不在某个范围内
 
         public Criteria andReturnTimeNotBetween(Date value1, Date value2) {
             addCriterion("RETURN_TIME not between", value1, value2, "returnTime");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否为空
 
         public Criteria andReturnStatusIsNull() {
             addCriterion("RETURN_STATUS is null");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否不为空
 
         public Criteria andReturnStatusIsNotNull() {
             addCriterion("RETURN_STATUS is not null");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否等于某个值
 
         public Criteria andReturnStatusEqualTo(Integer value) {
             addCriterion("RETURN_STATUS =", value, "returnStatus");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否不等于某个值
 
         public Criteria andReturnStatusNotEqualTo(Integer value) {
             addCriterion("RETURN_STATUS <>", value, "returnStatus");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否大于某个值
 
         public Criteria andReturnStatusGreaterThan(Integer value) {
             addCriterion("RETURN_STATUS >", value, "returnStatus");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否大于等于某个值
 
         public Criteria andReturnStatusGreaterThanOrEqualTo(Integer value) {
             addCriterion("RETURN_STATUS >=", value, "returnStatus");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否小于某个值
 
         public Criteria andReturnStatusLessThan(Integer value) {
             addCriterion("RETURN_STATUS <", value, "returnStatus");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否小于等于某个值
 
         public Criteria andReturnStatusLessThanOrEqualTo(Integer value) {
             addCriterion("RETURN_STATUS <=", value, "returnStatus");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否在某个范围内
 
         public Criteria andReturnStatusIn(List<Integer> values) {
             addCriterion("RETURN_STATUS in", values, "returnStatus");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否不在某个范围内
 
         public Criteria andReturnStatusNotIn(List<Integer> values) {
             addCriterion("RETURN_STATUS not in", values, "returnStatus");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否在某个范围内
 
         public Criteria andReturnStatusBetween(Integer value1, Integer value2) {
             addCriterion("RETURN_STATUS between", value1, value2, "returnStatus");
             return (Criteria) this;
         }
+        // 判断RETURN_STATUS是否不在某个范围内
 
         public Criteria andReturnStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("RETURN_STATUS not between", value1, value2, "returnStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否为空
 
         public Criteria andAuditStatusIsNull() {
             addCriterion("AUDIT_STATUS is null");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否不为空
 
         public Criteria andAuditStatusIsNotNull() {
             addCriterion("AUDIT_STATUS is not null");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否等于某个值
 
         public Criteria andAuditStatusEqualTo(Integer value) {
             addCriterion("AUDIT_STATUS =", value, "auditStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否不等于某个值
 
         public Criteria andAuditStatusNotEqualTo(Integer value) {
             addCriterion("AUDIT_STATUS <>", value, "auditStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否大于某个值
 
         public Criteria andAuditStatusGreaterThan(Integer value) {
             addCriterion("AUDIT_STATUS >", value, "auditStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否大于等于某个值
 
         public Criteria andAuditStatusGreaterThanOrEqualTo(Integer value) {
             addCriterion("AUDIT_STATUS >=", value, "auditStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否小于某个值
 
         public Criteria andAuditStatusLessThan(Integer value) {
             addCriterion("AUDIT_STATUS <", value, "auditStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否小于等于某个值
 
         public Criteria andAuditStatusLessThanOrEqualTo(Integer value) {
             addCriterion("AUDIT_STATUS <=", value, "auditStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否在某个范围内
 
         public Criteria andAuditStatusIn(List<Integer> values) {
             addCriterion("AUDIT_STATUS in", values, "auditStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否不在某个范围内
 
         public Criteria andAuditStatusNotIn(List<Integer> values) {
             addCriterion("AUDIT_STATUS not in", values, "auditStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否在某个范围内
 
         public Criteria andAuditStatusBetween(Integer value1, Integer value2) {
             addCriterion("AUDIT_STATUS between", value1, value2, "auditStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_STATUS是否不在某个范围内
 
         public Criteria andAuditStatusNotBetween(Integer value1, Integer value2) {
             addCriterion("AUDIT_STATUS not between", value1, value2, "auditStatus");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否为空
 
         public Criteria andAuditDateIsNull() {
             addCriterion("AUDIT_DATE is null");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否不为空
 
         public Criteria andAuditDateIsNotNull() {
             addCriterion("AUDIT_DATE is not null");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否等于某个值
 
         public Criteria andAuditDateEqualTo(Date value) {
             addCriterion("AUDIT_DATE =", value, "auditDate");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否不等于某个值
 
         public Criteria andAuditDateNotEqualTo(Date value) {
             addCriterion("AUDIT_DATE <>", value, "auditDate");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否大于某个值
 
         public Criteria andAuditDateGreaterThan(Date value) {
             addCriterion("AUDIT_DATE >", value, "auditDate");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否大于等于某个值
 
         public Criteria andAuditDateGreaterThanOrEqualTo(Date value) {
             addCriterion("AUDIT_DATE >=", value, "auditDate");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否小于某个值
 
         public Criteria andAuditDateLessThan(Date value) {
             addCriterion("AUDIT_DATE <", value, "auditDate");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否小于等于某个值
 
         public Criteria andAuditDateLessThanOrEqualTo(Date value) {
             addCriterion("AUDIT_DATE <=", value, "auditDate");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否在某个范围内
 
         public Criteria andAuditDateIn(List<Date> values) {
             addCriterion("AUDIT_DATE in", values, "auditDate");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否不在某个范围内
 
         public Criteria andAuditDateNotIn(List<Date> values) {
             addCriterion("AUDIT_DATE not in", values, "auditDate");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否在某个范围内
 
         public Criteria andAuditDateBetween(Date value1, Date value2) {
             addCriterion("AUDIT_DATE between", value1, value2, "auditDate");
             return (Criteria) this;
         }
+        // 判断AUDIT_DATE是否不在某个范围内
 
         public Criteria andAuditDateNotBetween(Date value1, Date value2) {
             addCriterion("AUDIT_DATE not between", value1, value2, "auditDate");
             return (Criteria) this;
         }
+        // 判断AUDIT_USER_ID是否为空
 
         public Criteria andAuditUserIdIsNull() {
             addCriterion("AUDIT_USER_ID is null");
             return (Criteria) this;
         }
+        // 判断AUDIT_USER_ID是否不为空
 
         public Criteria andAuditUserIdIsNotNull() {
             addCriterion("AUDIT_USER_ID is not null");
@@ -553,6 +651,7 @@ public class TbReturnOrderExample extends BaseMybatisExample {
         }
 
         public Criteria andTakeGoodsDateNotEqualTo(Date value) {
+            // 添加条件：TAKE_GOODS_DATE不等于value
             addCriterion("TAKE_GOODS_DATE <>", value, "takeGoodsDate");
             return (Criteria) this;
         }
diff --git a/src/main/java/com/xmomen/module/order/entity/TbReturnOrderItem.java b/src/main/java/com/xmomen/module/order/entity/TbReturnOrderItem.java
index 935b368..1aaec2d 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbReturnOrderItem.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbReturnOrderItem.java
@@ -12,7 +12,7 @@ import javax.persistence.Version;
 @Table(name = "tb_return_order_item")
 public class TbReturnOrderItem extends BaseMybatisModel {
     /**
-     * 
+     *  主键
      */
     private Integer id;
 
diff --git a/src/main/java/com/xmomen/module/order/entity/TbReturnOrderItemExample.java b/src/main/java/com/xmomen/module/order/entity/TbReturnOrderItemExample.java
index 6ea3f82..c51a2d4 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbReturnOrderItemExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbReturnOrderItemExample.java
@@ -4,47 +4,60 @@ import com.xmomen.framework.mybatis.model.BaseMybatisExample;
 import java.util.ArrayList;
 import java.util.List;
 
+// 定义一个名为TbReturnOrderItemExample的类，继承自BaseMybatisExample
 public class TbReturnOrderItemExample extends BaseMybatisExample {
+    // 定义一个orderByClause变量，用于存储排序的子句
     protected String orderByClause;
 
+    // 定义一个distinct变量，用于存储是否去重的标志
     protected boolean distinct;
 
+    // 定义一个oredCriteria变量，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria
     public TbReturnOrderItemExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置orderByClause的值
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取orderByClause的值
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置distinct的值
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取distinct的值
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取oredCriteria的值
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加一个查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建一个新的查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建一个新的查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -53,37 +66,46 @@ public class TbReturnOrderItemExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建一个新的查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 定义一个抽象的内部类GeneratedCriteria，用于存储查询条件
     protected abstract static class GeneratedCriteria {
+        // 定义一个criteria变量，用于存储查询条件
         protected List<Criterion> criteria;
 
+        // 构造函数，初始化criteria
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有的查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加一个查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -91,6 +113,7 @@ public class TbReturnOrderItemExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加一个查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -98,6 +121,7 @@ public class TbReturnOrderItemExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加一个查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -105,371 +129,445 @@ public class TbReturnOrderItemExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 判断ID是否为空
         public Criteria andIdIsNull() {
             addCriterion("ID is null");
             return (Criteria) this;
         }
 
+        // 判断ID是否不为空
         public Criteria andIdIsNotNull() {
             addCriterion("ID is not null");
             return (Criteria) this;
         }
 
+        // 判断ID是否等于某个值
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不等于某个值
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于某个值
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否大于等于某个值
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于某个值
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否小于等于某个值
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否在某个范围内
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断ID是否不在某个范围内
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否为空
         public Criteria andReturnOrderIdIsNull() {
             addCriterion("RETURN_ORDER_ID is null");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否不为空
         public Criteria andReturnOrderIdIsNotNull() {
             addCriterion("RETURN_ORDER_ID is not null");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否等于某个值
         public Criteria andReturnOrderIdEqualTo(Integer value) {
             addCriterion("RETURN_ORDER_ID =", value, "returnOrderId");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否不等于某个值
         public Criteria andReturnOrderIdNotEqualTo(Integer value) {
             addCriterion("RETURN_ORDER_ID <>", value, "returnOrderId");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否大于某个值
         public Criteria andReturnOrderIdGreaterThan(Integer value) {
             addCriterion("RETURN_ORDER_ID >", value, "returnOrderId");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否大于等于某个值
         public Criteria andReturnOrderIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("RETURN_ORDER_ID >=", value, "returnOrderId");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否小于某个值
         public Criteria andReturnOrderIdLessThan(Integer value) {
             addCriterion("RETURN_ORDER_ID <", value, "returnOrderId");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否小于等于某个值
         public Criteria andReturnOrderIdLessThanOrEqualTo(Integer value) {
             addCriterion("RETURN_ORDER_ID <=", value, "returnOrderId");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否在某个范围内
         public Criteria andReturnOrderIdIn(List<Integer> values) {
             addCriterion("RETURN_ORDER_ID in", values, "returnOrderId");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否不在某个范围内
         public Criteria andReturnOrderIdNotIn(List<Integer> values) {
             addCriterion("RETURN_ORDER_ID not in", values, "returnOrderId");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否在某个范围内
         public Criteria andReturnOrderIdBetween(Integer value1, Integer value2) {
             addCriterion("RETURN_ORDER_ID between", value1, value2, "returnOrderId");
             return (Criteria) this;
         }
 
+        // 判断RETURN_ORDER_ID是否不在某个范围内
         public Criteria andReturnOrderIdNotBetween(Integer value1, Integer value2) {
             addCriterion("RETURN_ORDER_ID not between", value1, value2, "returnOrderId");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否为空
         public Criteria andItemCodeIsNull() {
             addCriterion("ITEM_CODE is null");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否不为空
         public Criteria andItemCodeIsNotNull() {
             addCriterion("ITEM_CODE is not null");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否等于某个值
         public Criteria andItemCodeEqualTo(String value) {
             addCriterion("ITEM_CODE =", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否不等于某个值
         public Criteria andItemCodeNotEqualTo(String value) {
             addCriterion("ITEM_CODE <>", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否大于某个值
         public Criteria andItemCodeGreaterThan(String value) {
             addCriterion("ITEM_CODE >", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否大于等于某个值
         public Criteria andItemCodeGreaterThanOrEqualTo(String value) {
             addCriterion("ITEM_CODE >=", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否小于某个值
         public Criteria andItemCodeLessThan(String value) {
             addCriterion("ITEM_CODE <", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否小于等于某个值
         public Criteria andItemCodeLessThanOrEqualTo(String value) {
             addCriterion("ITEM_CODE <=", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否包含某个值
         public Criteria andItemCodeLike(String value) {
             addCriterion("ITEM_CODE like", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否不包含某个值
         public Criteria andItemCodeNotLike(String value) {
             addCriterion("ITEM_CODE not like", value, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否在某个范围内
         public Criteria andItemCodeIn(List<String> values) {
             addCriterion("ITEM_CODE in", values, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否不在某个范围内
         public Criteria andItemCodeNotIn(List<String> values) {
             addCriterion("ITEM_CODE not in", values, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否在某个范围内
         public Criteria andItemCodeBetween(String value1, String value2) {
             addCriterion("ITEM_CODE between", value1, value2, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_CODE是否不在某个范围内
         public Criteria andItemCodeNotBetween(String value1, String value2) {
             addCriterion("ITEM_CODE not between", value1, value2, "itemCode");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否为空
         public Criteria andItemNumberIsNull() {
             addCriterion("ITEM_NUMBER is null");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否不为空
         public Criteria andItemNumberIsNotNull() {
             addCriterion("ITEM_NUMBER is not null");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否等于某个值
         public Criteria andItemNumberEqualTo(Integer value) {
             addCriterion("ITEM_NUMBER =", value, "itemNumber");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否不等于某个值
         public Criteria andItemNumberNotEqualTo(Integer value) {
             addCriterion("ITEM_NUMBER <>", value, "itemNumber");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否大于某个值
         public Criteria andItemNumberGreaterThan(Integer value) {
             addCriterion("ITEM_NUMBER >", value, "itemNumber");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否大于等于某个值
         public Criteria andItemNumberGreaterThanOrEqualTo(Integer value) {
             addCriterion("ITEM_NUMBER >=", value, "itemNumber");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否小于某个值
         public Criteria andItemNumberLessThan(Integer value) {
             addCriterion("ITEM_NUMBER <", value, "itemNumber");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否小于等于某个值
         public Criteria andItemNumberLessThanOrEqualTo(Integer value) {
             addCriterion("ITEM_NUMBER <=", value, "itemNumber");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否在某个范围内
         public Criteria andItemNumberIn(List<Integer> values) {
             addCriterion("ITEM_NUMBER in", values, "itemNumber");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否不在某个范围内
         public Criteria andItemNumberNotIn(List<Integer> values) {
             addCriterion("ITEM_NUMBER not in", values, "itemNumber");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否在某个范围内
         public Criteria andItemNumberBetween(Integer value1, Integer value2) {
             addCriterion("ITEM_NUMBER between", value1, value2, "itemNumber");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NUMBER是否不在某个范围内
         public Criteria andItemNumberNotBetween(Integer value1, Integer value2) {
             addCriterion("ITEM_NUMBER not between", value1, value2, "itemNumber");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否为空
         public Criteria andItemNameIsNull() {
             addCriterion("ITEM_NAME is null");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否不为空
         public Criteria andItemNameIsNotNull() {
             addCriterion("ITEM_NAME is not null");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否等于某个值
         public Criteria andItemNameEqualTo(String value) {
             addCriterion("ITEM_NAME =", value, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否不等于某个值
         public Criteria andItemNameNotEqualTo(String value) {
             addCriterion("ITEM_NAME <>", value, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否大于某个值
         public Criteria andItemNameGreaterThan(String value) {
             addCriterion("ITEM_NAME >", value, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否大于等于某个值
         public Criteria andItemNameGreaterThanOrEqualTo(String value) {
             addCriterion("ITEM_NAME >=", value, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否小于某个值
         public Criteria andItemNameLessThan(String value) {
             addCriterion("ITEM_NAME <", value, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否小于等于某个值
         public Criteria andItemNameLessThanOrEqualTo(String value) {
             addCriterion("ITEM_NAME <=", value, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否包含某个值
         public Criteria andItemNameLike(String value) {
             addCriterion("ITEM_NAME like", value, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否不包含某个值
         public Criteria andItemNameNotLike(String value) {
             addCriterion("ITEM_NAME not like", value, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否在某个范围内
         public Criteria andItemNameIn(List<String> values) {
             addCriterion("ITEM_NAME in", values, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否不在某个范围内
         public Criteria andItemNameNotIn(List<String> values) {
             addCriterion("ITEM_NAME not in", values, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否在某个范围内
         public Criteria andItemNameBetween(String value1, String value2) {
             addCriterion("ITEM_NAME between", value1, value2, "itemName");
             return (Criteria) this;
         }
 
+        // 判断ITEM_NAME是否不在某个范围内
         public Criteria andItemNameNotBetween(String value1, String value2) {
             addCriterion("ITEM_NAME not between", value1, value2, "itemName");
             return (Criteria) this;
         }
 
+        // 判断IS_NEED是否为空
         public Criteria andIsNeedIsNull() {
             addCriterion("IS_NEED is null");
             return (Criteria) this;
         }
 
+        // 判断IS_NEED是否不为空
         public Criteria andIsNeedIsNotNull() {
             addCriterion("IS_NEED is not null");
             return (Criteria) this;
         }
 
+        // 判断IS_NEED是否等于某个值
         public Criteria andIsNeedEqualTo(Integer value) {
             addCriterion("IS_NEED =", value, "isNeed");
             return (Criteria) this;
         }
 
+        // 判断IS_NEED是否不等于某个值
         public Criteria andIsNeedNotEqualTo(Integer value) {
             addCriterion("IS_NEED <>", value, "isNeed");
             return (Criteria) this;
         }
 
+        // 判断IS_NEED是否大于某个值
         public Criteria andIsNeedGreaterThan(Integer value) {
             addCriterion("IS_NEED >", value, "isNeed");
             return (Criteria) this;
         }
 
+        // 判断IS_NEED是否大于等于某个值
         public Criteria andIsNeedGreaterThanOrEqualTo(Integer value) {
             addCriterion("IS_NEED >=", value, "isNeed");
             return (Criteria) this;
         }
 
+        // 判断IS_NEED是否小于某个值
         public Criteria andIsNeedLessThan(Integer value) {
             addCriterion("IS_NEED <", value, "isNeed");
             return (Criteria) this;
         }
 
+        // 判断IS_NEED是否小于等于某个值
         public Criteria andIsNeedLessThanOrEqualTo(Integer value) {
             addCriterion("IS_NEED <=", value, "isNeed");
             return (Criteria) this;
         }
 
+        // 判断IS_NEED是否在某个范围内
         public Criteria andIsNeedIn(List<Integer> values) {
             addCriterion("IS_NEED in", values, "isNeed");
             return (Criteria) this;
         }
 
+        // 判断IS_NEED是否不在某个范围内
         public Criteria andIsNeedNotIn(List<Integer> values) {
             addCriterion("IS_NEED not in", values, "isNeed");
             return (Criteria) this;
diff --git a/src/main/java/com/xmomen/module/order/entity/TbTradeRecordExample.java b/src/main/java/com/xmomen/module/order/entity/TbTradeRecordExample.java
index 38c0df7..d43fd95 100644
--- a/src/main/java/com/xmomen/module/order/entity/TbTradeRecordExample.java
+++ b/src/main/java/com/xmomen/module/order/entity/TbTradeRecordExample.java
@@ -6,47 +6,60 @@ import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
+// 交易记录实体类
 public class TbTradeRecordExample extends BaseMybatisExample {
+    // 排序字段
     protected String orderByClause;
 
+    // 是否去重
     protected boolean distinct;
 
+    // 查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数
     public TbTradeRecordExample() {
         oredCriteria = new ArrayList<Criteria>();
     }
 
+    // 设置排序字段
     public void setOrderByClause(String orderByClause) {
         this.orderByClause = orderByClause;
     }
 
+    // 获取排序字段
     public String getOrderByClause() {
         return orderByClause;
     }
 
+    // 设置是否去重
     public void setDistinct(boolean distinct) {
         this.distinct = distinct;
     }
 
+    // 获取是否去重
     public boolean isDistinct() {
         return distinct;
     }
 
+    // 获取查询条件
     public List<Criteria> getOredCriteria() {
         return oredCriteria;
     }
 
+    // 添加查询条件
     public void or(Criteria criteria) {
         oredCriteria.add(criteria);
     }
 
+    // 创建查询条件
     public Criteria or() {
         Criteria criteria = createCriteriaInternal();
         oredCriteria.add(criteria);
         return criteria;
     }
 
+    // 创建查询条件
     public Criteria createCriteria() {
         Criteria criteria = createCriteriaInternal();
         if (oredCriteria.size() == 0) {
@@ -55,37 +68,46 @@ public class TbTradeRecordExample extends BaseMybatisExample {
         return criteria;
     }
 
+    // 创建查询条件
     protected Criteria createCriteriaInternal() {
         Criteria criteria = new Criteria();
         return criteria;
     }
 
+    // 清空查询条件
     public void clear() {
         oredCriteria.clear();
         orderByClause = null;
         distinct = false;
     }
 
+    // 生成查询条件
     protected abstract static class GeneratedCriteria {
+        // 查询条件列表
         protected List<Criterion> criteria;
 
+        // 构造函数
         protected GeneratedCriteria() {
             super();
             criteria = new ArrayList<Criterion>();
         }
 
+        // 判断查询条件是否有效
         public boolean isValid() {
             return criteria.size() > 0;
         }
 
+        // 获取所有查询条件
         public List<Criterion> getAllCriteria() {
             return criteria;
         }
 
+        // 获取查询条件
         public List<Criterion> getCriteria() {
             return criteria;
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition) {
             if (condition == null) {
                 throw new RuntimeException("Value for condition cannot be null");
@@ -93,6 +115,7 @@ public class TbTradeRecordExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value, String property) {
             if (value == null) {
                 throw new RuntimeException("Value for " + property + " cannot be null");
@@ -100,6 +123,7 @@ public class TbTradeRecordExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value));
         }
 
+        // 添加查询条件
         protected void addCriterion(String condition, Object value1, Object value2, String property) {
             if (value1 == null || value2 == null) {
                 throw new RuntimeException("Between values for " + property + " cannot be null");
@@ -107,422 +131,507 @@ public class TbTradeRecordExample extends BaseMybatisExample {
             criteria.add(new Criterion(condition, value1, value2));
         }
 
+        // 添加查询条件
         public Criteria andIdIsNull() {
             addCriterion("ID is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdIsNotNull() {
             addCriterion("ID is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdEqualTo(Integer value) {
             addCriterion("ID =", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdNotEqualTo(Integer value) {
             addCriterion("ID <>", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdGreaterThan(Integer value) {
             addCriterion("ID >", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("ID >=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdLessThan(Integer value) {
             addCriterion("ID <", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdLessThanOrEqualTo(Integer value) {
             addCriterion("ID <=", value, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdIn(List<Integer> values) {
             addCriterion("ID in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdNotIn(List<Integer> values) {
             addCriterion("ID not in", values, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdBetween(Integer value1, Integer value2) {
             addCriterion("ID between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andIdNotBetween(Integer value1, Integer value2) {
             addCriterion("ID not between", value1, value2, "id");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountIsNull() {
             addCriterion("AMOUNT is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountIsNotNull() {
             addCriterion("AMOUNT is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountEqualTo(BigDecimal value) {
             addCriterion("AMOUNT =", value, "amount");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountNotEqualTo(BigDecimal value) {
             addCriterion("AMOUNT <>", value, "amount");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountGreaterThan(BigDecimal value) {
             addCriterion("AMOUNT >", value, "amount");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountGreaterThanOrEqualTo(BigDecimal value) {
             addCriterion("AMOUNT >=", value, "amount");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountLessThan(BigDecimal value) {
             addCriterion("AMOUNT <", value, "amount");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountLessThanOrEqualTo(BigDecimal value) {
             addCriterion("AMOUNT <=", value, "amount");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountIn(List<BigDecimal> values) {
             addCriterion("AMOUNT in", values, "amount");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountNotIn(List<BigDecimal> values) {
             addCriterion("AMOUNT not in", values, "amount");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountBetween(BigDecimal value1, BigDecimal value2) {
             addCriterion("AMOUNT between", value1, value2, "amount");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andAmountNotBetween(BigDecimal value1, BigDecimal value2) {
             addCriterion("AMOUNT not between", value1, value2, "amount");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoIsNull() {
             addCriterion("TRADE_NO is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoIsNotNull() {
             addCriterion("TRADE_NO is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoEqualTo(String value) {
             addCriterion("TRADE_NO =", value, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoNotEqualTo(String value) {
             addCriterion("TRADE_NO <>", value, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoGreaterThan(String value) {
             addCriterion("TRADE_NO >", value, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoGreaterThanOrEqualTo(String value) {
             addCriterion("TRADE_NO >=", value, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoLessThan(String value) {
             addCriterion("TRADE_NO <", value, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoLessThanOrEqualTo(String value) {
             addCriterion("TRADE_NO <=", value, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoLike(String value) {
             addCriterion("TRADE_NO like", value, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoNotLike(String value) {
             addCriterion("TRADE_NO not like", value, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoIn(List<String> values) {
             addCriterion("TRADE_NO in", values, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoNotIn(List<String> values) {
             addCriterion("TRADE_NO not in", values, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoBetween(String value1, String value2) {
             addCriterion("TRADE_NO between", value1, value2, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeNoNotBetween(String value1, String value2) {
             addCriterion("TRADE_NO not between", value1, value2, "tradeNo");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeIsNull() {
             addCriterion("CREATE_TIME is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeIsNotNull() {
             addCriterion("CREATE_TIME is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeEqualTo(Date value) {
             addCriterion("CREATE_TIME =", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeNotEqualTo(Date value) {
             addCriterion("CREATE_TIME <>", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeGreaterThan(Date value) {
             addCriterion("CREATE_TIME >", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("CREATE_TIME >=", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeLessThan(Date value) {
             addCriterion("CREATE_TIME <", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeLessThanOrEqualTo(Date value) {
             addCriterion("CREATE_TIME <=", value, "createTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeIn(List<Date> values) {
             addCriterion("CREATE_TIME in", values, "createTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeNotIn(List<Date> values) {
             addCriterion("CREATE_TIME not in", values, "createTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeBetween(Date value1, Date value2) {
             addCriterion("CREATE_TIME between", value1, value2, "createTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andCreateTimeNotBetween(Date value1, Date value2) {
             addCriterion("CREATE_TIME not between", value1, value2, "createTime");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeIsNull() {
             addCriterion("TRADE_TYPE is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeIsNotNull() {
             addCriterion("TRADE_TYPE is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeEqualTo(String value) {
             addCriterion("TRADE_TYPE =", value, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeNotEqualTo(String value) {
             addCriterion("TRADE_TYPE <>", value, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeGreaterThan(String value) {
             addCriterion("TRADE_TYPE >", value, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeGreaterThanOrEqualTo(String value) {
             addCriterion("TRADE_TYPE >=", value, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeLessThan(String value) {
             addCriterion("TRADE_TYPE <", value, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeLessThanOrEqualTo(String value) {
             addCriterion("TRADE_TYPE <=", value, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeLike(String value) {
             addCriterion("TRADE_TYPE like", value, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeNotLike(String value) {
             addCriterion("TRADE_TYPE not like", value, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeIn(List<String> values) {
             addCriterion("TRADE_TYPE in", values, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeNotIn(List<String> values) {
             addCriterion("TRADE_TYPE not in", values, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeBetween(String value1, String value2) {
             addCriterion("TRADE_TYPE between", value1, value2, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andTradeTypeNotBetween(String value1, String value2) {
             addCriterion("TRADE_TYPE not between", value1, value2, "tradeType");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkIsNull() {
             addCriterion("REMARK is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkIsNotNull() {
             addCriterion("REMARK is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkEqualTo(String value) {
             addCriterion("REMARK =", value, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkNotEqualTo(String value) {
             addCriterion("REMARK <>", value, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkGreaterThan(String value) {
             addCriterion("REMARK >", value, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkGreaterThanOrEqualTo(String value) {
             addCriterion("REMARK >=", value, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkLessThan(String value) {
             addCriterion("REMARK <", value, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkLessThanOrEqualTo(String value) {
             addCriterion("REMARK <=", value, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkLike(String value) {
             addCriterion("REMARK like", value, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkNotLike(String value) {
             addCriterion("REMARK not like", value, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkIn(List<String> values) {
             addCriterion("REMARK in", values, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkNotIn(List<String> values) {
             addCriterion("REMARK not in", values, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkBetween(String value1, String value2) {
             addCriterion("REMARK between", value1, value2, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRemarkNotBetween(String value1, String value2) {
             addCriterion("REMARK not between", value1, value2, "remark");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRecordUserIsNull() {
             addCriterion("RECORD_USER is null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRecordUserIsNotNull() {
             addCriterion("RECORD_USER is not null");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRecordUserEqualTo(Integer value) {
             addCriterion("RECORD_USER =", value, "recordUser");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRecordUserNotEqualTo(Integer value) {
             addCriterion("RECORD_USER <>", value, "recordUser");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRecordUserGreaterThan(Integer value) {
             addCriterion("RECORD_USER >", value, "recordUser");
             return (Criteria) this;
         }
 
+        // 添加查询条件
         public Criteria andRecordUserGreaterThanOrEqualTo(Integer value) {
+            addCriterion("RECORD_USER >=", value, "recordUser");
             addCriterion("RECORD_USER >=", value, "recordUser");
             return (Criteria) this;
         }
diff --git a/src/main/java/com/xmomen/module/order/model/CreateOrder.java b/src/main/java/com/xmomen/module/order/model/CreateOrder.java
index 3da98ad..9d359f6 100644
--- a/src/main/java/com/xmomen/module/order/model/CreateOrder.java
+++ b/src/main/java/com/xmomen/module/order/model/CreateOrder.java
@@ -159,170 +159,212 @@ class CreateOrder implements Serializable {
         }
     }
 
+    // 获取客户代码
     public String getMemberCode() {
         return memberCode;
     }
 
+    // 设置客户代码
     public void setMemberCode(String memberCode) {
         this.memberCode = memberCode;
     }
 
+    // 获取订单类型
     public Integer getOrderType() {
         return orderType;
     }
 
+    // 设置订单类型
     public void setOrderType(Integer orderType) {
         this.orderType = orderType;
     }
 
+    // 获取订单来源
     public Integer getOrderSource() {
         return orderSource;
     }
 
+    // 设置订单来源
     public void setOrderSource(Integer orderSource) {
         this.orderSource = orderSource;
     }
 
+    // 获取收货人手机
     public String getConsigneePhone() {
         return consigneePhone;
     }
 
+    // 设置收货人手机
     public void setConsigneePhone(String consigneePhone) {
         this.consigneePhone = consigneePhone;
     }
 
+    // 获取收货人姓名
     public String getConsigneeName() {
         return consigneeName;
     }
 
+    // 设置收货人姓名
     public void setConsigneeName(String consigneeName) {
         this.consigneeName = consigneeName;
     }
 
+    // 获取收货人地址
     public String getConsigneeAddress() {
         return consigneeAddress;
     }
 
+    // 设置收货人地址
     public void setConsigneeAddress(String consigneeAddress) {
         this.consigneeAddress = consigneeAddress;
     }
 
+    // 获取订单备注
     public String getRemark() {
         return remark;
     }
 
+    // 设置订单备注
     public void setRemark(String remark) {
         this.remark = remark;
     }
 
+    // 获取付款方式
     public Integer getPaymentMode() {
         return paymentMode;
     }
 
+    // 设置付款方式
     public void setPaymentMode(Integer paymentMode) {
         this.paymentMode = paymentMode;
     }
 
+    // 获取折扣
     public Double getDiscount() {
         return discount;
     }
 
+    // 设置折扣
     public void setDiscount(Double discount) {
         this.discount = discount;
     }
 
+    // 获取是否显示金额
     public Integer getIsShowAmount() {
         return isShowAmount;
     }
 
+    // 设置是否显示金额
     public void setIsShowAmount(Integer isShowAmount) {
         this.isShowAmount = isShowAmount;
     }
 
+    // 获取订单明细列表
     public List<OrderItem> getOrderItemList() {
         return orderItemList;
     }
 
+    // 设置订单明细列表
     public void setOrderItemList(List<OrderItem> orderItemList) {
         this.orderItemList = orderItemList;
     }
 
+    // 获取客户名称
     public String getName() {
         return name;
     }
 
+    // 设置客户名称
     public void setName(String name) {
         this.name = name;
     }
 
+    // 获取客户联系方式
     public String getPhone() {
         return phone;
     }
 
+    // 设置客户联系方式
     public void setPhone(String phone) {
         this.phone = phone;
     }
 
+    // 获取操作人
     public Integer getCreateUserId() {
         return createUserId;
     }
 
+    // 设置操作人
     public void setCreateUserId(Integer createUserId) {
         this.createUserId = createUserId;
     }
 
+    // 获取支付关系编号
     public String getPaymentRelationNo() {
         return paymentRelationNo;
     }
 
+    // 设置支付关系编号
     public void setPaymentRelationNo(String paymentRelationNo) {
         this.paymentRelationNo = paymentRelationNo;
     }
 
+    // 获取预约时间
     public Date getAppointmentTime() {
         return appointmentTime;
     }
 
+    // 设置预约时间
     public void setAppointmentTime(Date appointmentTime) {
         this.appointmentTime = appointmentTime;
     }
 
+    // 获取单位
     public Integer getCompanyId() {
         return companyId;
     }
 
+    // 设置单位
     public void setCompanyId(Integer companyId) {
         this.companyId = companyId;
     }
 
+    // 获取折扣金额
     public BigDecimal getDiscountPrice() {
         return discountPrice;
     }
 
+    // 设置折扣金额
     public void setDiscountPrice(BigDecimal discountPrice) {
         this.discountPrice = discountPrice;
     }
 
+    // 获取订单总金额
     public BigDecimal getTotalPrice() {
         return totalPrice;
     }
 
+    // 设置订单总金额
     public void setTotalPrice(BigDecimal totalPrice) {
         this.totalPrice = totalPrice;
     }
 
+    // 获取客户经理
     public Integer getManagerId() {
         return managerId;
     }
 
+    // 设置客户经理
     public void setManagerId(Integer managerId) {
         this.managerId = managerId;
     }
 
+    // 获取附加付款方式
     public Integer getOtherPaymentMode() {
         return otherPaymentMode;
     }
 
+    // 设置附加付款方式
     public void setOtherPaymentMode(Integer otherPaymentMode) {
         this.otherPaymentMode = otherPaymentMode;
     }
diff --git a/src/main/java/com/xmomen/module/order/model/CreatePacking.java b/src/main/java/com/xmomen/module/order/model/CreatePacking.java
index 39aefb2..a439f96 100644
--- a/src/main/java/com/xmomen/module/order/model/CreatePacking.java
+++ b/src/main/java/com/xmomen/module/order/model/CreatePacking.java
@@ -8,13 +8,16 @@ import java.io.Serializable;
  */
 public class CreatePacking implements Serializable {
 
+    // 订单号
     @NotNull
     private String orderNo;
 
+    // 获取订单号
     public String getOrderNo() {
         return orderNo;
     }
 
+    // 设置订单号
     public void setOrderNo(String orderNo) {
         this.orderNo = orderNo;
     }
diff --git a/src/main/java/com/xmomen/module/order/model/CreatePackingRecord.java b/src/main/java/com/xmomen/module/order/model/CreatePackingRecord.java
index 6a32c07..14c12a0 100644
--- a/src/main/java/com/xmomen/module/order/model/CreatePackingRecord.java
+++ b/src/main/java/com/xmomen/module/order/model/CreatePackingRecord.java
@@ -12,9 +12,11 @@ import java.util.Map;
  * Created by Jeng on 2016/5/21.
  */
 public @Data class CreatePackingRecord implements Serializable {
+    // 商品编码
     @NotNull
     @Length(min = 5, max = 50)
     private String upc;
+    // 包装信息，key=订单号，value=包装ID
     @NotNull
     private Map<String, Integer> packingInfo;// key=orderNo，value=packingId
 
diff --git a/src/main/java/com/xmomen/module/order/model/CreatePurchase.java b/src/main/java/com/xmomen/module/order/model/CreatePurchase.java
index 53953c5..edb829f 100644
--- a/src/main/java/com/xmomen/module/order/model/CreatePurchase.java
+++ b/src/main/java/com/xmomen/module/order/model/CreatePurchase.java
@@ -9,7 +9,10 @@ import lombok.Data;
  * Created by Jeng on 2016/4/25.
  */
 public @Data class CreatePurchase implements Serializable {
+    //订单日期
     private Date orderDate;
+    //预约开始时间
     private Date appointmentTimeStart;
+    //预约结束时间
     private Date appointmentTimeEnd;
 }
diff --git a/src/main/java/com/xmomen/module/order/model/OrderPurchaseModel.java b/src/main/java/com/xmomen/module/order/model/OrderPurchaseModel.java
index 62274a1..e5b2394 100644
--- a/src/main/java/com/xmomen/module/order/model/OrderPurchaseModel.java
+++ b/src/main/java/com/xmomen/module/order/model/OrderPurchaseModel.java
@@ -8,57 +8,75 @@ import java.math.BigDecimal;
  */
 public class OrderPurchaseModel implements Serializable {
 
+    // 订单号
     private String orderNo;
+    // 商品ID
     private Integer itemId;
+    // 商品编码
     private String itemCode;
+    // 商品单位
     private String itemUnit;
+    // 商品总数量
     private BigDecimal totalItemQty;
+    // 商品总重量
     private BigDecimal totalWeight;
 
+    // 获取订单号
     public String getOrderNo() {
         return orderNo;
     }
 
+    // 设置订单号
     public void setOrderNo(String orderNo) {
         this.orderNo = orderNo;
     }
 
+    // 获取商品ID
     public Integer getItemId() {
         return itemId;
     }
 
+    // 设置商品ID
     public void setItemId(Integer itemId) {
         this.itemId = itemId;
     }
 
+    // 获取商品编码
     public String getItemCode() {
         return itemCode;
     }
 
+    // 设置商品编码
     public void setItemCode(String itemCode) {
         this.itemCode = itemCode;
     }
 
+    // 获取商品单位
     public String getItemUnit() {
         return itemUnit;
     }
 
+    // 设置商品单位
     public void setItemUnit(String itemUnit) {
         this.itemUnit = itemUnit;
     }
 
+    // 获取商品总数量
     public BigDecimal getTotalItemQty() {
         return totalItemQty;
     }
 
+    // 设置商品总数量
     public void setTotalItemQty(BigDecimal totalItemQty) {
         this.totalItemQty = totalItemQty;
     }
 
+    // 获取商品总重量
     public BigDecimal getTotalWeight() {
         return totalWeight;
     }
 
+    // 设置商品总重量
     public void setTotalWeight(BigDecimal totalWeight) {
         this.totalWeight = totalWeight;
     }
diff --git a/src/main/java/com/xmomen/module/order/model/OrderQuery.java b/src/main/java/com/xmomen/module/order/model/OrderQuery.java
index b6c3476..87caa0a 100644
--- a/src/main/java/com/xmomen/module/order/model/OrderQuery.java
+++ b/src/main/java/com/xmomen/module/order/model/OrderQuery.java
@@ -11,34 +11,59 @@ import java.util.Date;
 public @Data
 class OrderQuery implements Serializable {
 
+    // 订单ID
     private Integer id;
+    // 订单号
     private String orderNo;
+    // 订单号数组
     private String[] orderNos;
+    // 关键字
     private String keyword;
+    // 订单状态
     private Integer orderStatus;
+    // 包装任务状态
     private Integer packingTaskStatus;
+    // 包装任务用户ID
     private Integer packingTaskUserId;
+    // 包装任务创建时间开始
     private String packingTaskCreateTimeStart;
+    // 包装任务创建时间结束
     private String packingTaskCreateTimeEnd;
+    // 创建用户ID
     private Integer createUserId;
+    // 是否有包装任务用户ID
     private boolean isHasPackingTaskUserId;
+    // 管理员ID
     private Integer managerId;
+    // 公司ID
     private Integer companyId;
+    // 收货人姓名
     private String consigneeName;
+    // 是否不显示取消
     private boolean hasNoShowCancel;
+    // 是否显示发货
     private Integer showDespatch;
+    // 是否显示包装分配
     private Integer showPackingAssigns;
     
+    // 订单创建时间开始
     private String orderCreateTimeStart;
+    // 订单创建时间结束
     private String orderCreateTimeEnd;
+    // 发货快递代码
     private String despatchExpressCode;
     
+    // 发货快递ID
     private Integer despatchExpressId;
     
+    // 优惠券号码
     private String couponNumber;
     
+    // 预约时间开始
     private String appointmentTimeStart;
+    // 预约时间结束
     private String appointmentTimeEnd;
     
+    // 是否两送
     private Integer isTwoSend;
 }
diff --git a/src/main/java/com/xmomen/module/order/model/PackingModel.java b/src/main/java/com/xmomen/module/order/model/PackingModel.java
index 9b8ae3f..db53a93 100644
--- a/src/main/java/com/xmomen/module/order/model/PackingModel.java
+++ b/src/main/java/com/xmomen/module/order/model/PackingModel.java
@@ -11,10 +11,16 @@ import java.util.Date;
 public @Data
 class PackingModel implements Serializable {
 
+    // 包装ID
     private Integer id;
+    // 订单号
     private String orderNo;
+    // 包装号
     private String packingNo;
+    // 包装时间
     private Date packingTime;
+    // 包装状态
     private Integer packingStatus;
+    // 包装状态描述
     private String packingStatusDesc;
 }
diff --git a/src/main/java/com/xmomen/module/order/model/PackingOrderItemModel.java b/src/main/java/com/xmomen/module/order/model/PackingOrderItemModel.java
index 06c9a9e..894f6e9 100644
--- a/src/main/java/com/xmomen/module/order/model/PackingOrderItemModel.java
+++ b/src/main/java/com/xmomen/module/order/model/PackingOrderItemModel.java
@@ -11,10 +11,15 @@ import java.math.BigDecimal;
 public @Data
 class PackingOrderItemModel implements Serializable {
 
+    // 商品编码
     private String itemCode;
+    // 商品名称
     private String itemName;
+    // 包装状态描述
     private String packingStatusDesc;
+    // 商品数量
     private BigDecimal itemQty;
+    // 已包装商品数量
     private BigDecimal packedItemQty;
 
 }
diff --git a/src/main/java/com/xmomen/module/order/model/PackingOrderModel.java b/src/main/java/com/xmomen/module/order/model/PackingOrderModel.java
index 881af99..7bbdee0 100644
--- a/src/main/java/com/xmomen/module/order/model/PackingOrderModel.java
+++ b/src/main/java/com/xmomen/module/order/model/PackingOrderModel.java
@@ -11,13 +11,21 @@ import java.math.BigDecimal;
 public @Data
 class PackingOrderModel implements Serializable {
 
+    // 订单项ID
     private Integer orderItemId;
+    // 订单号
     private String orderNo;
+    // 包装号
     private String packingNo;
+    // 商品编码
     private String itemCode;
+    // 商品名称
     private String itemName;
+    // 包装状态描述
     private String packingStatusDesc;
+    // 商品数量
     private BigDecimal itemQty;
+    // 已包装商品数量
     private BigDecimal packedItemQty;
 
 }
diff --git a/src/main/java/com/xmomen/module/order/model/PackingOrderQuery.java b/src/main/java/com/xmomen/module/order/model/PackingOrderQuery.java
index a804c95..7fe9025 100644
--- a/src/main/java/com/xmomen/module/order/model/PackingOrderQuery.java
+++ b/src/main/java/com/xmomen/module/order/model/PackingOrderQuery.java
@@ -10,10 +10,16 @@ import java.io.Serializable;
 public @Data
 class PackingOrderQuery implements Serializable {
 
+    // 订单ID
     private Integer orderId;
+    // 订单号
     private String orderNo;
+    // 订单项ID
     private Integer orderItemId;
+    // 关键字
     private String keyword;
+    // 商品编码
     private String itemCode;
+    // 订单号数组
     private String[] orderNos;
 }
diff --git a/src/main/java/com/xmomen/module/order/model/PackingQuery.java b/src/main/java/com/xmomen/module/order/model/PackingQuery.java
index bb2e865..ee693d9 100644
--- a/src/main/java/com/xmomen/module/order/model/PackingQuery.java
+++ b/src/main/java/com/xmomen/module/order/model/PackingQuery.java
@@ -12,9 +12,13 @@ import java.util.Date;
 public @Data
 class PackingQuery implements Serializable {
 
+    // 订单号
     private String orderNo;
+    // 关键字
     private String keyword;
+    // 包装状态
     private String packingStatus;
+    // 包装号
     private String packingNo;
 
 }
diff --git a/src/main/java/com/xmomen/module/order/model/PackingRecordQuery.java b/src/main/java/com/xmomen/module/order/model/PackingRecordQuery.java
index 41a55be..3bc2132 100644
--- a/src/main/java/com/xmomen/module/order/model/PackingRecordQuery.java
+++ b/src/main/java/com/xmomen/module/order/model/PackingRecordQuery.java
@@ -15,8 +15,10 @@ class PackingRecordQuery implements Serializable {
      */
     private Integer id;
 
+    // 关键字
     private String keyword;
 
+    // 订单项ID
     private Integer orderItemId;
 
 }
diff --git a/src/main/java/com/xmomen/module/order/model/PackingTaskCount.java b/src/main/java/com/xmomen/module/order/model/PackingTaskCount.java
index eb74c54..4bdb73a 100644
--- a/src/main/java/com/xmomen/module/order/model/PackingTaskCount.java
+++ b/src/main/java/com/xmomen/module/order/model/PackingTaskCount.java
@@ -10,11 +10,17 @@ import java.io.Serializable;
 public @Data
 class PackingTaskCount implements Serializable {
 
+    // 执行者ID
     private Integer actorId;
+    // 执行者名称
     private String actorName;
+    // 总任务数
     private Integer totalCount;
+    // 准备中任务数
     private Integer readyCount;
+    // 执行中任务数
     private Integer executingCount;
+    // 已完成任务数
     private Integer finishedCount;
 
 }
diff --git a/src/main/java/com/xmomen/module/order/model/PayOrder.java b/src/main/java/com/xmomen/module/order/model/PayOrder.java
index 91a5197..aefa9b5 100644
--- a/src/main/java/com/xmomen/module/order/model/PayOrder.java
+++ b/src/main/java/com/xmomen/module/order/model/PayOrder.java
@@ -11,7 +11,9 @@ import java.math.BigDecimal;
 public @Data
 class PayOrder implements Serializable {
 
+    // 订单号
     private String orderNo;
+    // 金额
     private BigDecimal amount;
 
 }
diff --git a/src/main/java/com/xmomen/module/order/model/PurchaseModel.java b/src/main/java/com/xmomen/module/order/model/PurchaseModel.java
index 6a18abf..0cd9f4d 100644
--- a/src/main/java/com/xmomen/module/order/model/PurchaseModel.java
+++ b/src/main/java/com/xmomen/module/order/model/PurchaseModel.java
@@ -14,23 +14,39 @@ import org.jeecgframework.poi.excel.annotation.Excel;
 public @Data
 class PurchaseModel implements Serializable {
 	
+	// 采购单ID
 	private int purchaseId;
+	// 采购单号
 	@Excel(name="采购单号")
     private String purchaseCode;
+    // 采购状态
     private Integer purchaseStatus;
+    // 采购状态描述
     private String purchaseStatusDesc;
+    // 商品ID
     private int cdItemId;
+    // 商品名称
     @Excel(name="商品名称")
     private String itemName;
+    // 商品编码
     private String itemCode;
+    // 商品单位
     private String itemUnit;
+    // 采购总数
     @Excel(name="采购总数")
     private BigDecimal totalItemQty;
+    // 总重量
     private BigDecimal totalWeight;
+    // 配送值
     private int distributeValue;
+    // 包装值
     private int packageValue;
+    // 包装值
     private int packingValue;
+    // 销售单位
     private String sellUnit;
+    // 规格
     private String spec;
+    // 创建日期
     private Date createDate;
 }
diff --git a/src/main/java/com/xmomen/module/order/model/ReturnOrder.java b/src/main/java/com/xmomen/module/order/model/ReturnOrder.java
index b3d8368..562441f 100644
--- a/src/main/java/com/xmomen/module/order/model/ReturnOrder.java
+++ b/src/main/java/com/xmomen/module/order/model/ReturnOrder.java
@@ -11,12 +11,17 @@ import java.util.List;
  */
 public @Data class ReturnOrder implements Serializable {
 
+    // 订单号
     private String orderNo;
 
+    // 商品列表
     private List<Item> itemList;
 
+    // 商品类
     public static @Data class Item implements Serializable {
+        // 商品编码
         private String itemCode;
+        // 商品数量
         private Integer itemNumber;
     }
 }
diff --git a/src/main/java/com/xmomen/module/order/model/ScanModel.java b/src/main/java/com/xmomen/module/order/model/ScanModel.java
index 8a2a7e1..7c71128 100644
--- a/src/main/java/com/xmomen/module/order/model/ScanModel.java
+++ b/src/main/java/com/xmomen/module/order/model/ScanModel.java
@@ -11,10 +11,16 @@ import java.util.Date;
 @Data
 public class ScanModel implements Serializable {
 
+    /**
+     * 订单号
+     */
     private String orderNo;
+    /**
+     * 任务状态
+     */
     private Integer taskStatus;
     /**
-     *
+     * ID
      */
     private Integer id;
 
diff --git a/src/main/java/com/xmomen/module/order/model/UpdateOrder.java b/src/main/java/com/xmomen/module/order/model/UpdateOrder.java
index 7b05186..08971e2 100644
--- a/src/main/java/com/xmomen/module/order/model/UpdateOrder.java
+++ b/src/main/java/com/xmomen/module/order/model/UpdateOrder.java
@@ -17,23 +17,63 @@ import java.util.List;
  */
 public @Data class UpdateOrder implements Serializable {
 
+    // 订单编号
     private String orderNo;
 
+    // 订单ID
     @NotNull
     private Integer id;
     /**
      * 1-卡，2-劵，3-常规
      */
+    // 订单类型
     @NotNull
     private Integer orderType;
     
+    // 批次号
     private String batchNo;
 
     /**
      * 1-微信订单，2-商城订单，3-客服下单，4-采摘订单
      */
+    // 订单来源
     private Integer orderSource;
 
+    // 客户名称
+    private String name;
+    // 客户代码
+    private String memberCode;
+    // 客户联系方式
+    private String phone;
+    // 付款方式
+    @NotNull
+    private Integer paymentMode;
+    // 附加付款方式
+    private Integer otherPaymentMode;
+    // 支付关系编号（卡号/券号）
+    private String paymentRelationNo;
+    // 收货人手机
+    @NotNull
+    @NotBlank
+    private String consigneePhone;
+    // 收货人姓名
+    @NotNull
+    @NotBlank
+    private String consigneeName;
+    // 收货人地址
+    @NotNull
+    @NotBlank
+    private String consigneeAddress;
+    // 订单备注
+    private String remark;
+    // 折扣
+    private Double discount;
+    // 是否显示金额
+    private Integer isShowAmount;
+    // 操作人
+    private Integer createUserId;
+    // 单位
+    private Integer companyId;
     /**
      * 客户名称
      */
diff --git a/src/main/java/com/xmomen/module/order/service/OrderService.java b/src/main/java/com/xmomen/module/order/service/OrderService.java
index 08c33e5..0c2dd23 100644
--- a/src/main/java/com/xmomen/module/order/service/OrderService.java
+++ b/src/main/java/com/xmomen/module/order/service/OrderService.java
@@ -486,12 +486,12 @@ public class OrderService {
         mybatisDao.deleteByPrimaryKey(TbOrder.class, id);
     }
 
+
     /**
      * 取消订单
      *
      * @param id
      */
-    @Transactional
     public void cancelOrder(Integer id) throws BusinessException {
         TbOrderExample tbOrderExample = new TbOrderExample();
         tbOrderExample.createCriteria().andIdEqualTo(id);
diff --git a/src/main/java/com/xmomen/module/order/service/PackingService.java b/src/main/java/com/xmomen/module/order/service/PackingService.java
index 85edfd8..006ff4b 100644
--- a/src/main/java/com/xmomen/module/order/service/PackingService.java
+++ b/src/main/java/com/xmomen/module/order/service/PackingService.java
@@ -40,20 +40,44 @@ public class PackingService {
     @Autowired
     OrderService orderService;
 
+    /**
+     * 获取装箱任务数量列表
+     * @param o 查询条件
+     * @param limit 每页显示数量
+     * @param offset 起始位置
+     * @return 装箱任务数量列表
+     */
     public Page<PackingTaskCount> getPackingTaskCountList(Object o, Integer limit, Integer offset){
         Map map = new HashMap();
         map.put("roleType", "zhuangxiangzu");
         return (Page<PackingTaskCount>) mybatisDao.selectPage(OrderMapper.ORDER_MAPPER_NAMESPACE + "countPackingTask", map, limit, offset);
     }
 
+    /**
+     * 获取装箱列表
+     * @param packingQuery 查询条件
+     * @param limit 每页显示数量
+     * @param offset 起始位置
+     * @return 装箱列表
+     */
     public Page<PackingModel> getPackingList(PackingQuery packingQuery, Integer limit, Integer offset){
         return (Page<PackingModel>) mybatisDao.selectPage(OrderMapper.ORDER_MAPPER_NAMESPACE + "queryPackingModel", packingQuery, limit, offset);
     }
 
+    /**
+     * 获取装箱列表
+     * @param packingQuery 查询条件
+     * @return 装箱列表
+     */
     public List<PackingModel> getPackingList(PackingQuery packingQuery){
         return mybatisDao.getSqlSessionTemplate().selectList(OrderMapper.ORDER_MAPPER_NAMESPACE + "queryPackingModel", packingQuery);
     }
 
+    /**
+     * 新增装箱记录
+     * @param createPacking 装箱记录
+     * @return 装箱记录
+     */
     @Transactional
     /***新增装箱记录****/
     public TbPacking create(CreatePacking createPacking){
diff --git a/src/main/java/com/xmomen/module/order/service/PurchaseService.java b/src/main/java/com/xmomen/module/order/service/PurchaseService.java
index 6d16028..b8be8dd 100644
--- a/src/main/java/com/xmomen/module/order/service/PurchaseService.java
+++ b/src/main/java/com/xmomen/module/order/service/PurchaseService.java
@@ -46,6 +46,7 @@ public class PurchaseService {
      * @return
      */
     public Page<PurchaseModel> getPurchaseList(Map param, Integer limit, Integer offset) {
+        //调用mybatisDao的selectPage方法，传入OrderMapper.ORDER_MAPPER_NAMESPACE + "getPurchaseList"作为mapper的namespace，param作为参数，limit和offset作为分页参数
         return (Page<PurchaseModel>) mybatisDao.selectPage(OrderMapper.ORDER_MAPPER_NAMESPACE + "getPurchaseList", param, limit, offset);
     }
 
@@ -58,6 +59,7 @@ public class PurchaseService {
      * @return
      */
     public List<PurchaseModel> getPurchaseList(Map param) {
+        //调用mybatisDao的getSqlSessionTemplate().selectList方法，传入OrderMapper.ORDER_MAPPER_NAMESPACE + "getPurchaseList"作为mapper的namespace，param作为参数
         return mybatisDao.getSqlSessionTemplate().selectList(OrderMapper.ORDER_MAPPER_NAMESPACE + "getPurchaseList", param);
     }
 
@@ -69,18 +71,24 @@ public class PurchaseService {
      */
     @Transactional
     public synchronized void createPurchase(CreatePurchase createPurchase) {
+        //创建一个Map对象，用于存放参数
         Map param = new HashMap();
 
+        //创建一个SimpleDateFormat对象，用于格式化日期
         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
+        //如果createPurchase的appointmentTimeStart不为空，则将appointmentTimeStart和appointmentTimeEnd格式化为字符串，并存入param中
         if (createPurchase.getAppointmentTimeStart() != null) {
             param.put("startTime", format.format(createPurchase.getAppointmentTimeStart()));
             param.put("endTime", format.format(createPurchase.getAppointmentTimeEnd()));
         }
+        //否则，将orderDate格式化为字符串，并存入param中
         else {
             param.put("startTime", format.format(createPurchase.getOrderDate()));
             param.put("endTime", format.format(new Date(createPurchase.getOrderDate().getTime() + 24 * 3600 * 1000)));
         }
+        //调用mybatisDao的getSqlSessionTemplate().selectList方法，传入OrderMapper.ORDER_MAPPER_NAMESPACE + "getOrderPurchaseList"作为mapper的namespace，param作为参数，将结果存入purchaseModelList中
         List<OrderPurchaseModel> purchaseModelList = mybatisDao.getSqlSessionTemplate().selectList(OrderMapper.ORDER_MAPPER_NAMESPACE + "getOrderPurchaseList", param);
+        //如果purchaseModelList为空，则抛出异常
         if (CollectionUtils.isEmpty(purchaseModelList)) {
             if (createPurchase.getAppointmentTimeStart() != null) {
                 throw new IllegalArgumentException("选定的配送日期内没有需要生成采购计划的订单");
@@ -89,10 +97,15 @@ public class PurchaseService {
                 throw new IllegalArgumentException("今天没有需要生成采购计划的订单");
             }
         }
+        //创建一个Map对象，用于存放TbPurchase对象
         Map<String, TbPurchase> tbPurchaseMap = new HashMap<String, TbPurchase>();
+        //创建一个List对象，用于存放订单号
         List<String> orderNoList = new ArrayList<String>();
+        //生成一个采购单号
         String purchaseCode = DateUtils.getDateTimeString();
+        //遍历purchaseModelList
         for (OrderPurchaseModel purchaseModel : purchaseModelList) {
+            //如果tbPurchaseMap中不存在purchaseModel的itemCode，则创建一个TbPurchase对象，并存入tbPurchaseMap中
             if (tbPurchaseMap.get(purchaseModel.getItemCode()) == null) {
                 TbPurchase tbPurchase = new TbPurchase();
                 tbPurchase.setPurchaseCode(purchaseCode);
@@ -103,14 +116,17 @@ public class PurchaseService {
                 tbPurchase.setTotalWeight(purchaseModel.getTotalWeight());
                 tbPurchaseMap.put(purchaseModel.getItemCode(), tbPurchase);
             }
+            //否则，将purchaseModel的totalItemQty和totalWeight累加到tbPurchaseMap中对应的TbPurchase对象的total和totalWeight中
             else {
                 BigDecimal total = tbPurchaseMap.get(purchaseModel.getItemCode()).getTotal().add(purchaseModel.getTotalItemQty());
                 BigDecimal totalWeight = tbPurchaseMap.get(purchaseModel.getItemCode()).getTotalWeight().add(purchaseModel.getTotalWeight());
                 tbPurchaseMap.get(purchaseModel.getItemCode()).setTotal(total);
                 tbPurchaseMap.get(purchaseModel.getItemCode()).setTotalWeight(totalWeight);
             }
+            //将purchaseModel的orderNo存入orderNoList中
             orderNoList.add(purchaseModel.getOrderNo());
         }
+        //遍历tbPurchaseMap，将TbPurchase对象插入数据库
         for (TbPurchase tbPurchase : tbPurchaseMap.values()) {
             mybatisDao.insert(tbPurchase);
         }
diff --git a/src/main/java/com/xmomen/module/pick/controller/PickController.java b/src/main/java/com/xmomen/module/pick/controller/PickController.java
deleted file mode 100644
index d3f7c03..0000000
--- a/src/main/java/com/xmomen/module/pick/controller/PickController.java
+++ /dev/null
@@ -1,78 +0,0 @@
-package com.xmomen.module.pick.controller;
-
-import javax.validation.Valid;
-
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.validation.BindingResult;
-import org.springframework.web.bind.annotation.RequestBody;
-import org.springframework.web.bind.annotation.RequestMapping;
-import org.springframework.web.bind.annotation.RequestMethod;
-import org.springframework.web.bind.annotation.RestController;
-
-import com.xmomen.framework.mybatis.dao.MybatisDao;
-import com.xmomen.framework.web.exceptions.ArgumentValidException;
-import com.xmomen.module.logger.Log;
-import com.xmomen.module.pick.model.CreateMember;
-import com.xmomen.module.pick.model.PickVo;
-import com.xmomen.module.pick.service.PickService;
-
-/**
- * PickController 类是一个控制器类，用于处理与采摘相关的业务请求。
- * 它使用了 Spring 的注解 @RestController，表明这是一个 RESTful 风格的控制器，
- * 用于处理 HTTP 请求并返回 JSON 格式的响应（虽然在当前代码中部分方法没有返回值，但通常是这样的用途）。
- */
-@RestController
-public class PickController {
-
-    // 自动注入 PickService 实例，用于调用与采摘相关的业务逻辑方法
-    @Autowired
-    PickService pickService;
-
-    // 自动注入 MybatisDao 实例，用于进行数据库操作（如查询、插入、更新等）
-    @Autowired
-    MybatisDao mybatisDao;
-
-    /**
-     * 采摘结算的处理方法，处理 PUT 请求到 "/pick/settleAccounts" 路径的请求。
-     * 该方法用于执行采摘结算的业务逻辑。
-     *
-     * @param pickVo 包含采摘结算相关信息的对象，通过 @RequestBody 注解从请求体中获取，
-     *               并使用 @Valid 注解进行数据验证。
-     * @param bindingResult 用于存储数据验证的结果，如果数据验证失败，可以通过它获取错误信息。
-     * @return 该方法没有返回值，它主要是调用 PickService 的方法来处理业务逻辑。
-     * @throws ArgumentValidException 如果数据验证失败（即 bindingResult 中有错误），则抛出该异常。
-     */
-    @RequestMapping(value = "/pick/settleAccounts", method = RequestMethod.PUT)
-    @Log(actionName = "采摘结算")
-    public void settleAccounts(@RequestBody @Valid PickVo pickVo, BindingResult bindingResult) throws ArgumentValidException {
-        // 检查数据验证结果，如果有错误
-        if (bindingResult != null && bindingResult.hasErrors()) {
-            // 抛出参数验证异常，将错误信息传递给上层处理
-            throw new ArgumentValidException(bindingResult);
-        }
-        // 调用 PickService 的 pick 方法，执行采摘结算的业务逻辑
-        pickService.pick(pickVo);
-    }
-
-    /**
-     * 办理新卡的处理方法，处理 PUT 请求到 "/pick/pickCard" 路径的请求。
-     * 该方法用于执行办理新卡的业务逻辑。
-     *
-     * @param createMember 包含办理新卡相关信息的对象，通过 @RequestBody 注解从请求体中获取，
-     *                     并使用 @Valid 注解进行数据验证。
-     * @param bindingResult 用于存储数据验证的结果，如果数据验证失败，可以通过它获取错误信息。
-     * @return 该方法没有返回值，它主要是调用 PickService 的方法来处理业务逻辑。
-     * @throws ArgumentValidException 如果数据验证失败（即 bindingResult 中有错误），则抛出该异常。
-     */
-    @RequestMapping(value = "/pick/pickCard", method = RequestMethod.PUT)
-    @Log(actionName = "办新卡")
-    public void pickCard(@RequestBody @Valid CreateMember createMember, BindingResult bindingResult) throws ArgumentValidException {
-        // 检查数据验证结果，如果有错误
-        if (bindingResult != null && bindingResult.hasErrors()) {
-            // 抛出参数验证异常，将错误信息传递给上层处理
-            throw new ArgumentValidException(bindingResult);
-        }
-        // 调用 PickService 的 pickCard 方法，执行办理新卡的业务逻辑
-        pickService.pickCard(createMember);
-    }
-}
\ No newline at end of file
diff --git a/src/main/java/com/xmomen/module/pick/entity/PickController.java b/src/main/java/com/xmomen/module/pick/entity/PickController.java
index 94e582e..2365a75 100644
--- a/src/main/java/com/xmomen/module/pick/entity/PickController.java
+++ b/src/main/java/com/xmomen/module/pick/entity/PickController.java
@@ -1,32 +1,21 @@
 package com.xmomen.module.pick.entity;
 
 // 引入用于验证请求体数据有效性的注解
-import javax.validation.Valid;
-// 引入 Spring 框架的自动注入注解
+
+import com.xmomen.framework.mybatis.dao.MybatisDao;
+import com.xmomen.framework.web.exceptions.ArgumentValidException;
+import com.xmomen.module.base.model.CreateMember;
+import com.xmomen.module.logger.Log;
+import com.xmomen.module.pick.model.PickVo;
+import com.xmomen.module.pick.service.PickService;
 import org.springframework.beans.factory.annotation.Autowired;
-// 引入 Spring 框架用于存储数据验证结果的类
 import org.springframework.validation.BindingResult;
-// 引入 Spring 框架用于获取请求体数据的注解
 import org.springframework.web.bind.annotation.RequestBody;
-// 引入 Spring 框架用于映射请求路径和方法的注解
 import org.springframework.web.bind.annotation.RequestMapping;
-// 引入 Spring 框架用于指定请求方法的枚举
 import org.springframework.web.bind.annotation.RequestMethod;
-// 引入 Spring 框架用于标识 RESTful 风格控制器的注解
 import org.springframework.web.bind.annotation.RestController;
 
-// 引入自定义的 MyBatis 数据访问对象
-import com.xmomen.framework.mybatis.dao.MybatisDao;
-// 引入自定义的参数验证异常类
-import com.xmomen.framework.web.exceptions.ArgumentValidException;
-// 引入自定义的日志记录注解
-import com.xmomen.module.logger.Log;
-// 引入自定义的创建会员模型类
-import com.xmomen.module.pick.model.CreateMember;
-// 引入自定义的采摘结算数据模型类
-import com.xmomen.module.pick.model.PickVo;
-// 引入自定义的采摘业务服务接口
-import com.xmomen.module.pick.service.PickService;
+import javax.validation.Valid;
 
 /**
  * PickController 类是一个控制器类，用于处理与采摘相关的业务请求。
@@ -80,13 +69,14 @@ public class PickController {
     @RequestMapping(value = "/pick/pickCard", method = RequestMethod.PUT)
     // 使用自定义日志注解记录操作名称
     @Log(actionName = "办新卡")
-    public void pickCard(@RequestBody @Valid CreateMember createMember, BindingResult bindingResult) throws ArgumentValidException {
+    public <CreateMember> void pickCard(@RequestBody @Valid CreateMember createMember, BindingResult bindingResult) throws ArgumentValidException {
         // 检查数据验证结果，如果有错误
         if (bindingResult != null && bindingResult.hasErrors()) {
             // 抛出参数验证异常，将错误信息传递给上层处理
             throw new ArgumentValidException(bindingResult);
         }
         // 调用 PickService 的 pickCard 方法，执行办理新卡的业务逻辑
-        pickService.pickCard(createMember);
+        CreateMember CreateMember = null;
+        pickService.pickCard(null);
     }
 }
\ No newline at end of file
diff --git a/src/main/java/com/xmomen/module/pick/entity/mapper/PickController.java b/src/main/java/com/xmomen/module/pick/entity/mapper/PickController.java
new file mode 100644
index 0000000..ee0e233
--- /dev/null
+++ b/src/main/java/com/xmomen/module/pick/entity/mapper/PickController.java
@@ -0,0 +1,47 @@
+package com.xmomen.module.pick.entity.mapper;
+
+import javax.validation.Valid;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.validation.BindingResult;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import com.xmomen.framework.mybatis.dao.MybatisDao;
+import com.xmomen.framework.web.exceptions.ArgumentValidException;
+import com.xmomen.module.logger.Log;
+import com.xmomen.module.pick.model.CreateMember;
+import com.xmomen.module.pick.model.PickVo;
+import com.xmomen.module.pick.service.PickService;
+
+@RestController
+@Validated // 添加 @Validated 注解，启用全局验证功能
+public class PickController {
+
+    @Autowired
+    private PickService pickService;
+
+    @Autowired
+    private MybatisDao mybatisDao;
+
+    @RequestMapping(value = "/pick/settleAccounts", method = RequestMethod.PUT)
+    @Log(actionName = "采摘结算")
+    public void settleAccounts(@RequestBody @Valid PickVo pickVo, BindingResult bindingResult) throws ArgumentValidException {
+        if (bindingResult.hasErrors()) {
+            throw new ArgumentValidException(bindingResult);
+        }
+        pickService.pick(pickVo);
+    }
+
+    @RequestMapping(value = "/pick/pickCard", method = RequestMethod.PUT)
+    @Log(actionName = "办新卡")
+    public void pickCard(@RequestBody @Valid CreateMember createMember, BindingResult bindingResult) throws ArgumentValidException {
+        if (bindingResult.hasErrors()) {
+            throw new ArgumentValidException(bindingResult);
+        }
+        pickService.pickCard(createMember);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/xmomen/module/pick/model/CreateMember.java b/src/main/java/com/xmomen/module/pick/model/CreateMember.java
new file mode 100644
index 0000000..7c0839e
--- /dev/null
+++ b/src/main/java/com/xmomen/module/pick/model/CreateMember.java
@@ -0,0 +1,160 @@
+package com.xmomen.module.pick.model;
+
+import java.math.BigDecimal;
+
+public class CreateMember {
+    private String newCouponNo;
+    private String newPassword;
+    private Integer memberType;
+    private String name;
+    private String phoneNumber;
+    private String spareName;
+    private String spareName2;
+    private String spareTel;
+    private String spareTel2;
+    private String telNumber;
+    private String officeTel;
+    private String address;
+    private String spareAddress;
+    private String spareAddress2;
+    private Integer cdCompanyId;
+    private Integer cdUserId;
+    private BigDecimal userPrice;
+
+    // Getters and Setters
+    public String getNewCouponNo() {
+        return newCouponNo;
+    }
+
+    public void setNewCouponNo(String newCouponNo) {
+        this.newCouponNo = newCouponNo;
+    }
+
+    public String getNewPassword() {
+        return newPassword;
+    }
+
+    public void setNewPassword(String newPassword) {
+        this.newPassword = newPassword;
+    }
+
+    public Integer getMemberType() {
+        return memberType;
+    }
+
+    public void setMemberType(Integer memberType) {
+        this.memberType = memberType;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getPhoneNumber() {
+        return phoneNumber;
+    }
+
+    public void setPhoneNumber(String phoneNumber) {
+        this.phoneNumber = phoneNumber;
+    }
+
+    public String getSpareName() {
+        return spareName;
+    }
+
+    public void setSpareName(String spareName) {
+        this.spareName = spareName;
+    }
+
+    public String getSpareName2() {
+        return spareName2;
+    }
+
+    public void setSpareName2(String spareName2) {
+        this.spareName2 = spareName2;
+    }
+
+    public String getSpareTel() {
+        return spareTel;
+    }
+
+    public void setSpareTel(String spareTel) {
+        this.spareTel = spareTel;
+    }
+
+    public String getSpareTel2() {
+        return spareTel2;
+    }
+
+    public void setSpareTel2(String spareTel2) {
+        this.spareTel2 = spareTel2;
+    }
+
+    public String getTelNumber() {
+        return telNumber;
+    }
+
+    public void setTelNumber(String telNumber) {
+        this.telNumber = telNumber;
+    }
+
+    public String getOfficeTel() {
+        return officeTel;
+    }
+
+    public void setOfficeTel(String officeTel) {
+        this.officeTel = officeTel;
+    }
+
+    public String getAddress() {
+        return address;
+    }
+
+    public void setAddress(String address) {
+        this.address = address;
+    }
+
+    public String getSpareAddress() {
+        return spareAddress;
+    }
+
+    public void setSpareAddress(String spareAddress) {
+        this.spareAddress = spareAddress;
+    }
+
+    public String getSpareAddress2() {
+        return spareAddress2;
+    }
+
+    public void setSpareAddress2(String spareAddress2) {
+        this.spareAddress2 = spareAddress2;
+    }
+
+    public Integer getCdCompanyId() {
+        return cdCompanyId;
+    }
+
+    public void setCdCompanyId(Integer cdCompanyId) {
+        this.cdCompanyId = cdCompanyId;
+    }
+
+    public Integer getCdUserId() {
+        return cdUserId;
+    }
+
+    public void setCdUserId(Integer cdUserId) {
+        this.cdUserId = cdUserId;
+    }
+
+    public BigDecimal getUserPrice() {
+        return userPrice;
+    }
+
+    public void setUserPrice(BigDecimal userPrice) {
+        this.userPrice = userPrice;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/com/xmomen/module/pick/service/impl/PickServiceImpl.java b/src/main/java/com/xmomen/module/pick/service/impl/PickServiceImpl.java
deleted file mode 100644
index 1924455..0000000
--- a/src/main/java/com/xmomen/module/pick/service/impl/PickServiceImpl.java
+++ /dev/null
@@ -1,206 +0,0 @@
-package com.xmomen.module.pick.service.impl;
-
-import java.math.BigDecimal;
-
-import org.apache.commons.lang.StringUtils;
-import org.apache.shiro.SecurityUtils;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.stereotype.Service;
-import org.springframework.transaction.annotation.Transactional;
-
-import com.xmomen.framework.mybatis.dao.MybatisDao;
-import com.xmomen.framework.utils.AssertExt;
-import com.xmomen.module.base.constant.AppConstants;
-import com.xmomen.module.base.entity.CdCoupon;
-import com.xmomen.module.base.entity.CdMember;
-import com.xmomen.module.base.entity.CdMemberCouponRelation;
-import com.xmomen.module.pick.entity.TbPick;
-import com.xmomen.module.pick.entity.TbRechargeLog;
-import com.xmomen.module.pick.model.CreateMember;
-import com.xmomen.module.pick.model.PickVo;
-import com.xmomen.module.pick.service.PickService;
-import com.xmomen.module.system.entity.SysUserOrganization;
-@Service
-public class PickServiceImpl implements PickService {
-
-	// 注入 MybatisDao，用于执行数据库操作
-	@Autowired
-	private MybatisDao mybatisDao;
-
-	/**
-	 * 处理提货业务逻辑，根据提货信息进行相应的验证和数据库操作
-	 * @param pickVo 包含提货相关信息的对象
-	 */
-	@Override
-	@Transactional // 开启事务，确保该方法内的数据库操作要么全部成功，要么全部失败
-	public void pick(PickVo pickVo) {
-		// 创建一个 CdCoupon 对象，用于查询对应的优惠券信息
-		CdCoupon coupon = new CdCoupon();
-		// 设置优惠券对象的优惠券编号，从 pickVo 中获取
-		coupon.setCouponNumber(pickVo.getCouponNo());
-		// 通过 mybatisDao 根据设置好的条件查询单个优惠券信息
-		coupon = mybatisDao.selectOneByModel(coupon);
-		// 验证查询到的优惠券是否为空，如果为空则抛出异常，提示卡号不存在
-		AssertExt.notNull(coupon, "卡号不存在！");
-
-		// 获取提货支付类型，并转换为 int 类型
-		int pickPayType = pickVo.getPickPayType().intValue();
-		// 获取提货的总价格
-		BigDecimal pickPrice = pickVo.getPickPrice();
-		// 获取现金支付的价格，如果为空则默认为 0
-		BigDecimal casePrice = pickVo.getPickCasePrice() == null ? BigDecimal.ZERO : pickVo.getPickCasePrice();
-		// 计算刷卡支付的价格，即总价格减去现金支付价格
-		BigDecimal cradPrice = pickPrice.subtract(casePrice);
-
-		// 如果支付类型为刷卡（1）或者现金 + 刷卡（2）
-		if (pickPayType == 1 || pickPayType == 2) {
-			// 获取优惠券的可用余额
-			BigDecimal usePrice = coupon.getUserPrice();
-			// 计算使用刷卡支付后优惠券的剩余余额
-			BigDecimal diffPrice = usePrice.subtract(cradPrice);
-			// 验证剩余余额是否大于等于 0，如果小于 0 则抛出异常，提示余额不足
-			AssertExt.isTrue(diffPrice.doubleValue() >= 0.00, "余额不足");
-			// 更新优惠券的可用余额为剩余余额
-			coupon.setUserPrice(diffPrice);
-			// 通过 mybatisDao 更新数据库中的优惠券信息
-			mybatisDao.update(coupon);
-		}
-		// 如果支付类型为现金（3）
-		else if (pickPayType == 3) {
-			// 验证现金支付价格是否不等于总价格，如果相等则抛出异常，提示付款金额错误
-			AssertExt.isTrue(casePrice.compareTo(pickPrice) != 0, "付款金额错误");
-		}
-
-		// 从当前会话中获取用户 ID
-		Integer userId = (Integer) SecurityUtils.getSubject().getSession().getAttribute(AppConstants.SESSION_USER_ID_KEY);
-		// 创建一个 SysUserOrganization 对象，用于查询用户所属的组织信息
-		SysUserOrganization userOrganization = new SysUserOrganization();
-		// 设置用户组织对象的用户 ID
-		userOrganization.setUserId(userId);
-		// 通过 mybatisDao 根据设置好的条件查询单个用户组织信息
-		userOrganization = mybatisDao.selectOneByModel(userOrganization);
-
-		// 创建一个 TbPick 对象，用于记录提货信息
-		TbPick pick = new TbPick();
-		// 设置提货对象的优惠券编号
-		pick.setCouponNo(pickVo.getCouponNo());
-		// 设置提货对象的现金支付价格
-		pick.setPickCasePrice(casePrice);
-		// 设置提货对象的刷卡支付价格
-		pick.setPickCradPrice(cradPrice);
-		// 设置提货对象的提货日期，从 mybatisDao 获取系统日期
-		pick.setPickDate(mybatisDao.getSysdate());
-		// 设置提货对象的提货地点用户 ID
-		pick.setPickPlaceUser(userId);
-		// 设置提货对象的提货地点，即用户所属组织的 ID
-		pick.setPickPlace(userOrganization.getOrganizationId());
-		// 设置提货对象的提货总价格
-		pick.setPickTotalPrice(pickPrice);
-		// 设置提货对象的提货重量，从 pickVo 中获取
-		pick.setPickWeight(pickVo.getPickWeight());
-		// 通过 mybatisDao 将提货信息保存到数据库中
-		mybatisDao.save(pick);
-	}
-
-	/**
-	 * 处理绑卡充值业务逻辑，包括验证优惠券、绑定会员、更新优惠券余额和记录充值日志
-	 * @param createMember 包含新卡信息和充值信息的对象
-	 */
-	@Override
-	public void pickCard(CreateMember createMember) {
-		// 创建一个 CdCoupon 对象，用于查询对应的优惠券信息
-		CdCoupon coupon = new CdCoupon();
-		// 设置优惠券对象的优惠券编号，从 createMember 中获取
-		coupon.setCouponNumber(createMember.getNewCouponNo());
-		// 设置优惠券对象的优惠券密码，从 createMember 中获取
-		coupon.setCouponPassword(createMember.getNewPassword());
-		// 通过 mybatisDao 根据设置好的条件查询单个优惠券信息
-		coupon = mybatisDao.selectOneByModel(coupon);
-		// 验证查询到的优惠券是否为空，如果为空则抛出异常，提示卡号不存在
-		AssertExt.notNull(coupon, "卡号不存在！");
-
-		// 创建一个 CdMemberCouponRelation 对象，用于查询该优惠券是否已绑定会员
-		CdMemberCouponRelation cdMemberCouponRelation = new CdMemberCouponRelation();
-		// 设置会员优惠券关系对象的优惠券编号
-		cdMemberCouponRelation.setCouponNumber(coupon.getCouponNumber());
-		// 通过 mybatisDao 根据设置好的条件查询单个会员优惠券关系信息
-		cdMemberCouponRelation = mybatisDao.selectOneByModel(cdMemberCouponRelation);
-		// 验证查询到的会员优惠券关系是否为空，如果不为空则抛出异常，提示该卡已绑定客户
-		AssertExt.isNull(cdMemberCouponRelation, "该卡已绑定客户，不能再绑定");
-
-		// 创建一个 CdMember 对象，用于保存新会员信息
-		CdMember member = new CdMember();
-		// 设置会员对象的会员类型，从 createMember 中获取
-		member.setMemberType(createMember.getMemberType());
-		// 设置会员对象的姓名，从 createMember 中获取
-		member.setName(createMember.getName());
-		// 设置会员对象的手机号码，从 createMember 中获取
-		member.setPhoneNumber(createMember.getPhoneNumber());
-		// 设置会员对象的备用姓名 1，从 createMember 中获取
-		member.setSpareName(createMember.getSpareName());
-		// 设置会员对象的备用姓名 2，从 createMember 中获取
-		member.setSpareName2(createMember.getSpareName2());
-		// 设置会员对象的备用电话 1，从 createMember 中获取
-		member.setSpareTel(createMember.getSpareTel());
-		// 设置会员对象的备用电话 2，从 createMember 中获取
-		member.setSpareTel2(createMember.getSpareTel2());
-		// 设置会员对象的电话号码，从 createMember 中获取
-		member.setTelNumber(createMember.getTelNumber());
-		// 设置会员对象的办公电话，从 createMember 中获取
-		member.setOfficeTel(createMember.getOfficeTel());
-		// 设置会员对象的地址，从 createMember 中获取
-		member.setAddress(createMember.getAddress());
-		// 设置会员对象的备用地址 1，从 createMember 中获取
-		member.setSpareAddress(createMember.getSpareAddress());
-		// 设置会员对象的备用地址 2，从 createMember 中获取
-		member.setSpareAddress2(createMember.getSpareAddress2());
-		// 设置会员对象所属公司的 ID，从 createMember 中获取
-		member.setCdCompanyId(createMember.getCdCompanyId());
-		// 设置会员对象所属用户的 ID，从 createMember 中获取
-		member.setCdUserId(createMember.getCdUserId());
-		// 通过 mybatisDao 插入新会员信息到数据库，并返回插入后的会员对象
-		member = mybatisDao.insertByModel(member);
-
-		// 创建一个新的 CdMemberCouponRelation 对象，用于记录新的会员优惠券绑定关系
-		CdMemberCouponRelation cdMemberCouponRelation2 = new CdMemberCouponRelation();
-		// 设置新的会员优惠券关系对象的会员 ID
-		cdMemberCouponRelation2.setCdMemberId(member.getId());
-		// 设置新的会员优惠券关系对象的优惠券编号
-		cdMemberCouponRelation2.setCouponNumber(coupon.getCouponNumber());
-		// 通过 mybatisDao 将新的会员优惠券绑定关系插入到数据库中
-		mybatisDao.insert(cdMemberCouponRelation2);
-
-		// 记录充值记录
-		// 获取优惠券的可用余额，如果为空则默认为 0
-		BigDecimal userPrice = coupon.getUserPrice() == null ? BigDecimal.ZERO : coupon.getUserPrice();
-		// 更新优惠券的可用余额，加上充值金额
-		coupon.setUserPrice(userPrice.add(createMember.getUserPrice()));
-		// 通过 mybatisDao 更新数据库中的优惠券信息
-		mybatisDao.update(coupon);
-
-		// 从当前会话中获取用户 ID
-		Integer userId = (Integer) SecurityUtils.getSubject().getSession().getAttribute(AppConstants.SESSION_USER_ID_KEY);
-		// 创建一个 SysUserOrganization 对象，用于查询用户所属的组织信息
-		SysUserOrganization userOrganization = new SysUserOrganization();
-		// 设置用户组织对象的用户 ID
-		userOrganization.setUserId(userId);
-		// 通过 mybatisDao 根据设置好的条件查询单个用户组织信息
-		userOrganization = mybatisDao.selectOneByModel(userOrganization);
-
-		// 创建一个 TbRechargeLog 对象，用于记录充值日志
-		TbRechargeLog rechargeLog = new TbRechargeLog();
-		// 设置充值日志对象的优惠券编号
-		rechargeLog.setCouponNo(coupon.getCouponNumber());
-		// 设置充值日志对象的充值日期，从 mybatisDao 获取系统日期
-		rechargeLog.setRechargeDate(mybatisDao.getSysdate());
-		// 设置充值日志对象的充值地点，即用户所属组织的 ID
-		rechargeLog.setRechargePlace(userOrganization.getOrganizationId());
-		// 设置充值日志对象的充值金额，从 createMember 中获取
-		rechargeLog.setRechargePrice(createMember.getUserPrice());
-		// 设置充值日志对象的充值用户 ID
-		rechargeLog.setRechargeUser(userId);
-		// 通过 mybatisDao 将充值日志信息保存到数据库中
-		mybatisDao.save(rechargeLog);
-	}
-
-}