jiujian / client-customer-order-service

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

feat(ClientCustomerOrderService): 添加 SKU 菜品库存相关 RPC接口

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