Merge remote-tracking branch 'origin/sit' into sit

alien-dining/src/main/java/shop/alien/dining/controller/StoreOrderController.java

@@ -192,20 +192,31 @@ public class StoreOrderController {
         }
     }
 
-    @ApiOperation(value = "更新餐具数量", notes = "更新购物车中餐具的数量，并推送SSE和WebSocket消息")
+    @ApiOperation(value = "更新餐具数量", notes = "更新购物车中餐具的数量，并推送SSE和WebSocket消息。餐具数量为0或未传时不往购物车加餐具（0会移除已有餐具项）")
     @PutMapping("/cart/update-tableware")
     public R<CartDTO> updateTablewareQuantity(
             @ApiParam(value = "桌号ID", required = true) @RequestParam Integer tableId,
-            @ApiParam(value = "餐具数量", required = true) @RequestParam Integer quantity) {
+            @ApiParam(value = "餐具数量，0或未传则不往购物车加餐具") @RequestParam(required = false) Integer quantity) {
         log.info("StoreOrderController.updateTablewareQuantity?tableId={}, quantity={}", tableId, quantity);
         try {
             // 验证 token
             if (!TokenUtil.hasValidToken()) {
                 return R.fail("用户未登录");
             }
-            if (quantity == null || quantity < 0) {
+            if (quantity != null && quantity < 0) {
                 return R.fail("餐具数量不能小于0");
             }
+            // 餐具数量为 0 或 null 时不往购物车加餐具：0 则移除已有餐具项，null 则直接返回当前购物车
+            if (quantity == null) {
+                CartDTO cart = cartService.getCart(tableId);
+                sseService.pushCartUpdate(tableId, cart);
+                return R.data(cart);
+            }
+            if (quantity == 0) {
+                CartDTO cart = cartService.updateTablewareQuantity(tableId, 0);
+                sseService.pushCartUpdate(tableId, cart);
+                return R.data(cart);
+            }
             CartDTO cart = cartService.updateTablewareQuantity(tableId, quantity);
             // 推送购物车更新消息（SSE）
             sseService.pushCartUpdate(tableId, cart);
@@ -257,23 +268,6 @@ public class StoreOrderController {
         }
     }
 
-    @ApiOperation(value = "加餐", notes = "在已有订单基础上添加菜品")
-    @PostMapping("/add-dish")
-    public R<StoreOrder> addDishToOrder(@Valid @RequestBody shop.alien.entity.store.dto.AddDishDTO dto) {
-        log.info("StoreOrderController.addDishToOrder?dto={}", dto);
-        try {
-            // 验证 token（用户信息在 StoreOrderService 中从 token 获取）
-            if (!TokenUtil.hasValidToken()) {
-                return R.fail("用户未登录");
-            }
-            StoreOrder order = orderService.addDishToOrder(dto.getOrderId(), dto.getCuisineId(), dto.getQuantity(), dto.getRemark());
-            return R.data(order);
-        } catch (Exception e) {
-            log.error("加餐失败: {}", e.getMessage(), e);
-            return R.fail("加餐失败: " + e.getMessage());
-        }
-    }
-
     @ApiOperation(value = "支付订单", notes = "支付订单，支付成功后订单状态变为已支付(1)，需要单独调用完成订单接口将订单状态改为已完成(3)")
     @PostMapping("/pay/{orderId}")
     public R<Object> payOrder(
@@ -418,7 +412,7 @@ public class StoreOrderController {
             @ApiParam(value = "每页数量", required = true) @RequestParam(defaultValue = "10") Long size,
             @ApiParam(value = "门店ID") @RequestParam(required = false) Integer storeId,
             @ApiParam(value = "桌号ID") @RequestParam(required = false) Integer tableId,
-            @ApiParam(value = "订单状态") @RequestParam(required = false) Integer orderStatus,
+            @ApiParam(value = "订单状态：0=进行中（待支付+已支付），3=已完成") @RequestParam(required = false) Integer orderStatus,
             @ApiParam(value = "搜索关键词（订单编号或菜品名称，限15字）") @RequestParam(required = false) String keyword) {
         log.info("StoreOrderController.getOrderPage?current={}, size={}, storeId={}, tableId={}, orderStatus={}, keyword={}", current, size, storeId, tableId, orderStatus, keyword);
         try {

alien-dining/src/main/java/shop/alien/dining/service/StoreOrderService.java

@@ -85,17 +85,6 @@ public interface StoreOrderService extends IService<StoreOrder> {
     IPage<StoreOrderPageVO> getOrderPageWithCuisines(Page<StoreOrder> page, Integer storeId, Integer tableId, Integer orderStatus, String keyword);
 
     /**
-     * 加餐（在已有订单基础上添加菜品）
-     *
-     * @param orderId 订单ID
-     * @param cuisineId 菜品ID
-     * @param quantity 数量
-     * @param remark 备注
-     * @return 订单信息
-     */
-    StoreOrder addDishToOrder(Integer orderId, Integer cuisineId, Integer quantity, String remark);
-
-    /**
      * 完成订单（支付完成后调用）
      *
      * @param orderId 订单ID

alien-dining/src/main/java/shop/alien/dining/service/impl/CartServiceImpl.java

@@ -425,8 +425,19 @@ public class CartServiceImpl implements CartService {
             }
         }
         
-        // 将餐具项添加到保留列表中
+        // 将餐具项添加到保留列表中，若有已下单数量则恢复为已下单数量（与菜品逻辑一致）
         if (tablewareItem != null) {
+            Integer tablewareLocked = tablewareItem.getLockedQuantity();
+            if (tablewareLocked != null && tablewareLocked > 0) {
+                Integer currentQty = tablewareItem.getQuantity();
+                if (currentQty == null || !currentQty.equals(tablewareLocked)) {
+                    tablewareItem.setQuantity(tablewareLocked);
+                    tablewareItem.setSubtotalAmount(tablewareItem.getUnitPrice().multiply(BigDecimal.valueOf(tablewareLocked)));
+                    hasChanges = true;
+                    log.info("恢复餐具数量为已下单数量, cuisineId={}, oldQuantity={}, orderedQuantity={}",
+                            tablewareItem.getCuisineId(), currentQty, tablewareLocked);
+                }
+            }
             orderedItems.add(tablewareItem);
             orderedCuisineIds.add(tablewareItem.getCuisineId());
             log.info("保留餐具项, cuisineId={}, quantity={}", tablewareItem.getCuisineId(), tablewareItem.getQuantity());
@@ -719,6 +730,11 @@ public class CartServiceImpl implements CartService {
         String userPhone = TokenUtil.getCurrentUserPhone();
 
         if (tablewareItem != null) {
+            // 下单后只能增不能减：已有已下单数量时，用餐人数不能少于已下单数量
+            Integer lockedQuantity = tablewareItem.getLockedQuantity();
+            if (lockedQuantity != null && lockedQuantity > 0 && dinerCount < lockedQuantity) {
+                throw new RuntimeException("餐具数量不能少于已下单数量（" + lockedQuantity + "）");
+            }
             // 更新餐具数量和单价
             tablewareItem.setQuantity(dinerCount);
             tablewareItem.setUnitPrice(tablewareUnitPrice);
@@ -803,6 +819,11 @@ public class CartServiceImpl implements CartService {
             tablewareItem.setAddUserPhone(userPhone);
             items.add(tablewareItem);
         } else {
+            // 下单后只能增不能减：已有已下单数量时，数量不能少于已下单数量
+            Integer lockedQuantity = tablewareItem.getLockedQuantity();
+            if (lockedQuantity != null && lockedQuantity > 0 && quantity < lockedQuantity) {
+                throw new RuntimeException("餐具数量不能少于已下单数量（" + lockedQuantity + "）");
+            }
             // 如果已存在，更新单价（可能门店修改了餐具费）
             tablewareItem.setUnitPrice(tablewareUnitPrice);
         }

alien-dining/src/main/java/shop/alien/dining/service/impl/StoreOrderServiceImpl.java

@@ -112,7 +112,7 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
             }
         }
         
-        // 如果没有新增商品且没有商品数量增加，不允许创建订单
+        // 如果没有新增商品且没有商品数量增加，不允许创建/更新订单（下单后只能增不能减，不支持减量同步）
         if (!hasNewItems && !hasQuantityIncrease) {
             throw new RuntimeException("购物车中没有新增商品或商品数量未增加，无法创建订单");
         }
@@ -577,8 +577,24 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
         return this.getById(orderId);
     }
 
+    /** 前端只传 0=进行中、3=已完成。进行中对应库表 0待支付+1已支付，已完成对应 3。 */
+    private List<Integer> resolveOrderStatusFilter(Integer orderStatus) {
+        if (orderStatus == null) {
+            return null;
+        }
+        if (orderStatus == 0) {
+            return Arrays.asList(0, 1); // 进行中 = 待支付 + 已支付
+        }
+        if (orderStatus == 3) {
+            return Collections.singletonList(3); // 已完成
+        }
+        return null; // 其他值不参与筛选
+    }
+
     @Override
     public IPage<StoreOrder> getOrderPage(Page<StoreOrder> page, Integer storeId, Integer tableId, Integer orderStatus, String keyword) {
+        // 前端只传 0=进行中、3=已完成。进行中=待支付(0)+已支付(1)，已完成=3
+        List<Integer> orderStatusList = resolveOrderStatusFilter(orderStatus);
         LambdaQueryWrapper<StoreOrder> wrapper = new LambdaQueryWrapper<>();
         wrapper.eq(StoreOrder::getDeleteFlag, 0);
         if (storeId != null) {
@@ -587,8 +603,8 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
         if (tableId != null) {
             wrapper.eq(StoreOrder::getTableId, tableId);
         }
-        if (orderStatus != null) {
-            wrapper.eq(StoreOrder::getOrderStatus, orderStatus);
+        if (orderStatusList != null && !orderStatusList.isEmpty()) {
+            wrapper.in(StoreOrder::getOrderStatus, orderStatusList);
         }
         
         // 搜索功能：按订单编号模糊搜索
@@ -604,7 +620,9 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
 
     @Override
     public IPage<StoreOrderPageVO> getOrderPageWithCuisines(Page<StoreOrder> page, Integer storeId, Integer tableId, Integer orderStatus, String keyword) {
-        log.info("分页查询订单列表（包含菜品信息）, storeId={}, tableId={}, orderStatus={}, keyword={}", storeId, tableId, orderStatus, keyword);
+        // 前端只传 0=进行中、3=已完成。进行中=待支付(0)+已支付(1)，已完成=3
+        List<Integer> orderStatusList = resolveOrderStatusFilter(orderStatus);
+        log.info("分页查询订单列表（包含菜品信息）, storeId={}, tableId={}, orderStatus={}, keyword={}", storeId, tableId, orderStatusList, keyword);
         
         // 限制搜索关键词长度（15字）
         String searchKeyword = null;
@@ -627,8 +645,8 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
             if (tableId != null) {
                 orderNoWrapper.eq(StoreOrder::getTableId, tableId);
             }
-            if (orderStatus != null) {
-                orderNoWrapper.eq(StoreOrder::getOrderStatus, orderStatus);
+            if (orderStatusList != null && !orderStatusList.isEmpty()) {
+                orderNoWrapper.in(StoreOrder::getOrderStatus, orderStatusList);
             }
             List<StoreOrder> orderNoMatches = this.list(orderNoWrapper);
             orderNoMatches.forEach(order -> orderIdsSet.add(order.getId()));
@@ -640,7 +658,7 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
                     .eq(StoreOrderDetail::getDeleteFlag, 0);
             
             // 如果有限制条件，需要先查询符合条件的订单ID
-            if (storeId != null || tableId != null || orderStatus != null) {
+            if (storeId != null || tableId != null || (orderStatusList != null && !orderStatusList.isEmpty())) {
                 LambdaQueryWrapper<StoreOrder> filterWrapper = new LambdaQueryWrapper<>();
                 filterWrapper.eq(StoreOrder::getDeleteFlag, 0)
                         .select(StoreOrder::getId);
@@ -650,8 +668,8 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
                 if (tableId != null) {
                     filterWrapper.eq(StoreOrder::getTableId, tableId);
                 }
-                if (orderStatus != null) {
-                    filterWrapper.eq(StoreOrder::getOrderStatus, orderStatus);
+                if (orderStatusList != null && !orderStatusList.isEmpty()) {
+                    filterWrapper.in(StoreOrder::getOrderStatus, orderStatusList);
                 }
                 List<StoreOrder> filteredOrders = this.list(filterWrapper);
                 Set<Integer> filteredOrderIds = filteredOrders.stream()
@@ -693,8 +711,8 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
         if (tableId != null) {
             wrapper.eq(StoreOrder::getTableId, tableId);
         }
-        if (orderStatus != null) {
-            wrapper.eq(StoreOrder::getOrderStatus, orderStatus);
+        if (orderStatusList != null && !orderStatusList.isEmpty()) {
+            wrapper.in(StoreOrder::getOrderStatus, orderStatusList);
         }
         // 如果有关键词搜索，只查询匹配的订单ID
         if (matchingOrderIds != null && !matchingOrderIds.isEmpty()) {
@@ -730,10 +748,23 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
         Map<Integer, List<StoreOrderDetail>> detailsMap = allDetails.stream()
                 .collect(Collectors.groupingBy(StoreOrderDetail::getOrderId));
         
-        // 5. 构建返回结果
+        // 5. 批量查询门店名称
+        Set<Integer> storeIds = orders.stream().map(StoreOrder::getStoreId).filter(Objects::nonNull).collect(Collectors.toSet());
+        Map<Integer, String> storeNameMap = new HashMap<>();
+        if (!storeIds.isEmpty()) {
+            List<StoreInfo> storeList = storeInfoMapper.selectBatchIds(storeIds);
+            if (storeList != null) {
+                for (StoreInfo s : storeList) {
+                    storeNameMap.put(s.getId(), s.getStoreName());
+                }
+            }
+        }
+        
+        // 6. 构建返回结果
         List<StoreOrderPageVO> voList = orders.stream().map(order -> {
             StoreOrderPageVO vo = new StoreOrderPageVO();
             vo.setOrder(order);
+            vo.setStoreName(storeNameMap.getOrDefault(order.getStoreId(), ""));
             
             // 获取该订单的菜品列表
             List<StoreOrderDetail> orderDetails = detailsMap.getOrDefault(order.getId(), new ArrayList<>());
@@ -753,7 +784,7 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
             return vo;
         }).collect(Collectors.toList());
         
-        // 6. 构建分页结果
+        // 7. 构建分页结果
         Page<StoreOrderPageVO> resultPage = new Page<>(page.getCurrent(), page.getSize());
         resultPage.setRecords(voList);
         resultPage.setTotal(orderPage.getTotal());
@@ -763,148 +794,6 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
     }
 
     @Override
-    public StoreOrder addDishToOrder(Integer orderId, Integer cuisineId, Integer quantity, String remark) {
-        log.info("加餐, orderId={}, cuisineId={}, quantity={}", orderId, cuisineId, quantity);
-
-        // 验证订单状态
-        StoreOrder order = validateOrderForOperation(orderId, 0, "加餐");
-
-        // 验证菜品
-        StoreCuisine cuisine = storeCuisineMapper.selectById(cuisineId);
-        if (cuisine == null) {
-            throw new RuntimeException("菜品不存在");
-        }
-        if (cuisine.getShelfStatus() != 1) {
-            throw new RuntimeException("菜品已下架");
-        }
-
-        // 获取当前用户信息
-        Object[] userInfo = getCurrentUserInfo();
-        Integer userId = (Integer) userInfo[0];
-        String userPhone = (String) userInfo[1];
-
-        // 在加餐之前，检查订单明细中是否已经有 is_add_dish=1 的记录
-        // 如果没有，说明这是首次加餐（首次订单发生变化）
-        LambdaQueryWrapper<StoreOrderDetail> checkBeforeAddDishWrapper = new LambdaQueryWrapper<>();
-        checkBeforeAddDishWrapper.eq(StoreOrderDetail::getOrderId, orderId)
-                .eq(StoreOrderDetail::getDeleteFlag, 0)
-                .eq(StoreOrderDetail::getIsAddDish, 1);
-        Integer addDishCountBefore = orderDetailMapper.selectCount(checkBeforeAddDishWrapper);
-        boolean isFirstAddDish = (addDishCountBefore == null || addDishCountBefore == 0);
-
-        // 查询是否已有该菜品
-        LambdaQueryWrapper<StoreOrderDetail> detailWrapper = new LambdaQueryWrapper<>();
-        detailWrapper.eq(StoreOrderDetail::getOrderId, orderId);
-        detailWrapper.eq(StoreOrderDetail::getCuisineId, cuisineId);
-        detailWrapper.eq(StoreOrderDetail::getDeleteFlag, 0);
-        StoreOrderDetail existingDetail = orderDetailMapper.selectOne(detailWrapper);
-
-        Date now = new Date();
-        Integer quantityBefore = 0; // 加餐前的数量（用于记录变更日志）
-        BigDecimal addAmount; // 新增的金额
-        
-        if (existingDetail != null) {
-            // 记录加餐前的数量
-            quantityBefore = existingDetail.getQuantity();
-            // 计算新增金额（单价 * 新增数量）
-            addAmount = existingDetail.getUnitPrice().multiply(BigDecimal.valueOf(quantity));
-            // 更新数量
-            existingDetail.setQuantity(existingDetail.getQuantity() + quantity);
-            existingDetail.setSubtotalAmount(existingDetail.getUnitPrice()
-                    .multiply(BigDecimal.valueOf(existingDetail.getQuantity())));
-            if (StringUtils.hasText(remark)) {
-                existingDetail.setRemark(remark);
-            }
-            // 如果之前不是加餐，现在标记为加餐
-            if (existingDetail.getIsAddDish() == null || existingDetail.getIsAddDish() == 0) {
-                existingDetail.setIsAddDish(1); // 标记为加餐
-                existingDetail.setAddDishTime(now);
-            }
-            existingDetail.setUpdatedTime(now);
-            existingDetail.setUpdatedUserId(userId);
-            orderDetailMapper.updateById(existingDetail);
-        } else {
-            // 添加新菜品（加餐）
-            quantityBefore = 0; // 新菜品，加餐前数量为0
-            // 计算新增金额（单价 * 数量）
-            addAmount = cuisine.getTotalPrice().multiply(BigDecimal.valueOf(quantity));
-            StoreOrderDetail detail = new StoreOrderDetail();
-            detail.setOrderId(orderId);
-            detail.setOrderNo(order.getOrderNo());
-            detail.setCuisineId(cuisine.getId());
-            detail.setCuisineName(cuisine.getName());
-            
-            // 设置菜品类型：如果为null，默认为1（单品）
-            Integer cuisineType = cuisine.getCuisineType();
-            if (cuisineType == null) {
-                cuisineType = 1; // 默认为单品
-                log.warn("菜品类型为null，使用默认值1, cuisineId={}", cuisine.getId());
-            }
-            detail.setCuisineType(cuisineType);
-            
-            detail.setCuisineImage(cuisine.getImages());
-            detail.setUnitPrice(cuisine.getTotalPrice());
-            detail.setQuantity(quantity);
-            detail.setSubtotalAmount(addAmount);
-            detail.setAddUserId(userId);
-            detail.setAddUserPhone(userPhone);
-            detail.setIsAddDish(1); // 标记为加餐
-            detail.setAddDishTime(now);
-            detail.setRemark(remark);
-            detail.setCreatedUserId(userId);
-            detail.setCreatedTime(now);
-            detail.setUpdatedTime(now);
-            orderDetailMapper.insert(detail);
-        }
-
-        // 增量计算订单总金额（避免重新查询所有订单明细）
-        BigDecimal newTotalAmount = order.getTotalAmount().add(addAmount);
-
-        // 加餐时只更新订单总金额，不计算优惠金额和实付金额（因为可能还会继续加菜，支付时再统一计算）
-        // 如果订单使用了优惠券，不验证最低消费（因为可能还会继续加菜，支付时再验证）
-        order.setTotalAmount(newTotalAmount);
-        // order.setDiscountAmount 和 order.setPayAmount 保持不变，支付时再计算
-        order.setUpdatedTime(new Date());
-        order.setUpdatedUserId(userId);
-        this.updateById(order);
-
-        // 记录加餐变更日志
-        List<shop.alien.entity.store.dto.CartItemDTO> addDishItems = new ArrayList<>();
-        shop.alien.entity.store.dto.CartItemDTO addDishItem = new shop.alien.entity.store.dto.CartItemDTO();
-        addDishItem.setCuisineId(cuisine.getId());
-        addDishItem.setCuisineName(cuisine.getName());
-        addDishItem.setCuisineType(cuisine.getCuisineType());
-        addDishItem.setCuisineImage(cuisine.getImages());
-        addDishItem.setUnitPrice(cuisine.getTotalPrice());
-        // 设置当前数量（加餐后的总数量）
-        addDishItem.setQuantity(quantityBefore + quantity);
-        // 设置已下单数量（加餐前的数量，用于计算变化）
-        addDishItem.setLockedQuantity(quantityBefore);
-        addDishItem.setSubtotalAmount(cuisine.getTotalPrice().multiply(BigDecimal.valueOf(quantity)));
-        addDishItem.setRemark(remark);
-        addDishItems.add(addDishItem);
-        
-        recordOrderChangeLog(orderId, order.getOrderNo(), addDishItems, 2, now, userId, userPhone);
-
-        // 如果是首次加餐（首次订单发生变化），更新餐桌状态为加餐状态（3）
-        if (isFirstAddDish) {
-            StoreTable table = storeTableMapper.selectById(order.getTableId());
-            if (table != null) {
-                table.setStatus(3); // 加餐状态
-                table.setUpdatedTime(new Date());
-                if (userId != null) {
-                    table.setUpdatedUserId(userId);
-                }
-                storeTableMapper.updateById(table);
-                log.info("首次加餐，更新餐桌状态为加餐状态, tableId={}, orderId={}", table.getId(), orderId);
-            }
-        }
-
-        log.info("加餐成功, orderId={}", orderId);
-        return order;
-    }
-
-    @Override
     public boolean completeOrder(Integer orderId) {
         log.info("完成订单, orderId={}", orderId);
 
@@ -1575,6 +1464,7 @@ public class StoreOrderServiceImpl extends ServiceImpl<StoreOrderMapper, StoreOr
             batchVO.setOperationTime(firstLog.getOperationTime());
             batchVO.setOperatorUserId(firstLog.getOperatorUserId());
             batchVO.setOperatorUserPhone(firstLog.getOperatorUserPhone());
+            batchVO.setRemark(firstLog.getRemark());
             
             // 计算批次统计信息
             Integer totalQuantityChange = batchLogs.stream()

alien-entity/src/main/java/shop/alien/entity/store/dto/AddDishDTO.java

@@ -1,33 +0,0 @@
-package shop.alien.entity.store.dto;
-
-import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
-import lombok.Data;
-
-import javax.validation.constraints.NotNull;
-
-/**
- * 加餐DTO
- *
- * @author system
- * @since 2025-01-XX
- */
-@Data
-@ApiModel(value = "AddDishDTO对象", description = "加餐")
-public class AddDishDTO {
-
-    @ApiModelProperty(value = "订单ID", required = true)
-    @NotNull(message = "订单ID不能为空")
-    private Integer orderId;
-
-    @ApiModelProperty(value = "菜品ID", required = true)
-    @NotNull(message = "菜品ID不能为空")
-    private Integer cuisineId;
-
-    @ApiModelProperty(value = "数量", required = true)
-    @NotNull(message = "数量不能为空")
-    private Integer quantity;
-
-    @ApiModelProperty(value = "备注")
-    private String remark;
-}

alien-entity/src/main/java/shop/alien/entity/store/vo/OrderChangeLogBatchVO.java

@@ -36,6 +36,9 @@ public class OrderChangeLogBatchVO {
     @ApiModelProperty(value = "操作人手机号")
     private String operatorUserPhone;
 
+    @ApiModelProperty(value = "备注（该批次对应的备注，如下单/加餐时的备注）")
+    private String remark;
+
     @ApiModelProperty(value = "该批次商品数量变化总和")
     private Integer totalQuantityChange;