lzh

src/main/java/com/xmomen/module/receipt/controller/ReceivingCodeRequestController.java

@@ -19,12 +19,10 @@ import com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper;
 public class ReceivingCodeRequestController {
 	@Autowired
     MybatisDao mybatisDao;
-	
+
-    /**
+    /*
-     * 查询收货码请求
+    查询收货码请求
-     * @param id
+    */
-     * @return
-     */
     @RequestMapping(value = "/receivingCodeRequest", method = RequestMethod.GET)
     @Log(actionName = "查询收货码请求")
     public Page<TbReceivingCodeRequest> getExpressList(@RequestParam(value = "limit") Integer limit,
@@ -38,6 +36,7 @@ public class ReceivingCodeRequestController {
          map.put("keyword", keyword);
          map.put("requestTimeStart", requestTimeStart);
          map.put("requestTimeEnd", requestTimeEnd);
+        // 调用mybatisDao的selectPage方法，传入ReceivingCodeRequestMapperNameSpace + "getReceivingCodeRequestList"作为参数，map作为参数，limit和offset作为参数
         return (Page<TbReceivingCodeRequest>) mybatisDao.selectPage(ReceivingCodeRequestMapper.ReceivingCodeRequestMapperNameSpace + "getReceivingCodeRequestList", map, limit, offset);
     }
     

src/main/java/com/xmomen/module/receipt/controller/ReturnOrderController.java

@@ -22,9 +22,7 @@ import com.xmomen.module.receipt.model.ReturnOrderModel;
 import com.xmomen.module.receipt.model.ReturnOrderQuery;
 import com.xmomen.module.receipt.service.ReturnOrderService;
 
-/**
+
- * Created by Jeng on 2016/3/30.
- */
 @RestController
 public class ReturnOrderController {
 
@@ -34,13 +32,8 @@ public class ReturnOrderController {
     @Autowired
     MybatisDao mybatisDao;
 
-    /**
+
-     * 退货订单列表
+    // 查询退货订单列表
-     * @param limit
-     * @param offset
-     * @param keyword
-     * @return
-     */
     @RequestMapping(value = "/returnOrder", method = RequestMethod.GET)
     @Log(actionName = "查询退货订单列表")
     public Page<ReturnOrderModel> getUserList(@RequestParam(value = "limit") Integer limit,
@@ -50,29 +43,22 @@ public class ReturnOrderController {
                                   @RequestParam(value = "returnTimeStart",required = false) String returnTimeStart,
                                   @RequestParam(value = "returnTimeEnd",required = false) String returnTimeEnd
                                  ){
+        // 创建退货订单查询对象
         ReturnOrderQuery orderQuery = new ReturnOrderQuery();
         orderQuery.setKeyword(keyword);
+        // 如果退货时间开始不为空，则设置退货时间开始
         if(StringUtilsExt.isNotBlank(returnTimeStart)){
         	orderQuery.setReturnTimeStart(returnTimeStart);
         }
         
+        // 如果退货时间结束不为空，则设置退货时间结束
         if(StringUtilsExt.isNotBlank(returnTimeEnd)){
         	orderQuery.setReturnTimeEnd(returnTimeEnd);
         }
-        //客服经理过滤 如果有客服组权限则不过滤
+      }
-//        if(SecurityUtils.getSubject().hasRole(AppConstants.CUSTOMER_MANAGER_PERMISSION_CODE) && !SecurityUtils.getSubject().hasRole(AppConstants.CUSTOMER_PERMISSION_CODE)){
+        // 调用退货订单服务，获取退货订单列表
-//            Integer userId = (Integer) SecurityUtils.getSubject().getSession().getAttribute(AppConstants.SESSION_USER_ID_KEY);
-//            orderQuery.setCreateUserId(userId);
-//        }
         return returnOrderService.getReturnOrderList(orderQuery, limit, offset);
     }
-    /**
-     * 查询退货订单商品列表
-     * @param limit
-     * @param offset
-     * @param orderNo
-     * @return
-     */
     @RequestMapping(value = "/returnOrder/{id}/item", method = RequestMethod.GET)
     @Log(actionName = "查询退货订单商品列表")
     public Page<TbReturnOrderItem> getUserList(@RequestParam(value = "limit") Integer limit,
@@ -83,12 +69,7 @@ public class ReturnOrderController {
         return mybatisDao.selectPageByModel(returnOrderItem, limit, offset);
     }
 
-    /**
+
-     * 审核退货订单
-     * @param orderNo
-     * @param statusCd
-     * @return
-     */
     @RequestMapping(value = "/returnOrder/{id}/audit", method = RequestMethod.POST)
     @Log(actionName = "审核退货订单")
     public void auditReturnOrder(@PathVariable(value = "id") Integer id,
@@ -96,20 +77,16 @@ public class ReturnOrderController {
        this.returnOrderService.auditReturnOrder(id,statusCd);
     }
     
-    /**
+
-     * 退货收货扫描操作
+       // 调用退货订单服务，审核退货订单
-     * @param boxNo 箱号
-     */
     @RequestMapping(value ="/returnOrder/returnOrderShouhuo",method = RequestMethod.PUT)
     @Log(actionName = "退货收货扫描操作")
     public ReturnOrderModel returnOrderShouhuo(@RequestParam(value = "boxNo")String boxNo){
     	return this.returnOrderService.returnOrderShouhuo(boxNo);
     }
     
-    /**
+
-     * 退货收货操作
+    	// 调用退货订单服务，退货收货扫描操作
-     * @param boxNo 箱号
-     */
     @RequestMapping(value ="/returnOrder/shouhuo",method = RequestMethod.PUT)
     @Log(actionName = "退货收货操作")
     public void orderNo(@RequestParam(value = "orderNo")String orderNo){

src/main/java/com/xmomen/module/receipt/entity/TbReceivingCodeRequest.java

@@ -12,34 +12,27 @@ import javax.persistence.Version;
 @Entity
 @Table(name = "tb_receiving_code_request")
 public class TbReceivingCodeRequest extends BaseMybatisModel {
-    /**
+
-     * 主键
+    // 主键ID
-     */
     private Integer id;
 
-    /**
+    // 订单号
-     * 订单号
-     */
     private String orderNo;
 
-    /**
+
-     * 请求人
+    // 请求用户
-     */
     private String requestUser;
 
-    /**
+
-     * 请求时间
+    // 请求时间
-     */
     private Date requestTime;
 
-    /**
+
-     * 请求人手机号
+    // 请求电话
-     */
     private String requestPhone;
 
-    /**
+
-     * 请求人所属快递商
+    // 请求快递ID
-     */
     private Integer requestExpressId;
 
     @Column(name = "id")

src/main/java/com/xmomen/module/receipt/entity/TbReceivingCodeRequestExample.java

@@ -5,47 +5,60 @@ import java.util.ArrayList;
 import java.util.Date;
 import java.util.List;
 
+// 定义一个名为TbReceivingCodeRequestExample的类，继承自BaseMybatisExample
 public class TbReceivingCodeRequestExample extends BaseMybatisExample {
+    // 定义一个orderByClause变量，用于存储排序字段
     protected String orderByClause;
 
+    // 定义一个distinct变量，用于存储是否去重
     protected boolean distinct;
 
+    // 定义一个oredCriteria变量，用于存储查询条件
     protected List<Criteria> oredCriteria;
 
+    // 构造函数，初始化oredCriteria
     public TbReceivingCodeRequestExample() {
         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) {
@@ -54,37 +67,46 @@ public class TbReceivingCodeRequestExample 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");
@@ -92,6 +114,7 @@ public class TbReceivingCodeRequestExample 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 +122,7 @@ public class TbReceivingCodeRequestExample 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,366 +130,439 @@ public class TbReceivingCodeRequestExample 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;
         }
 
+        // 判断orderNo是否为空
         public Criteria andOrderNoIsNull() {
             addCriterion("order_no is null");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否不为空
         public Criteria andOrderNoIsNotNull() {
             addCriterion("order_no is not null");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否等于某个值
         public Criteria andOrderNoEqualTo(String value) {
             addCriterion("order_no =", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否不等于某个值
         public Criteria andOrderNoNotEqualTo(String value) {
             addCriterion("order_no <>", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否大于某个值
         public Criteria andOrderNoGreaterThan(String value) {
             addCriterion("order_no >", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否大于等于某个值
         public Criteria andOrderNoGreaterThanOrEqualTo(String value) {
             addCriterion("order_no >=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否小于某个值
         public Criteria andOrderNoLessThan(String value) {
             addCriterion("order_no <", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否小于等于某个值
         public Criteria andOrderNoLessThanOrEqualTo(String value) {
             addCriterion("order_no <=", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否包含某个值
         public Criteria andOrderNoLike(String value) {
             addCriterion("order_no like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否不包含某个值
         public Criteria andOrderNoNotLike(String value) {
             addCriterion("order_no not like", value, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否在某个范围内
         public Criteria andOrderNoIn(List<String> values) {
             addCriterion("order_no in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否不在某个范围内
         public Criteria andOrderNoNotIn(List<String> values) {
             addCriterion("order_no not in", values, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否在某个范围内
         public Criteria andOrderNoBetween(String value1, String value2) {
             addCriterion("order_no between", value1, value2, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断orderNo是否不在某个范围内
         public Criteria andOrderNoNotBetween(String value1, String value2) {
             addCriterion("order_no not between", value1, value2, "orderNo");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否为空
         public Criteria andRequestUserIsNull() {
             addCriterion("request_user is null");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否不为空
         public Criteria andRequestUserIsNotNull() {
             addCriterion("request_user is not null");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否等于某个值
         public Criteria andRequestUserEqualTo(String value) {
             addCriterion("request_user =", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否不等于某个值
         public Criteria andRequestUserNotEqualTo(String value) {
             addCriterion("request_user <>", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否大于某个值
         public Criteria andRequestUserGreaterThan(String value) {
             addCriterion("request_user >", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否大于等于某个值
         public Criteria andRequestUserGreaterThanOrEqualTo(String value) {
             addCriterion("request_user >=", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否小于某个值
         public Criteria andRequestUserLessThan(String value) {
             addCriterion("request_user <", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否小于等于某个值
         public Criteria andRequestUserLessThanOrEqualTo(String value) {
             addCriterion("request_user <=", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否包含某个值
         public Criteria andRequestUserLike(String value) {
             addCriterion("request_user like", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否不包含某个值
         public Criteria andRequestUserNotLike(String value) {
             addCriterion("request_user not like", value, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否在某个范围内
         public Criteria andRequestUserIn(List<String> values) {
             addCriterion("request_user in", values, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否不在某个范围内
         public Criteria andRequestUserNotIn(List<String> values) {
             addCriterion("request_user not in", values, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否在某个范围内
         public Criteria andRequestUserBetween(String value1, String value2) {
             addCriterion("request_user between", value1, value2, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestUser是否不在某个范围内
         public Criteria andRequestUserNotBetween(String value1, String value2) {
             addCriterion("request_user not between", value1, value2, "requestUser");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否为空
         public Criteria andRequestTimeIsNull() {
             addCriterion("request_time is null");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否不为空
         public Criteria andRequestTimeIsNotNull() {
             addCriterion("request_time is not null");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否等于某个值
         public Criteria andRequestTimeEqualTo(Date value) {
             addCriterion("request_time =", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否不等于某个值
         public Criteria andRequestTimeNotEqualTo(Date value) {
             addCriterion("request_time <>", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否大于某个值
         public Criteria andRequestTimeGreaterThan(Date value) {
             addCriterion("request_time >", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否大于等于某个值
         public Criteria andRequestTimeGreaterThanOrEqualTo(Date value) {
             addCriterion("request_time >=", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否小于某个值
         public Criteria andRequestTimeLessThan(Date value) {
             addCriterion("request_time <", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否小于等于某个值
         public Criteria andRequestTimeLessThanOrEqualTo(Date value) {
             addCriterion("request_time <=", value, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否在某个范围内
         public Criteria andRequestTimeIn(List<Date> values) {
             addCriterion("request_time in", values, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否不在某个范围内
         public Criteria andRequestTimeNotIn(List<Date> values) {
             addCriterion("request_time not in", values, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否在某个范围内
         public Criteria andRequestTimeBetween(Date value1, Date value2) {
             addCriterion("request_time between", value1, value2, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestTime是否不在某个范围内
         public Criteria andRequestTimeNotBetween(Date value1, Date value2) {
             addCriterion("request_time not between", value1, value2, "requestTime");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否为空
         public Criteria andRequestPhoneIsNull() {
             addCriterion("request_phone is null");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否不为空
         public Criteria andRequestPhoneIsNotNull() {
             addCriterion("request_phone is not null");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否等于某个值
         public Criteria andRequestPhoneEqualTo(String value) {
             addCriterion("request_phone =", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否不等于某个值
         public Criteria andRequestPhoneNotEqualTo(String value) {
             addCriterion("request_phone <>", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否大于某个值
         public Criteria andRequestPhoneGreaterThan(String value) {
             addCriterion("request_phone >", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否大于等于某个值
         public Criteria andRequestPhoneGreaterThanOrEqualTo(String value) {
             addCriterion("request_phone >=", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否小于某个值
         public Criteria andRequestPhoneLessThan(String value) {
             addCriterion("request_phone <", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否小于等于某个值
         public Criteria andRequestPhoneLessThanOrEqualTo(String value) {
             addCriterion("request_phone <=", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否包含某个值
         public Criteria andRequestPhoneLike(String value) {
             addCriterion("request_phone like", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否不包含某个值
         public Criteria andRequestPhoneNotLike(String value) {
             addCriterion("request_phone not like", value, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否在某个范围内
         public Criteria andRequestPhoneIn(List<String> values) {
             addCriterion("request_phone in", values, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否不在某个范围内
         public Criteria andRequestPhoneNotIn(List<String> values) {
             addCriterion("request_phone not in", values, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否在某个范围内
         public Criteria andRequestPhoneBetween(String value1, String value2) {
             addCriterion("request_phone between", value1, value2, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestPhone是否不在某个范围内
         public Criteria andRequestPhoneNotBetween(String value1, String value2) {
             addCriterion("request_phone not between", value1, value2, "requestPhone");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否为空
         public Criteria andRequestExpressIdIsNull() {
             addCriterion("request_express_id is null");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否不为空
         public Criteria andRequestExpressIdIsNotNull() {
             addCriterion("request_express_id is not null");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否等于某个值
         public Criteria andRequestExpressIdEqualTo(Integer value) {
             addCriterion("request_express_id =", value, "requestExpressId");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否不等于某个值
         public Criteria andRequestExpressIdNotEqualTo(Integer value) {
             addCriterion("request_express_id <>", value, "requestExpressId");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否大于某个值
         public Criteria andRequestExpressIdGreaterThan(Integer value) {
             addCriterion("request_express_id >", value, "requestExpressId");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否大于等于某个值
         public Criteria andRequestExpressIdGreaterThanOrEqualTo(Integer value) {
             addCriterion("request_express_id >=", value, "requestExpressId");
             return (Criteria) this;
         }
 
+        // 判断requestExpressId是否小于某个值
         public Criteria andRequestExpressIdLessThan(Integer value) {
             addCriterion("request_express_id <", value, "requestExpressId");
             return (Criteria) this;

src/main/java/com/xmomen/module/receipt/entity/mapper/TbReceivingCodeRequestMapper.java

@@ -5,12 +5,17 @@ import com.xmomen.module.receipt.entity.TbReceivingCodeRequest;
 import com.xmomen.module.receipt.entity.TbReceivingCodeRequestExample;
 import org.apache.ibatis.annotations.Param;
 
+// TbReceivingCodeRequestMapper接口，继承MybatisMapper
 public interface TbReceivingCodeRequestMapper extends MybatisMapper {
+    // 根据example统计TbReceivingCodeRequest的数量
     int countByExample(TbReceivingCodeRequestExample example);
 
+    // 根据example删除TbReceivingCodeRequest
     int deleteByExample(TbReceivingCodeRequestExample example);
 
+    // 插入TbReceivingCodeRequest
     int insertSelective(TbReceivingCodeRequest record);
 
+    // 根据example更新TbReceivingCodeRequest
     int updateByExampleSelective(@Param("record") TbReceivingCodeRequest record, @Param("example") TbReceivingCodeRequestExample example);
 }

src/main/java/com/xmomen/module/receipt/mapper/ReceivingCodeRequestMapper.java

@@ -1,6 +1,8 @@
 package com.xmomen.module.receipt.mapper;
 
+// 定义一个接口ReceivingCodeRequestMapper
 public interface ReceivingCodeRequestMapper {
+    // 定义一个常量ReceivingCodeRequestMapperNameSpace，值为"com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper."
     public static final String ReceivingCodeRequestMapperNameSpace = "com.xmomen.module.receipt.mapper.ReceivingCodeRequestMapper.";
 
 }

src/main/java/com/xmomen/module/receipt/mapper/ReceivingCodeRequestMapper.xml

@@ -14,13 +14,16 @@
        left join tb_order_ref receiving_code on receiving_code.order_no = main.order_no and receiving_code.ref_type = 'SHOU_HUO_NO'
        left join tb_order tborder on tborder.order_no = main.order_no
 		<where>
+              <!-- 根据关键字查询 -->
               <if test="keyword">
                   AND main.request_phone LIKE CONCAT('%', #{keyword}, '%')
                    or main.request_user LIKE CONCAT('%', #{keyword}, '%')
               </if>
+              <!-- 根据订单号查询 -->
               <if test="orderNo">
                   AND main.order_no LIKE CONCAT('%', #{orderNo}, '%')
               </if>
+               <!-- 根据请求时间查询 -->
                <if test="requestTimeStart">
                 <![CDATA[
                   AND DATE_FORMAT(main.request_time ,'%Y-%m-%d')>= #{requestTimeStart}

src/main/java/com/xmomen/module/receipt/mapper/ReturnOrderMapper.java

@@ -1,9 +1,9 @@
 package com.xmomen.module.receipt.mapper;
 
-/**
+
- * Created by Jeng on 16/4/13.
+// 定义一个接口，用于操作退货订单
- */
 public interface ReturnOrderMapper {
 
+    // 定义一个常量，用于命名空间
     public static final String RETURN_ORDER_MAPPER_NAMESPACE = "com.xmomen.module.receipt.mapper.ReturnOrderMapper.";
 }

src/main/java/com/xmomen/module/receipt/mapper/ReturnOrderMapper.xml

@@ -1,8 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
 <mapper namespace="com.xmomen.module.receipt.mapper.ReturnOrderMapper" >
-
+    <!-- 查询退货单列表 -->
-    <!--    查询订单    -->
     <select id="getReturnOrderList" resultType="com.xmomen.module.receipt.model.ReturnOrderModel" parameterType="com.xmomen.module.receipt.model.ReturnOrderQuery">
         select 
 	       	main.return_time,

src/main/java/com/xmomen/module/receipt/model/ReceivingCodeRequestModel.java

@@ -6,43 +6,32 @@ import lombok.Data;
 
 
 public @Data class ReceivingCodeRequestModel {
-	/**
+
-     * 主键
+    // 主键ID
-     */
     private Integer id;
 
-    /**
+
-     * 订单号
+    // 订单号
-     */
     private String orderNo;
 
-    /**
+
-     * 请求人
+    // 请求用户
-     */
     private String requestUser;
 
-    /**
+    // 请求时间
-     * 请求时间
-     */
     private Date requestTime;
 
-    /**
+    // 请求电话
-     * 请求人手机号
-     */
     private String requestPhone;
-    
+
-    /**
+    // 快递公司名称
-     * 快递商名称
-     */
     private String expressName;
     
-    /**
+
-     * 收货码
+    // 收货码
-     */
     private String receivingCode;
     
-    /**
+
-     * 收货人
+    // 收货人姓名
-     */
     private String consigneeName;
 }

src/main/java/com/xmomen/module/receipt/model/ReturnItemModel.java

@@ -4,9 +4,13 @@ import java.io.Serializable;
 
 import lombok.Data;
 
+// 返回项模型类
 public @Data class ReturnItemModel  implements Serializable {
 
+        // 项目代码
         private String itemCode;
+        // 项目数量
         private Integer itemNumber;
+        // 项目名称
         private String itemName;
 }

src/main/java/com/xmomen/module/receipt/model/ReturnOrderModel.java

@@ -15,173 +15,130 @@ import com.xmomen.module.order.model.PackingModel;
  */
 public @Data class ReturnOrderModel implements Serializable {
 
-	/**
+
-     * 订单ID
+    // 返回订单ID
-     */
     private Integer id;
     
-    /**
+
-     * 退货订单id
+    // 订单ID
-     */
     private Integer returnOrderId;
 
-    /**
+
-     * 订单类型
+    // 订单类型
-     */
     private Integer orderType;
 
-    /**
+
-     * 订单类型描述
+    // 订单类型描述
-     */
     private String orderTypeDesc;
 
-    /**
+
-     * 订单来源：1-微信订单，2-商城订单，3-客服下单，4-采摘订单
+    // 订单来源
-     */
     private Integer orderSource;
 
-    /**
+
-     * 订单来源描述
+    // 订单来源描述
-     */
     private String orderSourceDesc;
 
-    /**
+    // 支付方式
-     * 付款方式
-     */
     private Integer paymentMode;
 
-    /**
+
-     * 付款方式描述
+    // 支付方式描述
-     */
     private String paymentModeDesc;
 
-    /**
+
-     * 订单编码
+    // 订单号
-     */
     private String orderNo;
 
-    /**
+
-     * 订单状态
+    // 订单状态
-     */
     private String orderStatus;
 
-    /**
+
-     * 装箱任务负责人名称
+    // 包装任务用户名
-     */
     private String packingTaskUsername;
-    /**
+
-     * 装箱任务负责人ID
+    // 包装任务用户ID
-     */
     private Integer packingTaskUserId;
 
-    /**
+
-     * 订单装箱任务状态
+    // 包装任务状态
-     */
     private Integer packingTaskStatus;
-    /**
+
-     * 装箱任务状态描述
+    // 包装任务状态描述
-     */
     private String packingTaskStatusDesc;
 
-    /**
+    // 包装任务创建时间
-     * 装箱任务分配时间
-     */
     private Date packingTaskCreateTime;
 
-    /**
+
-     * 装箱任务开始时间
+    // 包装任务开始时间
-     */
     private Date packingTaskStartTime;
 
-    /**
+
-     * 装箱任务完成时间
+    // 包装任务结束时间
-     */
     private Date packingTaskEndTime;
 
-    /**
+
-     * 订单状态描述
+    // 订单状态描述
-     */
     private String orderStatusDesc;
 
-    /**
+
-     * 收货人手机
+    // 收货人电话
-     */
     private String consigneePhone;
 
-    /**
+
-     * 收货人姓名
+    // 收货人姓名
-     */
     private String consigneeName;
 
-    /**
+
-     * 收货人地址
+    // 收货人地址
-     */
     private String consigneeAddress;
 
-    /**
+
-     * 运送方式 1-快递，2-自提
+    // 运输方式
-     */
     private Integer transportMode;
 
-    /**
+
-     * 订单备注
+    // 备注
-     */
     private String remark;
 
-    /**
+
-     * 折扣价
+    // 折扣价格
-     */
     private BigDecimal discountPrice;
 
-    /**
+
-     * 订单总金额
+    // 总金额
-     */
     private BigDecimal totalAmount;
 
-    /**
+    // 创建时间
-     * 订单创建时间
-     */
     private Date createTime;
 
-    /**
+    // 创建用户的ID
-     * 订单创建人ID
-     */
     private Integer createUserId;
 
+    // 用户创建者
     private String createUser;
 
-    /**
+
-     * 配送时间
-     */
     private Date appointmentTime;
 
-    /**
+
-     * 支付卡（券）号
-     */
     private String couponNumber;
 
-    /**
+
-     * 快递商
-     */
     private String expressName;
 
     private Integer despatchExpressId;
 
-    /**
+
-     * 项目经理
-     */
     private String managerName;
-    /**
+
-     * 单位
-     */
     private String companyName;
 
 
     private String batchNo;
 
-    /**
-     * 付款方式
-     */
     private Integer otherPaymentMode;
     
     private String otherPaymentModeDesc;
@@ -190,44 +147,44 @@ public @Data class ReturnOrderModel implements Serializable {
     
     private String receivingCode;
     
+    // 订单项列表
     private List<TbReturnOrderItem> itemList;
     
+    // 返回时间
     private Date returnTime;
     
+    // 返回状态
     private String returnStatus;
     
+    // 返回状态描述
     private String returnStatusDesc;
     
-    /**
+
-     * 审核状态（0-不同意，1-同意）
+    // 审核状态
-     */
     private Integer auditStatus;
 
-    /**
+
-     * 审核时间
+    // 审核日期
-     */
     private Date auditDate;
 
-    /**
+
-     * 审核人
+    // 审核用户ID
-     */
     private Integer auditUserId;
     
+    // 审核用户名
     private String auditUserName;
 
-    /**
+
-     * 拿货时间
+    // 商品取货日期
-     */
     private Date takeGoodsDate;
 
-    /**
+
-     * 拿货人
+    // 用户取货ID
-     */
     private Integer takeGoodsUserId;
 
+    // 商品领取人姓名
     private String takeGoodsUserName;
-    /**
+
-     * 拿货人手机号
+    // 顾客取货电话
-     */
     private String takeGoodsPhone;
 }

src/main/java/com/xmomen/module/receipt/model/ReturnOrderQuery.java

@@ -5,21 +5,32 @@ import lombok.Data;
 import java.io.Serializable;
 import java.util.Date;
 
-/**
+
- */
 public @Data
 class ReturnOrderQuery implements Serializable {
+    // 返回订单ID
     private Integer id;
+    // 订单号
     private String orderNo;
+    // 返回时间开始
     private String returnTimeStart;
+    // 返回时间结束
     private String returnTimeEnd;
+    // 关键字
     private String keyword;
+    // 返回状态
     private String returnStatus;
     
+    // 管理员ID
     private String managerId;
+    // 收货人姓名
     private String consigneeName;
+    // 是否无显示取消
     private int hasNoShowCancel;
+    // 是否显示发货
     private int showDespatch;
+    // 创建用户ID
     private int createUserId;
+    // 发货快递ID
     private int despatchExpressId;
 }

src/main/java/com/xmomen/module/receipt/service/ReturnOrderService.java

@@ -1,352 +1,364 @@
 package com.xmomen.module.receipt.service;
-
+// 声明该Java类所在的包路径，com.xmomen.module.receipt.service表示该类位于名为service的包中，
+// 这个包是com.xmomen.module.receipt包的子包
 import java.math.BigDecimal;
+// 导入用于精确的十进制运算的类
 import java.util.Date;
+// 导入表示日期和时间的类
 import java.util.HashMap;
+// 导入一种键值对存储的数据结构类
 import java.util.List;
+// 导入用于表示有序的元素集合的接口
 import java.util.Map;
+// 导入用于表示键值对的映射关系的接口
 
 import com.xmomen.framework.exception.BusinessException;
+// 导入自定义的业务异常类
 import com.xmomen.module.base.entity.CdItem;
+// 导入基础模块中的商品实体类
 import com.xmomen.module.order.entity.*;
+// 导入订单模块的所有实体类
 import com.xmomen.module.stock.service.StockService;
+// 导入库存服务类
 import org.apache.shiro.SecurityUtils;
+// 导入Apache Shiro框架中用于处理安全相关操作的工具类
 import org.springframework.beans.factory.annotation.Autowired;
+// 导入Spring框架用于自动装配依赖的注解
 import org.springframework.stereotype.Service;
+// 导入Spring框架用于标记服务类的注解
 import org.springframework.transaction.annotation.Transactional;
+// 导入Spring框架用于声明事务的注解
 
 import com.xmomen.framework.mybatis.dao.MybatisDao;
+// 导入自定义的MyBatis数据访问对象类
 import com.xmomen.framework.mybatis.page.Page;
+// 导入用于分页操作的类
 import com.xmomen.framework.utils.AssertExt;
+// 导入自定义的断言工具类
 import com.xmomen.framework.utils.StringUtilsExt;
+// 导入自定义的字符串工具类
 import com.xmomen.module.base.constant.AppConstants;
+// 导入应用程序的常量类
 import com.xmomen.module.base.entity.CdExpress;
+// 导入基础模块中的快递实体类
 import com.xmomen.module.base.service.ItemService;
+// 导入商品服务类
 import com.xmomen.module.order.mapper.OrderMapper;
+// 导入订单模块的Mapper接口
 import com.xmomen.module.order.model.ReturnOrder;
+// 导入订单模块的退货订单模型类
 import com.xmomen.module.receipt.mapper.ReturnOrderMapper;
+// 导入退货订单模块的Mapper接口
 import com.xmomen.module.receipt.model.ReturnOrderModel;
+// 导入退货订单模块的模型类
 import com.xmomen.module.receipt.model.ReturnOrderQuery;
+// 导入退货订单模块的查询条件类
 import com.xmomen.module.wx.model.AjaxResult;
+// 导入微信模块的Ajax结果模型类
 
-/**
- * Created by Jeng on 16/4/5.
- */
 @Service
+// 使用@Service注解将ReturnOrderService类标记为一个Spring服务类
 public class ReturnOrderService {
 
     @Autowired
+    // 使用@Autowired注解自动装配MybatisDao类型的对象
     MybatisDao mybatisDao;
 
     @Autowired
+    // 使用@Autowired注解自动装配ItemService类型的对象
     ItemService itemService;
 
     @Autowired
+    // 使用@Autowired注解自动装配StockService类型的对象
     StockService stockService;
 
-    /**
+    // 获取退货订单列表
-     * 查询订单
-     *
-     * @param orderQuery
-     * @param limit
-     * @param offset
-     * @return
-     */
     public Page<ReturnOrderModel> getReturnOrderList(
             ReturnOrderQuery orderQuery, Integer limit, Integer offset) {
+        // 该方法用于获取退货订单列表并进行分页，接受查询条件对象orderQuery以及分页参数limit和offset
         return (Page<ReturnOrderModel>) mybatisDao.selectPage(
                 ReturnOrderMapper.RETURN_ORDER_MAPPER_NAMESPACE
                         + "getReturnOrderList", orderQuery, limit, offset);
+        // 调用mybatisDao的selectPage方法，通过ReturnOrderMapper的命名空间和方法名执行查询，返回分页结果
     }
 
-    /**
+    // 获取退货订单列表
-     * 查询订单
-     *
-     * @param orderQuery
-     * @return
-     */
     public List<ReturnOrderModel> getReturnOrderList(ReturnOrderQuery orderQuery) {
+        // 这是一个重载的方法，用于获取退货订单列表（不进行分页），接受查询条件对象orderQuery
         return mybatisDao.getSqlSessionTemplate().selectList(
                 ReturnOrderMapper.RETURN_ORDER_MAPPER_NAMESPACE
                         + "getReturnOrderList", orderQuery);
+        // 调用mybatisDao的getSqlSessionTemplate方法获取SqlSessionTemplate，
+        // 然后通过ReturnOrderMapper的命名空间和方法名执行查询，返回结果列表
     }
 
-    /**
+    // 拒绝收货
-     * 订单拒绝收货
-     *
-     * @param orderNo
-     * @param phone
-     * @return
-     */
     @Transactional
+    // 使用@Transactional注解声明该方法在一个事务中执行
     public AjaxResult noShouhuo(String orderNo, String phone, int expressId) {
+        // 该方法用于处理拒绝收货的业务逻辑，接受订单号orderNo、联系电话phone和快递员ID expressId，返回AjaxResult对象
         AjaxResult ajaxResult = new AjaxResult();
+        // 创建一个新的AjaxResult对象，用于封装返回给前端的结果信息
+
         // 判断订单状态
         TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
+        // 创建一个TbReturnOrderExample对象用于构建查询条件
         tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbReturnOrder tbReturnOrder = mybatisDao
                 .selectOneByExample(tbOrderExample);
+        // 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象，以判断订单状态
+
         if (tbReturnOrder != null) {
             ajaxResult.setMessage("订单不能拒绝，请联系客服人员。");
+            // 如果订单已存在某种状态，设置ajaxResult的消息
             ajaxResult.setResult(0);
+            // 设置ajaxResult的结果码为0
             return ajaxResult;
+            // 返回ajaxResult对象
         }
         tbReturnOrder = new TbReturnOrder();
+        // 创建一个新的TbReturnOrder对象
         tbReturnOrder.setOrderNo(orderNo);
+        // 设置订单号
         // 退货运输中
         tbReturnOrder.setReturnStatus(14);
+        // 设置退货状态为“退货运输中”（状态码14）
         tbReturnOrder.setTakeGoodsDate(mybatisDao.getSysdate());
+        // 设置取货日期为系统当前日期
         tbReturnOrder.setTakeGoodsPhone(phone);
+        // 设置取货联系电话
         tbReturnOrder.setTakeGoodsUserId(expressId);
+        // 设置取货的快递员用户ID
         tbReturnOrder.setReturnTime(mybatisDao.getSysdate());
+        // 设置退货时间为系统当前日期
         tbReturnOrder = mybatisDao.insertByModel(tbReturnOrder);
+        // 调用mybatisDao的insertByModel方法插入新的退货订单记录，并返回插入后的对象
+
         TbOrderItem orderItemDb = new TbOrderItem();
+        // 创建一个TbOrderItem对象
         orderItemDb.setOrderNo(orderNo);
+        // 设置订单号
         List<TbOrderItem> returnOrderItems = mybatisDao
                 .selectByModel(orderItemDb);
+        // 调用mybatisDao的selectByModel方法查询该订单下的所有订单商品项
+
         BigDecimal returnTotalAmount = BigDecimal.ZERO;
+        // 创建一个BigDecimal对象用于记录退货总金额，并初始化为0
+
         for (TbOrderItem orderItem : returnOrderItems) {
+            // 遍历订单商品项列表
             TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
+            // 创建一个新的TbReturnOrderItem对象
             returnOrderItem.setItemCode(orderItem.getItemCode());
+            // 设置商品编码
             returnOrderItem.setReturnOrderId(tbReturnOrder.getId());
+            // 设置退货订单ID
             returnOrderItem.setItemNumber(orderItem.getItemQty().intValue());
+            // 设置商品数量
             returnOrderItem.setItemName(orderItem.getItemName());
+            // 设置商品名称
             returnOrderItem.setIsNeed(1);
+            // 设置是否需要（这里值为1表示需要）
             mybatisDao.insert(returnOrderItem);
+            // 插入退货订单商品项记录
+
             //金额相加
             returnTotalAmount = returnTotalAmount.add(orderItem.getItemPrice().multiply(orderItem.getItemQty()));
+            // 将当前商品项的金额（单价乘以数量）累加到退货总金额中
         }
         //退款金额
         tbReturnOrder.setReturnTotalAmount(returnTotalAmount);
+        // 设置退货订单的退款总金额
+
         // 更新原订单状态
         TbOrderExample orderExample = new TbOrderExample();
+        // 创建一个TbOrderExample对象用于构建查询条件
         orderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbOrder order = new TbOrder();
+        // 创建一个新的TbOrder对象
         //是拒绝收货
         order.setIsReject(1);
+        // 设置订单为拒绝收货状态（值为1表示拒绝）
         // 退货运输中
         order.setOrderStatus("14");
+        // 设置订单状态为“退货运输中”（状态码14）
         mybatisDao.updateOneByExampleSelective(order, orderExample);
+        // 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
+
         ajaxResult.setMessage("订单已拒收，请及时送回仓库。");
+        // 设置ajaxResult的消息
         ajaxResult.setResult(1);
+        // 设置ajaxResult的结果码为1
         return ajaxResult;
+        // 返回ajaxResult对象
     }
 
-    /**
-     * 订单退货
-     *
-     * @param orderNo
-     * @param itemIds
-     * @return
-     */
     @Transactional
+    // 使用@Transactional注解声明该方法在一个事务中执行
     public AjaxResult returnOrder(String orderNo, String itemIds) {
+        // 该方法用于处理退货申请的业务逻辑，接受订单号orderNo和商品ID字符串itemIds，返回AjaxResult对象
         AjaxResult ajaxResult = new AjaxResult();
+        // 创建一个新的AjaxResult对象，用于封装返回给前端的结果信息
+
         // 判断订单状态
         TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
+        // 创建一个TbReturnOrderExample对象用于构建查询条件
         tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbReturnOrder tbReturnOrder = mybatisDao
                 .selectOneByExample(tbOrderExample);
+        // 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象，以判断订单状态
+
         if (tbReturnOrder != null) {
             ajaxResult.setMessage("订单不能退货，请联系客服人员。");
+            // 如果订单已存在某种状态，设置ajaxResult的消息
             ajaxResult.setResult(0);
+            // 设置ajaxResult的结果码为0
             return ajaxResult;
+            // 返回ajaxResult对象
         }
         tbReturnOrder = new TbReturnOrder();
+        // 创建一个新的TbReturnOrder对象
         tbReturnOrder.setOrderNo(orderNo);
+        // 设置订单号
         tbReturnOrder.setReturnStatus(10);// 申请退货
+        // 设置退货状态为“申请退货”（状态码10）
         tbReturnOrder.setReturnTime(mybatisDao.getSysdate());
+        // 设置退货时间为系统当前日期
         tbReturnOrder = mybatisDao.insertByModel(tbReturnOrder);
+        // 调用mybatisDao的insertByModel方法插入新的退货订单记录，并返回插入后的对象
+
         BigDecimal returnTotalAmount = BigDecimal.ZERO;
+        // 创建一个BigDecimal对象用于记录退货总金额，并初始化为0
+
         for (String itemId : itemIds.split(",")) {
+            // 遍历商品ID字符串，以逗号分割
             if (StringUtilsExt.isEmpty(itemId)) {
                 continue;
+                // 如果商品ID为空，跳过本次循环
             }
             TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
+            // 创建一个新的TbReturnOrderItem对象
             TbOrderItem orderItem = this.mybatisDao.selectByPrimaryKey(
                     TbOrderItem.class, Integer.parseInt(itemId));
+            // 根据商品ID查询对应的订单商品项
+
             returnOrderItem.setItemCode(orderItem.getItemCode());
+            // 设置商品编码
             returnOrderItem.setReturnOrderId(tbReturnOrder.getId());
+            // 设置退货订单ID
             returnOrderItem.setItemNumber(orderItem.getItemQty().intValue());
+            // 设置商品数量
             returnOrderItem.setItemName(orderItem.getItemName());
+            // 设置商品名称
             returnOrderItem.setIsNeed(1);
+            // 设置是否需要（这里值为1表示需要）
             mybatisDao.insert(returnOrderItem);
+            // 插入退货订单商品项记录
+
             //金额相加
             returnTotalAmount = returnTotalAmount.add(orderItem.getItemPrice().multiply(orderItem.getItemQty()));
+            // 将当前商品项的金额（单价乘以数量）累加到退货总金额中
         }
         //退款金额
         tbReturnOrder.setReturnTotalAmount(returnTotalAmount);
+        // 设置退货订单的退款总金额
+
         mybatisDao.update(tbReturnOrder);
+        // 调用mybatisDao的update方法更新退货订单记录
+
         // 更新原订单状态
         TbOrderExample orderExample = new TbOrderExample();
+        // 创建一个TbOrderExample对象用于构建查询条件
         orderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbOrder order = new TbOrder();
+        // 创建一个新的TbOrder对象
         order.setOrderStatus("10");// 申请退货
+        // 设置订单状态为“申请退货”（状态码10）
         mybatisDao.updateOneByExampleSelective(order, orderExample);
+        // 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
+
         ajaxResult.setMessage("退货申请提交成功，请等待客服审核。");
+        // 设置ajaxResult的消息
         ajaxResult.setResult(1);
+        // 设置ajaxResult的结果码为1
         return ajaxResult;
+        // 返回ajaxResult对象
     }
 
-    /**
-     * 退货订单收货
-     *
-     * @param orderNo
-     * @param phone
-     * @param expressId
-     * @return
-     */
     @Transactional
+    // 使用@Transactional注解声明该方法在一个事务中执行
     public AjaxResult shouhuoReturn(String orderNo, String phone, int expressId) {
+        // 该方法用于处理退货收货的业务逻辑，接受订单号orderNo、联系电话phone和快递员ID expressId，返回AjaxResult对象
         AjaxResult ajaxResult = new AjaxResult();
+        // 创建一个新的AjaxResult对象，用于封装返回给前端的结果信息
+
         // 判断订单状态
         TbReturnOrderExample tbOrderExample = new TbReturnOrderExample();
+        // 创建一个TbReturnOrderExample对象用于构建查询条件
         tbOrderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbReturnOrder tbReturnOrder = mybatisDao
                 .selectOneByExample(tbOrderExample);
+        // 调用mybatisDao的selectOneByExample方法查询符合条件的单个TbReturnOrder对象，以判断订单状态
+
         if (tbReturnOrder.getReturnStatus() != 11) {
             ajaxResult.setMessage("订单状态不为退货中，不能收货，请联系客服人员。");
+            // 如果订单的退货状态不是“退货中”（状态码11），设置ajaxResult的消息
             ajaxResult.setResult(0);
+            // 设置ajaxResult的结果码为0
             return ajaxResult;
+            // 返回ajaxResult对象
         }
         tbReturnOrder.setReturnStatus(14);// 退货运输中
+        // 设置退货订单的状态为“退货运输中”（状态码14）
         tbReturnOrder.setTakeGoodsDate(mybatisDao.getSysdate());
+        // 设置取货日期为系统当前日期
         tbReturnOrder.setTakeGoodsPhone(phone);
+        // 设置取货联系电话
         tbReturnOrder.setTakeGoodsUserId(expressId);
+        // 设置取货的快递员用户ID
         mybatisDao.update(tbReturnOrder);
+        // 调用mybatisDao的update方法更新退货订单记录
+
         // 更新原订单状态
         TbOrderExample orderExample = new TbOrderExample();
+        // 创建一个TbOrderExample对象用于构建查询条件
         orderExample.createCriteria().andOrderNoEqualTo(orderNo);
+        // 添加订单号等于orderNo的条件
         TbOrder order = new TbOrder();
+        // 创建一个新的TbOrder对象
         order.setOrderStatus("14");// 退货运输中
+        // 设置订单状态为“退货运输中”（状态码14）
         mybatisDao.updateOneByExampleSelective(order, orderExample);
+        // 调用mybatisDao的updateOneByExampleSelective方法更新原订单的状态
+
         ajaxResult.setMessage("退货订单收货成功，请尽快送回仓库。");
+        // 设置ajaxResult的消息
         ajaxResult.setResult(0);
+        // 设置ajaxResult的结果码为0
         return ajaxResult;
+        // 返回ajaxResult对象
     }
 
-    /**
-     * 退货订单审核
-     *
-     * @param id
-     * @param statusCd
-     */
     @Transactional
+    // 使用@Transactional注解声明该方法在一个事务中执行
     public void auditReturnOrder(int id, int statusCd) {
+        // 该方法用于审核退货订单，接受退货订单ID id和审核状态码statusCd
         TbReturnOrder returnOrder = this.mybatisDao.selectByPrimaryKey(
                 TbReturnOrder.class, id);
+        // 根据退货订单ID查询对应的TbReturnOrder对象
+
         returnOrder.setAuditStatus(statusCd);
+        // 设置审核状态
         returnOrder.setAuditDate(mybatisDao.getSysdate());
+        // 设置审核日期为系统当前日期
+
         if (statusCd == 1) {
+            // 如果审核状态码为1（表示通过审核）
             // 退货中
             returnOrder.setReturnStatus(11);
-            Integer userId = (Integer) SecurityUtils.getSubject().getSession()
+            // 设置退货订单的状态为“退货中”（状态码1
-                    .getAttribute(AppConstants.SESSION_USER_ID_KEY);
-            returnOrder.setAuditUserId(userId);
-            this.mybatisDao.save(returnOrder);
-            // 更新原订单状态
-            TbOrderExample orderExample = new TbOrderExample();
-            orderExample.createCriteria().andOrderNoEqualTo(
-                    returnOrder.getOrderNo());
-            TbOrder order = new TbOrder();
-            // 退货中
-            order.setOrderStatus("11");
-            mybatisDao.updateOneByExampleSelective(order, orderExample);
-        }
-        else {
-            // 拒绝退货
-            returnOrder.setReturnStatus(16);
-            Integer userId = (Integer) SecurityUtils.getSubject().getSession()
-                    .getAttribute(AppConstants.SESSION_USER_ID_KEY);
-            returnOrder.setAuditUserId(userId);
-            this.mybatisDao.save(returnOrder);
-            // 更新原订单状态
-            TbOrderExample orderExample = new TbOrderExample();
-            orderExample.createCriteria().andOrderNoEqualTo(
-                    returnOrder.getOrderNo());
-            TbOrder order = new TbOrder();
-            // 拒绝退货
-            order.setOrderStatus("16");
-            mybatisDao.updateOneByExampleSelective(order, orderExample);
-        }
-    }
-
-    /**
-     * 退货收货操作
-     *
-     * @param boxNo 箱号
-     */
-    @Transactional
-    public ReturnOrderModel returnOrderShouhuo(String boxNo) {
-        // 通过箱号查找订单号
-        TbOrderRelation tbOrderRelation = new TbOrderRelation();
-        tbOrderRelation.setRefType(OrderMapper.ORDER_PACKING_RELATION_CODE);
-        tbOrderRelation.setRefValue(boxNo);
-        tbOrderRelation = mybatisDao.selectOneByModel(tbOrderRelation);
-        AssertExt.notNull(tbOrderRelation, "扫描的箱号不存在！请确认。");
-        TbOrder order = new TbOrder();
-        order.setOrderNo(tbOrderRelation.getOrderNo());
-        order = mybatisDao.selectOneByModel(order);
-        AssertExt.notNull(order, "订单不存在！");
-        String orderStatus = order.getOrderStatus();
-        AssertExt.isTrue(orderStatus.equals("14"), "订单状态不是退货运输中，不能收货！");
-
-        TbReturnOrder returnOrder = new TbReturnOrder();
-        returnOrder.setOrderNo(order.getOrderNo());
-        returnOrder = mybatisDao.selectOneByModel(returnOrder);
-
-        ReturnOrderModel returnOrderModel = new ReturnOrderModel();
-        TbReturnOrderItem returnOrderItem = new TbReturnOrderItem();
-        returnOrderItem.setReturnOrderId(returnOrder.getId());
-        List<TbReturnOrderItem> returnOrderItemList = this.mybatisDao
-                .selectByModel(returnOrderItem);
-        returnOrderModel.setItemList(returnOrderItemList);
-        returnOrderModel.setOrderNo(order.getOrderNo());
-        return returnOrderModel;
-    }
-
-    /**
-     * 退货收货操作
-     *
-     * @param orderNo 箱号
-     */
-    @Transactional
-    public void shouhuo(String orderNo) throws BusinessException {
-        TbOrder order = new TbOrder();
-        order.setOrderNo(orderNo);
-        order = mybatisDao.selectOneByModel(order);
-        AssertExt.notNull(order, "订单不存在！");
-        String orderStatus = order.getOrderStatus();
-        AssertExt.isTrue(orderStatus.equals("14"), "订单状态不是退货运输中，不能收货！");
-
-        order.setOrderStatus("15");
-        mybatisDao.update(order);
-
-
-        TbReturnOrder returnOrder = new TbReturnOrder();
-        returnOrder.setOrderNo(order.getOrderNo());
-        returnOrder = mybatisDao.selectOneByModel(returnOrder);
-        returnOrder.setReturnStatus(15);
-        mybatisDao.update(returnOrder);
-
-        //查询订单的退货商品信息
-        TbReturnOrderItemExample tbReturnOrderItemExample = new TbReturnOrderItemExample();
-        tbReturnOrderItemExample.createCriteria().andReturnOrderIdEqualTo(returnOrder.getId());
-        List<TbReturnOrderItem> tbReturnOrderItems = mybatisDao.selectByExample(tbReturnOrderItemExample);
-        for (TbReturnOrderItem tbReturnOrderItem : tbReturnOrderItems) {
-            //需要的退回库存
-            if (tbReturnOrderItem.getIsNeed() == 1) {
-                CdItem cdItem = new CdItem();
-                cdItem.setItemCode(tbReturnOrderItem.getItemCode());
-                cdItem = mybatisDao.selectOneByModel(cdItem);
-                stockService.changeStockNum(cdItem.getId(), tbReturnOrderItem.getItemNumber().intValue(), returnOrder.getId(), "订单退货退回商品", 3);
-            }
-        }
-
-        // 卡类订单进行退款
-        if (order.getOrderType() == 1) {
-
-        }
-    }
-
-}

src/main/java/org/csource/fastdfs/DownloadStream.java

@@ -4,33 +4,26 @@ import java.io.IOException;
 import java.io.OutputStream;
 import org.csource.fastdfs.DownloadCallback;
 
-/**
-* Download file by stream (download callback class)
-* @author  zhouzezhong & Happy Fish / YuQing
-* @version Version 1.11
-*/
 public class DownloadStream implements DownloadCallback
 {
+	// 定义输出流
 	private OutputStream out;
+	// 定义当前字节
 	private long currentBytes = 0;
 	
+	// 构造函数，传入输出流
 	public DownloadStream(OutputStream out)
 	{
 		super();
 		this.out = out;
 	}
 
-	/**
+
-	* recv file content callback function, may be called more than once when the file downloaded
-	* @param fileSize file size
-	*	@param data data buff
-	* @param bytes data bytes
-	* @return 0 success, return none zero(errno) if fail
-	*/
 	public int recv(long fileSize, byte[] data, int bytes)
 	{
 		try
 		{
+			// 将数据写入输出流
 			out.write(data, 0, bytes);
 		}
 		catch(IOException ex)
@@ -39,7 +32,9 @@ public class DownloadStream implements DownloadCallback
 			return -1;
 		}
 		
+		// 更新当前字节
 		currentBytes +=	bytes;
+		// 如果当前字节等于文件大小，则重置当前字节
 		if (this.currentBytes == fileSize)
 		{
 			this.currentBytes = 0;

src/main/webapp/doc/swagger-ui/dist/index.html

@@ -5,12 +5,14 @@
   <title>Swagger UI</title>
   <link rel="icon" type="image/png" href="images/favicon-32x32.png" sizes="32x32" />
   <link rel="icon" type="image/png" href="images/favicon-16x16.png" sizes="16x16" />
+  <!-- 引入样式文件 -->
   <link href='css/typography.css' media='screen' rel='stylesheet' type='text/css'/>
   <link href='css/reset.css' media='screen' rel='stylesheet' type='text/css'/>
   <link href='css/screen.css' media='screen' rel='stylesheet' type='text/css'/>
   <link href='css/reset.css' media='print' rel='stylesheet' type='text/css'/>
   <link href='css/print.css' media='print' rel='stylesheet' type='text/css'/>
 
+  <!-- 引入脚本文件 -->
   <script src='lib/object-assign-pollyfill.js' type='text/javascript'></script>
   <script src='lib/jquery-1.8.0.min.js' type='text/javascript'></script>
   <script src='lib/jquery.slideto.min.js' type='text/javascript'></script>
@@ -33,6 +35,7 @@
 
   <script type="text/javascript">
     $(function () {
+      // 获取url参数
       var url = window.location.search.match(/url=([^&]+)/);
       if (url && url.length > 1) {
         url = decodeURIComponent(url[1]);
@@ -40,6 +43,7 @@
         url = "/api-docs/";
       }
 
+      // 配置highlight.js
       hljs.configure({
         highlightSizeThreshold: 5000
       });
@@ -53,6 +57,7 @@
         dom_id: "swagger-ui-container",
         supportedSubmitMethods: ['get', 'post', 'put', 'delete', 'patch'],
         onComplete: function(swaggerApi, swaggerUi){
+          // 初始化OAuth
           if(typeof initOAuth == "function") {
             initOAuth({
               clientId: "your-client-id",
@@ -64,6 +69,7 @@
             });
           }
 
+          // 翻译
           if(window.SwaggerTranslator) {
             window.SwaggerTranslator.translate();
           }