jiujian / client-customer-order-service

Go to a project
Toggle navigation Toggle navigation pinning
zhuyifan
c3d7f95c 1 parent 0e685719

feat(ClientCustomerOrderService): 添加增加 SKU 销售数量的功能 

feat(ClientCustomerOrderService): 添加 SKU 菜品库存相关 RPC接口
Inline Side-by-side
Showing 7 changed files with 879 additions and 502 deletions
1 +package com.tianting.infoloop.mapper;
2 +
3 +import com.tianting.infoloop.inject.MyBaseMapper;
4 +import com.tianting.infoloop.model.db.SkuSellQuantity;
5 +
6 +/**
7 +* @author zhuyf
8 +* @description 针对表【sku_sell_quantities(sku售卖量)】的数据库操作Mapper
9 +* @createDate 2025-02-28 14:03:59
10 +* @Entity com.tianting.infoloop.model.db.SkuSellQuantity
11 +*/
12 +public interface SkuSellQuantityMapper extends MyBaseMapper<SkuSellQuantity> {
13 +
14 +
15 +}
1 +package com.tianting.infoloop.model.db;
2 +
3 +import com.baomidou.mybatisplus.annotation.FieldFill;
4 +import com.baomidou.mybatisplus.annotation.IdType;
5 +import com.baomidou.mybatisplus.annotation.TableField;
6 +import com.baomidou.mybatisplus.annotation.TableId;
7 +import com.baomidou.mybatisplus.annotation.TableLogic;
8 +import com.baomidou.mybatisplus.annotation.TableName;
9 +import com.baomidou.mybatisplus.extension.activerecord.Model;
10 +import lombok.Data;
11 +import lombok.EqualsAndHashCode;
12 +import lombok.experimental.Accessors;
13 +
14 +import java.io.Serializable;
15 +import java.time.LocalDateTime;
16 +
17 +/**
18 + * sku售卖量
19 + * @TableName sku_sell_quantities
20 + */
21 +@EqualsAndHashCode(callSuper = true)
22 +@Data
23 +@Accessors(chain = true)
24 +@TableName(value ="sku_sell_quantities")
25 +public class SkuSellQuantity extends Model<OrderDetailDb> implements Serializable {
26 +
27 + @TableId(type = IdType.AUTO)
28 + private Integer id;
29 +
30 + /**
31 + *
32 + */
33 + private Integer enterpriseId;
34 +
35 + /**
36 + *
37 + */
38 + private Integer stallId;
39 +
40 + /**
41 + * 商品ID
42 + */
43 + private Integer skuId;
44 +
45 + /**
46 + * 最大可售量
47 + */
48 + private Integer maxSellQuantity;
49 +
50 + /**
51 + * 今日已售量
52 + */
53 + private Integer todaySellQuantity;
54 +
55 + /**
56 + *
57 + */
58 + private Integer createdBy;
59 +
60 +
61 + @TableField(fill = FieldFill.INSERT)
62 + private LocalDateTime createdAt;
63 +
64 + /**
65 + *
66 + */
67 + private Integer creationSource;
68 +
69 + /**
70 + *
71 + */
72 + private Integer updatedBy;
73 +
74 +
75 + @TableField(fill = FieldFill.INSERT_UPDATE)
76 + private LocalDateTime updatedAt;
77 +
78 + /**
79 + *
80 + */
81 + private Integer updateSource;
82 +
83 + @TableLogic
84 + private Integer isDeleted;
85 +
86 +}
...\ No newline at end of file ...\ No newline at end of file
1 +package com.tianting.infoloop.service;
2 +
3 +import com.baomidou.mybatisplus.extension.service.IService;
4 +import com.tianting.infoloop.model.db.SkuSellQuantity;
5 +
6 +/**
7 +* @author zhuyf
8 +* @description 针对表【sku_sell_quantities(sku售卖量)】的数据库操作Service
9 +* @createDate 2025-02-28 14:03:59
10 +*/
11 +public interface SkuSellQuantityService extends IService<SkuSellQuantity> {
12 +
13 +}
...@@ -7,12 +7,16 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; ...@@ -7,12 +7,16 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
7 import com.baomidou.mybatisplus.core.metadata.IPage; 7 import com.baomidou.mybatisplus.core.metadata.IPage;
8 import com.baomidou.mybatisplus.core.toolkit.Wrappers; 8 import com.baomidou.mybatisplus.core.toolkit.Wrappers;
9 import com.baomidou.mybatisplus.extension.plugins.pagination.Page; 9 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
10 +import com.infoloop.tianting.clientcustomerorderservice.AddSkusSellQuantitiesRpcRequest;
11 +import com.infoloop.tianting.clientcustomerorderservice.AddSkusSellQuantitiesRpcResponse;
10 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateClientCustomerOrderDetailsRpcRequest; 12 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateClientCustomerOrderDetailsRpcRequest;
11 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateClientCustomerOrderDetailsRpcResponse; 13 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateClientCustomerOrderDetailsRpcResponse;
12 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateClientCustomerOrdersRpcRequest; 14 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateClientCustomerOrdersRpcRequest;
13 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateClientCustomerOrdersRpcResponse; 15 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateClientCustomerOrdersRpcResponse;
14 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateOrderOperationRecordsRequest; 16 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateOrderOperationRecordsRequest;
15 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateOrderOperationRecordsResponse; 17 import com.infoloop.tianting.clientcustomerorderservice.BatchCreateOrderOperationRecordsResponse;
18 +import com.infoloop.tianting.clientcustomerorderservice.BatchSaveSkuSellQuantitiesRpcRequest;
19 +import com.infoloop.tianting.clientcustomerorderservice.BatchSaveSkuSellQuantitiesRpcResponse;
16 import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrderDetailsRpcRequest; 20 import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrderDetailsRpcRequest;
17 import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrderDetailsRpcResponse; 21 import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrderDetailsRpcResponse;
18 import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrdersRpcRequest; 22 import com.infoloop.tianting.clientcustomerorderservice.BatchUpdateClientCustomerOrdersRpcRequest;
...@@ -42,13 +46,18 @@ import com.infoloop.tianting.clientcustomerorderservice.GetOrderOperationRecords ...@@ -42,13 +46,18 @@ import com.infoloop.tianting.clientcustomerorderservice.GetOrderOperationRecords
42 import com.infoloop.tianting.clientcustomerorderservice.GetOrderOperationRecordsByOrderIdResponse; 46 import com.infoloop.tianting.clientcustomerorderservice.GetOrderOperationRecordsByOrderIdResponse;
43 import com.infoloop.tianting.clientcustomerorderservice.OrderCountByStatus; 47 import com.infoloop.tianting.clientcustomerorderservice.OrderCountByStatus;
44 import com.infoloop.tianting.clientcustomerorderservice.OrderOperationRecord; 48 import com.infoloop.tianting.clientcustomerorderservice.OrderOperationRecord;
49 +import com.infoloop.tianting.clientcustomerorderservice.OrderSourceEnum;
45 import com.infoloop.tianting.clientcustomerorderservice.OrderStatusEnum; 50 import com.infoloop.tianting.clientcustomerorderservice.OrderStatusEnum;
46 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByConditionRpcRequest; 51 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByConditionRpcRequest;
47 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByConditionRpcResponse; 52 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByConditionRpcResponse;
48 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByPaginationRpcRequest; 53 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByPaginationRpcRequest;
49 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByPaginationRpcResponse; 54 import com.infoloop.tianting.clientcustomerorderservice.QueryClientCustomerOrdersByPaginationRpcResponse;
50 -import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderDetailRpcResponse; 55 +import com.infoloop.tianting.clientcustomerorderservice.QuerySkuSellQuantitiesByStallAndSkuIdsRpcRequest;
51 -import com.infoloop.tianting.clientcustomerorderservice.SingleClientCustomerOrderRpcResponse; 56 +import com.infoloop.tianting.clientcustomerorderservice.QuerySkuSellQuantitiesByStallAndSkuIdsRpcResponse;
57 +import com.infoloop.tianting.clientcustomerorderservice.QuerySkuSellQuantitiesByStallRpcRequest;
58 +import com.infoloop.tianting.clientcustomerorderservice.QuerySkuSellQuantitiesByStallRpcResponse;
59 +import com.infoloop.tianting.clientcustomerorderservice.SingleSkuSellQuantityRpcResponse;
60 +import com.infoloop.tianting.clientcustomerorderservice.SkuSellQuantityModification;
52 import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderDetailRpcRequest; 61 import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderDetailRpcRequest;
53 import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderDetailRpcResponse; 62 import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderDetailRpcResponse;
54 import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderRpcRequest; 63 import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrderRpcRequest;
...@@ -56,9 +65,11 @@ import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrde ...@@ -56,9 +65,11 @@ import com.infoloop.tianting.clientcustomerorderservice.UpdateClientCustomerOrde
56 import com.tianting.infoloop.model.db.OrderDb; 65 import com.tianting.infoloop.model.db.OrderDb;
57 import com.tianting.infoloop.model.db.OrderDetailDb; 66 import com.tianting.infoloop.model.db.OrderDetailDb;
58 import com.tianting.infoloop.model.db.OrderOperationRecordDb; 67 import com.tianting.infoloop.model.db.OrderOperationRecordDb;
68 +import com.tianting.infoloop.model.db.SkuSellQuantity;
59 import com.tianting.infoloop.service.OrderDbService; 69 import com.tianting.infoloop.service.OrderDbService;
60 import com.tianting.infoloop.service.OrderDetailDbService; 70 import com.tianting.infoloop.service.OrderDetailDbService;
61 import com.tianting.infoloop.service.OrderOperationRecordDbService; 71 import com.tianting.infoloop.service.OrderOperationRecordDbService;
72 +import com.tianting.infoloop.service.SkuSellQuantityService;
62 import com.tianting.infoloop.utils.DbToProtoUtil; 73 import com.tianting.infoloop.utils.DbToProtoUtil;
63 import com.tianting.infoloop.utils.ProtoBeanUtil; 74 import com.tianting.infoloop.utils.ProtoBeanUtil;
64 import io.grpc.Status; 75 import io.grpc.Status;
...@@ -68,349 +79,354 @@ import lombok.extern.slf4j.Slf4j; ...@@ -68,349 +79,354 @@ import lombok.extern.slf4j.Slf4j;
68 import org.springframework.beans.factory.annotation.Autowired; 79 import org.springframework.beans.factory.annotation.Autowired;
69 import org.springframework.stereotype.Service; 80 import org.springframework.stereotype.Service;
70 81
82 +import java.util.ArrayList;
83 +import java.util.List;
84 +import java.util.function.Function;
71 import java.util.stream.Collectors; 85 import java.util.stream.Collectors;
72 86
73 import static com.tianting.infoloop.constants.ConfigConstants.DATA_SOURCE_MASTER; 87 import static com.tianting.infoloop.constants.ConfigConstants.DATA_SOURCE_MASTER;
88 +import static com.tianting.infoloop.constants.ConfigConstants.DATA_SOURCE_SLAVE;
74 89
75 @Slf4j 90 @Slf4j
76 @Service 91 @Service
77 @RequiredArgsConstructor(onConstructor_ = @Autowired) 92 @RequiredArgsConstructor(onConstructor_ = @Autowired)
78 public class OrderGrpcService extends ClientCustomerOrderServiceRpcGrpc.ClientCustomerOrderServiceRpcImplBase { 93 public class OrderGrpcService extends ClientCustomerOrderServiceRpcGrpc.ClientCustomerOrderServiceRpcImplBase {
79 - private final OrderDbService orderDbService; 94 + private final OrderDbService orderDbService;
80 - private final OrderDetailDbService orderDetailDbService; 95 + private final OrderDetailDbService orderDetailDbService;
81 - private final OrderOperationRecordDbService orderOperationRecordDbService; 96 + private final OrderOperationRecordDbService orderOperationRecordDbService;
82 - 97 + private final SkuSellQuantityService skuSellQuantityService;
83 - @Override 98 +
84 - @DS(DATA_SOURCE_MASTER) 99 + @Override
85 - public void createClientCustomerOrder(final CreateClientCustomerOrderRpcRequest request, 100 + @DS(DATA_SOURCE_MASTER)
86 - final StreamObserver<CreateClientCustomerOrderRpcResponse> responseObserver) { 101 + public void createClientCustomerOrder(final CreateClientCustomerOrderRpcRequest request,
87 - final var builder = CreateClientCustomerOrderRpcResponse.newBuilder(); 102 + final StreamObserver<CreateClientCustomerOrderRpcResponse> responseObserver) {
88 - try { 103 + final var builder = CreateClientCustomerOrderRpcResponse.newBuilder();
89 - final var data = orderDbService.createOrderDb(request); 104 + try {
90 - builder.setId(data.getId()); 105 + final var data = orderDbService.createOrderDb(request);
91 - builder.setIsCreated(true); 106 + builder.setId(data.getId());
92 - } catch (final Exception e) { 107 + builder.setIsCreated(true);
93 - log.error("createClientCustomerOrder error;", e); 108 + } catch (final Exception e) {
94 - responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 109 + log.error("createClientCustomerOrder error;", e);
110 + responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
111 + }
112 + responseObserver.onNext(builder.build());
113 + responseObserver.onCompleted();
95 } 114 }
96 - responseObserver.onNext(builder.build()); 115 +
97 - responseObserver.onCompleted(); 116 + @Override
98 - } 117 + @DS(DATA_SOURCE_MASTER)
99 - 118 + public void batchCreateClientCustomerOrders(final BatchCreateClientCustomerOrdersRpcRequest request,
100 - @Override 119 + final StreamObserver<BatchCreateClientCustomerOrdersRpcResponse> responseStreamObserver) {
101 - @DS(DATA_SOURCE_MASTER) 120 + final var builder = BatchCreateClientCustomerOrdersRpcResponse.newBuilder();
102 - public void batchCreateClientCustomerOrders(final BatchCreateClientCustomerOrdersRpcRequest request, 121 + try {
103 - final StreamObserver<BatchCreateClientCustomerOrdersRpcResponse> responseStreamObserver) { 122 + final var data = orderDbService.batchCreateOrderDbs(request);
104 - final var builder = BatchCreateClientCustomerOrdersRpcResponse.newBuilder(); 123 + builder.setIsCreated(data.size() == request.getCreationsCount()).addAllIds(data.stream().map(
105 - try { 124 + OrderDb::getId).collect(Collectors.toList()));
106 - final var data = orderDbService.batchCreateOrderDbs(request); 125 + } catch (final Exception e) {
107 - builder.setIsCreated(data.size() == request.getCreationsCount()).addAllIds(data.stream().map( 126 + log.error("createClientCustomerOrder error;", e);
108 - OrderDb::getId).collect(Collectors.toList())); 127 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
109 - } catch (final Exception e) { 128 + }
110 - log.error("createClientCustomerOrder error;", e); 129 + responseStreamObserver.onNext(builder.build());
111 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 130 + responseStreamObserver.onCompleted();
112 } 131 }
113 - responseStreamObserver.onNext(builder.build()); 132 +
114 - responseStreamObserver.onCompleted(); 133 + @Override
115 - } 134 + @DS(DATA_SOURCE_MASTER)
116 - 135 + public void getClientCustomerOrdersByCustomerId(final GetClientCustomerOrdersByCustomerIdRpcRequest request,
117 - @Override 136 + final StreamObserver<GetClientCustomerOrdersByCustomerIdRpcResponse> responseObserver) {
118 - @DS(DATA_SOURCE_MASTER) 137 +
119 - public void getClientCustomerOrdersByCustomerId(final GetClientCustomerOrdersByCustomerIdRpcRequest request, 138 + final var builder = GetClientCustomerOrdersByCustomerIdRpcResponse.newBuilder();
120 - final StreamObserver<GetClientCustomerOrdersByCustomerIdRpcResponse> responseObserver) { 139 + try {
121 - 140 + final var list = orderDbService.getOrdersByCustomerId(request.getCustomerId());
122 - final var builder = GetClientCustomerOrdersByCustomerIdRpcResponse.newBuilder(); 141 + if (!list.isEmpty()) {
123 - try {
124 - final var list = orderDbService.getOrdersByCustomerId(request.getCustomerId());
125 - if (!list.isEmpty()) {
126 // final var allResponses = ProtoBeanUtil.beanListToProtoList(list, 142 // final var allResponses = ProtoBeanUtil.beanListToProtoList(list,
127 // SingleClientCustomerOrderRpcResponse.class); 143 // SingleClientCustomerOrderRpcResponse.class);
128 - final var allResponses = DbToProtoUtil.orderDbListToProtoList(list); 144 + final var allResponses = DbToProtoUtil.orderDbListToProtoList(list);
129 - builder.addAllResponses(allResponses); 145 + builder.addAllResponses(allResponses);
130 - } 146 + }
131 - } catch (final Exception e) { 147 + } catch (final Exception e) {
132 - log.error("getClientCustomerOrdersByCustomerId error;", e); 148 + log.error("getClientCustomerOrdersByCustomerId error;", e);
133 - responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 149 + responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
150 + }
151 + responseObserver.onNext(builder.build());
152 + responseObserver.onCompleted();
134 } 153 }
135 - responseObserver.onNext(builder.build()); 154 +
136 - responseObserver.onCompleted(); 155 + @Override
137 - } 156 + @DS(DATA_SOURCE_MASTER)
138 - 157 + public void getClientCustomerOrderById(final GetClientCustomerOrderByIdRpcRequest request,
139 - @Override 158 + final StreamObserver<GetClientCustomerOrderByIdRpcResponse> responseStreamObserver) {
140 - @DS(DATA_SOURCE_MASTER) 159 + final var builder = GetClientCustomerOrderByIdRpcResponse.newBuilder();
141 - public void getClientCustomerOrderById(final GetClientCustomerOrderByIdRpcRequest request, 160 + try {
142 - final StreamObserver<GetClientCustomerOrderByIdRpcResponse> responseStreamObserver) { 161 + final var data = orderDbService.getById(request.getId());
143 - final var builder = GetClientCustomerOrderByIdRpcResponse.newBuilder(); 162 + if (data != null) {
144 - try {
145 - final var data = orderDbService.getById(request.getId());
146 - if (data != null) {
147 // builder.setResponse(ProtoBeanUtil.beanToProto(data, SingleClientCustomerOrderRpcResponse.class)); 163 // builder.setResponse(ProtoBeanUtil.beanToProto(data, SingleClientCustomerOrderRpcResponse.class));
148 - builder.setResponse(DbToProtoUtil.orderDbToProto(data)); 164 + builder.setResponse(DbToProtoUtil.orderDbToProto(data));
149 - } 165 + }
150 - } catch (final Exception e) { 166 + } catch (final Exception e) {
151 - log.error("getClientCustomerOrderById error;", e); 167 + log.error("getClientCustomerOrderById error;", e);
152 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 168 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
169 + }
170 + responseStreamObserver.onNext(builder.build());
171 + responseStreamObserver.onCompleted();
153 } 172 }
154 - responseStreamObserver.onNext(builder.build()); 173 +
155 - responseStreamObserver.onCompleted(); 174 + @Override
156 - } 175 + @DS(DATA_SOURCE_MASTER)
157 - 176 + public void getClientCustomerOrdersByIds(final GetClientCustomerOrdersByIdsRpcRequest request,
158 - @Override 177 + final StreamObserver<GetClientCustomerOrdersByIdsRpcResponse> responseStreamObserver) {
159 - @DS(DATA_SOURCE_MASTER)
160 - public void getClientCustomerOrdersByIds(final GetClientCustomerOrdersByIdsRpcRequest request,
161 - final StreamObserver<GetClientCustomerOrdersByIdsRpcResponse> responseStreamObserver) {
162 final var builder = GetClientCustomerOrdersByIdsRpcResponse.newBuilder(); 178 final var builder = GetClientCustomerOrdersByIdsRpcResponse.newBuilder();
163 try { 179 try {
164 if (request.getIdsList().isEmpty()) { 180 if (request.getIdsList().isEmpty()) {
165 - responseStreamObserver.onNext(builder.build()); 181 + responseStreamObserver.onNext(builder.build());
166 - responseStreamObserver.onCompleted(); 182 + responseStreamObserver.onCompleted();
167 - return; 183 + return;
168 } 184 }
169 final var list = orderDbService.listByIds(request.getIdsList()); 185 final var list = orderDbService.listByIds(request.getIdsList());
170 if (!list.isEmpty()) { 186 if (!list.isEmpty()) {
171 // builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleClientCustomerOrderRpcResponse.class)); 187 // builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleClientCustomerOrderRpcResponse.class));
172 - builder.addAllResponses(DbToProtoUtil.orderDbListToProtoList(list)); 188 + builder.addAllResponses(DbToProtoUtil.orderDbListToProtoList(list));
173 } 189 }
174 } catch (final Exception e) { 190 } catch (final Exception e) {
175 log.error("getClientCustomerOrdersByIds error;", e); 191 log.error("getClientCustomerOrdersByIds error;", e);
176 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 192 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
177 - }
178 - responseStreamObserver.onNext(builder.build());
179 - responseStreamObserver.onCompleted();
180 - }
181 -
182 - @Override
183 - @DS(DATA_SOURCE_MASTER)
184 - public void queryClientCustomerOrdersByPagination(final QueryClientCustomerOrdersByPaginationRpcRequest request,
185 - final StreamObserver<QueryClientCustomerOrdersByPaginationRpcResponse> responseObserver) {
186 - final var builder = QueryClientCustomerOrdersByPaginationRpcResponse.newBuilder();
187 - try {
188 - IPage<OrderDb> page = new Page<>(request.getPageNo(), request.getPageSize());
189 - LambdaQueryWrapper<OrderDb> queryWrapper = Wrappers.lambdaQuery();
190 - if (!request.getKeyword().isEmpty()) {
191 - queryWrapper.like(OrderDb::getMealTime, request.getKeyword());
192 - }
193 - queryWrapper.eq(OrderDb::getEnterpriseId, request.getEnterpriseId());
194 - queryWrapper.eq(OrderDb::getClientId, request.getClientId());
195 - queryWrapper.in(OrderDb::getStallId, request.getStallIdsList());
196 - queryWrapper.eq(OrderDb::getStatus, request.getStatusValue());
197 - queryWrapper.orderByDesc(OrderDb::getCreatedAt);
198 - final var result = orderDbService.page(page, queryWrapper);
199 -
200 - // 查询各个状态的订单数量
201 - int unknownCount = 0;
202 - int toPrepareCount = 0;
203 - int preparingCount = 0;
204 - int allServedCount = 0;
205 - int canceledCount = 0;
206 - for(OrderStatusEnum status: OrderStatusEnum.values()) {
207 - LambdaQueryWrapper<OrderDb> queryCountWrapper = Wrappers.lambdaQuery();
208 - if (!request.getKeyword().isEmpty()) {
209 - queryCountWrapper.like(OrderDb::getMealTime, request.getKeyword());
210 - }
211 - queryCountWrapper.eq(OrderDb::getEnterpriseId, request.getEnterpriseId());
212 - queryCountWrapper.eq(OrderDb::getClientId, request.getClientId());
213 - queryCountWrapper.eq(OrderDb::getStatus, status.ordinal());
214 - queryCountWrapper.in(OrderDb::getStallId, request.getStallIdsList());
215 - final var count = orderDbService.count(queryCountWrapper);
216 - if (status.equals(OrderStatusEnum.UNKNOWN_STATUS)) {
217 - unknownCount += count;
218 - } else if (status.equals(OrderStatusEnum.TO_PREPARE)) {
219 - toPrepareCount += count;
220 - } else if (status.equals(OrderStatusEnum.PREPARING)) {
221 - preparingCount += count;
222 - } else if (status.equals(OrderStatusEnum.PARTIAL_SERVED) || status.equals(OrderStatusEnum.ALL_SERVED)) {
223 - allServedCount += count;
224 - } else {
225 - canceledCount += count;
226 } 193 }
227 - } 194 + responseStreamObserver.onNext(builder.build());
228 - 195 + responseStreamObserver.onCompleted();
229 - builder.setCountByStatus(OrderCountByStatus.newBuilder() 196 + }
230 - .setUnknownCount(unknownCount) 197 +
231 - .setToPrepareCount(toPrepareCount) 198 + @Override
232 - .setPreparingCount(preparingCount) 199 + @DS(DATA_SOURCE_MASTER)
233 - .setAllServedCount(allServedCount) 200 + public void queryClientCustomerOrdersByPagination(final QueryClientCustomerOrdersByPaginationRpcRequest request,
234 - .setCanceledCount(canceledCount) 201 + final StreamObserver<QueryClientCustomerOrdersByPaginationRpcResponse> responseObserver) {
235 - .build()); 202 + final var builder = QueryClientCustomerOrdersByPaginationRpcResponse.newBuilder();
236 - builder.setTotal(result.getTotal()); 203 + try {
237 - builder.setPages(result.getPages()); 204 + IPage<OrderDb> page = new Page<>(request.getPageNo(), request.getPageSize());
238 - if (!result.getRecords().isEmpty()) { 205 + LambdaQueryWrapper<OrderDb> queryWrapper = Wrappers.lambdaQuery();
206 + if (!request.getKeyword().isEmpty()) {
207 + queryWrapper.like(OrderDb::getMealTime, request.getKeyword());
208 + }
209 + queryWrapper.eq(OrderDb::getEnterpriseId, request.getEnterpriseId());
210 + queryWrapper.eq(OrderDb::getClientId, request.getClientId());
211 + queryWrapper.in(OrderDb::getStallId, request.getStallIdsList());
212 + queryWrapper.eq(OrderDb::getStatus, request.getStatusValue());
213 + queryWrapper.orderByDesc(OrderDb::getCreatedAt);
214 + final var result = orderDbService.page(page, queryWrapper);
215 +
216 + // 查询各个状态的订单数量
217 + int unknownCount = 0;
218 + int toPrepareCount = 0;
219 + int preparingCount = 0;
220 + int allServedCount = 0;
221 + int canceledCount = 0;
222 + for (OrderStatusEnum status : OrderStatusEnum.values()) {
223 + LambdaQueryWrapper<OrderDb> queryCountWrapper = Wrappers.lambdaQuery();
224 + if (!request.getKeyword().isEmpty()) {
225 + queryCountWrapper.like(OrderDb::getMealTime, request.getKeyword());
226 + }
227 + queryCountWrapper.eq(OrderDb::getEnterpriseId, request.getEnterpriseId());
228 + queryCountWrapper.eq(OrderDb::getClientId, request.getClientId());
229 + queryCountWrapper.eq(OrderDb::getStatus, status.ordinal());
230 + queryCountWrapper.in(OrderDb::getStallId, request.getStallIdsList());
231 + final var count = orderDbService.count(queryCountWrapper);
232 + if (status.equals(OrderStatusEnum.UNKNOWN_STATUS)) {
233 + unknownCount += count;
234 + } else if (status.equals(OrderStatusEnum.TO_PREPARE)) {
235 + toPrepareCount += count;
236 + } else if (status.equals(OrderStatusEnum.PREPARING)) {
237 + preparingCount += count;
238 + } else if (status.equals(OrderStatusEnum.PARTIAL_SERVED) || status.equals(OrderStatusEnum.ALL_SERVED)) {
239 + allServedCount += count;
240 + } else {
241 + canceledCount += count;
242 + }
243 + }
244 +
245 + builder.setCountByStatus(OrderCountByStatus.newBuilder()
246 + .setUnknownCount(unknownCount)
247 + .setToPrepareCount(toPrepareCount)
248 + .setPreparingCount(preparingCount)
249 + .setAllServedCount(allServedCount)
250 + .setCanceledCount(canceledCount)
251 + .build());
252 + builder.setTotal(result.getTotal());
253 + builder.setPages(result.getPages());
254 + if (!result.getRecords().isEmpty()) {
239 // builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(result.getRecords(), SingleClientCustomerOrderRpcResponse.class)); 255 // builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(result.getRecords(), SingleClientCustomerOrderRpcResponse.class));
240 - builder.addAllResponses(DbToProtoUtil.orderDbListToProtoList(result.getRecords())); 256 + builder.addAllResponses(DbToProtoUtil.orderDbListToProtoList(result.getRecords()));
241 - } 257 + }
242 - } catch (final Exception e) { 258 + } catch (final Exception e) {
243 - log.error("queryClientCustomerOrdersByPagination error;", e); 259 + log.error("queryClientCustomerOrdersByPagination error;", e);
244 - responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 260 + responseObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
261 + }
262 + responseObserver.onNext(builder.build());
263 + responseObserver.onCompleted();
245 } 264 }
246 - responseObserver.onNext(builder.build()); 265 +
247 - responseObserver.onCompleted(); 266 +
248 - } 267 + @Override
249 - 268 + @DS(DATA_SOURCE_MASTER)
250 - 269 + public void queryClientCustomerOrdersByCondition(final
251 - @Override 270 + QueryClientCustomerOrdersByConditionRpcRequest request,
252 - @DS(DATA_SOURCE_MASTER) 271 + final StreamObserver<QueryClientCustomerOrdersByConditionRpcResponse> responseStreamObserver) {
253 - public void queryClientCustomerOrdersByCondition(final 272 + final var builder = QueryClientCustomerOrdersByConditionRpcResponse.newBuilder();
254 - QueryClientCustomerOrdersByConditionRpcRequest request, 273 + try {
255 - final StreamObserver<QueryClientCustomerOrdersByConditionRpcResponse> responseStreamObserver) { 274 + LambdaQueryWrapper<OrderDb> queryWrapper = Wrappers.lambdaQuery();
256 - final var builder = QueryClientCustomerOrdersByConditionRpcResponse.newBuilder(); 275 +
257 - try { 276 + queryWrapper.eq(OrderDb::getEnterpriseId, request.getEnterpriseId());
258 - LambdaQueryWrapper<OrderDb> queryWrapper = Wrappers.lambdaQuery(); 277 + if (request.getShouldFilterClientIds()) {
259 - 278 + queryWrapper.in(OrderDb::getId, request.getClientIdsList());
260 - queryWrapper.eq(OrderDb::getEnterpriseId, request.getEnterpriseId()); 279 + }
261 - if (request.getShouldFilterClientIds()) { 280 +
262 - queryWrapper.in(OrderDb::getId, request.getClientIdsList()); 281 + if (request.getShouldFilterOrderCode()) {
263 - } 282 + queryWrapper.likeLeft(OrderDb::getOrderCode, request.getOrderCode());
264 - 283 + }
265 - if (request.getShouldFilterOrderCode()) { 284 +
266 - queryWrapper.likeLeft(OrderDb::getOrderCode, request.getOrderCode()); 285 + if (request.getShouldFilterClientIds()) {
267 - } 286 + queryWrapper.in(OrderDb::getClientId, request.getClientIdsList());
268 - 287 + }
269 - if (request.getShouldFilterClientIds()) { 288 +
270 - queryWrapper.in(OrderDb::getClientId, request.getClientIdsList()); 289 + if (request.getShouldFilterStallIds()) {
271 - } 290 + queryWrapper.in(OrderDb::getStallId, request.getStallIdsList());
272 - 291 + }
273 - if (request.getShouldFilterStallIds()) { 292 +
274 - queryWrapper.in(OrderDb::getStallId, request.getStallIdsList()); 293 + if (request.getShouldFilterCustomerIds()) {
275 - } 294 + queryWrapper.in(OrderDb::getCustomerId, request.getCustomerIdsList());
276 - 295 + }
277 - if (request.getShouldFilterCustomerIds()) { 296 +
278 - queryWrapper.in(OrderDb::getCustomerId, request.getCustomerIdsList()); 297 + if (request.getShouldFilterOpenIds()) {
279 - } 298 + queryWrapper.in(OrderDb::getOpenId, request.getOpenIdsList());
280 - 299 + }
281 - if (request.getShouldFilterOpenIds()) { 300 +
282 - queryWrapper.in(OrderDb::getOpenId, request.getOpenIdsList()); 301 + if (request.getShouldFilterStatus()) {
283 - } 302 + queryWrapper.eq(OrderDb::getStatus, request.getStatusValue());
284 - 303 + }
285 - if (request.getShouldFilterStatus()) { 304 +
286 - queryWrapper.eq(OrderDb::getStatus, request.getStatusValue()); 305 + if (request.getShouldFilterMenuIds()) {
287 - } 306 + queryWrapper.in(OrderDb::getMenuId, request.getMenuIdsList());
288 - 307 + }
289 - if (request.getShouldFilterMenuIds()) { 308 +
290 - queryWrapper.in(OrderDb::getMenuId, request.getMenuIdsList()); 309 + if (request.getShouldFilterCloseTimeType()) {
291 - } 310 + queryWrapper.eq(OrderDb::getCloseTimeType, request.getCloseTimeTypeValue());
292 - 311 + }
293 - if (request.getShouldFilterCloseTimeType()) { 312 +
294 - queryWrapper.eq(OrderDb::getCloseTimeType, request.getCloseTimeTypeValue()); 313 + if (request.getShouldFilterOnlinePay()) {
295 - } 314 + queryWrapper.eq(OrderDb::getOnlinePay, request.getOnlinePay());
296 - 315 + }
297 - if (request.getShouldFilterOnlinePay()) { 316 +
298 - queryWrapper.eq(OrderDb::getOnlinePay, request.getOnlinePay()); 317 + if (request.getShouldFilterPayTimeStart()) {
299 - } 318 + queryWrapper.ge(OrderDb::getPayTime, LocalDateTimeUtil.ofUTC(request.getPayTimeStart()));
300 - 319 + }
301 - if (request.getShouldFilterPayTimeStart()) { 320 +
302 - queryWrapper.ge(OrderDb::getPayTime, LocalDateTimeUtil.ofUTC(request.getPayTimeStart())); 321 + if (request.getShouldFilterPayTimeEnd()) {
303 - } 322 + queryWrapper.le(OrderDb::getPayTime, LocalDateTimeUtil.ofUTC(request.getPayTimeEnd()));
304 - 323 + }
305 - if (request.getShouldFilterPayTimeEnd()) { 324 +
306 - queryWrapper.le(OrderDb::getPayTime, LocalDateTimeUtil.ofUTC(request.getPayTimeEnd())); 325 + if (request.getShouldFilterPayStatus()) {
307 - } 326 + queryWrapper.eq(OrderDb::getPayStatus, request.getPayStatusValue()); // 假设PayStatusEnum有getValue方法获取对应整数值
308 - 327 + }
309 - if (request.getShouldFilterPayStatus()) { 328 +
310 - queryWrapper.eq(OrderDb::getPayStatus, request.getPayStatusValue()); // 假设PayStatusEnum有getValue方法获取对应整数值 329 + if (request.getShouldFilterMealTimeStart()) {
311 - } 330 + queryWrapper.ge(OrderDb::getMealTime, LocalDateTimeUtil.ofUTC(request.getMealTimeStart()));
312 - 331 + }
313 - if (request.getShouldFilterMealTimeStart()) { 332 +
314 - queryWrapper.ge(OrderDb::getMealTime, LocalDateTimeUtil.ofUTC(request.getMealTimeStart())); 333 + if (request.getShouldFilterMealTimeEnd()) {
315 - } 334 + queryWrapper.le(OrderDb::getMealTime, LocalDateTimeUtil.ofUTC(request.getMealTimeEnd()));
316 - 335 + }
317 - if (request.getShouldFilterMealTimeEnd()) { 336 +
318 - queryWrapper.le(OrderDb::getMealTime, LocalDateTimeUtil.ofUTC(request.getMealTimeEnd())); 337 + if (request.getShouldFilterRoomNo()) {
319 - } 338 + queryWrapper.eq(OrderDb::getRoomNo, request.getRoomNo());
320 - 339 + }
321 - if (request.getShouldFilterRoomNo()) { 340 +
322 - queryWrapper.eq(OrderDb::getRoomNo, request.getRoomNo()); 341 + if (request.getShouldFilterTableCode()) {
323 - } 342 + queryWrapper.eq(OrderDb::getTableCode, request.getTableCode());
324 - 343 + }
325 - if (request.getShouldFilterTableCode()) { 344 +
326 - queryWrapper.eq(OrderDb::getTableCode, request.getTableCode()); 345 + if (request.getShouldFilterPickupCode()) {
327 - } 346 + queryWrapper.eq(OrderDb::getPickupCode, request.getPickupCode());
328 - 347 + }
329 - if (request.getShouldFilterPickupCode()) { 348 +
330 - queryWrapper.eq(OrderDb::getPickupCode, request.getPickupCode()); 349 + if (request.getShouldFilterOrderType()) {
331 - } 350 + queryWrapper.eq(OrderDb::getOrderType, request.getOrderTypeValue()); // 假设OrderTypeEnum有getValue方法获取对应整数值
332 - 351 + }
333 - if (request.getShouldFilterOrderType()) { 352 +
334 - queryWrapper.eq(OrderDb::getOrderType, request.getOrderTypeValue()); // 假设OrderTypeEnum有getValue方法获取对应整数值 353 + if (request.getShouldFilterCreatedAtStart()) {
335 - } 354 + queryWrapper.ge(OrderDb::getCreatedAt, LocalDateTimeUtil.ofUTC(request.getCreatedAtStart()));
336 - 355 + }
337 - if (request.getShouldFilterCreatedAtStart()) { 356 +
338 - queryWrapper.ge(OrderDb::getCreatedAt, LocalDateTimeUtil.ofUTC(request.getCreatedAtStart())); 357 + if (request.getShouldFilterCreatedAtEnd()) {
339 - } 358 + queryWrapper.le(OrderDb::getCreatedAt, LocalDateTimeUtil.ofUTC(request.getCreatedAtEnd()));
340 - 359 + }
341 - if (request.getShouldFilterCreatedAtEnd()) { 360 +
342 - queryWrapper.le(OrderDb::getCreatedAt, LocalDateTimeUtil.ofUTC(request.getCreatedAtEnd())); 361 + if (request.getShouldFilterIsRead()) {
343 - } 362 + queryWrapper.eq(OrderDb::getIsRead, request.getIsRead());
344 - 363 + }
345 - if (request.getShouldFilterIsRead()) { 364 + queryWrapper.orderByDesc(OrderDb::getCreatedAt);
346 - queryWrapper.eq(OrderDb::getIsRead, request.getIsRead()); 365 + final var list = orderDbService.list(queryWrapper);
347 - } 366 + if (!list.isEmpty()) {
348 - queryWrapper.orderByDesc(OrderDb::getCreatedAt);
349 - final var list = orderDbService.list(queryWrapper);
350 - if (!list.isEmpty()) {
351 // builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleClientCustomerOrderRpcResponse.class)); 367 // builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleClientCustomerOrderRpcResponse.class));
352 - builder.addAllResponses(DbToProtoUtil.orderDbListToProtoList(list)); 368 + builder.addAllResponses(DbToProtoUtil.orderDbListToProtoList(list));
353 - } 369 + }
354 - } catch (final Exception e) { 370 + } catch (final Exception e) {
355 - log.error("queryTestExampleDbByCondition error;", e); 371 + log.error("queryTestExampleDbByCondition error;", e);
356 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 372 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
373 + }
374 + responseStreamObserver.onNext(builder.build());
375 + responseStreamObserver.onCompleted();
357 } 376 }
358 - responseStreamObserver.onNext(builder.build()); 377 +
359 - responseStreamObserver.onCompleted(); 378 + @Override
360 - } 379 + @DS(DATA_SOURCE_MASTER)
361 - 380 + public void updateClientCustomerOrder(final UpdateClientCustomerOrderRpcRequest request,
362 - @Override 381 + final StreamObserver<UpdateClientCustomerOrderRpcResponse> responseStreamObserver) {
363 - @DS(DATA_SOURCE_MASTER) 382 + final var builder = UpdateClientCustomerOrderRpcResponse.newBuilder();
364 - public void updateClientCustomerOrder(final UpdateClientCustomerOrderRpcRequest request, 383 + builder.setIsUpdated(false);
365 - final StreamObserver<UpdateClientCustomerOrderRpcResponse> responseStreamObserver) { 384 + try {
366 - final var builder = UpdateClientCustomerOrderRpcResponse.newBuilder(); 385 + builder.setIsUpdated(orderDbService.updateOrderDb(request));
367 - builder.setIsUpdated(false); 386 + } catch (final Exception e) {
368 - try { 387 + log.error("updateClientCustomerOrder error;", e);
369 - builder.setIsUpdated(orderDbService.updateOrderDb(request)); 388 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
370 - } catch (final Exception e) { 389 + }
371 - log.error("updateClientCustomerOrder error;", e); 390 + responseStreamObserver.onNext(builder.build());
372 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 391 + responseStreamObserver.onCompleted();
373 } 392 }
374 - responseStreamObserver.onNext(builder.build()); 393 +
375 - responseStreamObserver.onCompleted(); 394 + @Override
376 - } 395 + @DS(DATA_SOURCE_MASTER)
377 - 396 + public void batchUpdateClientCustomerOrders(final BatchUpdateClientCustomerOrdersRpcRequest request,
378 - @Override 397 + final StreamObserver<BatchUpdateClientCustomerOrdersRpcResponse> responseStreamObserver) {
379 - @DS(DATA_SOURCE_MASTER) 398 + final var builder = BatchUpdateClientCustomerOrdersRpcResponse.newBuilder();
380 - public void batchUpdateClientCustomerOrders(final BatchUpdateClientCustomerOrdersRpcRequest request, 399 + builder.setIsUpdated(false);
381 - final StreamObserver<BatchUpdateClientCustomerOrdersRpcResponse> responseStreamObserver) { 400 + try {
382 - final var builder = BatchUpdateClientCustomerOrdersRpcResponse.newBuilder(); 401 + builder.setIsUpdated(orderDbService.batchUpdateOrderDbs(request));
383 - builder.setIsUpdated(false); 402 + } catch (final Exception e) {
384 - try { 403 + log.error("batchUpdateClientCustomerOrders error;", e);
385 - builder.setIsUpdated(orderDbService.batchUpdateOrderDbs(request)); 404 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
386 - } catch (final Exception e) { 405 + }
387 - log.error("batchUpdateClientCustomerOrders error;", e); 406 + responseStreamObserver.onNext(builder.build());
388 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 407 + responseStreamObserver.onCompleted();
389 } 408 }
390 - responseStreamObserver.onNext(builder.build()); 409 +
391 - responseStreamObserver.onCompleted(); 410 + @Override
392 - } 411 + @DS(DATA_SOURCE_MASTER)
393 - 412 + public void deleteClientCustomerOrdersByIds(final DeleteClientCustomerOrdersByIdsRpcRequest request,
394 - @Override 413 + final StreamObserver<DeleteClientCustomerOrdersRpcResponse> responseStreamObserver) {
395 - @DS(DATA_SOURCE_MASTER) 414 + final var builder = DeleteClientCustomerOrdersRpcResponse.newBuilder();
396 - public void deleteClientCustomerOrdersByIds(final DeleteClientCustomerOrdersByIdsRpcRequest request, 415 + builder.setIsDeleted(false);
397 - final StreamObserver<DeleteClientCustomerOrdersRpcResponse> responseStreamObserver) { 416 + try {
398 - final var builder = DeleteClientCustomerOrdersRpcResponse.newBuilder(); 417 + if (request.getIdsList().isEmpty()) {
399 - builder.setIsDeleted(false); 418 + responseStreamObserver.onNext(builder.build());
400 - try { 419 + responseStreamObserver.onCompleted();
401 - if (request.getIdsList().isEmpty()) { 420 + return;
421 + }
422 + builder.setIsDeleted(orderDbService.removeBatchByIds(request.getIdsList()));
423 + } catch (final Exception e) {
424 + log.error("deleteClientCustomerOrdersByIds error;", e);
425 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
426 + }
402 responseStreamObserver.onNext(builder.build()); 427 responseStreamObserver.onNext(builder.build());
403 responseStreamObserver.onCompleted(); 428 responseStreamObserver.onCompleted();
404 - return;
405 - }
406 - builder.setIsDeleted(orderDbService.removeBatchByIds(request.getIdsList()));
407 - } catch (final Exception e) {
408 - log.error("deleteClientCustomerOrdersByIds error;", e);
409 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
410 } 429 }
411 - responseStreamObserver.onNext(builder.build());
412 - responseStreamObserver.onCompleted();
413 - }
414 430
415 // @Override 431 // @Override
416 // @DS(DATA_SOURCE_MASTER) 432 // @DS(DATA_SOURCE_MASTER)
...@@ -431,214 +447,338 @@ public class OrderGrpcService extends ClientCustomerOrderServiceRpcGrpc.ClientCu ...@@ -431,214 +447,338 @@ public class OrderGrpcService extends ClientCustomerOrderServiceRpcGrpc.ClientCu
431 // responseStreamObserver.onCompleted(); 447 // responseStreamObserver.onCompleted();
432 // } 448 // }
433 449
434 - @Override 450 + @Override
435 - @DS(DATA_SOURCE_MASTER) 451 + @DS(DATA_SOURCE_MASTER)
436 - public void getClientCustomerOrderDetailById( 452 + public void getClientCustomerOrderDetailById(
437 - final GetClientCustomerOrderDetailByIdRpcRequest request, 453 + final GetClientCustomerOrderDetailByIdRpcRequest request,
438 - final StreamObserver<GetClientCustomerOrderDetailByIdRpcResponse> responseStreamObserver) { 454 + final StreamObserver<GetClientCustomerOrderDetailByIdRpcResponse> responseStreamObserver) {
439 - final var builder = GetClientCustomerOrderDetailByIdRpcResponse.newBuilder(); 455 + final var builder = GetClientCustomerOrderDetailByIdRpcResponse.newBuilder();
440 - try { 456 + try {
441 - final var data = orderDetailDbService.getById(request.getId()); 457 + final var data = orderDetailDbService.getById(request.getId());
442 - if (data != null) { 458 + if (data != null) {
443 // builder.setResponse(ProtoBeanUtil.beanToProto(data, SingleClientCustomerOrderDetailRpcResponse.class)); 459 // builder.setResponse(ProtoBeanUtil.beanToProto(data, SingleClientCustomerOrderDetailRpcResponse.class));
444 - builder.setResponse(DbToProtoUtil.orderDetailDbToProto(data)); 460 + builder.setResponse(DbToProtoUtil.orderDetailDbToProto(data));
445 - } 461 + }
446 - } catch (final Exception e) { 462 + } catch (final Exception e) {
447 - log.error("getClientCustomerOrderDetailById error;", e); 463 + log.error("getClientCustomerOrderDetailById error;", e);
448 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 464 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
465 + }
466 + responseStreamObserver.onNext(builder.build());
467 + responseStreamObserver.onCompleted();
449 } 468 }
450 - responseStreamObserver.onNext(builder.build()); 469 +
451 - responseStreamObserver.onCompleted(); 470 + @Override
452 - } 471 + @DS(DATA_SOURCE_MASTER)
453 - 472 + public void getClientCustomerOrderDetailsByIds(
454 - @Override 473 + final GetClientCustomerOrderDetailsByIdsRpcRequest request,
455 - @DS(DATA_SOURCE_MASTER) 474 + final StreamObserver<GetClientCustomerOrderDetailsByIdsRpcResponse> responseStreamObserver
456 - public void getClientCustomerOrderDetailsByIds( 475 + ) {
457 - final GetClientCustomerOrderDetailsByIdsRpcRequest request, 476 + final var builder = GetClientCustomerOrderDetailsByIdsRpcResponse.newBuilder();
458 - final StreamObserver<GetClientCustomerOrderDetailsByIdsRpcResponse> responseStreamObserver 477 + try {
459 - ) { 478 + if (request.getIdsList().isEmpty()) {
460 - final var builder = GetClientCustomerOrderDetailsByIdsRpcResponse.newBuilder(); 479 + responseStreamObserver.onNext(builder.build());
461 - try { 480 + responseStreamObserver.onCompleted();
462 - if (request.getIdsList().isEmpty()) { 481 + return;
482 + }
483 + final var list = orderDetailDbService.listByIds(request.getIdsList());
484 + if (!list.isEmpty()) {
485 +// builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleClientCustomerOrderDetailRpcResponse.class));
486 + builder.addAllResponses(DbToProtoUtil.orderDetailDbListToProtoList(list));
487 + }
488 + } catch (final Exception e) {
489 + log.error("getClientCustomerOrderDetailsByIds error;", e);
490 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
491 + }
463 responseStreamObserver.onNext(builder.build()); 492 responseStreamObserver.onNext(builder.build());
464 responseStreamObserver.onCompleted(); 493 responseStreamObserver.onCompleted();
465 - return; 494 +
466 - } 495 + }
467 - final var list = orderDetailDbService.listByIds(request.getIdsList()); 496 +
468 - if (!list.isEmpty()) { 497 + @Override
498 + @DS(DATA_SOURCE_MASTER)
499 + public void getClientCustomerOrderDetailsByOrderIds(
500 + final GetClientCustomerOrderDetailsByOrderIdsRpcRequest request,
501 + final StreamObserver<GetClientCustomerOrderDetailsByOrderIdsRpcResponse> responseStreamObserver
502 + ) {
503 + final var builder = GetClientCustomerOrderDetailsByOrderIdsRpcResponse.newBuilder();
504 + try {
505 + if (request.getOrderIdsList().isEmpty()) {
506 + responseStreamObserver.onNext(builder.build());
507 + responseStreamObserver.onCompleted();
508 + return;
509 + }
510 + final var list = orderDetailDbService.getOrderDetailsByOrderIds(request);
511 + if (!list.isEmpty()) {
469 // builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleClientCustomerOrderDetailRpcResponse.class)); 512 // builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleClientCustomerOrderDetailRpcResponse.class));
470 - builder.addAllResponses(DbToProtoUtil.orderDetailDbListToProtoList(list)); 513 + builder.addAllResponses(DbToProtoUtil.orderDetailDbListToProtoList(list));
471 - } 514 + }
472 - } catch (final Exception e) { 515 + } catch (final Exception e) {
473 - log.error("getClientCustomerOrderDetailsByIds error;", e); 516 + log.error("getClientCustomerOrderDetailsByIds error;", e);
474 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 517 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
518 + }
519 + responseStreamObserver.onNext(builder.build());
520 + responseStreamObserver.onCompleted();
475 } 521 }
476 - responseStreamObserver.onNext(builder.build()); 522 +
477 - responseStreamObserver.onCompleted(); 523 + @Override
478 - 524 + @DS(DATA_SOURCE_MASTER)
479 - } 525 + public void createClientCustomerOrderDetail(
480 - 526 + final CreateClientCustomerOrderDetailRpcRequest request,
481 - @Override 527 + final StreamObserver<CreateClientCustomerOrderDetailRpcResponse> responseStreamObserver
482 - @DS(DATA_SOURCE_MASTER) 528 + ) {
483 - public void getClientCustomerOrderDetailsByOrderIds( 529 + final var builder = CreateClientCustomerOrderDetailRpcResponse.newBuilder();
484 - final GetClientCustomerOrderDetailsByOrderIdsRpcRequest request, 530 + try {
485 - final StreamObserver<GetClientCustomerOrderDetailsByOrderIdsRpcResponse> responseStreamObserver 531 + final var data = orderDetailDbService.createOrderDetailDb(request);
486 - ) { 532 + builder.setId(data.getId());
487 - final var builder = GetClientCustomerOrderDetailsByOrderIdsRpcResponse.newBuilder(); 533 + builder.setIsCreated(true);
488 - try { 534 + } catch (final Exception e) {
489 - if (request.getOrderIdsList().isEmpty()) { 535 + log.error("createClientCustomerOrder error;", e);
536 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
537 + }
490 responseStreamObserver.onNext(builder.build()); 538 responseStreamObserver.onNext(builder.build());
491 responseStreamObserver.onCompleted(); 539 responseStreamObserver.onCompleted();
492 - return;
493 - }
494 - final var list = orderDetailDbService.getOrderDetailsByOrderIds(request);
495 - if (!list.isEmpty()) {
496 -// builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleClientCustomerOrderDetailRpcResponse.class));
497 - builder.addAllResponses(DbToProtoUtil.orderDetailDbListToProtoList(list));
498 - }
499 - } catch (final Exception e) {
500 - log.error("getClientCustomerOrderDetailsByIds error;", e);
501 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
502 } 540 }
503 - responseStreamObserver.onNext(builder.build()); 541 +
504 - responseStreamObserver.onCompleted(); 542 + @Override
505 - } 543 + @DS(DATA_SOURCE_MASTER)
506 - 544 + public void batchCreateClientCustomerOrderDetails(
507 - @Override 545 + final BatchCreateClientCustomerOrderDetailsRpcRequest request,
508 - @DS(DATA_SOURCE_MASTER) 546 + final StreamObserver<BatchCreateClientCustomerOrderDetailsRpcResponse> responseStreamObserver
509 - public void createClientCustomerOrderDetail( 547 + ) {
510 - final CreateClientCustomerOrderDetailRpcRequest request, 548 + final var builder = BatchCreateClientCustomerOrderDetailsRpcResponse.newBuilder();
511 - final StreamObserver<CreateClientCustomerOrderDetailRpcResponse> responseStreamObserver 549 + builder.setIsCreated(false);
512 - ) { 550 + try {
513 - final var builder = CreateClientCustomerOrderDetailRpcResponse.newBuilder(); 551 + final var list = orderDetailDbService.batchCreateOrderDetailDb(request);
514 - try { 552 + builder.setIsCreated(list.size() == request.getCreationsCount()).addAllIds(list.stream().map(
515 - final var data = orderDetailDbService.createOrderDetailDb(request); 553 + OrderDetailDb::getId).collect(Collectors.toList()));
516 - builder.setId(data.getId()); 554 + } catch (final Exception e) {
517 - builder.setIsCreated(true); 555 + log.error("batchCreateTestExampleDb error;", e);
518 - } catch (final Exception e) { 556 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
519 - log.error("createClientCustomerOrder error;", e); 557 + }
520 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 558 + responseStreamObserver.onNext(builder.build());
559 + responseStreamObserver.onCompleted();
521 } 560 }
522 - responseStreamObserver.onNext(builder.build()); 561 +
523 - responseStreamObserver.onCompleted(); 562 + @Override
524 - } 563 + @DS(DATA_SOURCE_MASTER)
525 - 564 + public void updateClientCustomerOrderDetail(
526 - @Override 565 + final UpdateClientCustomerOrderDetailRpcRequest request,
527 - @DS(DATA_SOURCE_MASTER) 566 + final StreamObserver<UpdateClientCustomerOrderDetailRpcResponse> responseStreamObserver
528 - public void batchCreateClientCustomerOrderDetails( 567 + ) {
529 - final BatchCreateClientCustomerOrderDetailsRpcRequest request, 568 + final var builder = UpdateClientCustomerOrderDetailRpcResponse.newBuilder();
530 - final StreamObserver<BatchCreateClientCustomerOrderDetailsRpcResponse> responseStreamObserver 569 + builder.setIsUpdated(false);
531 - ) { 570 + try {
532 - final var builder = BatchCreateClientCustomerOrderDetailsRpcResponse.newBuilder(); 571 + builder.setIsUpdated(orderDetailDbService.updateOrderDetailDb(request));
533 - builder.setIsCreated(false); 572 + } catch (final Exception e) {
534 - try { 573 + log.error("updateClientCustomerOrderDetail error;", e);
535 - final var list = orderDetailDbService.batchCreateOrderDetailDb(request); 574 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
536 - builder.setIsCreated(list.size() == request.getCreationsCount()).addAllIds(list.stream().map( 575 + }
537 - OrderDetailDb::getId).collect(Collectors.toList())); 576 + responseStreamObserver.onNext(builder.build());
538 - } catch (final Exception e) { 577 + responseStreamObserver.onCompleted();
539 - log.error("batchCreateTestExampleDb error;", e);
540 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
541 } 578 }
542 - responseStreamObserver.onNext(builder.build()); 579 +
543 - responseStreamObserver.onCompleted(); 580 + @Override
544 - } 581 + @DS(DATA_SOURCE_MASTER)
545 - 582 + public void batchUpdateClientCustomerOrderDetails(
546 - @Override 583 + final BatchUpdateClientCustomerOrderDetailsRpcRequest request,
547 - @DS(DATA_SOURCE_MASTER) 584 + final StreamObserver<BatchUpdateClientCustomerOrderDetailsRpcResponse> responseStreamObserver
548 - public void updateClientCustomerOrderDetail( 585 + ) {
549 - final UpdateClientCustomerOrderDetailRpcRequest request, 586 + final var builder = BatchUpdateClientCustomerOrderDetailsRpcResponse.newBuilder();
550 - final StreamObserver<UpdateClientCustomerOrderDetailRpcResponse> responseStreamObserver 587 + builder.setIsUpdated(false);
551 - ) { 588 + try {
552 - final var builder = UpdateClientCustomerOrderDetailRpcResponse.newBuilder(); 589 + builder.setIsUpdated(orderDetailDbService.batchUpdateOrderDetailDbs(request));
553 - builder.setIsUpdated(false); 590 + } catch (final Exception e) {
554 - try { 591 + log.error("batchUpdateClientCustomerOrderDetails error;", e);
555 - builder.setIsUpdated(orderDetailDbService.updateOrderDetailDb(request)); 592 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
556 - } catch (final Exception e) { 593 + }
557 - log.error("updateClientCustomerOrderDetail error;", e); 594 + responseStreamObserver.onNext(builder.build());
558 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 595 + responseStreamObserver.onCompleted();
559 } 596 }
560 - responseStreamObserver.onNext(builder.build()); 597 +
561 - responseStreamObserver.onCompleted(); 598 + @Override
562 - } 599 + @DS(DATA_SOURCE_MASTER)
563 - 600 + public void deleteClientCustomerOrderDetailsByIds(
564 - @Override 601 + final DeleteClientCustomerOrderDetailsByIdsRpcRequest request,
565 - @DS(DATA_SOURCE_MASTER) 602 + final StreamObserver<DeleteClientCustomerOrderDetailsRpcResponse> responseStreamObserver
566 - public void batchUpdateClientCustomerOrderDetails( 603 + ) {
567 - final BatchUpdateClientCustomerOrderDetailsRpcRequest request, 604 + final var builder = DeleteClientCustomerOrderDetailsRpcResponse.newBuilder();
568 - final StreamObserver<BatchUpdateClientCustomerOrderDetailsRpcResponse> responseStreamObserver 605 + builder.setIsDeleted(false);
569 - ) { 606 + try {
570 - final var builder = BatchUpdateClientCustomerOrderDetailsRpcResponse.newBuilder(); 607 + if (request.getIdsList().isEmpty()) {
571 - builder.setIsUpdated(false); 608 + responseStreamObserver.onNext(builder.build());
572 - try { 609 + responseStreamObserver.onCompleted();
573 - builder.setIsUpdated(orderDetailDbService.batchUpdateOrderDetailDbs(request)); 610 + return;
574 - } catch (final Exception e) { 611 + }
575 - log.error("batchUpdateClientCustomerOrderDetails error;", e); 612 + builder.setIsDeleted(orderDetailDbService.removeBatchByIds(request.getIdsList()));
576 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 613 + } catch (final Exception e) {
614 + log.error("deleteClientCustomerOrderDetailsByIds error;", e);
615 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
616 + }
617 + responseStreamObserver.onNext(builder.build());
618 + responseStreamObserver.onCompleted();
577 } 619 }
578 - responseStreamObserver.onNext(builder.build()); 620 +
579 - responseStreamObserver.onCompleted(); 621 + @Override
580 - } 622 + @DS(DATA_SOURCE_MASTER)
581 - 623 + public void getOrderOperationRecordsByOrderId(
582 - @Override 624 + final GetOrderOperationRecordsByOrderIdRequest request,
583 - @DS(DATA_SOURCE_MASTER) 625 + final StreamObserver<GetOrderOperationRecordsByOrderIdResponse> responseStreamObserver
584 - public void deleteClientCustomerOrderDetailsByIds( 626 + ) {
585 - final DeleteClientCustomerOrderDetailsByIdsRpcRequest request, 627 + final var builder = GetOrderOperationRecordsByOrderIdResponse.newBuilder();
586 - final StreamObserver<DeleteClientCustomerOrderDetailsRpcResponse> responseStreamObserver 628 + try {
587 - ) { 629 + final var list = orderOperationRecordDbService.getOrderOperationRecordsByOrderId(request);
588 - final var builder = DeleteClientCustomerOrderDetailsRpcResponse.newBuilder(); 630 + if (!list.isEmpty()) {
589 - builder.setIsDeleted(false); 631 + builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list,
590 - try { 632 + OrderOperationRecord.class));
591 - if (request.getIdsList().isEmpty()) { 633 + }
634 + } catch (final Exception e) {
635 + log.error("getClientCustomerOrdersByCustomerId error;", e);
636 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
637 + }
592 responseStreamObserver.onNext(builder.build()); 638 responseStreamObserver.onNext(builder.build());
593 responseStreamObserver.onCompleted(); 639 responseStreamObserver.onCompleted();
594 - return;
595 - }
596 - builder.setIsDeleted(orderDetailDbService.removeBatchByIds(request.getIdsList()));
597 - } catch (final Exception e) {
598 - log.error("deleteClientCustomerOrderDetailsByIds error;", e);
599 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
600 } 640 }
601 - responseStreamObserver.onNext(builder.build()); 641 +
602 - responseStreamObserver.onCompleted(); 642 + @Override
603 - } 643 + @DS(DATA_SOURCE_MASTER)
604 - 644 + public void batchCreateOrderOperationRecords(
605 - @Override 645 + final BatchCreateOrderOperationRecordsRequest request,
606 - @DS(DATA_SOURCE_MASTER) 646 + final StreamObserver<BatchCreateOrderOperationRecordsResponse> responseStreamObserver) {
607 - public void getOrderOperationRecordsByOrderId( 647 + final var builder = BatchCreateOrderOperationRecordsResponse.newBuilder();
608 - final GetOrderOperationRecordsByOrderIdRequest request, 648 + try {
609 - final StreamObserver<GetOrderOperationRecordsByOrderIdResponse> responseStreamObserver 649 + final var data = orderOperationRecordDbService.batchCreateOrderOperationRecords(request);
610 - ) { 650 + builder.setIsCreated(data.size() == request.getCreationsCount()).addAllIds(data.stream().map(
611 - final var builder = GetOrderOperationRecordsByOrderIdResponse.newBuilder(); 651 + OrderOperationRecordDb::getId).collect(Collectors.toList()));
612 - try { 652 + } catch (final Exception e) {
613 - final var list = orderOperationRecordDbService.getOrderOperationRecordsByOrderId(request); 653 + log.error("batchCreateOrderOperationRecords error;", e);
614 - if (!list.isEmpty()) { 654 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
615 - builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, 655 + }
616 - OrderOperationRecord.class)); 656 + responseStreamObserver.onNext(builder.build());
617 - } 657 + responseStreamObserver.onCompleted();
618 - } catch (final Exception e) {
619 - log.error("getClientCustomerOrdersByCustomerId error;", e);
620 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
621 } 658 }
622 - responseStreamObserver.onNext(builder.build()); 659 +
623 - responseStreamObserver.onCompleted(); 660 + @Override
624 - } 661 + @DS(DATA_SOURCE_SLAVE)
625 - 662 + public void querySkuSellQuantitiesByStall(final QuerySkuSellQuantitiesByStallRpcRequest request,
626 - @Override 663 + final StreamObserver<QuerySkuSellQuantitiesByStallRpcResponse> responseStreamObserver) {
627 - @DS(DATA_SOURCE_MASTER) 664 + final var builder = QuerySkuSellQuantitiesByStallRpcResponse.newBuilder();
628 - public void batchCreateOrderOperationRecords( 665 + try {
629 - final BatchCreateOrderOperationRecordsRequest request, 666 + LambdaQueryWrapper<SkuSellQuantity> queryWrapper = new LambdaQueryWrapper<>();
630 - final StreamObserver<BatchCreateOrderOperationRecordsResponse> responseStreamObserver 667 + queryWrapper.eq(SkuSellQuantity::getEnterpriseId, request.getEnterpriseId());
631 - ) { 668 + queryWrapper.eq(SkuSellQuantity::getStallId, request.getStallId());
632 - final var builder = BatchCreateOrderOperationRecordsResponse.newBuilder(); 669 + final var list = skuSellQuantityService.list(queryWrapper);
633 - try { 670 + builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleSkuSellQuantityRpcResponse.class));
634 - final var data = orderOperationRecordDbService.batchCreateOrderOperationRecords(request); 671 + } catch (final Exception e) {
635 - builder.setIsCreated(data.size() == request.getCreationsCount()).addAllIds(data.stream().map( 672 + log.error("querySkuSellQuantitiesByStall error;", e);
636 - OrderOperationRecordDb::getId).collect(Collectors.toList())); 673 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
637 - } catch (final Exception e) { 674 + }
638 - log.error("batchCreateOrderOperationRecords error;", e); 675 + responseStreamObserver.onNext(builder.build());
639 - responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException()); 676 + responseStreamObserver.onCompleted();
640 } 677 }
641 - responseStreamObserver.onNext(builder.build()); 678 +
642 - responseStreamObserver.onCompleted(); 679 + @Override
643 - } 680 + @DS(DATA_SOURCE_SLAVE)
681 + public void querySkuSellQuantitiesByStallAndSkuIds(final QuerySkuSellQuantitiesByStallAndSkuIdsRpcRequest request,
682 + final StreamObserver<QuerySkuSellQuantitiesByStallAndSkuIdsRpcResponse> responseStreamObserver) {
683 + final var builder = QuerySkuSellQuantitiesByStallAndSkuIdsRpcResponse.newBuilder();
684 + try {
685 + LambdaQueryWrapper<SkuSellQuantity> queryWrapper = new LambdaQueryWrapper<>();
686 + queryWrapper.eq(SkuSellQuantity::getEnterpriseId, request.getEnterpriseId());
687 + queryWrapper.eq(SkuSellQuantity::getStallId, request.getStallId());
688 + queryWrapper.in(SkuSellQuantity::getSkuId, request.getSkuIdsList());
689 + final var list = skuSellQuantityService.list(queryWrapper);
690 + builder.addAllResponses(ProtoBeanUtil.beanListToProtoList(list, SingleSkuSellQuantityRpcResponse.class));
691 + } catch (final Exception e) {
692 + log.error("querySkuSellQuantitiesByStallAndSkuIds error;", e);
693 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
694 + }
695 + responseStreamObserver.onNext(builder.build());
696 + responseStreamObserver.onCompleted();
697 + }
698 +
699 + @Override
700 + @DS(DATA_SOURCE_MASTER)
701 + public void batchSaveSkuSellQuantities(final BatchSaveSkuSellQuantitiesRpcRequest request,
702 + final StreamObserver<BatchSaveSkuSellQuantitiesRpcResponse> responseStreamObserver) {
703 + final var builder = BatchSaveSkuSellQuantitiesRpcResponse.newBuilder();
704 + try {
705 + List<SkuSellQuantity> skuSellQuantities = new ArrayList<>();
706 + for (SkuSellQuantityModification skuSellQuantityModification : request.getSkuSellQuantityModificationsList()) {
707 + SkuSellQuantity skuSellQuantity = new SkuSellQuantity();
708 + skuSellQuantity.setId(skuSellQuantityModification.getId() == 0 ? null : skuSellQuantityModification.getId());
709 + skuSellQuantity.setEnterpriseId(request.getEnterpriseId());
710 + skuSellQuantity.setStallId(skuSellQuantityModification.getStallId());
711 + skuSellQuantity.setSkuId(skuSellQuantityModification.getSkuId());
712 + skuSellQuantity.setMaxSellQuantity(skuSellQuantityModification.getMaxSellQuantity());
713 + skuSellQuantity.setCreatedBy(request.getUpdatedBy());
714 + skuSellQuantity.setCreationSource(OrderSourceEnum.STALL_VALUE);
715 + skuSellQuantity.setUpdatedBy(request.getUpdatedBy());
716 + skuSellQuantity.setUpdateSource(OrderSourceEnum.STALL_VALUE);
717 + skuSellQuantities.add(skuSellQuantity);
718 + }
719 + final boolean saveOrUpdateBatch = skuSellQuantityService.saveOrUpdateBatch(skuSellQuantities);
720 + builder.setIsSaved(saveOrUpdateBatch);
721 + } catch (final Exception e) {
722 + log.error("batchSaveSkuSellQuantities error;", e);
723 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
724 + }
725 + responseStreamObserver.onNext(builder.build());
726 + responseStreamObserver.onCompleted();
727 + }
728 +
729 + @Override
730 + @DS(DATA_SOURCE_MASTER)
731 + public void addSkusSellQuantities(final AddSkusSellQuantitiesRpcRequest request,
732 + final StreamObserver<AddSkusSellQuantitiesRpcResponse> responseStreamObserver) {
733 + final var builder = AddSkusSellQuantitiesRpcResponse.newBuilder();
734 + try {
735 + LambdaQueryWrapper<SkuSellQuantity> queryWrapper = new LambdaQueryWrapper<>();
736 + queryWrapper.eq(SkuSellQuantity::getEnterpriseId, request.getEnterpriseId());
737 + queryWrapper.eq(SkuSellQuantity::getStallId, request.getStallId());
738 + queryWrapper.in(SkuSellQuantity::getSkuId, request.getSkuSellQuantitiesList().stream()
739 + .map(com.infoloop.tianting.clientcustomerorderservice.SkuSellQuantity::getSkuId)
740 + .collect(Collectors.toList()));
741 + final var list = skuSellQuantityService.list(queryWrapper.last("FOR UPDATE"));
742 + final var skuSellQuantityMap = list.stream().collect(Collectors.toMap(SkuSellQuantity::getSkuId, Function.identity()));
743 + final var updates = new ArrayList<SkuSellQuantity>();
744 + for (var sellQuantity : request.getSkuSellQuantitiesList()) {
745 + final var skuSellQuantity = skuSellQuantityMap.get(sellQuantity.getSkuId());
746 + if (skuSellQuantity == null) {
747 + throw new IllegalArgumentException("addSkusSellQuantities skuId not exists; " + sellQuantity.getSkuId());
748 + }
749 + final int quantity = sellQuantity.getQuantity();
750 + if (quantity < 0) {
751 + log.info("Negative quantity detected; skuId={}, quantity={}", sellQuantity.getSkuId(), quantity);
752 + }
753 + final int todaySellQuantity = skuSellQuantity.getTodaySellQuantity() + quantity;
754 + if (todaySellQuantity < 0) {
755 + log.error("Negative total todaySellQuantity; skuId={}, todaySellQuantity={}", sellQuantity.getSkuId(), todaySellQuantity);
756 + builder.setIsAdded(false);
757 + responseStreamObserver.onNext(builder.build());
758 + responseStreamObserver.onCompleted();
759 + return;
760 + }
761 + if (todaySellQuantity > skuSellQuantity.getMaxSellQuantity()) {
762 + log.error("addSkusSellQuantities quantity exceeds maxSellQuantity; skuId={}, quantity={}, maxSellQuantity={}", sellQuantity.getSkuId(), sellQuantity.getQuantity(), skuSellQuantity.getMaxSellQuantity());
763 + builder.setIsAdded(false);
764 + responseStreamObserver.onNext(builder.build());
765 + responseStreamObserver.onCompleted();
766 + return;
767 + }
768 + updates.add(new SkuSellQuantity()
769 + .setId(skuSellQuantity.getId())
770 + .setTodaySellQuantity(todaySellQuantity));
771 + }
772 + if (!updates.isEmpty()) {
773 + builder.setIsAdded(skuSellQuantityService.updateBatchById(updates));
774 + }
775 + } catch (final Exception e) {
776 + log.error("addSkusSellQuantities error;", e);
777 + responseStreamObserver.onError(Status.INTERNAL.withDescription(e.getMessage()).asException());
778 + return;
779 + }
780 + responseStreamObserver.onNext(builder.build());
781 + responseStreamObserver.onCompleted();
782 + }
783 +
644 } 784 }
......
1 +package com.tianting.infoloop.service.impl;
2 +
3 +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
4 +import com.tianting.infoloop.mapper.SkuSellQuantityMapper;
5 +import com.tianting.infoloop.model.db.SkuSellQuantity;
6 +import com.tianting.infoloop.service.SkuSellQuantityService;
7 +import org.springframework.stereotype.Service;
8 +
9 +/**
10 +* @author zhuyf
11 +* @description 针对表【sku_sell_quantities(sku售卖量)】的数据库操作Service实现
12 +* @createDate 2025-02-28 14:03:59
13 +*/
14 +@Service
15 +public class SkuSellQuantityServiceImpl extends ServiceImpl<SkuSellQuantityMapper, SkuSellQuantity> implements SkuSellQuantityService {
16 +
17 +}
...@@ -33,6 +33,14 @@ service ClientCustomerOrderServiceRpc { ...@@ -33,6 +33,14 @@ service ClientCustomerOrderServiceRpc {
33 // 操作记录 33 // 操作记录
34 rpc GetOrderOperationRecordsByOrderId (GetOrderOperationRecordsByOrderIdRequest) returns (GetOrderOperationRecordsByOrderIdResponse) {} 34 rpc GetOrderOperationRecordsByOrderId (GetOrderOperationRecordsByOrderIdRequest) returns (GetOrderOperationRecordsByOrderIdResponse) {}
35 rpc BatchCreateOrderOperationRecords (BatchCreateOrderOperationRecordsRequest) returns (BatchCreateOrderOperationRecordsResponse) {} 35 rpc BatchCreateOrderOperationRecords (BatchCreateOrderOperationRecordsRequest) returns (BatchCreateOrderOperationRecordsResponse) {}
36 +
37 +
38 + // sku菜品库存
39 + rpc QuerySkuSellQuantitiesByStall(QuerySkuSellQuantitiesByStallRpcRequest) returns (QuerySkuSellQuantitiesByStallRpcResponse) {}
40 + rpc QuerySkuSellQuantitiesByStallAndSkuIds(QuerySkuSellQuantitiesByStallAndSkuIdsRpcRequest) returns (QuerySkuSellQuantitiesByStallAndSkuIdsRpcResponse) {}
41 + rpc BatchSaveSkuSellQuantities(BatchSaveSkuSellQuantitiesRpcRequest) returns (BatchSaveSkuSellQuantitiesRpcResponse) {}
42 + rpc AddSkusSellQuantities(AddSkusSellQuantitiesRpcRequest) returns (AddSkusSellQuantitiesRpcResponse) {}
43 +
36 } 44 }
37 45
38 enum OrderStatusEnum { 46 enum OrderStatusEnum {
...@@ -608,3 +616,71 @@ message BatchCreateOrderOperationRecordsResponse { ...@@ -608,3 +616,71 @@ message BatchCreateOrderOperationRecordsResponse {
608 bool isCreated = 1; 616 bool isCreated = 1;
609 repeated int32 ids = 2; 617 repeated int32 ids = 2;
610 } 618 }
619 +
620 +message SingleSkuSellQuantityRpcResponse {
621 + int32 id = 1;
622 + int32 enterpriseId = 2;
623 + int32 stallId = 3;
624 + int32 skuId = 4;
625 + int32 maxSellQuantity = 5;
626 + int32 todaySellQuantity = 6;
627 + int32 createdBy = 7;
628 + int64 createdAt = 8;
629 + int32 creationSource = 9;
630 + int32 updatedBy = 10;
631 + int64 updatedAt = 11;
632 + int32 updateSource = 12;
633 + bool isDeleted = 13;
634 +}
635 +
636 +message QuerySkuSellQuantitiesByStallRpcRequest {
637 + int32 enterpriseId = 1;
638 + int32 stallId = 2;
639 +}
640 +
641 +message QuerySkuSellQuantitiesByStallRpcResponse {
642 + repeated SingleSkuSellQuantityRpcResponse responses = 1;
643 +}
644 +
645 +message QuerySkuSellQuantitiesByStallAndSkuIdsRpcRequest {
646 + int32 enterpriseId = 1;
647 + int32 stallId = 2;
648 + repeated int32 skuIds = 3;
649 +}
650 +
651 +message QuerySkuSellQuantitiesByStallAndSkuIdsRpcResponse {
652 + repeated SingleSkuSellQuantityRpcResponse responses = 1;
653 +}
654 +
655 +message BatchSaveSkuSellQuantitiesRpcRequest {
656 + repeated SkuSellQuantityModification skuSellQuantityModifications = 1;
657 + int32 enterpriseId = 2;
658 + int32 updatedBy = 3;
659 + int32 updateSource = 4;
660 +}
661 +
662 +message SkuSellQuantityModification {
663 + int32 id = 1;
664 + int32 stallId = 2;
665 + int32 skuId = 3;
666 + int32 maxSellQuantity = 4;
667 +}
668 +
669 +message BatchSaveSkuSellQuantitiesRpcResponse {
670 + bool isSaved = 1;
671 +}
672 +
673 +message AddSkusSellQuantitiesRpcRequest {
674 + int32 enterpriseId = 1;
675 + int32 stallId = 2;
676 + repeated SkuSellQuantity skuSellQuantities = 3;
677 +}
678 +
679 +message SkuSellQuantity {
680 + int32 skuId = 1;
681 + int32 quantity = 2;
682 +}
683 +
684 +message AddSkusSellQuantitiesRpcResponse {
685 + bool isAdded = 1;
686 +}
......
1 +<?xml version="1.0" encoding="UTF-8"?>
2 +<!DOCTYPE mapper
3 + PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
4 + "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
5 +<mapper namespace="com.tianting.infoloop.mapper.SkuSellQuantityMapper">
6 +
7 + <resultMap id="BaseResultMap" type="com.tianting.infoloop.model.db.SkuSellQuantity">
8 + <id property="id" column="id" jdbcType="INTEGER"/>
9 + <result property="enterpriseId" column="enterpriseId" jdbcType="INTEGER"/>
10 + <result property="stallId" column="stallId" jdbcType="INTEGER"/>
11 + <result property="skuId" column="skuId" jdbcType="INTEGER"/>
12 + <result property="maxSellQuantity" column="maxSellQuantity" jdbcType="INTEGER"/>
13 + <result property="todaySellQuantity" column="todaySellQuantity" jdbcType="INTEGER"/>
14 + <result property="createdBy" column="createdBy" jdbcType="INTEGER"/>
15 + <result property="createdAt" column="createdAt" jdbcType="TIMESTAMP"/>
16 + <result property="creationSource" column="creationSource" jdbcType="INTEGER"/>
17 + <result property="updatedBy" column="updatedBy" jdbcType="INTEGER"/>
18 + <result property="updatedAt" column="updatedAt" jdbcType="TIMESTAMP"/>
19 + <result property="updateSource" column="updateSource" jdbcType="INTEGER"/>
20 + <result property="isDeleted" column="isDeleted" jdbcType="TINYINT"/>
21 + </resultMap>
22 +
23 + <sql id="Base_Column_List">
24 + id,enterpriseId,stallId,
25 + skuId,maxSellQuantity,todaySellQuantity,
26 + createdBy,createdAt,creationSource,
27 + updatedBy,updatedAt,updateSource,
28 + isDeleted
29 + </sql>
30 +</mapper>