菜品售卖量接口

@@ -44,6 +44,11 @@ public @interface RepeatSubmit {
     String message() default "不允许重复提交，请稍后再试";
     String message() default "不允许重复提交，请稍后再试";
 
 
     /**
     /**
+     * 是否根据登录用户ID加锁
+     */
+    boolean isLockByLoginUser() default true;
+
+    /**
      * 方法执行完自动释放锁
      * 方法执行完自动释放锁
      */
      */
     boolean methodAutoUnlock() default true;
     boolean methodAutoUnlock() default true;

@@ -110,7 +110,11 @@ public class RepeatSubmitAspect {
                 }
                 }
             }
             }
         }
         }
+        if (requestLock.isLockByLoginUser()) {
             final var operatorId = LoginContextHolder.hasLogin() ? LoginContextHolder.getId() : null;
             final var operatorId = LoginContextHolder.hasLogin() ? LoginContextHolder.getId() : null;
             return requestLock.prefix() + (operatorId != null ? CommonConstants.COLON + operatorId : "") + (sb.length() > 0 ? CommonConstants.UNDERLINE + sb : "");
             return requestLock.prefix() + (operatorId != null ? CommonConstants.COLON + operatorId : "") + (sb.length() > 0 ? CommonConstants.UNDERLINE + sb : "");
+        } else {
+            return requestLock.prefix() + (sb.length() > 0 ? CommonConstants.UNDERLINE + sb : "");
+        }
     }
     }
 }
 }

@@ -9,7 +9,7 @@ import io.lettuce.core.resource.ClientResources;
 import io.lettuce.core.tracing.BraveTracing;
 import io.lettuce.core.tracing.BraveTracing;
 import org.redisson.Redisson;
 import org.redisson.Redisson;
 import org.redisson.api.RedissonClient;
 import org.redisson.api.RedissonClient;
-import org.redisson.client.codec.StringCodec;
+import org.redisson.codec.JsonJacksonCodec;
 import org.redisson.config.Config;
 import org.redisson.config.Config;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Qualifier;
 import org.springframework.beans.factory.annotation.Qualifier;
@@ -68,7 +68,7 @@ public class RedisConfig {
                                          @Value(REDIS_PORT) final String port,
                                          @Value(REDIS_PORT) final String port,
                                          @Value(REDIS_DATABASE) final int dbToken) {
                                          @Value(REDIS_DATABASE) final int dbToken) {
         final var config = new Config();
         final var config = new Config();
-        config.setCodec(StringCodec.INSTANCE);
+        config.setCodec(new JsonJacksonCodec());
 
 
         config.useSingleServer()
         config.useSingleServer()
                 .setAddress("redis://" + url + ":" + port)
                 .setAddress("redis://" + url + ":" + port)

@@ -15,8 +15,15 @@ import org.springframework.http.converter.StringHttpMessageConverter;
 import org.springframework.web.client.DefaultResponseErrorHandler;
 import org.springframework.web.client.DefaultResponseErrorHandler;
 import org.springframework.web.client.RestTemplate;
 import org.springframework.web.client.RestTemplate;
 
 
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.X509TrustManager;
 import java.io.IOException;
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
 import java.nio.charset.StandardCharsets;
+import java.security.KeyManagementException;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.cert.X509Certificate;
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeUnit;
 
 
@@ -40,8 +47,26 @@ public class RestTemplateConfig {
     private Integer keepAliveDuration;
     private Integer keepAliveDuration;
 
 
     @Bean
     @Bean
-    public OkHttpClient okHttpClient() {
+    public OkHttpClient okHttpClient() throws NoSuchAlgorithmException, KeyManagementException {
+        TrustManager[] trustAllCertificates = new TrustManager[]{
+                new X509TrustManager() {
+                    @Override
+                    public void checkClientTrusted(X509Certificate[] chain, String authType) {}
+
+                    @Override
+                    public void checkServerTrusted(X509Certificate[] chain, String authType) {}
+
+                    @Override
+                    public X509Certificate[] getAcceptedIssuers() {
+                        return new X509Certificate[0];
+                    }
+                }
+        };
+        SSLContext sslContext = SSLContext.getInstance("TLS");
+        sslContext.init(null, trustAllCertificates, new SecureRandom());
         return new OkHttpClient.Builder()
         return new OkHttpClient.Builder()
+                .sslSocketFactory(sslContext.getSocketFactory(), (X509TrustManager) trustAllCertificates[0])
+                .hostnameVerifier((hostname, session) -> true)
                 .connectTimeout(connectTimeout, TimeUnit.SECONDS)
                 .connectTimeout(connectTimeout, TimeUnit.SECONDS)
                 .readTimeout(readTimeout, TimeUnit.SECONDS)
                 .readTimeout(readTimeout, TimeUnit.SECONDS)
                 .writeTimeout(writeTimeout, TimeUnit.SECONDS)
                 .writeTimeout(writeTimeout, TimeUnit.SECONDS)

 package com.infoloop.tianting.controller;
 package com.infoloop.tianting.controller;
 
 
 import com.github.xiaoymin.knife4j.annotations.ApiSupport;
 import com.github.xiaoymin.knife4j.annotations.ApiSupport;
+import com.infoloop.tianting.annotation.RepeatSubmit;
 import com.infoloop.tianting.model.dto.OrderDbDTO;
 import com.infoloop.tianting.model.dto.OrderDbDTO;
 import com.infoloop.tianting.model.dto.OrderDbDTO.BatchUpdateOrderDetailResponse;
 import com.infoloop.tianting.model.dto.OrderDbDTO.BatchUpdateOrderDetailResponse;
 import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderDto;
@@ -67,6 +68,7 @@ public class OrderController {
     @ApiOperation(value = "创建订单")
     @ApiOperation(value = "创建订单")
     @PostMapping("/orders")
     @PostMapping("/orders")
     @ResponseStatus(HttpStatus.OK)
     @ResponseStatus(HttpStatus.OK)
+    @RepeatSubmit(prefix = "createOrder", isLockByLoginUser = false)
     public CreateOrderResponse createOrder(@Valid @RequestBody CreateOrderDto createOrderDto) {
     public CreateOrderResponse createOrder(@Valid @RequestBody CreateOrderDto createOrderDto) {
         return orderService.createOrder(createOrderDto);
         return orderService.createOrder(createOrderDto);
     }
     }
@@ -74,12 +76,11 @@ public class OrderController {
     @ApiOperation(value = "院区端创建订单")
     @ApiOperation(value = "院区端创建订单")
     @PostMapping("/operator/orders")
     @PostMapping("/operator/orders")
     @ResponseStatus(HttpStatus.OK)
     @ResponseStatus(HttpStatus.OK)
-    public CreateOrderResponse createOrderByOperator(
-            @Valid @RequestBody OrderDbDTO.OperatorCreateOrderDto createOrderDto) {
+    @RepeatSubmit(prefix = "createOrder", isLockByLoginUser = false)
+    public CreateOrderResponse createOrderByOperator(@Valid @RequestBody OrderDbDTO.OperatorCreateOrderDto createOrderDto) {
         return orderService.orderCreation(createOrderDto);
         return orderService.orderCreation(createOrderDto);
     }
     }
 
 
-    //  @SaIgnore
     @ApiOperation(value = "修改订单")
     @ApiOperation(value = "修改订单")
     @PatchMapping("/orders/modification")
     @PatchMapping("/orders/modification")
     @ResponseStatus(HttpStatus.OK)
     @ResponseStatus(HttpStatus.OK)
@@ -87,20 +88,17 @@ public class OrderController {
         return orderService.updateOrder(updateOrderDto);
         return orderService.updateOrder(updateOrderDto);
     }
     }
 
 
-    //  @SaIgnore
     @ApiOperation(value = "批量修改订单详情")
     @ApiOperation(value = "批量修改订单详情")
     @PatchMapping("/order_details/modification")
     @PatchMapping("/order_details/modification")
     @ResponseStatus(HttpStatus.OK)
     @ResponseStatus(HttpStatus.OK)
-    public BatchUpdateOrderDetailResponse batchUpdateOrderDetails(
-            @Valid @RequestBody OrderDbDTO.OrderDetailBatchUpdateDto updateDto) {
+    public BatchUpdateOrderDetailResponse batchUpdateOrderDetails(@Valid @RequestBody OrderDbDTO.OrderDetailBatchUpdateDto updateDto) {
         return orderService.batchUpdateOrderDetails(updateDto);
         return orderService.batchUpdateOrderDetails(updateDto);
     }
     }
 
 
     @ApiOperation(value = "获取已预定该餐单的次数")
     @ApiOperation(value = "获取已预定该餐单的次数")
     @PostMapping("/order/check")
     @PostMapping("/order/check")
     @ResponseStatus(HttpStatus.OK)
     @ResponseStatus(HttpStatus.OK)
-    public Integer checkOrder(
-            @Valid @RequestBody OrderDbDTO.getMenuOrderCountDto checkIfOrderedDto) {
+    public Integer checkOrder(@Valid @RequestBody OrderDbDTO.getMenuOrderCountDto checkIfOrderedDto) {
         return orderService.getMenuOrderCount(checkIfOrderedDto);
         return orderService.getMenuOrderCount(checkIfOrderedDto);
     }
     }
 
 

 package com.infoloop.tianting.controller;
 package com.infoloop.tianting.controller;
 
 
 import com.github.xiaoymin.knife4j.annotations.ApiSupport;
 import com.github.xiaoymin.knife4j.annotations.ApiSupport;
+import com.infoloop.tianting.model.common.PageResult;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuDto;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuDto;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuIdsDto;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuIdsDto;
+import com.infoloop.tianting.model.dto.SkuSellQuantityDTO;
+import com.infoloop.tianting.model.vo.SkuSellQuantityStatisticsVO;
+import com.infoloop.tianting.model.vo.SkuSellQuantityVO;
 import com.infoloop.tianting.service.SkuService;
 import com.infoloop.tianting.service.SkuService;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiOperation;
@@ -11,7 +15,10 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.HttpStatus;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.PutMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;
 import org.springframework.web.bind.annotation.RestController;
@@ -32,7 +39,36 @@ public class SkuController {
     @ApiOperation(value = "根据sku ids获取")
     @ApiOperation(value = "根据sku ids获取")
     @PostMapping("/skus")
     @PostMapping("/skus")
     @ResponseStatus(HttpStatus.OK)
     @ResponseStatus(HttpStatus.OK)
-    public List<SkuDto> getOrderByCustomerId(@Valid @RequestBody SkuIdsDto skuIdsDto) {
+    public List<SkuDto> getSkusByIds(@Valid @RequestBody SkuIdsDto skuIdsDto) {
         return skuService.getSkusByIds(skuIdsDto.getIds());
         return skuService.getSkusByIds(skuIdsDto.getIds());
     }
     }
+
+    @ApiOperation(value = "获取菜品售卖量统计")
+    @GetMapping("/stall/{stallId}/skusellquantities/statistics")
+    @ResponseStatus(HttpStatus.OK)
+    public SkuSellQuantityStatisticsVO querySkuSellQuantityStatistics(@PathVariable("stallId") int stallId) {
+        return skuService.querySkuSellQuantityStatistics(stallId);
+    }
+
+    @ApiOperation(value = "分页查询菜品售卖量")
+    @PostMapping("/skusellquantities/query")
+    @ResponseStatus(HttpStatus.OK)
+    public PageResult<SkuSellQuantityVO> querySkuSellQuantity(@Valid @RequestBody SkuSellQuantityDTO.QuerySkuSellQuantityDTO querySkuSellQuantityDTO) {
+        return skuService.querySkuSellQuantity(querySkuSellQuantityDTO);
+    }
+
+    @ApiOperation(value = "批量设置菜品售卖量")
+    @PutMapping("/stall/{stallId}/skusellquantities/batchset")
+    @ResponseStatus(HttpStatus.CREATED)
+    public boolean batchSetSkuSellQuantity(@PathVariable("stallId") int stallId,
+                                           @Valid @RequestBody SkuSellQuantityDTO.BatchSetSkuSellQuantityDTO batchSetSkuSellQuantityDTO) {
+        return skuService.batchSetSkuSellQuantity(stallId, batchSetSkuSellQuantityDTO);
+    }
+
+    @ApiOperation(value = "根据菜品ids批量查询菜品售卖量")
+    @PostMapping("/skusellquantities/querybyskuids")
+    @ResponseStatus(HttpStatus.OK)
+    public List<SkuSellQuantityVO> querySkuSellQuantityBySkuIds(@Valid @RequestBody SkuSellQuantityDTO.QuerySkuSellQuantityBySkuIdsDTO querySkuSellQuantityBySkuIdsDTO) {
+        return skuService.querySkuSellQuantityBySkuIds(querySkuSellQuantityBySkuIdsDTO);
+    }
 }
 }

+package com.infoloop.tianting.enums;
+
+public enum SkuSellQuantityStatus {
+
+    ALL,
+    SOLD_OUT,
+    ON_SALE
+}

@@ -29,6 +29,12 @@ public enum ErrorCodeEnum implements BaseEnum {
     ORDER_COUNT_LIMIT(406000005, "已超过该餐单预定次数"),
     ORDER_COUNT_LIMIT(406000005, "已超过该餐单预定次数"),
 
 
     QUERY_CLIENT_CUSTOMER_ERROR(406000006, "获取当日在住客户失败"),
     QUERY_CLIENT_CUSTOMER_ERROR(406000006, "获取当日在住客户失败"),
+
+    SKUS_SOLD_OUT_TODAY(406000007, "下单菜品\n{0}\n今日已售罄"),
+
+    SKUS_STOCK_NO_ENOUGH_TODAY(406000007, "下单菜品\n{0}\n库存不足"),
+
+    ORDER_CANCEL(406000008, "订单已自动取消")
     ;
     ;
     private final int code;
     private final int code;
 
 

+package com.infoloop.tianting.logic.delay;
+
+import lombok.extern.slf4j.Slf4j;
+import org.redisson.api.RBlockingQueue;
+import org.redisson.api.RedissonClient;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+@Slf4j
+public class DelayTaskQueueExecutor<T> {
+
+    private final RedissonClient redissonClient;
+    private final RBlockingQueue<T> blockingDeque;
+    private final Processor<T> processor;
+    private final ExecutorService executorService;
+    private volatile boolean running = true;
+
+    public interface Processor<T> {
+        void process(T task) throws InterruptedException;
+    }
+
+    public DelayTaskQueueExecutor(String threadName, RedissonClient redissonClient, RBlockingQueue<T> blockingDeque, Processor<T> processor) {
+        this.redissonClient = redissonClient;
+        this.blockingDeque = blockingDeque;
+        this.processor = processor;
+        this.executorService = Executors.newSingleThreadExecutor(r -> {
+            Thread t = new Thread(r);
+            t.setName(threadName);
+            return t;
+        });
+        this.executorService.submit(this::looper);
+    }
+
+    public void looper() {
+        while (running) {
+            try {
+                if (redissonClient.isShutdown()) {
+                    shutdown();
+                    return;
+                }
+                T task = blockingDeque.take();
+                processor.process(task);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                break;
+            } catch (Exception e) {
+                log.error("Task processing error in thread: {}", Thread.currentThread().getName(), e);
+            }
+        }
+    }
+
+    public void shutdown() {
+        running = false;
+        executorService.shutdown();
+        try {
+            if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
+                log.warn("Executor did not terminate in the specified time.");
+                executorService.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            log.error("Shutdown interrupted", e);
+            executorService.shutdownNow();
+            Thread.currentThread().interrupt();
+        }
+    }
+}

+package com.infoloop.tianting.logic.delay;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.redisson.api.RBlockingQueue;
+import org.redisson.api.RDelayedQueue;
+import org.redisson.api.RedissonClient;
+import org.springframework.stereotype.Service;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Consumer;
+
+@Slf4j
+@Service
+@RequiredArgsConstructor
+public class DelayedQueue<T> {
+
+    private final RedissonClient redissonClient;
+
+    private final Map<String, RDelayedQueue<T>> delayedQueues = new ConcurrentHashMap<>();
+
+    /**
+     * 初始化队列，传入队列名称和处理逻辑
+     */
+    public void initQueue(String queueName, Consumer<T> processMessage) {
+        RBlockingQueue<T> blockingQueue = redissonClient.getBlockingQueue(queueName);
+        RDelayedQueue<T> delayedQueue = redissonClient.getDelayedQueue(blockingQueue);
+        delayedQueues.put(queueName, delayedQueue);
+        DelayTaskQueueExecutor.Processor<T> processor = task -> {
+            try {
+                processMessage.accept(task);
+            } catch (Exception e) {
+                log.error("Error processing task: {}", task, e);
+            }
+        };
+        new DelayTaskQueueExecutor<>(queueName + " DELAY TASK", redissonClient, blockingQueue, processor);
+        log.info("Initialized delay queue for {}", queueName);
+    }
+
+    public void addToQueue(String queueName, T message, long delay, TimeUnit timeUnit) {
+        RDelayedQueue<T> queue = getDelayedQueue(queueName);
+        queue.offer(message, delay, timeUnit);
+        log.info("Added to queue: {}, msg: {}, delay: {} {}", queueName, message, delay, timeUnit);
+    }
+
+    public void addToQueue(String queueName, List<T> messages, long delay, TimeUnit timeUnit) {
+        RDelayedQueue<T> queue = getDelayedQueue(queueName);
+        messages.forEach(message -> {
+            queue.offer(message, delay, timeUnit);
+            log.info("Added to queue: {}, msg: {}, delay: {} {}", queueName, message, delay, timeUnit);
+        });
+    }
+
+    private RDelayedQueue<T> getDelayedQueue(String queueName) {
+        RDelayedQueue<T> queue = delayedQueues.get(queueName);
+        if (queue == null) {
+            throw new IllegalArgumentException("Queue not initialized: " + queueName);
+        }
+        return queue;
+    }
+
+}

+package com.infoloop.tianting.logic.delay;
+
+import com.infoloop.tianting.clientcustomerorderservice.PayStatusEnum;
+import com.infoloop.tianting.logic.delay.param.AutoCancelParam;
+import com.infoloop.tianting.model.bo.AddSkusSellQuantityBO;
+import com.infoloop.tianting.service.client.OrderServiceRpcClient;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.PostConstruct;
+import java.util.stream.Collectors;
+
+@Slf4j
+@Component
+@RequiredArgsConstructor
+public class OrderAutoCancelDelayTask {
+
+    private final DelayedQueue<AutoCancelParam> delayedQueue;
+
+    private final OrderServiceRpcClient orderServiceRpcClient;
+
+    public static final String AUTO_CANCEL_ORDER_DELAY_QUEUE = "AUTO_CANCEL_ORDER_QUEUE";
+
+    @PostConstruct
+    public void init() {
+        delayedQueue.initQueue(AUTO_CANCEL_ORDER_DELAY_QUEUE, this::execute);
+    }
+
+    private void execute(AutoCancelParam param) {
+        try {
+            final var orderById = orderServiceRpcClient.getOrderById(param.getOrderId());
+            if (orderById == null) {
+                log.error("Order not found, orderId: {}", param.getOrderId());
+                return;
+            }
+            if (orderById.getPayStatus() == PayStatusEnum.PAY_CANCELED) {
+                log.info("Order {} already canceled, skipping.", param.getOrderId());
+                return;
+            }
+            if (orderById.getPayStatus() != PayStatusEnum.TO_PAY) {
+                log.info("Order {} not to pay, skipping.", param.getOrderId());
+                return;
+            }
+            final var isUpdated = orderServiceRpcClient.updateClientCustomerOrderCancel(orderById.getEnterpriseId(), orderById.getId());
+            if (isUpdated) {
+                final var orderDetails = orderServiceRpcClient.getOrderDetailsByOrderId(orderById.getId());
+                final var isSuccess = orderServiceRpcClient.addSkusSellQuantities(orderById.getEnterpriseId(), orderById.getStallId(), orderDetails.stream().map(e -> AddSkusSellQuantityBO.builder()
+                        .skuId(e.getSkuId())
+                        .quantity(-e.getCount())
+                        .build()).collect(Collectors.toList()));
+                log.info("Order {} addSkusSellQuantities result: {}", param.getOrderId(), isSuccess);
+            }
+        } catch (Exception e) {
+            log.error("OrderAutoCancelDelayTask execute error", e);
+        }
+    }
+
+}

+package com.infoloop.tianting.logic.delay.param;
+
+import lombok.Data;
+
+@Data
+public class AutoCancelParam {
+
+    private int orderId;
+
+}

+package com.infoloop.tianting.model.bo;
+
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class AddSkusSellQuantityBO {
+
+    private int skuId;
+
+    private int quantity;
+}

+package com.infoloop.tianting.model.bo;
+
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@Builder
+public class SkuSellQuantityBO {
+
+    private Integer id;
+
+    private int skuId;
+
+    private int maxSellQuantity;
+}

@@ -3,19 +3,16 @@ package com.infoloop.tianting.model.common;
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModel;
 import io.swagger.annotations.ApiModelProperty;
 import io.swagger.annotations.ApiModelProperty;
 import lombok.Data;
 import lombok.Data;
-import lombok.Singular;
 
 
+import javax.validation.constraints.NotEmpty;
 import java.util.List;
 import java.util.List;
 
 
 @Data
 @Data
 @ApiModel(description = "公共参数")
 @ApiModel(description = "公共参数")
-public class Param {
+public class IdsParam {
 
 
     @ApiModelProperty(value = "ids")
     @ApiModelProperty(value = "ids")
-    @Singular("id")
+    @NotEmpty(message = "ids不能为空")
     private List<Integer> ids;
     private List<Integer> ids;
 
 
-    @ApiModelProperty(value = "keyword")
-    private String keyword;
-
 }
 }

 package com.infoloop.tianting.model.dto;
 package com.infoloop.tianting.model.dto;
 
 
+import com.infoloop.tianting.annotation.RequestKeyParam;
 import com.infoloop.tianting.clientcustomerorderservice.CloseTimeType;
 import com.infoloop.tianting.clientcustomerorderservice.CloseTimeType;
 import com.infoloop.tianting.clientcustomerorderservice.OrderSourceEnum;
 import com.infoloop.tianting.clientcustomerorderservice.OrderSourceEnum;
 import com.infoloop.tianting.clientcustomerorderservice.OrderStatusEnum;
 import com.infoloop.tianting.clientcustomerorderservice.OrderStatusEnum;
@@ -200,6 +201,8 @@ public class OrderDbDTO {
   @Builder
   @Builder
   @ApiModel(description = "创建订单视图")
   @ApiModel(description = "创建订单视图")
   public static class OperatorCreateOrderDto {
   public static class OperatorCreateOrderDto {
+
+    @RequestKeyParam
     @ApiModelProperty(value = "档口 ID")
     @ApiModelProperty(value = "档口 ID")
     private Integer stallId;
     private Integer stallId;
 
 
@@ -234,6 +237,7 @@ public class OrderDbDTO {
     @ApiModelProperty(value = "院区 ID")
     @ApiModelProperty(value = "院区 ID")
     private Integer clientId;
     private Integer clientId;
 
 
+    @RequestKeyParam
     @ApiModelProperty(value = "档口 ID")
     @ApiModelProperty(value = "档口 ID")
     private Integer stallId;
     private Integer stallId;
 
 
@@ -534,6 +538,7 @@ public class OrderDbDTO {
   @ToString
   @ToString
   @ApiModel(description = "订单详情信息，即菜品细节")
   @ApiModel(description = "订单详情信息，即菜品细节")
   public static class OperatorCreateOrderDetailDto {
   public static class OperatorCreateOrderDetailDto {
+
     @ApiModelProperty(value = "餐单详情 id，即菜品")
     @ApiModelProperty(value = "餐单详情 id，即菜品")
     private Integer menuDetailId;
     private Integer menuDetailId;
 
 

+package com.infoloop.tianting.model.dto;
+
+import com.infoloop.tianting.enums.SkuSellQuantityStatus;
+import com.infoloop.tianting.model.common.PageInfo;
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import javax.validation.constraints.NotEmpty;
+import javax.validation.constraints.NotNull;
+import java.util.List;
+
+@Data
+@ApiModel(description = "SkuSellQuantityDTO")
+public class SkuSellQuantityDTO {
+
+    @Data
+    @ApiModel(description = "批量设置菜品售卖量")
+    public static class BatchSetSkuSellQuantityDTO {
+
+        @ApiModelProperty("菜品 Ids")
+        @NotEmpty
+        private List<Integer> skuIds;
+
+        @ApiModelProperty("最大售卖数量")
+        @NotNull
+        private Integer maxSellQuantity;
+    }
+
+
+    @EqualsAndHashCode(callSuper = true)
+    @Data
+    @ApiModel(description = "分页查询菜品售卖量")
+    public static class QuerySkuSellQuantityDTO extends PageInfo {
+
+        @ApiModelProperty("档口Id")
+        @NotNull
+        private Integer stallId;
+
+        @ApiModelProperty("菜品售卖状态")
+        @NotNull
+        private SkuSellQuantityStatus status;
+
+        @ApiModelProperty("关键字")
+        private String keyword;
+    }
+
+    @Data
+    @ApiModel(description = "根据菜品 Ids 查询菜品售卖量")
+    public static class QuerySkuSellQuantityBySkuIdsDTO {
+
+        @ApiModelProperty("档口Id")
+        @NotNull
+        private Integer stallId;
+
+        @ApiModelProperty("菜品售卖状态")
+        @NotEmpty
+        private List<Integer> skuIds;
+    }
+
+}

+package com.infoloop.tianting.model.vo;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Builder;
+import lombok.Data;
+
+@Data
+@ApiModel
+@Builder
+public class SkuSellQuantityStatisticsVO {
+
+    @ApiModelProperty("全部")
+    private int total;
+
+    @ApiModelProperty("售罄")
+    private Long soldOut;
+
+    @ApiModelProperty("在售")
+    private Long onSale;
+}

+package com.infoloop.tianting.model.vo;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Builder;
+import lombok.Data;
+
+
+@Data
+@ApiModel
+@Builder
+public class SkuSellQuantityVO {
+
+    @ApiModelProperty("菜品Id")
+    private Integer skuId;
+
+    @ApiModelProperty("菜品名称")
+    private String skuName;
+
+    @ApiModelProperty("菜品编号")
+    private String skuCode;
+
+    @ApiModelProperty("最大售卖数量")
+    private int maxSellQuantity;
+
+    @ApiModelProperty("今日售卖数量")
+    private int todaySellQuantity;
+
+    @ApiModelProperty("是否售罄")
+    private Boolean soldOut;
+
+}

@@ -6,6 +6,7 @@ import com.infoloop.tianting.model.dto.MenuDbDTO.BatchCreateMenuRefsResponseDto;
 import com.infoloop.tianting.model.dto.MenuDbDTO.MenuDetailDto;
 import com.infoloop.tianting.model.dto.MenuDbDTO.MenuDetailDto;
 import com.infoloop.tianting.model.dto.MenuDbDTO.MenuDto;
 import com.infoloop.tianting.model.dto.MenuDbDTO.MenuDto;
 import com.infoloop.tianting.model.dto.MenuDbDTO.MenuRefDto;
 import com.infoloop.tianting.model.dto.MenuDbDTO.MenuRefDto;
+
 import java.util.List;
 import java.util.List;
 
 
 public interface MenuService {
 public interface MenuService {
@@ -21,4 +22,6 @@ public interface MenuService {
   List<MenuRefDto> getClientCustomerMenuRefsByCustomerId(Integer enterpriseId, Integer customerId);
   List<MenuRefDto> getClientCustomerMenuRefsByCustomerId(Integer enterpriseId, Integer customerId);
 
 
   BatchCreateMenuRefsResponseDto batchCreateMenuRefs(BatchCreateMenuRefsDto batchCreateMenuRefsDto);
   BatchCreateMenuRefsResponseDto batchCreateMenuRefs(BatchCreateMenuRefsDto batchCreateMenuRefsDto);
+
+  List<Integer> queryMenuSkuIdsByStallId(int enterpriseId, int stallId);
 }
 }

 package com.infoloop.tianting.service;
 package com.infoloop.tianting.service;
 
 
 import com.infoloop.tianting.model.common.OrderPageResult;
 import com.infoloop.tianting.model.common.OrderPageResult;
-import com.infoloop.tianting.model.common.PageResult;
 import com.infoloop.tianting.model.dto.OrderDbDTO.BatchUpdateOrderDetailResponse;
 import com.infoloop.tianting.model.dto.OrderDbDTO.BatchUpdateOrderDetailResponse;
-import com.infoloop.tianting.model.dto.OrderDbDTO.getMenuOrderCountDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderResponse;
 import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderResponse;
 import com.infoloop.tianting.model.dto.OrderDbDTO.OperatorCreateOrderDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.OperatorCreateOrderDto;
@@ -15,6 +13,8 @@ import com.infoloop.tianting.model.dto.OrderDbDTO.QueryOrderByConditionDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.QueryOrderByPaginationDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.QueryOrderByPaginationDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.UpdateOrderDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.UpdateOrderDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.UpdateOrderResponse;
 import com.infoloop.tianting.model.dto.OrderDbDTO.UpdateOrderResponse;
+import com.infoloop.tianting.model.dto.OrderDbDTO.getMenuOrderCountDto;
+
 import java.util.List;
 import java.util.List;
 
 
 public interface OrderService {
 public interface OrderService {

 package com.infoloop.tianting.service;
 package com.infoloop.tianting.service;
 
 
+import com.infoloop.tianting.model.common.PageResult;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuDto;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuDto;
+import com.infoloop.tianting.model.dto.SkuSellQuantityDTO;
+import com.infoloop.tianting.model.vo.SkuSellQuantityStatisticsVO;
+import com.infoloop.tianting.model.vo.SkuSellQuantityVO;
+
+import javax.validation.Valid;
 import java.util.List;
 import java.util.List;
 
 
 public interface SkuService {
 public interface SkuService {
 
 
   List<SkuDto> getSkusByIds(List<Integer> ids);
   List<SkuDto> getSkusByIds(List<Integer> ids);
 
 
+  SkuSellQuantityStatisticsVO querySkuSellQuantityStatistics(int stallId);
+
+  PageResult<SkuSellQuantityVO> querySkuSellQuantity(SkuSellQuantityDTO.QuerySkuSellQuantityDTO querySkuSellQuantityDTO);
+
+  boolean batchSetSkuSellQuantity(int stallId, SkuSellQuantityDTO.BatchSetSkuSellQuantityDTO batchSetSkuSellQuantityDTO);
+
+  List<SkuSellQuantityVO> querySkuSellQuantityBySkuIds(SkuSellQuantityDTO.@Valid QuerySkuSellQuantityBySkuIdsDTO querySkuSellQuantityBySkuIdsDTO);
 }
 }

 package com.infoloop.tianting.service.client;
 package com.infoloop.tianting.service.client;
 
 
 import com.infoloop.tianting.SingleResponse;
 import com.infoloop.tianting.SingleResponse;
+import com.infoloop.tianting.SingleSkuResponse;
 import com.infoloop.tianting.SingleSpecialResponse;
 import com.infoloop.tianting.SingleSpecialResponse;
+import com.infoloop.tianting.clientcustomerorderservice.AddSkusSellQuantitiesRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateOrderOperationRecordsRequest;
 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateOrderOperationRecordsRequest;
 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateOrderOperationRecordsResponse;
 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateOrderOperationRecordsResponse;
+import com.infoloop.tianting.clientcustomerorderservice.BatchSaveSkuSellQuantitiesRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrderDetailsRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrderDetailsRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrderDetailsRpcResponse;
 import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrderDetailsRpcResponse;
 import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderCreation;
 import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderCreation;
@@ -13,7 +16,6 @@ import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderModif
 import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderServiceRpcGrpc;
 import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderServiceRpcGrpc;
 import com.infoloop.tianting.clientcustomerorderservice.CloseTimeType;
 import com.infoloop.tianting.clientcustomerorderservice.CloseTimeType;
 import com.infoloop.tianting.clientcustomerorderservice.CreateClientCustomerOrderRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.CreateClientCustomerOrderRpcRequest;
-import com.infoloop.tianting.clientcustomerorderservice.CreateClientCustomerOrderRpcResponse;
 import com.infoloop.tianting.clientcustomerorderservice.CustomerNotice;
 import com.infoloop.tianting.clientcustomerorderservice.CustomerNotice;
 import com.infoloop.tianting.clientcustomerorderservice.GetClientCustomerOrderByIdRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.GetClientCustomerOrderByIdRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.GetClientCustomerOrderDetailsByIdsRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.GetClientCustomerOrderDetailsByIdsRpcRequest;
@@ -28,13 +30,26 @@ import com.infoloop.tianting.clientcustomerorderservice.PayStatusEnum;
 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByConditionRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByConditionRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByPaginationRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByPaginationRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByPaginationRpcResponse;
 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByPaginationRpcResponse;
+import com.infoloop.tianting.clientcustomerorderservice.QuerySkuSellQuantitiesByStallAndSkuIdsRpcRequest;
+import com.infoloop.tianting.clientcustomerorderservice.QuerySkuSellQuantitiesByStallRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.ServeStatusEnum;
 import com.infoloop.tianting.clientcustomerorderservice.ServeStatusEnum;
 import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderDetailRpcResponse;
 import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderDetailRpcResponse;
 import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderRpcResponse;
 import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderRpcResponse;
+import com.infoloop.tianting.clientcustomerorderservice.SingleSkuSellQuantityRpcResponse;
+import com.infoloop.tianting.clientcustomerorderservice.SkuSellQuantity;
+import com.infoloop.tianting.clientcustomerorderservice.SkuSellQuantityModification;
 import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderRpcRequest;
 import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderRpcResponse;
 import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderRpcResponse;
 import com.infoloop.tianting.context.LoginContextHolder;
 import com.infoloop.tianting.context.LoginContextHolder;
 import com.infoloop.tianting.enums.OrderTypeEnum;
 import com.infoloop.tianting.enums.OrderTypeEnum;
+import com.infoloop.tianting.exception.ClientEndExceptions;
+import com.infoloop.tianting.exception.ErrorCodeEnum;
+import com.infoloop.tianting.logic.delay.DelayedQueue;
+import com.infoloop.tianting.logic.delay.OrderAutoCancelDelayTask;
+import com.infoloop.tianting.logic.delay.param.AutoCancelParam;
+import com.infoloop.tianting.menuservice.CloseTimeTypeEnum;
+import com.infoloop.tianting.model.bo.AddSkusSellQuantityBO;
+import com.infoloop.tianting.model.bo.SkuSellQuantityBO;
 import com.infoloop.tianting.model.dto.OperationDTO.BatchOperationDto;
 import com.infoloop.tianting.model.dto.OperationDTO.BatchOperationDto;
 import com.infoloop.tianting.model.dto.OperationDTO.SingleOperationDto;
 import com.infoloop.tianting.model.dto.OperationDTO.SingleOperationDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderDetailDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.CreateOrderDetailDto;
@@ -59,7 +74,10 @@ import javax.annotation.Nullable;
 import java.time.LocalDate;
 import java.time.LocalDate;
 import java.time.ZoneOffset;
 import java.time.ZoneOffset;
 import java.util.ArrayList;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
 @Slf4j
 @Slf4j
@@ -72,6 +90,7 @@ public class OrderServiceRpcClient {
     private final SkuServiceRpcClient skuServiceRpcClient;
     private final SkuServiceRpcClient skuServiceRpcClient;
     private final OperatorServiceRpcClient operatorServiceRpcClient;
     private final OperatorServiceRpcClient operatorServiceRpcClient;
     private final RedissonClient redissonClient;
     private final RedissonClient redissonClient;
+    private final DelayedQueue<AutoCancelParam> delayedQueue;
 
 
     @Nullable
     @Nullable
     public SingleClientCustomerOrderRpcResponse getOrderById(Integer orderId) {
     public SingleClientCustomerOrderRpcResponse getOrderById(Integer orderId) {
@@ -149,6 +168,23 @@ public class OrderServiceRpcClient {
         return orderServiceRpcBlockingStub.updateClientCustomerOrder(request);
         return orderServiceRpcBlockingStub.updateClientCustomerOrder(request);
     }
     }
 
 
+    public boolean updateClientCustomerOrderCancel(int enterpriseId, int id) {
+        final var modification = ClientCustomerOrderModification.newBuilder()
+                .setId(id)
+                .setShouldUpdateStatus(true)
+                .setStatus(OrderStatusEnum.ORDER_CANCELED)
+                .setShouldUpdatePayStatus(true)
+                .setPayStatus(PayStatusEnum.PAY_CANCELED)
+                .build();
+        final var request = UpdateClientCustomerOrderRpcRequest.newBuilder()
+                .setEnterpriseId(enterpriseId)
+                .setUpdatedBy(0)
+                .setUpdateSource(OrderSourceEnum.STALL)
+                .setModification(modification)
+                .build();
+        return orderServiceRpcBlockingStub.updateClientCustomerOrder(request).getIsUpdated();
+    }
+
     public UpdateClientCustomerOrderRpcResponse updateClientCustomerOrderPaymentResult(SingleClientCustomerOrderRpcResponse order, ClientCustomerOrderModification modification) {
     public UpdateClientCustomerOrderRpcResponse updateClientCustomerOrderPaymentResult(SingleClientCustomerOrderRpcResponse order, ClientCustomerOrderModification modification) {
         final var request = UpdateClientCustomerOrderRpcRequest.newBuilder()
         final var request = UpdateClientCustomerOrderRpcRequest.newBuilder()
                 .setEnterpriseId(order.getEnterpriseId())
                 .setEnterpriseId(order.getEnterpriseId())
@@ -160,16 +196,15 @@ public class OrderServiceRpcClient {
     }
     }
 
 
 
 
-    public BatchUpdateClientCustomerOrderDetailsRpcResponse batchUpdateClientCustomerOrderDetails(
-            OrderDetailBatchUpdateDto orderDetailBatchUpdateDto) {
+    public BatchUpdateClientCustomerOrderDetailsRpcResponse batchUpdateClientCustomerOrderDetails(OrderDetailBatchUpdateDto orderDetailBatchUpdateDto) {
         final var operatorLoginInfo = LoginContextHolder.getLoginInfo();
         final var operatorLoginInfo = LoginContextHolder.getLoginInfo();
         final var operator = operatorServiceRpcClient.getCOperatorById(operatorLoginInfo.getId());
         final var operator = operatorServiceRpcClient.getCOperatorById(operatorLoginInfo.getId());
-        List<Integer> idsOfNeedUpdateMenuDetails = new ArrayList<>();
-        List<Integer> idsOfAddCount = new ArrayList<>();
-        List<OrderDetailDto> orgionalOrderDetails = new ArrayList<>();
+        final var idsOfNeedUpdateMenuDetails = new ArrayList<Integer>();
+        final var idsOfAddCount = new ArrayList<Integer>();
+        List<OrderDetailDto> originalOrderDetails = new ArrayList<>();
         List<OrderDetailDto> newOrderDetails;
         List<OrderDetailDto> newOrderDetails;
         final var modifications = orderDetailBatchUpdateDto.getDetails().stream().map(d -> {
         final var modifications = orderDetailBatchUpdateDto.getDetails().stream().map(d -> {
-                    MealDetail mealDetail = MealDetail.newBuilder().build();
+                    var mealDetail = MealDetail.newBuilder().build();
                     Integer menuDetailId = 0;
                     Integer menuDetailId = 0;
                     int mealId = 0;
                     int mealId = 0;
                     int categoryId = 0;
                     int categoryId = 0;
@@ -178,8 +213,7 @@ public class OrderServiceRpcClient {
                     if (d.getShouldUpdateMenuDetailId()) {
                     if (d.getShouldUpdateMenuDetailId()) {
                         idsOfNeedUpdateMenuDetails.add(d.getId());
                         idsOfNeedUpdateMenuDetails.add(d.getId());
                         menuDetailId = d.getMenuDetailId();
                         menuDetailId = d.getMenuDetailId();
-                        final var menuDetail = menuServiceRpcClient.getMenuDetailById(
-                                operatorLoginInfo.getEnterpriseId(), menuDetailId).getResponse();
+                        final var menuDetail = menuServiceRpcClient.getMenuDetailById(operatorLoginInfo.getEnterpriseId(), menuDetailId).getResponse();
                         mealId = menuDetail.getMealId();
                         mealId = menuDetail.getMealId();
                         categoryId = menuDetail.getCategoryId();
                         categoryId = menuDetail.getCategoryId();
                         skuId = menuDetail.getSkuId();
                         skuId = menuDetail.getSkuId();
@@ -190,8 +224,7 @@ public class OrderServiceRpcClient {
                             final var skuAvoids = rpcSkus.get(0).getAvoidsList().stream().map(SingleResponse::getName).collect(Collectors.toList());
                             final var skuAvoids = rpcSkus.get(0).getAvoidsList().stream().map(SingleResponse::getName).collect(Collectors.toList());
                             final var tastes = rpcSkus.get(0).getTastesList().stream().map(SingleResponse::getName).collect(Collectors.toList());
                             final var tastes = rpcSkus.get(0).getTastesList().stream().map(SingleResponse::getName).collect(Collectors.toList());
                             final var efficacies = rpcSkus.get(0).getEfficaciesList().stream().map(SingleResponse::getName).collect(Collectors.toList());
                             final var efficacies = rpcSkus.get(0).getEfficaciesList().stream().map(SingleResponse::getName).collect(Collectors.toList());
-                            final var allergies = rpcSkus.get(0).getAllergiesList().stream().map(
-                                    SingleSpecialResponse::getName).collect(Collectors.toList());
+                            final var allergies = rpcSkus.get(0).getAllergiesList().stream().map(SingleSpecialResponse::getName).collect(Collectors.toList());
                             final var skuDoctors = rpcSkus.get(0).getDoctorsList().stream().map(SingleSpecialResponse::getName).collect(Collectors.toList());
                             final var skuDoctors = rpcSkus.get(0).getDoctorsList().stream().map(SingleSpecialResponse::getName).collect(Collectors.toList());
                             mealDetail = MealDetail.newBuilder()
                             mealDetail = MealDetail.newBuilder()
                                     .setBasicMaterials(rpcSkus.get(0).getBasicMaterials())
                                     .setBasicMaterials(rpcSkus.get(0).getBasicMaterials())
@@ -249,8 +282,7 @@ public class OrderServiceRpcClient {
         totalIds.addAll(idsOfAddCount);
         totalIds.addAll(idsOfAddCount);
         if (!idsOfNeedUpdateMenuDetails.isEmpty() || !idsOfAddCount.isEmpty()) {
         if (!idsOfNeedUpdateMenuDetails.isEmpty() || !idsOfAddCount.isEmpty()) {
             final var orgionalResponseList = getClientCustomerOrderDetailsByIds(totalIds);
             final var orgionalResponseList = getClientCustomerOrderDetailsByIds(totalIds);
-            orgionalOrderDetails = orgionalResponseList.stream().map(d ->
-                    OrderDetailDto.builder()
+            originalOrderDetails = orgionalResponseList.stream().map(d -> OrderDetailDto.builder()
                     .id(d.getId())
                     .id(d.getId())
                     .count(d.getCount())
                     .count(d.getCount())
                     .categoryId(d.getCategoryId())
                     .categoryId(d.getCategoryId())
@@ -287,7 +319,6 @@ public class OrderServiceRpcClient {
         final var res = orderServiceRpcBlockingStub.batchUpdateClientCustomerOrderDetails(request);
         final var res = orderServiceRpcBlockingStub.batchUpdateClientCustomerOrderDetails(request);
         if (res.getIsUpdated()) {
         if (res.getIsUpdated()) {
             if (!idsOfNeedUpdateMenuDetails.isEmpty() || !idsOfAddCount.isEmpty()) {
             if (!idsOfNeedUpdateMenuDetails.isEmpty() || !idsOfAddCount.isEmpty()) {
-
                 final var newResponseList = getClientCustomerOrderDetailsByIds(totalIds);
                 final var newResponseList = getClientCustomerOrderDetailsByIds(totalIds);
                 newOrderDetails = newResponseList.stream().map(d ->
                 newOrderDetails = newResponseList.stream().map(d ->
                         OrderDetailDto.builder()
                         OrderDetailDto.builder()
@@ -323,19 +354,18 @@ public class OrderServiceRpcClient {
                                 .updatedAt(DateUtil.formatDate(d.getUpdatedAt()))
                                 .updatedAt(DateUtil.formatDate(d.getUpdatedAt()))
                                 .updatedBy(d.getUpdatedBy())
                                 .updatedBy(d.getUpdatedBy())
                                 .build()).collect(Collectors.toList());
                                 .build()).collect(Collectors.toList());
-
                 // 替换菜品的操作记录
                 // 替换菜品的操作记录
                 List<SingleOperationDto> operations = new ArrayList<>();
                 List<SingleOperationDto> operations = new ArrayList<>();
-                for (OrderDetailDto orgionalDetail : orgionalOrderDetails) {
+                for (OrderDetailDto originalDetail : originalOrderDetails) {
                     OrderOperationType orderOperationType = OrderOperationType.UNKNOWN_OPERATION_TYPE;
                     OrderOperationType orderOperationType = OrderOperationType.UNKNOWN_OPERATION_TYPE;
-                    if (idsOfNeedUpdateMenuDetails.contains(orgionalDetail.getId())) {
+                    if (idsOfNeedUpdateMenuDetails.contains(originalDetail.getId())) {
                         orderOperationType = OrderOperationType.REPLACE_DISHES;
                         orderOperationType = OrderOperationType.REPLACE_DISHES;
-                    } else if (idsOfAddCount.contains(orgionalDetail.getId())) {
+                    } else if (idsOfAddCount.contains(originalDetail.getId())) {
                         orderOperationType = OrderOperationType.ADD_DISHES;
                         orderOperationType = OrderOperationType.ADD_DISHES;
                     }
                     }
-                    String orgionalDetailStr = "";
+                    String originalDetailStr;
                     String newDetailStr = "";
                     String newDetailStr = "";
-                    final var newDetail = newOrderDetails.stream().filter(n -> n.getId().equals(orgionalDetail.getId())).findFirst();
+                    final var newDetail = newOrderDetails.stream().filter(n -> n.getId().equals(originalDetail.getId())).findFirst();
                     if (newDetail.isPresent()) {
                     if (newDetail.isPresent()) {
                         final var newOrderDetailOperation = OrderDetailOperationDto.builder()
                         final var newOrderDetailOperation = OrderDetailOperationDto.builder()
                                 .id(newDetail.get().getId())
                                 .id(newDetail.get().getId())
@@ -347,23 +377,23 @@ public class OrderServiceRpcClient {
                                 .build();
                                 .build();
                         newDetailStr = JsonUtil.writeAsJson(List.of(newOrderDetailOperation));
                         newDetailStr = JsonUtil.writeAsJson(List.of(newOrderDetailOperation));
                     }
                     }
-                    final var orgionalOrderDetailOperation = OrderDetailOperationDto.builder()
-                            .id(orgionalDetail.getId())
-                            .skuId(orgionalDetail.getSkuId())
-                            .skuName(orgionalDetail.getShowName())
-                            .count(orgionalDetail.getCount())
-                            .adjustSkuRemark(orgionalDetail.getAdjustSkuRemark())
-                            .serveStatus(orgionalDetail.getServeStatus().name())
+                    final var originalOrderDetailOperation = OrderDetailOperationDto.builder()
+                            .id(originalDetail.getId())
+                            .skuId(originalDetail.getSkuId())
+                            .skuName(originalDetail.getShowName())
+                            .count(originalDetail.getCount())
+                            .adjustSkuRemark(originalDetail.getAdjustSkuRemark())
+                            .serveStatus(originalDetail.getServeStatus().name())
                             .build();
                             .build();
-                    orgionalDetailStr = JsonUtil.writeAsJson(List.of(orgionalOrderDetailOperation));
+                    originalDetailStr = JsonUtil.writeAsJson(List.of(originalOrderDetailOperation));
                     final var operation = SingleOperationDto.builder()
                     final var operation = SingleOperationDto.builder()
-                            .orderId(orgionalDetail.getOrderId())
+                            .orderId(originalDetail.getOrderId())
                             .shouldCreateAdjustOrderDetailJson(true)
                             .shouldCreateAdjustOrderDetailJson(true)
                             .shouldCreateOriginalOrderDetailJson(true)
                             .shouldCreateOriginalOrderDetailJson(true)
                             .shouldCreateAdjustOrderJson(false)
                             .shouldCreateAdjustOrderJson(false)
                             .shouldCreateOriginalOrderJson(false)
                             .shouldCreateOriginalOrderJson(false)
                             .adjustOrderDetailJson(newDetailStr)
                             .adjustOrderDetailJson(newDetailStr)
-                            .originalOrderDetailJson(orgionalDetailStr)
+                            .originalOrderDetailJson(originalDetailStr)
                             .type(orderOperationType)
                             .type(orderOperationType)
                             .build();
                             .build();
                     operations.add(operation);
                     operations.add(operation);
@@ -381,9 +411,7 @@ public class OrderServiceRpcClient {
         return res;
         return res;
     }
     }
 
 
-    public BatchCreateOrderOperationRecordsResponse batchCreateOrderOperationRecords(
-            BatchOperationDto batchOperationDto) {
-
+    public BatchCreateOrderOperationRecordsResponse batchCreateOrderOperationRecords(BatchOperationDto batchOperationDto) {
         final var request = BatchCreateOrderOperationRecordsRequest.newBuilder()
         final var request = BatchCreateOrderOperationRecordsRequest.newBuilder()
                 .addAllCreations(batchOperationDto.getCreations().stream().map(c ->
                 .addAllCreations(batchOperationDto.getCreations().stream().map(c ->
                         OrderOperationRecordCreation.newBuilder()
                         OrderOperationRecordCreation.newBuilder()
@@ -407,8 +435,7 @@ public class OrderServiceRpcClient {
 
 
     }
     }
 
 
-    public QueryClientCustomerOrdersByPaginationRpcResponse queryClientCustomerOrdersByPagination(
-            QueryOrderByPaginationDto queryOrderDto) {
+    public QueryClientCustomerOrdersByPaginationRpcResponse queryClientCustomerOrdersByPagination(QueryOrderByPaginationDto queryOrderDto) {
         final var request = QueryClientCustomerOrdersByPaginationRpcRequest.newBuilder()
         final var request = QueryClientCustomerOrdersByPaginationRpcRequest.newBuilder()
                 .setKeyword(queryOrderDto.getKeyword() == null ? "" : queryOrderDto.getKeyword())
                 .setKeyword(queryOrderDto.getKeyword() == null ? "" : queryOrderDto.getKeyword())
                 .setPageNo(queryOrderDto.getPn())
                 .setPageNo(queryOrderDto.getPn())
@@ -536,14 +563,95 @@ public class OrderServiceRpcClient {
                 .setShouldCreateOrderDetails(true)
                 .setShouldCreateOrderDetails(true)
                 .addAllOrderDetails(orderDetails)
                 .addAllOrderDetails(orderDetails)
                 .build();
                 .build();
-        CreateClientCustomerOrderRpcResponse orderResponse = orderServiceRpcBlockingStub
+        final var menuById = menuServiceRpcClient.getMenuById(createOrderDto.getEnterpriseId(), createOrderDto.getMenuId());
+        if (menuById.getResponse().getOrderRuleJson().getCloseTimeType() == CloseTimeTypeEnum.IMMEDIATELY) {
+            final var skuIds = createOrderDto.getOrderDetailDtos().stream().map(CreateOrderDetailDto::getSkuId).collect(Collectors.toList());
+            final var skuSellQuantities = this.querySkuSellQuantitiesByStallAndSkuIds(createOrderDto.getEnterpriseId(), createOrderDto.getStallId(), skuIds);
+            final var skuSellQuantityMap = skuSellQuantities.stream().collect(Collectors.toMap(SingleSkuSellQuantityRpcResponse::getSkuId, Function.identity()));
+            final var skuMap = skuServiceRpcClient.getSkusByIds(skuIds).stream().collect(Collectors.toMap(SingleSkuResponse::getId, Function.identity()));
+            final var soldOutSkus = new ArrayList<String>();
+            final var skuStockMap = new HashMap<String, Integer>();
+            for (var orderDetail : createOrderDto.getOrderDetailDtos()) {
+                final var skuSellQuantityRpcResponse = skuSellQuantityMap.get(orderDetail.getSkuId());
+                if (skuSellQuantityRpcResponse == null) {
+                    log.error("skuSellQuantityRpcResponse is null; stallId:{}, skuId:{}", createOrderDto.getStallId(), orderDetail.getSkuId());
+                    soldOutSkus.add(skuMap.get(orderDetail.getSkuId()).getName());
+                    continue;
+                }
+                if ((skuSellQuantityRpcResponse.getTodaySellQuantity() + orderDetail.getCount()) > skuSellQuantityRpcResponse.getMaxSellQuantity()) {
+                    log.error("skuSellQuantityRpcResponse stock no enough; stallId:{}, skuId:{}, count:{}", createOrderDto.getStallId(), orderDetail.getSkuId(), orderDetail.getCount());
+                    skuStockMap.put(skuMap.get(orderDetail.getSkuId()).getName(), skuSellQuantityRpcResponse.getMaxSellQuantity() - skuSellQuantityRpcResponse.getTodaySellQuantity());
+                    continue;
+                }
+            }
+            if (!soldOutSkus.isEmpty()) {
+                throw ClientEndExceptions.BusinessException.build(ErrorCodeEnum.SKUS_SOLD_OUT_TODAY, String.join(",", soldOutSkus));
+            }
+            if (!skuStockMap.isEmpty()) {
+                final var noEnoughSkus = String.join(", ", skuStockMap.keySet());
+                throw ClientEndExceptions.BusinessException.build(ErrorCodeEnum.SKUS_STOCK_NO_ENOUGH_TODAY, noEnoughSkus);
+            }
+        }
+        final var orderResponse = orderServiceRpcBlockingStub
                 .createClientCustomerOrder(CreateClientCustomerOrderRpcRequest.newBuilder()
                 .createClientCustomerOrder(CreateClientCustomerOrderRpcRequest.newBuilder()
                         .setCreation(creation)
                         .setCreation(creation)
                         .setCreationSource(OrderSourceEnum.forNumber(createOrderDto.getCreationSource()))
                         .setCreationSource(OrderSourceEnum.forNumber(createOrderDto.getCreationSource()))
                         .setEnterpriseId(createOrderDto.getEnterpriseId())
                         .setEnterpriseId(createOrderDto.getEnterpriseId())
                         .setCreatedBy(createOrderDto.getCreatedBy())
                         .setCreatedBy(createOrderDto.getCreatedBy())
                         .build());
                         .build());
+        if (orderResponse.getIsCreated() && menuById.getResponse().getOrderRuleJson().getCloseTimeType() == CloseTimeTypeEnum.IMMEDIATELY) {
+            final var isSuccess = this.addSkusSellQuantities(createOrderDto.getEnterpriseId(), createOrderDto.getStallId(),
+                    orderDetails.stream().map(e -> AddSkusSellQuantityBO.builder()
+                            .skuId(e.getSkuId())
+                            .quantity(e.getCount())
+                            .build()).collect(Collectors.toList()));
+            if (isSuccess) {
+                final var autoCancelParam = new AutoCancelParam();
+                autoCancelParam.setOrderId(orderResponse.getId());
+                delayedQueue.addToQueue(OrderAutoCancelDelayTask.AUTO_CANCEL_ORDER_DELAY_QUEUE, autoCancelParam, 10, TimeUnit.MINUTES);
+            }
+        }
         return CreateOrderResponse.builder().id(orderResponse.getId()).isCreated(true).build();
         return CreateOrderResponse.builder().id(orderResponse.getId()).isCreated(true).build();
     }
     }
 
 
+
+    public List<SingleSkuSellQuantityRpcResponse> querySkuSellQuantitiesByStall(int enterpriseId, int stallId) {
+        return orderServiceRpcBlockingStub.querySkuSellQuantitiesByStall(QuerySkuSellQuantitiesByStallRpcRequest.newBuilder()
+                .setEnterpriseId(enterpriseId)
+                .setStallId(stallId)
+                .build()).getResponsesList();
+    }
+
+    public List<SingleSkuSellQuantityRpcResponse> querySkuSellQuantitiesByStallAndSkuIds(int enterpriseId, int stallId, List<Integer> skuIds) {
+        return orderServiceRpcBlockingStub.querySkuSellQuantitiesByStallAndSkuIds(QuerySkuSellQuantitiesByStallAndSkuIdsRpcRequest.newBuilder()
+                .setEnterpriseId(enterpriseId)
+                .setStallId(stallId)
+                .addAllSkuIds(skuIds)
+                .build()).getResponsesList();
+    }
+
+    public boolean batchSaveSkuSellQuantities(int enterpriseId, int stallId, List<SkuSellQuantityBO> skuSellQuantityBOs) {
+        return orderServiceRpcBlockingStub.batchSaveSkuSellQuantities(BatchSaveSkuSellQuantitiesRpcRequest.newBuilder()
+                .setEnterpriseId(enterpriseId)
+                .setUpdatedBy(stallId)
+                .addAllSkuSellQuantityModifications(skuSellQuantityBOs.stream().map(e -> SkuSellQuantityModification.newBuilder()
+                        .setId(e.getId() == null ? 0 : e.getId())
+                        .setStallId(stallId)
+                        .setSkuId(e.getSkuId())
+                        .setMaxSellQuantity(e.getMaxSellQuantity())
+                        .build()).collect(Collectors.toList()))
+                .build()).getIsSaved();
+    }
+
+    public boolean addSkusSellQuantities(int enterpriseId, int stallId, List<AddSkusSellQuantityBO> skuSellQuantityBOs) {
+        return orderServiceRpcBlockingStub.addSkusSellQuantities(AddSkusSellQuantitiesRpcRequest.newBuilder()
+                .setEnterpriseId(enterpriseId)
+                .setStallId(stallId)
+                .addAllSkuSellQuantities(skuSellQuantityBOs.stream().map(e -> SkuSellQuantity.newBuilder()
+                        .setSkuId(e.getSkuId())
+                        .setQuantity(e.getQuantity())
+                        .build()).collect(Collectors.toList()))
+                .build()).getIsAdded();
+    }
+
 }
 }

@@ -8,8 +8,11 @@ import com.fasterxml.jackson.databind.ObjectMapper;
 import com.fasterxml.jackson.databind.PropertyNamingStrategy;
 import com.fasterxml.jackson.databind.PropertyNamingStrategy;
 import com.fasterxml.jackson.dataformat.xml.XmlMapper;
 import com.fasterxml.jackson.dataformat.xml.XmlMapper;
 import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderModification;
 import com.infoloop.tianting.clientcustomerorderservice.ClientCustomerOrderModification;
+import com.infoloop.tianting.clientcustomerorderservice.OrderStatusEnum;
 import com.infoloop.tianting.clientcustomerorderservice.PayStatusEnum;
 import com.infoloop.tianting.clientcustomerorderservice.PayStatusEnum;
 import com.infoloop.tianting.config.BusinessConfig;
 import com.infoloop.tianting.config.BusinessConfig;
+import com.infoloop.tianting.exception.ClientEndExceptions;
+import com.infoloop.tianting.exception.ErrorCodeEnum;
 import com.infoloop.tianting.model.dto.PayDTO.PayInformRequestDto;
 import com.infoloop.tianting.model.dto.PayDTO.PayInformRequestDto;
 import com.infoloop.tianting.model.dto.PayDTO.PayResponseDto;
 import com.infoloop.tianting.model.dto.PayDTO.PayResponseDto;
 import com.infoloop.tianting.model.dto.PayDTO.ThirdPartyPayInformRequestDto;
 import com.infoloop.tianting.model.dto.PayDTO.ThirdPartyPayInformRequestDto;
@@ -49,6 +52,11 @@ public class PayServiceClient {
     private String clientId;
     private String clientId;
 
 
     public PayResponseDto payInform(PayInformRequestDto payRequestDto) {
     public PayResponseDto payInform(PayInformRequestDto payRequestDto) {
+        final var orderById = orderServiceRpcClient.getOrderById(Integer.valueOf(payRequestDto.getOrderId()));
+        if (orderById == null || orderById.getPayStatus() == PayStatusEnum.PAY_CANCELED || orderById.getStatus() == OrderStatusEnum.ORDER_CANCELED) {
+            log.info("Order {} not found or canceled, skipping.", payRequestDto.getOrderId());
+            throw ClientEndExceptions.BusinessException.build(ErrorCodeEnum.ORDER_CANCEL);
+        }
         String url = businessConfig.getPayUrl();
         String url = businessConfig.getPayUrl();
         String requestDate = DateUtil.formatDate(LocalDateTime.now(), DateUtil.YMDHMS);
         String requestDate = DateUtil.formatDate(LocalDateTime.now(), DateUtil.YMDHMS);
         ThirdPartyPayInformRequestDto jsonData = buildRequestData(payRequestDto, requestDate);
         ThirdPartyPayInformRequestDto jsonData = buildRequestData(payRequestDto, requestDate);

@@ -2,6 +2,7 @@ package com.infoloop.tianting.service.client;
 
 
 import com.infoloop.tianting.GeDishSkuByIdsRpcResponse;
 import com.infoloop.tianting.GeDishSkuByIdsRpcResponse;
 import com.infoloop.tianting.GetSkusByIdsRpcRequest;
 import com.infoloop.tianting.GetSkusByIdsRpcRequest;
+import com.infoloop.tianting.SingleSkuResponse;
 import com.infoloop.tianting.SkuServiceProtoRpcGrpc;
 import com.infoloop.tianting.SkuServiceProtoRpcGrpc;
 import lombok.RequiredArgsConstructor;
 import lombok.RequiredArgsConstructor;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -21,4 +22,12 @@ public class SkuServiceRpcClient {
                 .build();
                 .build();
         return skuServiceProtoRpcBlockingStub.getDishSkusByIds(request);
         return skuServiceProtoRpcBlockingStub.getDishSkusByIds(request);
     }
     }
+
+    public List<SingleSkuResponse> getSkusByIds(List<Integer> ids) {
+        final var request = GetSkusByIdsRpcRequest.newBuilder()
+                .addAllIds(ids)
+                .setIncludeDeleted(false)
+                .build();
+        return skuServiceProtoRpcBlockingStub.getSkusByIds(request).getResponseList();
+    }
 }
 }

 package com.infoloop.tianting.service.impl;
 package com.infoloop.tianting.service.impl;
 
 
+import com.infoloop.tianting.context.LoginContextHolder;
+import com.infoloop.tianting.menuservice.SingleMenuDetailRpcResponse;
+import com.infoloop.tianting.menuservice.SingleMenuRpcResponse;
 import com.infoloop.tianting.model.dto.MenuDbDTO.BatchCreateMenuRefsDto;
 import com.infoloop.tianting.model.dto.MenuDbDTO.BatchCreateMenuRefsDto;
 import com.infoloop.tianting.model.dto.MenuDbDTO.BatchCreateMenuRefsResponseDto;
 import com.infoloop.tianting.model.dto.MenuDbDTO.BatchCreateMenuRefsResponseDto;
 import com.infoloop.tianting.model.dto.MenuDbDTO.DishRuleJson;
 import com.infoloop.tianting.model.dto.MenuDbDTO.DishRuleJson;
@@ -197,4 +200,10 @@ public class MenuServiceImpl implements MenuService {
                 .build();
                 .build();
     }
     }
 
 
+    @Override
+    public List<Integer> queryMenuSkuIdsByStallId(int enterpriseId, int stallId) {
+        final var menuIds = menuServiceRpcClient.queryPublishedMenusByStallId(LoginContextHolder.getEnterpriseId(), stallId).getResponsesList().stream().map(SingleMenuRpcResponse::getId).collect(Collectors.toList());
+        return menuServiceRpcClient.queryMenuDetailsByMenuIds(LoginContextHolder.getEnterpriseId(), menuIds).getResponsesList().stream().map(SingleMenuDetailRpcResponse::getSkuId).distinct().collect(Collectors.toList());
+    }
+
 }
 }

@@ -56,7 +56,6 @@ import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 
 
-import java.time.LocalDate;
 import java.util.ArrayList;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.List;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
@@ -112,16 +111,12 @@ public class OrderServiceImpl implements OrderService {
         if (placeOrderCount != 0 && menuOrderCount >= placeOrderCount) {
         if (placeOrderCount != 0 && menuOrderCount >= placeOrderCount) {
             throw ClientEndExceptions.OperationForbidden.build(ErrorCodeEnum.ORDER_COUNT_LIMIT.name());
             throw ClientEndExceptions.OperationForbidden.build(ErrorCodeEnum.ORDER_COUNT_LIMIT.name());
         }
         }
-        createOrderDto.setCloseTimeType(
-                CloseTimeType.forNumber(menu.getOrderRuleJson().getCloseTimeType().getNumber()));
+        createOrderDto.setCloseTimeType(CloseTimeType.forNumber(menu.getOrderRuleJson().getCloseTimeType().getNumber()));
         createOrderDto.setRoomNo(record.getRoomNo());
         createOrderDto.setRoomNo(record.getRoomNo());
         createOrderDto.setCreationSource(OrderSourceEnum.STALL.getNumber());
         createOrderDto.setCreationSource(OrderSourceEnum.STALL.getNumber());
         createOrderDto.setEnterpriseId(operatorLoginInfo.getEnterpriseId());
         createOrderDto.setEnterpriseId(operatorLoginInfo.getEnterpriseId());
 //    createOrderDto.setStallId();
 //    createOrderDto.setStallId();
-        var onlinePay = false;
-        if (menu.getOrderRuleJson().getModeOfPayment() == ModeOfPaymentEnum.ONLINE) {
-            onlinePay = true;
-        }
+        var onlinePay = menu.getOrderRuleJson().getModeOfPayment() == ModeOfPaymentEnum.ONLINE;
         createOrderDto.setOnlinePay(onlinePay);
         createOrderDto.setOnlinePay(onlinePay);
         OrderTypeEnum orderType;
         OrderTypeEnum orderType;
         if (menu.getOrderRuleJson().getCloseTimeType() == CloseTimeTypeEnum.RESERVATION) {
         if (menu.getOrderRuleJson().getCloseTimeType() == CloseTimeTypeEnum.RESERVATION) {
@@ -231,8 +226,7 @@ public class OrderServiceImpl implements OrderService {
     }
     }
 
 
     @Override
     @Override
-    public BatchUpdateOrderDetailResponse batchUpdateOrderDetails(
-            OrderDetailBatchUpdateDto batchUpdateDto) {
+    public BatchUpdateOrderDetailResponse batchUpdateOrderDetails(OrderDetailBatchUpdateDto batchUpdateDto) {
         final var response = orderServiceRpcClient.batchUpdateClientCustomerOrderDetails(batchUpdateDto);
         final var response = orderServiceRpcClient.batchUpdateClientCustomerOrderDetails(batchUpdateDto);
         return BatchUpdateOrderDetailResponse.builder()
         return BatchUpdateOrderDetailResponse.builder()
                 .isUpdated(response.getIsUpdated())
                 .isUpdated(response.getIsUpdated())
@@ -243,7 +237,7 @@ public class OrderServiceImpl implements OrderService {
     public Integer getMenuOrderCount(getMenuOrderCountDto checkIfOrdered) {
     public Integer getMenuOrderCount(getMenuOrderCountDto checkIfOrdered) {
         final var operatorLoginInfo = LoginContextHolder.getLoginInfo();
         final var operatorLoginInfo = LoginContextHolder.getLoginInfo();
         final var mealTimeStart = checkIfOrdered.getMealTime().toLocalDate().atStartOfDay();
         final var mealTimeStart = checkIfOrdered.getMealTime().toLocalDate().atStartOfDay();
-        LocalDate tomorrow = checkIfOrdered.getMealTime().toLocalDate().plusDays(1);
+        final var tomorrow = checkIfOrdered.getMealTime().toLocalDate().plusDays(1);
         final var mealTimeEnd = tomorrow.atStartOfDay();
         final var mealTimeEnd = tomorrow.atStartOfDay();
         final var queryOrderDto = QueryOrderByConditionDto.builder()
         final var queryOrderDto = QueryOrderByConditionDto.builder()
                 .enterpriseId(operatorLoginInfo.getEnterpriseId())
                 .enterpriseId(operatorLoginInfo.getEnterpriseId())

 package com.infoloop.tianting.service.impl;
 package com.infoloop.tianting.service.impl;
 
 
+import com.infoloop.tianting.SingleSkuResponse;
+import com.infoloop.tianting.clientcustomerorderservice.SingleSkuSellQuantityRpcResponse;
+import com.infoloop.tianting.context.LoginContextHolder;
+import com.infoloop.tianting.enums.SkuSellQuantityStatus;
+import com.infoloop.tianting.model.bo.SkuSellQuantityBO;
+import com.infoloop.tianting.model.common.PageResult;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuDetailSingleResponseDto;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuDetailSingleResponseDto;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuDto;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuDto;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuSpecialDetailSingleResponseDto;
 import com.infoloop.tianting.model.dto.SkuDbDTO.SkuSpecialDetailSingleResponseDto;
+import com.infoloop.tianting.model.dto.SkuSellQuantityDTO;
+import com.infoloop.tianting.model.vo.SkuSellQuantityStatisticsVO;
+import com.infoloop.tianting.model.vo.SkuSellQuantityVO;
+import com.infoloop.tianting.service.MenuService;
 import com.infoloop.tianting.service.SkuService;
 import com.infoloop.tianting.service.SkuService;
+import com.infoloop.tianting.service.client.OrderServiceRpcClient;
 import com.infoloop.tianting.service.client.SkuServiceRpcClient;
 import com.infoloop.tianting.service.client.SkuServiceRpcClient;
 import com.infoloop.tianting.utils.DateUtil;
 import com.infoloop.tianting.utils.DateUtil;
+import com.infoloop.tianting.utils.PageUtil;
 import lombok.RequiredArgsConstructor;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.stereotype.Service;
 
 
+import java.util.Comparator;
 import java.util.List;
 import java.util.List;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Collectors;
 
 
 @Slf4j
 @Slf4j
 @Service
 @Service
 @RequiredArgsConstructor(onConstructor = @__(@Autowired))
 @RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class SkuServiceImpl implements SkuService {
 public class SkuServiceImpl implements SkuService {
+
+    private final MenuService menuService;
+
     private final SkuServiceRpcClient skuServiceRpcClient;
     private final SkuServiceRpcClient skuServiceRpcClient;
 
 
+    private final OrderServiceRpcClient orderServiceRpcClient;
+
     @Override
     @Override
     public List<SkuDto> getSkusByIds(List<Integer> ids) {
     public List<SkuDto> getSkusByIds(List<Integer> ids) {
         final var response = skuServiceRpcClient.getDishSkusByIds(ids);
         final var response = skuServiceRpcClient.getDishSkusByIds(ids);
@@ -56,4 +75,133 @@ public class SkuServiceImpl implements SkuService {
                         .build()
                         .build()
         ).collect(Collectors.toList());
         ).collect(Collectors.toList());
     }
     }
+
+    @Override
+    public SkuSellQuantityStatisticsVO querySkuSellQuantityStatistics(int stallId) {
+        final var skuIds = menuService.queryMenuSkuIdsByStallId(LoginContextHolder.getEnterpriseId(), stallId);
+        final var responses = orderServiceRpcClient.querySkuSellQuantitiesByStall(LoginContextHolder.getEnterpriseId(), stallId);
+        final var skuSellQuantitiesMap = responses.stream().collect(Collectors.toMap(SingleSkuSellQuantityRpcResponse::getSkuId, Function.identity()));
+        final var soldOut = skuIds.stream()
+                .filter(e -> skuSellQuantitiesMap.get(e) == null || skuSellQuantitiesMap.get(e).getMaxSellQuantity() == skuSellQuantitiesMap.get(e).getTodaySellQuantity())
+                .count();
+        final int total = skuIds.size();
+        return SkuSellQuantityStatisticsVO.builder()
+                .total(total)
+                .soldOut(soldOut)
+                .onSale(total - soldOut)
+                .build();
+    }
+
+    @Override
+    public PageResult<SkuSellQuantityVO> querySkuSellQuantity(SkuSellQuantityDTO.QuerySkuSellQuantityDTO querySkuSellQuantityDTO) {
+        final var stallId = querySkuSellQuantityDTO.getStallId();
+        final var enterpriseId = LoginContextHolder.getEnterpriseId();
+        final var skuIds = menuService.queryMenuSkuIdsByStallId(enterpriseId, stallId);
+        var responses = orderServiceRpcClient.querySkuSellQuantitiesByStall(enterpriseId, stallId);
+        final var skuSellQuantityMap = responses.stream().collect(Collectors.toMap(SingleSkuSellQuantityRpcResponse::getSkuId, Function.identity()));
+        responses = skuIds.stream()
+                .map(skuId -> {
+                    var response = skuSellQuantityMap.get(skuId);
+                    if (response == null) {
+                        response = SingleSkuSellQuantityRpcResponse.newBuilder()
+                                .setSkuId(skuId)
+                                .setMaxSellQuantity(0)
+                                .setTodaySellQuantity(0)
+                                .build();
+                    }
+                    return response;
+                })
+                .collect(Collectors.toList());
+        if (querySkuSellQuantityDTO.getStatus() != SkuSellQuantityStatus.ALL) {
+            responses = responses.stream()
+                    .filter(e -> {
+                        switch (querySkuSellQuantityDTO.getStatus()) {
+                            case SOLD_OUT:
+                                return e.getMaxSellQuantity() == e.getTodaySellQuantity();
+                            case ON_SALE:
+                                return e.getMaxSellQuantity() != e.getTodaySellQuantity();
+                            default:
+                                return true;
+                        }
+                    })
+                    .collect(Collectors.toList());
+        }
+        final var skuList = skuServiceRpcClient.getSkusByIds(responses.stream().map(SingleSkuSellQuantityRpcResponse::getSkuId).collect(Collectors.toList()));
+        final var skuMap = skuList.stream().collect(Collectors.toMap(SingleSkuResponse::getId, Function.identity()));
+        final var keyword = querySkuSellQuantityDTO.getKeyword();
+        if (keyword != null && !keyword.isEmpty()) {
+            responses = responses.stream()
+                    .filter(e -> {
+                        var sku = skuMap.get(e.getSkuId());
+                        return sku != null && (sku.getCode().contains(keyword) || sku.getName().contains(keyword));
+                    })
+                    .collect(Collectors.toList());
+        }
+        final var skuSellQuantityVOS = responses.stream()
+                .map(e -> {
+                    var sku = skuMap.get(e.getSkuId());
+                    return SkuSellQuantityVO.builder()
+                            .skuId(e.getSkuId())
+                            .skuName(sku != null ? sku.getName() : "")
+                            .skuCode(sku != null ? sku.getCode() : "")
+                            .maxSellQuantity(e.getMaxSellQuantity())
+                            .todaySellQuantity(e.getTodaySellQuantity())
+                            .soldOut(e.getMaxSellQuantity() == e.getTodaySellQuantity())
+                            .build();
+                })
+                .sorted(Comparator.comparing(SkuSellQuantityVO::getSkuCode))
+                .collect(Collectors.toList());
+        return PageUtil.subListPage(skuSellQuantityVOS, querySkuSellQuantityDTO.getPageNo(), querySkuSellQuantityDTO.getPageSize());
+    }
+
+    @Override
+    public boolean batchSetSkuSellQuantity(int stallId, SkuSellQuantityDTO.BatchSetSkuSellQuantityDTO batchSetSkuSellQuantityDTO) {
+        final var responses = orderServiceRpcClient.querySkuSellQuantitiesByStallAndSkuIds(LoginContextHolder.getEnterpriseId(), stallId, batchSetSkuSellQuantityDTO.getSkuIds());
+        final var skuMap = responses.stream().collect(Collectors.toMap(SingleSkuSellQuantityRpcResponse::getSkuId, Function.identity()));
+        final var skuSellQuantityBOs = batchSetSkuSellQuantityDTO.getSkuIds().stream().map(skuId -> SkuSellQuantityBO.builder()
+                .id(skuMap.get(skuId) == null ? null : skuMap.get(skuId).getId())
+                .skuId(skuId)
+                .maxSellQuantity(batchSetSkuSellQuantityDTO.getMaxSellQuantity())
+                .build()
+        ).collect(Collectors.toList());
+        return orderServiceRpcClient.batchSaveSkuSellQuantities(LoginContextHolder.getEnterpriseId(), stallId, skuSellQuantityBOs);
+    }
+
+    @Override
+    public List<SkuSellQuantityVO> querySkuSellQuantityBySkuIds(SkuSellQuantityDTO.QuerySkuSellQuantityBySkuIdsDTO querySkuSellQuantityBySkuIdsDTO) {
+        final var stallId = querySkuSellQuantityBySkuIdsDTO.getStallId();
+        final var enterpriseId = LoginContextHolder.getEnterpriseId();
+        final var skuIds = menuService.queryMenuSkuIdsByStallId(enterpriseId, stallId);
+        var responses = orderServiceRpcClient.querySkuSellQuantitiesByStall(enterpriseId, stallId);
+        final var skuSellQuantityMap = responses.stream().collect(Collectors.toMap(SingleSkuSellQuantityRpcResponse::getSkuId, Function.identity()));
+        responses = skuIds.stream()
+                .map(skuId -> {
+                    var response = skuSellQuantityMap.get(skuId);
+                    if (response == null) {
+                        response = SingleSkuSellQuantityRpcResponse.newBuilder()
+                                .setSkuId(skuId)
+                                .setMaxSellQuantity(0)
+                                .setTodaySellQuantity(0)
+                                .build();
+                    }
+                    return response;
+                })
+                .collect(Collectors.toList());
+        final var skuList = skuServiceRpcClient.getSkusByIds(responses.stream().map(SingleSkuSellQuantityRpcResponse::getSkuId).collect(Collectors.toList()));
+        final var skuMap = skuList.stream().collect(Collectors.toMap(SingleSkuResponse::getId, Function.identity()));
+        return responses.stream()
+                .map(e -> {
+                    var sku = skuMap.get(e.getSkuId());
+                    return SkuSellQuantityVO.builder()
+                            .skuId(e.getSkuId())
+                            .skuName(sku != null ? sku.getName() : "")
+                            .skuCode(sku != null ? sku.getCode() : "")
+                            .maxSellQuantity(e.getMaxSellQuantity())
+                            .todaySellQuantity(e.getTodaySellQuantity())
+                            .soldOut(e.getMaxSellQuantity() == e.getTodaySellQuantity())
+                            .build();
+                })
+                .sorted(Comparator.comparing(SkuSellQuantityVO::getSkuCode))
+                .collect(Collectors.toList());
+    }
 }
 }

@@ -2,13 +2,23 @@ package com.infoloop.tianting.utils;
 
 
 import com.infoloop.tianting.model.common.OrderPageResult;
 import com.infoloop.tianting.model.common.OrderPageResult;
 import com.infoloop.tianting.model.common.PageResult;
 import com.infoloop.tianting.model.common.PageResult;
-
 import com.infoloop.tianting.model.dto.OrderDbDTO.OrderCountByStatusDto;
 import com.infoloop.tianting.model.dto.OrderDbDTO.OrderCountByStatusDto;
+
 import java.util.LinkedList;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.List;
 
 
 public class PageUtil {
 public class PageUtil {
 
 
+    public static <T> PageResult<T> buildEmpty(T t) {
+        PageResult<T> pageRet = new PageResult<>();
+        pageRet.setTotalCount(0);
+        pageRet.setDataList(List.of(t));
+        pageRet.setPageNo(0);
+        pageRet.setPageSize(0);
+        pageRet.setTotalPage(0);
+        return pageRet;
+    }
+
     /**
     /**
      * 自定义分页
      * 自定义分页
      */
      */

@@ -33,6 +33,14 @@ service ClientCustomerOrderServiceRpc {
   // 操作记录
   // 操作记录
   rpc GetOrderOperationRecordsByOrderId (GetOrderOperationRecordsByOrderIdRequest) returns (GetOrderOperationRecordsByOrderIdResponse) {}
   rpc GetOrderOperationRecordsByOrderId (GetOrderOperationRecordsByOrderIdRequest) returns (GetOrderOperationRecordsByOrderIdResponse) {}
   rpc BatchCreateOrderOperationRecords (BatchCreateOrderOperationRecordsRequest) returns (BatchCreateOrderOperationRecordsResponse) {}
   rpc BatchCreateOrderOperationRecords (BatchCreateOrderOperationRecordsRequest) returns (BatchCreateOrderOperationRecordsResponse) {}
+
+
+  // sku菜品库存
+  rpc QuerySkuSellQuantitiesByStall(QuerySkuSellQuantitiesByStallRpcRequest) returns (QuerySkuSellQuantitiesByStallRpcResponse) {}
+  rpc QuerySkuSellQuantitiesByStallAndSkuIds(QuerySkuSellQuantitiesByStallAndSkuIdsRpcRequest) returns (QuerySkuSellQuantitiesByStallAndSkuIdsRpcResponse) {}
+  rpc BatchSaveSkuSellQuantities(BatchSaveSkuSellQuantitiesRpcRequest) returns (BatchSaveSkuSellQuantitiesRpcResponse) {}
+  rpc AddSkusSellQuantities(AddSkusSellQuantitiesRpcRequest) returns (AddSkusSellQuantitiesRpcResponse) {}
+
 }
 }
 
 
 enum OrderStatusEnum {
 enum OrderStatusEnum {
@@ -608,3 +616,71 @@ message BatchCreateOrderOperationRecordsResponse {
   bool isCreated = 1;
   bool isCreated = 1;
   repeated int32 ids = 2;
   repeated int32 ids = 2;
 }
 }
+
+message SingleSkuSellQuantityRpcResponse {
+  int32 id = 1;
+  int32 enterpriseId = 2;
+  int32 stallId = 3;
+  int32 skuId = 4;
+  int32 maxSellQuantity = 5;
+  int32 todaySellQuantity = 6;
+  int32 createdBy = 7;
+  int64 createdAt = 8;
+  int32 creationSource = 9;
+  int32 updatedBy = 10;
+  int64 updatedAt = 11;
+  int32 updateSource = 12;
+  bool isDeleted = 13;
+}
+
+message QuerySkuSellQuantitiesByStallRpcRequest {
+  int32 enterpriseId = 1;
+  int32 stallId = 2;
+}
+
+message QuerySkuSellQuantitiesByStallRpcResponse {
+  repeated SingleSkuSellQuantityRpcResponse responses = 1;
+}
+
+message QuerySkuSellQuantitiesByStallAndSkuIdsRpcRequest {
+  int32 enterpriseId = 1;
+  int32 stallId = 2;
+  repeated int32 skuIds = 3;
+}
+
+message QuerySkuSellQuantitiesByStallAndSkuIdsRpcResponse {
+  repeated SingleSkuSellQuantityRpcResponse responses = 1;
+}
+
+message BatchSaveSkuSellQuantitiesRpcRequest {
+  repeated SkuSellQuantityModification skuSellQuantityModifications = 1;
+  int32 enterpriseId = 2;
+  int32 updatedBy = 3;
+  int32 updateSource = 4;
+}
+
+message SkuSellQuantityModification {
+  int32 id = 1;
+  int32 stallId = 2;
+  int32 skuId = 3;
+  int32 maxSellQuantity = 4;
+}
+
+message BatchSaveSkuSellQuantitiesRpcResponse {
+  bool isSaved = 1;
+}
+
+message AddSkusSellQuantitiesRpcRequest {
+  int32 enterpriseId = 1;
+  int32 stallId = 2;
+  repeated SkuSellQuantity skuSellQuantities = 3;
+}
+
+message SkuSellQuantity {
+  int32 skuId = 1;
+  int32 quantity = 2;
+}
+
+message AddSkusSellQuantitiesRpcResponse {
+  bool isAdded = 1;
+}