Skip to content

GitLab

Commit 7abfefba authored by shengnan hu's avatar shengnan hu
Browse files

init

parents
Pipeline #281 passed with stage
in 1 minute and 55 seconds
Hide whitespace changes
Inline Side-by-side
Showing with 1739 additions and 0 deletions
mall4cloud-order/pom.xml 0 → 100644
View file @ 7abfefba
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>mall4cloud</artifactId>
<groupId>com.mall4j.cloud</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>mall4cloud-order</artifactId>
<description>mall4cloud 订单服务</description>
<packaging>jar</packaging>
<dependencies>
<!--注册中心客户端-->
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-starter-loadbalancer</artifactId>
</dependency>
<dependency>
<groupId>com.alibaba.cloud</groupId>
<artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
</dependency>
<dependency>
<groupId>com.mall4j.cloud</groupId>
<artifactId>mall4cloud-common-database</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.mall4j.cloud</groupId>
<artifactId>mall4cloud-common-rocketmq</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.mall4j.cloud</groupId>
<artifactId>mall4cloud-common-security</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.mall4j.cloud</groupId>
<artifactId>mall4cloud-api-user</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.mall4j.cloud</groupId>
<artifactId>mall4cloud-api-product</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.mall4j.cloud</groupId>
<artifactId>mall4cloud-api-multishop</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.mall4j.cloud</groupId>
<artifactId>mall4cloud-api-platform</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.mall4j.cloud</groupId>
<artifactId>mall4cloud-api-order</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>com.mall4j.cloud</groupId>
<artifactId>mall4cloud-api-search</artifactId>
<version>${project.version}</version>
</dependency>
<dependency>
<groupId>org.springframework.cloud</groupId>
<artifactId>spring-cloud-commons</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
mall4cloud-order/src/main/java/com/mall4j/cloud/order/OrderApplication.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;
/**
* @author FrozenWatermelon
* @date 2020/11/19
*/
@SpringBootApplication(scanBasePackages = { "com.mall4j.cloud" })
@EnableFeignClients(basePackages = {"com.mall4j.cloud.api.**.feign"})
public class OrderApplication {
public static void main(String[] args) {
SpringApplication.run(OrderApplication.class, args);
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/bo/SubmitOrderPayAmountInfoBO.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.bo;
import io.swagger.v3.oas.annotations.media.Schema;
import java.util.Date;
/**
* @author FrozenWatermelon
* @date 2021/2/4
*/
public class SubmitOrderPayAmountInfoBO {
@Schema(description = "创建时间" )
private Date createTime;
@Schema(description = "总共需要支付金额" )
private Long totalFee;
@Schema(description = "订单地址id" )
private Long orderAddrId;
public Long getTotalFee() {
return totalFee;
}
public void setTotalFee(Long totalFee) {
this.totalFee = totalFee;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Long getOrderAddrId() {
return orderAddrId;
}
public void setOrderAddrId(Long orderAddrId) {
this.orderAddrId = orderAddrId;
}
@Override
public String toString() {
return "SubmitOrderPayAmountInfoBO{" +
"createTime=" + createTime +
", totalFee=" + totalFee +
", orderAddrId=" + orderAddrId +
'}';
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/config/OrderCacheTtlAdapter.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.config;
import com.mall4j.cloud.common.cache.adapter.CacheTtlAdapter;
import com.mall4j.cloud.common.cache.bo.CacheNameWithTtlBO;
import com.mall4j.cloud.common.cache.constant.OrderCacheNames;
import org.springframework.stereotype.Component;
import java.util.ArrayList;
import java.util.List;
/**
* @author FrozenWatermelon
* @date 2020/12/18
*/
@Component
public class OrderCacheTtlAdapter implements CacheTtlAdapter {
@Override
public List<CacheNameWithTtlBO> listCacheNameWithTtl() {
List<CacheNameWithTtlBO> cacheNameWithTtls = new ArrayList<>();
// 确认订单缓存30分钟
cacheNameWithTtls.add(new CacheNameWithTtlBO(OrderCacheNames.ORDER_CONFIRM_UUID_KEY, 60 * 30));
cacheNameWithTtls.add(new CacheNameWithTtlBO(OrderCacheNames.ORDER_CONFIRM_KEY, 60 * 30));
return cacheNameWithTtls;
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/config/RocketMqConfig.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.config;
import com.mall4j.cloud.common.rocketmq.config.RocketMqAdapter;
import com.mall4j.cloud.common.rocketmq.config.RocketMqConstant;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;
/**
* @author FrozenWatermelon
* @date 2021/3/30
*/
@RefreshScope
@Configuration
public class RocketMqConfig {
@Autowired
private RocketMqAdapter rocketMqAdapter;
@Lazy
@Bean(destroyMethod = "destroy")
public RocketMQTemplate stockMqTemplate() {
return rocketMqAdapter.getTemplateByTopicName(RocketMqConstant.STOCK_UNLOCK_TOPIC);
}
@Lazy
@Bean(destroyMethod = "destroy")
public RocketMQTemplate orderCancelTemplate() {
return rocketMqAdapter.getTemplateByTopicName(RocketMqConstant.ORDER_CANCEL_TOPIC);
}
@Lazy
@Bean(destroyMethod = "destroy")
public RocketMQTemplate orderNotifyStockTemplate() {
return rocketMqAdapter.getTemplateByTopicName(RocketMqConstant.ORDER_NOTIFY_STOCK_TOPIC);
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/controller/app/MyOrderController.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.controller.app;
import com.mall4j.cloud.api.feign.SearchOrderFeignClient;
import com.mall4j.cloud.api.order.constant.OrderStatus;
import com.mall4j.cloud.api.vo.EsPageVO;
import com.mall4j.cloud.api.vo.search.EsOrderVO;
import com.mall4j.cloud.common.dto.OrderSearchDTO;
import com.mall4j.cloud.common.response.ResponseEnum;
import com.mall4j.cloud.common.response.ServerResponseEntity;
import com.mall4j.cloud.common.security.AuthUserContext;
import com.mall4j.cloud.order.model.Order;
import com.mall4j.cloud.order.model.OrderAddr;
import com.mall4j.cloud.order.model.OrderItem;
import com.mall4j.cloud.order.service.*;
import com.mall4j.cloud.order.service.OrderAddrService;
import com.mall4j.cloud.order.service.OrderItemService;
import com.mall4j.cloud.order.service.OrderService;
import com.mall4j.cloud.order.vo.OrderAddrVO;
import com.mall4j.cloud.order.vo.OrderCountVO;
import com.mall4j.cloud.order.vo.OrderItemVO;
import com.mall4j.cloud.order.vo.OrderShopVO;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import com.mall4j.cloud.common.util.BeanUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
/**
* 我的订单
*
* @author FrozenWatermelon
*/
@RestController
@RequestMapping("/p/myOrder")
@Tag(name = "app-我的订单接口")
public class MyOrderController {
@Autowired
private OrderService orderService;
@Autowired
private OrderItemService orderItemService;
@Autowired
private SearchOrderFeignClient searchOrderFeignClient;
@Autowired
private OrderAddrService orderAddrService;
/**
* 订单详情信息接口
*/
@GetMapping("/order_detail")
@Operation(summary = "订单详情信息" , description = "根据订单号获取订单详情信息")
@Parameter(name = "orderId", description = "订单号" , required = true)
public ServerResponseEntity<OrderShopVO> orderDetail(@RequestParam(value = "orderId") Long orderId) {
Long userId = AuthUserContext.get().getUserId();
OrderShopVO orderShopDto = new OrderShopVO();
Order order = orderService.getOrderByOrderIdAndUserId(orderId, userId);
OrderAddr orderAddr = orderAddrService.getByOrderAddrId(order.getOrderAddrId());
List<OrderItem> orderItems = orderItemService.listOrderItemsByOrderId(orderId);
orderShopDto.setShopId(order.getShopId());
orderShopDto.setDeliveryType(order.getDeliveryType());
orderShopDto.setShopName(order.getShopName());
orderShopDto.setCreateTime(order.getCreateTime());
orderShopDto.setStatus(order.getStatus());
orderShopDto.setOrderAddr(BeanUtil.map(orderAddr, OrderAddrVO.class));
// 付款时间
orderShopDto.setPayTime(order.getPayTime());
// 发货时间
orderShopDto.setDeliveryTime(order.getDeliveryTime());
// 完成时间
orderShopDto.setFinallyTime(order.getFinallyTime());
// 取消时间
orderShopDto.setCancelTime(order.getCancelTime());
// 更新时间
orderShopDto.setUpdateTime(order.getUpdateTime());
orderShopDto.setOrderItems(BeanUtil.mapAsList(orderItems, OrderItemVO.class));
orderShopDto.setTotal(order.getTotal());
orderShopDto.setTotalNum(order.getAllCount());
return ServerResponseEntity.success(orderShopDto);
}
@GetMapping("/order_count")
@Operation(summary = "计算各个订单数量" , description = "根据订单状态计算各个订单数量")
public ServerResponseEntity<OrderCountVO> orderCount() {
Long userId = AuthUserContext.get().getUserId();
OrderCountVO orderCount = orderService.countNumberOfStatus(userId);
return ServerResponseEntity.success(orderCount);
}
/**
* 分页获取
*/
@GetMapping("/search_order")
@Operation(summary = "订单列表信息查询" , description = "根据订单编号或者订单中商品名称搜索")
public ServerResponseEntity<EsPageVO<EsOrderVO>> searchOrder(OrderSearchDTO orderSearchDTO) {
Long userId = AuthUserContext.get().getUserId();
orderSearchDTO.setUserId(userId);
return searchOrderFeignClient.getOrderPage(orderSearchDTO);
}
/**
* 取消订单
*/
@PutMapping("/cancel/{orderId}")
@Operation(summary = "根据订单号取消订单" , description = "根据订单号取消订单")
@Parameter(name = "orderId", description = "订单号" , required = true)
public ServerResponseEntity<String> cancel(@PathVariable("orderId") Long orderId) {
Long userId = AuthUserContext.get().getUserId();
Order order = orderService.getOrderByOrderIdAndUserId(orderId, userId);
if (!Objects.equals(order.getStatus(), OrderStatus.UNPAY.value())) {
// 订单已支付，无法取消订单
return ServerResponseEntity.fail(ResponseEnum.ORDER_PAYED);
}
// 如果订单未支付的话，将订单设为取消状态
orderService.cancelOrderAndGetCancelOrderIds(Collections.singletonList(order.getOrderId()));
return ServerResponseEntity.success();
}
/**
* 确认收货
*/
@PutMapping("/receipt/{orderId}")
@Operation(summary = "根据订单号确认收货" , description = "根据订单号确认收货")
public ServerResponseEntity<String> receipt(@PathVariable("orderId") Long orderId) {
Long userId = AuthUserContext.get().getUserId();
Order order = orderService.getOrderByOrderIdAndUserId(orderId, userId);
if (!Objects.equals(order.getStatus(), OrderStatus.CONSIGNMENT.value())) {
// 订单未发货，无法确认收货
return ServerResponseEntity.fail(ResponseEnum.ORDER_NO_DELIVERY);
}
List<OrderItem> orderItems = orderItemService.listOrderItemsByOrderId(orderId);
order.setOrderItems(orderItems);
// 确认收货
orderService.receiptOrder(order.getOrderId());
return ServerResponseEntity.success();
}
/**
* 删除订单
*/
@DeleteMapping("/{orderId}")
@Operation(summary = "根据订单号删除订单" , description = "根据订单号删除订单")
@Parameter(name = "orderId", description = "订单号" , required = true)
public ServerResponseEntity<String> delete(@PathVariable("orderId") Long orderId) {
Long userId = AuthUserContext.get().getUserId();
Order order = orderService.getOrderByOrderIdAndUserId(orderId, userId);
if (!Objects.equals(order.getStatus(), OrderStatus.SUCCESS.value()) && !Objects.equals(order.getStatus(), OrderStatus.CLOSE.value()) ) {
// 订单未完成或未关闭，无法删除订单
return ServerResponseEntity.fail(ResponseEnum.ORDER_NOT_FINISH_OR_CLOSE);
}
// 删除订单
orderService.deleteOrder(order.getOrderId());
return ServerResponseEntity.success();
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/controller/app/OrderController.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.controller.app;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import com.mall4j.cloud.api.product.manager.ShopCartAdapter;
import com.mall4j.cloud.api.user.feign.UserAddrFeignClient;
import com.mall4j.cloud.common.cache.constant.CacheNames;
import com.mall4j.cloud.common.cache.constant.OrderCacheNames;
import com.mall4j.cloud.common.cache.util.CacheManagerUtil;
import com.mall4j.cloud.common.cache.util.RedisUtil;
import com.mall4j.cloud.common.constant.Constant;
import com.mall4j.cloud.common.order.vo.*;
import com.mall4j.cloud.common.response.ResponseEnum;
import com.mall4j.cloud.common.response.ServerResponseEntity;
import com.mall4j.cloud.common.security.AuthUserContext;
import com.mall4j.cloud.order.bo.SubmitOrderPayAmountInfoBO;
import com.mall4j.cloud.order.dto.app.OrderDTO;
import com.mall4j.cloud.order.model.OrderAddr;
import com.mall4j.cloud.order.service.OrderAddrService;
import com.mall4j.cloud.order.service.OrderItemService;
import com.mall4j.cloud.order.service.OrderService;
import com.mall4j.cloud.order.vo.SubmitOrderPayInfoVO;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.Operation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.web.bind.annotation.*;
import jakarta.validation.Valid;
import java.util.*;
/**
* 订单信息
*
* @author FrozenWatermelon
* @date 2020-12-05 14:13:50
*/
@RestController("appOrderController")
@RequestMapping("/a/order")
@Tag(name = "app-订单信息")
public class OrderController {
@Autowired
private OrderService orderService;
@Autowired
private ShopCartAdapter shopCartAdapter;
@Autowired
private CacheManagerUtil cacheManagerUtil;
@Autowired
private OrderItemService orderItemService;
@Autowired
private OrderAddrService orderAddrService;
@Autowired
private UserAddrFeignClient userAddrFeignClient;
/**
* 生成订单
*/
@PostMapping("/confirm")
@Operation(summary = "结算，生成订单信息" , description = "传入下单所需要的参数进行下单")
public ServerResponseEntity<ShopCartOrderMergerVO> confirm(@Valid @RequestBody OrderDTO orderParam){
Long userId = AuthUserContext.get().getUserId();
// 将要返回给前端的完整的订单信息
ShopCartOrderMergerVO shopCartOrderMerger = new ShopCartOrderMergerVO();
shopCartOrderMerger.setDvyType(orderParam.getDvyType());
ServerResponseEntity<UserAddrVO> addrFeign = userAddrFeignClient.getUserAddrByAddrId(orderParam.getAddrId());
if (addrFeign.isSuccess()){
shopCartOrderMerger.setUserAddr(addrFeign.getData());
}
ServerResponseEntity<List<ShopCartItemVO>> shopCartItemResponse = shopCartAdapter.getShopCartItems(orderParam.getShopCartItem());
if (!shopCartItemResponse.isSuccess()) {
return ServerResponseEntity.transform(shopCartItemResponse);
}
List<ShopCartItemVO> shopCartItems = shopCartItemResponse.getData();
// 购物车
List<ShopCartVO> shopCarts = shopCartAdapter.conversionShopCart(shopCartItems);
// 重算一遍订单金额
recalculateAmountWhenFinishingCalculateShop(shopCartOrderMerger, shopCarts);
// 防止重复提交
RedisUtil.STRING_REDIS_TEMPLATE.opsForValue().set(OrderCacheNames.ORDER_CONFIRM_UUID_KEY + CacheNames.UNION + userId, String.valueOf(userId));
// 保存订单计算结果缓存，省得重新计算并且用户确认的订单金额与提交的一致
cacheManagerUtil.putCache(OrderCacheNames.ORDER_CONFIRM_KEY,String.valueOf(userId),shopCartOrderMerger);
return ServerResponseEntity.success(shopCartOrderMerger);
}
/**
* 这里有提交订单的代码
* 购物车/立即购买 提交订单,根据店铺拆单
*/
@PostMapping("/submit")
@Operation(summary = "提交订单，返回支付流水号" , description = "根据传入的参数判断是否为购物车提交订单，同时对购物车进行删除，用户开始进行支付")
public ServerResponseEntity<List<Long>> submitOrders() {
Long userId = AuthUserContext.get().getUserId();
ShopCartOrderMergerVO mergerOrder = cacheManagerUtil.getCache(OrderCacheNames.ORDER_CONFIRM_KEY, String.valueOf(userId));
// 看看订单有没有过期
if (mergerOrder == null) {
return ServerResponseEntity.fail(ResponseEnum.ORDER_EXPIRED);
}
// 防止重复提交
boolean cad = RedisUtil.cad(OrderCacheNames.ORDER_CONFIRM_UUID_KEY + CacheNames.UNION + userId, String.valueOf(userId));
if (!cad) {
return ServerResponseEntity.fail(ResponseEnum.REPEAT_ORDER);
}
List<Long> orderIds = orderService.submit(userId,mergerOrder);
return ServerResponseEntity.success(orderIds);
}
@GetMapping("/order_pay_info")
@Operation(summary = "获取订单支付信息" , description = "获取订单支付的商品/地址信息")
@Parameter(name = "orderIds", description = "订单流水号" , required = true)
public ServerResponseEntity<SubmitOrderPayInfoVO> getOrderPayInfoByOrderNumber(@RequestParam("orderIds") String orderIds) {
long[] orderIdList = StrUtil.splitToLong(orderIds, ",");
List<String> spuNameList = orderItemService.getSpuNameListByOrderIds(orderIdList);
//获取订单信息
SubmitOrderPayAmountInfoBO submitOrderPayAmountInfo = orderService.getSubmitOrderPayAmountInfo(orderIdList);
if (Objects.isNull(submitOrderPayAmountInfo) || Objects.isNull(submitOrderPayAmountInfo.getCreateTime()) ) {
return ServerResponseEntity.fail(ResponseEnum.ORDER_NOT_EXIST);
}
Date endTime = DateUtil.offsetMinute(submitOrderPayAmountInfo.getCreateTime(), Constant.ORDER_CANCEL_TIME);
SubmitOrderPayInfoVO orderPayInfoParam = new SubmitOrderPayInfoVO();
orderPayInfoParam.setSpuNameList(spuNameList);
orderPayInfoParam.setEndTime(endTime);
orderPayInfoParam.setTotalFee(submitOrderPayAmountInfo.getTotalFee());
// 地址
if (Objects.nonNull(submitOrderPayAmountInfo.getOrderAddrId())) {
OrderAddr orderAddr = orderAddrService.getByOrderAddrId(submitOrderPayAmountInfo.getOrderAddrId());
//写入商品名、收货地址/电话
String addr = orderAddr.getProvince() + orderAddr.getCity() + orderAddr.getArea() + orderAddr.getAddr();
orderPayInfoParam.setUserAddr(addr);
orderPayInfoParam.setConsignee(orderAddr.getConsignee());
orderPayInfoParam.setMobile(orderAddr.getMobile());
}
return ServerResponseEntity.success(orderPayInfoParam);
}
/**
* 重算一遍订单金额
*/
private void recalculateAmountWhenFinishingCalculateShop(ShopCartOrderMergerVO shopCartOrderMerger, List<ShopCartVO> shopCarts) {
// 所有店铺的订单信息
List<ShopCartOrderVO> shopCartOrders = new ArrayList<>();
long total = 0;
int totalCount = 0;
// 所有店铺所有的商品item
for (ShopCartVO shopCart : shopCarts) {
// 每个店铺的订单信息
ShopCartOrderVO shopCartOrder = new ShopCartOrderVO();
shopCartOrder.setShopId(shopCart.getShopId());
shopCartOrder.setShopName(shopCart.getShopName());
total += shopCart.getTotal();
totalCount += shopCart.getTotalCount();
shopCartOrder.setTotal(shopCart.getTotal());
shopCartOrder.setTotalCount(shopCart.getTotalCount());
shopCartOrder.setShopCartItemVO(shopCart.getshopCartItem());
shopCartOrders.add(shopCartOrder);
}
shopCartOrderMerger.setTotal(total);
shopCartOrderMerger.setTotalCount(totalCount);
shopCartOrderMerger.setShopCartOrders(shopCartOrders);
}
public static void main(String[] args) {
System.out.println(new BCryptPasswordEncoder().encode("123456"));
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/controller/multishop/OrderController.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.controller.multishop;
import com.mall4j.cloud.api.feign.SearchOrderFeignClient;
import com.mall4j.cloud.api.order.constant.OrderStatus;
import com.mall4j.cloud.api.order.dto.DeliveryOrderDTO;
import com.mall4j.cloud.api.vo.EsPageVO;
import com.mall4j.cloud.api.vo.search.EsOrderVO;
import com.mall4j.cloud.common.dto.OrderSearchDTO;
import com.mall4j.cloud.common.response.ResponseEnum;
import com.mall4j.cloud.common.response.ServerResponseEntity;
import com.mall4j.cloud.common.security.AuthUserContext;
import com.mall4j.cloud.order.model.Order;
import com.mall4j.cloud.order.model.OrderAddr;
import com.mall4j.cloud.order.service.OrderAddrService;
import com.mall4j.cloud.order.service.OrderService;
import com.mall4j.cloud.order.vo.OrderAddrVO;
import com.mall4j.cloud.order.vo.OrderVO;
import io.swagger.v3.oas.annotations.tags.Tag;
import io.swagger.v3.oas.annotations.Operation;
import com.mall4j.cloud.common.util.BeanUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import jakarta.validation.Valid;
import java.util.Objects;
/**
* @author FrozenWatermelon on 2018/09/15.
*/
@RestController("multishopOrderController")
@Controller
@RequestMapping("/m/order")
@Tag(name = "multishop-订单接口")
public class OrderController {
@Autowired
private OrderService orderService;
@Autowired
private SearchOrderFeignClient searchOrderFeignClient;
@Autowired
private OrderAddrService orderAddrService;
/**
* 分页获取
*/
@GetMapping("/page")
@Operation(summary = "分页获取订单详情")
public ServerResponseEntity<EsPageVO<EsOrderVO>> page(OrderSearchDTO orderSearchDTO) {
Long shopId = AuthUserContext.get().getTenantId();
orderSearchDTO.setShopId(shopId);
return searchOrderFeignClient.getOrderPage(orderSearchDTO);
}
/**
* 获取信息
*/
@GetMapping("/order_info/{orderId}")
@Operation(summary = "根据id获取订单详情")
public ServerResponseEntity<OrderVO> info(@PathVariable("orderId") Long orderId) {
// 订单和订单项
Order order = orderService.getOrderAndOrderItemData(orderId, AuthUserContext.get().getTenantId());
// 详情用户收货地址
OrderAddr orderAddr = orderAddrService.getByOrderAddrId(order.getOrderAddrId());
order.setOrderAddr(BeanUtil.map(orderAddr, OrderAddr.class));
OrderVO orderVO = BeanUtil.map(order, OrderVO.class);
return ServerResponseEntity.success(orderVO);
}
/**
* 获取订单用户下单地址
*/
@GetMapping("/order_addr/{orderAddrId}")
@Operation(summary = "获取订单用户下单地址")
public ServerResponseEntity<OrderAddrVO> getOrderAddr(@PathVariable("orderAddrId") Long orderAddrId) {
OrderAddr orderAddr = orderAddrService.getByOrderAddrId(orderAddrId);
return ServerResponseEntity.success(BeanUtil.map(orderAddr, OrderAddrVO.class));
}
/**
* 订单项待发货数量查询
*/
@GetMapping("/order_item_and_address/{orderId}")
@Operation(summary = "订单项待发货数量查询")
public ServerResponseEntity<OrderVO> getOrderItemAndAddress(@PathVariable("orderId") Long orderId) {
// 订单和订单项
Order order = orderService.getOrderAndOrderItemData(orderId, AuthUserContext.get().getTenantId());
OrderVO orderVO = BeanUtil.map(order, OrderVO.class);
// 用户收货地址
OrderAddr orderAddr = orderAddrService.getByOrderAddrId(order.getOrderAddrId());
orderVO.setOrderAddr(BeanUtil.map(orderAddr, OrderAddrVO.class));
return ServerResponseEntity.success(orderVO);
}
/**
* 发货
*/
@PostMapping("/delivery")
@Operation(summary = "发货")
public ServerResponseEntity<Void> delivery(@Valid @RequestBody DeliveryOrderDTO deliveryOrderParam) {
OrderVO order = orderService.getOrderByOrderId(deliveryOrderParam.getOrderId());
// 订单不在支付状态
if (!Objects.equals(order.getStatus(), OrderStatus.PADYED.value())){
return ServerResponseEntity.fail(ResponseEnum.ORDER_NOT_PAYED);
}
orderService.delivery(deliveryOrderParam);
return ServerResponseEntity.success();
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/dto/app/OrderDTO.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.dto.app;
import com.mall4j.cloud.api.product.dto.ShopCartItemDTO;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
/**
* 订单参数
*
* @author FrozenWatermelon
* @date 2020-12-04 11:27:35
*/
public class OrderDTO {
@Schema(description = "立即购买时提交的商品项,如果该值为空，则说明是从购物车进入，如果该值不为空则说明为立即购买" )
private ShopCartItemDTO shopCartItem;
@NotNull(message = "配送类型不能为空")
@Schema(description = "配送类型3：无需快递" )
private Integer dvyType;
@Schema(description = "地址ID，0为默认地址" )
@NotNull(message = "地址不能为空")
private Long addrId;
public Integer getDvyType() {
return dvyType;
}
public void setDvyType(Integer dvyType) {
this.dvyType = dvyType;
}
public ShopCartItemDTO getShopCartItem() {
return shopCartItem;
}
public void setShopCartItem(ShopCartItemDTO shopCartItem) {
this.shopCartItem = shopCartItem;
}
public Long getAddrId() {
return addrId;
}
public void setAddrId(Long addrId) {
this.addrId = addrId;
}
@Override
public String toString() {
return "OrderDTO{" +
"shopCartItem=" + shopCartItem +
", dvyType=" + dvyType +
", addrId=" + addrId +
'}';
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/dto/multishop/OrderAdminDTO.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.dto.multishop;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull;
/**
* 订单参数
*
* @author FrozenWatermelon
* @date 2020-12-04 11:27:35
*/
public class OrderAdminDTO {
@Schema(description = "订单id" )
private Long orderId;
@Schema(description = "店铺id" )
private Long shopId;
@NotNull(message = "配送类型不能为空")
@Schema(description = "配送类型 3：无需快递" )
private Integer dvyType;
public Long getOrderId() {
return orderId;
}
public void setOrderId(Long orderId) {
this.orderId = orderId;
}
public Integer getDvyType() {
return dvyType;
}
public void setDvyType(Integer dvyType) {
this.dvyType = dvyType;
}
public Long getShopId() {
return shopId;
}
public void setShopId(Long shopId) {
this.shopId = shopId;
}
@Override
public String toString() {
return "OrderDTO{" +
", orderId=" + orderId +
", shopId=" + shopId +
", dvyType=" + dvyType +
'}';
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/dto/multishop/OrderItemDTO.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.dto.multishop;
import com.mall4j.cloud.common.vo.BaseVO;
import io.swagger.v3.oas.annotations.media.Schema;
/**
* 订单项VO
*
* @author FrozenWatermelon
* @date 2020-12-04 11:27:35
*/
public class OrderItemDTO extends BaseVO{
private static final long serialVersionUID = 1L;
@Schema(description = "订单项ID" )
private Long orderItemId;
@Schema(description = "变化金额" , requiredMode = Schema.RequiredMode.REQUIRED)
private Long changeAmount;
public Long getOrderItemId() {
return orderItemId;
}
public void setOrderItemId(Long orderItemId) {
this.orderItemId = orderItemId;
}
public Long getChangeAmount() {
return changeAmount;
}
public void setChangeAmount(Long changeAmount) {
this.changeAmount = changeAmount;
}
@Override
public String toString() {
return "OrderItemDTO{" +
"orderItemId=" + orderItemId +
", changeAmount=" + changeAmount +
'}';
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/feign/OrderFeignController.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.feign;
import cn.hutool.core.collection.CollectionUtil;
import com.mall4j.cloud.api.order.bo.EsOrderBO;
import com.mall4j.cloud.api.order.bo.OrderSimpleAmountInfoBO;
import com.mall4j.cloud.api.order.bo.OrderStatusBO;
import com.mall4j.cloud.api.order.constant.OrderStatus;
import com.mall4j.cloud.api.order.feign.OrderFeignClient;
import com.mall4j.cloud.api.order.vo.OrderAmountVO;
import com.mall4j.cloud.common.response.ResponseEnum;
import com.mall4j.cloud.common.response.ServerResponseEntity;
import com.mall4j.cloud.order.service.OrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.Objects;
/**
* @author FrozenWatermelon
* @date 2020/12/25
*/
@RestController
public class OrderFeignController implements OrderFeignClient {
@Autowired
private OrderService orderService;
@Override
public ServerResponseEntity<OrderAmountVO> getOrdersAmountAndIfNoCancel(List<Long> orderIds) {
List<OrderStatusBO> orderStatus = orderService.getOrdersStatus(orderIds);
if (CollectionUtil.isEmpty(orderStatus)) {
return ServerResponseEntity.fail(ResponseEnum.ORDER_NOT_EXIST);
}
for (OrderStatusBO statusBO : orderStatus) {
// 订单已关闭
if (statusBO.getStatus() == null || Objects.equals(statusBO.getStatus(), OrderStatus.CLOSE.value())) {
return ServerResponseEntity.fail(ResponseEnum.ORDER_EXPIRED);
}
}
OrderAmountVO orderAmountVO = orderService.getOrdersActualAmount(orderIds);
return ServerResponseEntity.success(orderAmountVO);
}
@Override
public ServerResponseEntity<List<OrderStatusBO>> getOrdersStatus(List<Long> orderIds) {
List<OrderStatusBO> orderStatusList = orderService.getOrdersStatus(orderIds);
return ServerResponseEntity.success(orderStatusList);
}
@Override
public ServerResponseEntity<List<OrderSimpleAmountInfoBO>> getOrdersSimpleAmountInfo(List<Long> orderIds) {
return ServerResponseEntity.success(orderService.getOrdersSimpleAmountInfo(orderIds));
}
@Override
public ServerResponseEntity<EsOrderBO> getEsOrder(Long orderId) {
EsOrderBO esOrderBO = orderService.getEsOrder(orderId);
return ServerResponseEntity.success(esOrderBO);
}
@Override
public ServerResponseEntity<Void> updateOrderState(List<Long> orderIds) {
return null;
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/listener/OrderCancelConsumer.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.listener;
import com.mall4j.cloud.common.rocketmq.config.RocketMqConstant;
import com.mall4j.cloud.order.service.OrderService;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* @author FrozenWatermelon
*/
@Component
@RocketMQMessageListener(topic = RocketMqConstant.ORDER_CANCEL_TOPIC,consumerGroup = RocketMqConstant.ORDER_CANCEL_TOPIC)
public class OrderCancelConsumer implements RocketMQListener<List<Long>> {
@Autowired
private OrderService orderService;
/**
* 订单取消状态修改后再进行其他服务
*/
@Override
public void onMessage(List<Long> orderIds) {
// 如果订单未支付的话，将订单设为取消状态
orderService.cancelOrderAndGetCancelOrderIds(orderIds);
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/listener/OrderNotifyConsumer.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.listener;
import com.mall4j.cloud.common.exception.Mall4cloudException;
import com.mall4j.cloud.common.order.bo.PayNotifyBO;
import com.mall4j.cloud.common.response.ResponseEnum;
import com.mall4j.cloud.common.rocketmq.config.RocketMqConstant;
import com.mall4j.cloud.common.util.Json;
import com.mall4j.cloud.order.service.OrderService;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.spring.annotation.RocketMQMessageListener;
import org.apache.rocketmq.spring.core.RocketMQListener;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.support.GenericMessage;
import org.springframework.stereotype.Component;
import java.util.Objects;
/**
* @author FrozenWatermelon
* @date 2021/1/7
*/
@Component
@RocketMQMessageListener(topic = RocketMqConstant.ORDER_NOTIFY_TOPIC,consumerGroup = RocketMqConstant.ORDER_NOTIFY_TOPIC)
public class OrderNotifyConsumer implements RocketMQListener<PayNotifyBO> {
@Autowired
private OrderService orderService;
@Autowired
private RocketMQTemplate orderNotifyStockTemplate;
private static final Logger LOG = LoggerFactory.getLogger(OrderNotifyConsumer.class);
@Override
public void onMessage(PayNotifyBO message) {
LOG.info("订单回调开始... message: " + Json.toJsonString(message));
orderService.updateByToPaySuccess(message.getOrderIds());
// 发送消息，订单支付成功 通知库存扣减
SendStatus sendStockStatus = orderNotifyStockTemplate.syncSend(RocketMqConstant.ORDER_NOTIFY_STOCK_TOPIC, new GenericMessage<>(message)).getSendStatus();
if (!Objects.equals(sendStockStatus,SendStatus.SEND_OK)) {
throw new Mall4cloudException(ResponseEnum.EXCEPTION);
}
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/mapper/OrderAddrMapper.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.mapper;
import com.mall4j.cloud.order.model.OrderAddr;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 用户订单配送地址
*
* @author FrozenWatermelon
* @date 2020-12-05 14:13:50
*/
public interface OrderAddrMapper {
/**
* 获取用户订单配送地址列表
* @return 用户订单配送地址列表
*/
List<OrderAddr> list();
/**
* 根据用户订单配送地址id获取用户订单配送地址
*
* @param orderAddrId 用户订单配送地址id
* @return 用户订单配送地址
*/
OrderAddr getByOrderAddrId(@Param("orderAddrId") Long orderAddrId);
/**
* 保存用户订单配送地址
* @param orderAddr 用户订单配送地址
*/
void save(@Param("orderAddr") OrderAddr orderAddr);
/**
* 更新用户订单配送地址
* @param orderAddr 用户订单配送地址
*/
void update(@Param("orderAddr") OrderAddr orderAddr);
/**
* 根据用户订单配送地址id删除用户订单配送地址
* @param orderAddrId
*/
void deleteById(@Param("orderAddrId") Long orderAddrId);
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/mapper/OrderItemMapper.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.mapper;
import com.mall4j.cloud.order.model.OrderItem;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 订单项
*
* @author FrozenWatermelon
* @date 2020-12-04 11:27:35
*/
public interface OrderItemMapper {
/**
* 保存订单项
*
* @param orderItem 订单项
*/
void save(@Param("orderItem") OrderItem orderItem);
/**
* 更新订单项
*
* @param orderItem 订单项
*/
void update(@Param("orderItem") OrderItem orderItem);
/**
* 根据订单项id删除订单项
*
* @param orderItemId
*/
void deleteById(@Param("orderItemId") Long orderItemId);
/**
* 批量保存
*
* @param orderItems 订单项列表
*/
void saveBatch(@Param("orderItems") List<OrderItem> orderItems);
/**
* 根据订单号获取订单项
*
* @param orderId 订单id
* @return 订单项
*/
List<OrderItem> listOrderItemsByOrderId(@Param("orderId") Long orderId);
/**
* 根据订单id获取商品名称
*
* @param orderIdList 订单id
* @return 商品名称列表
*/
List<String> getSpuNameListByOrderIds(@Param("orderIdList") long[] orderIdList);
/**
* 根据订单id获取订单项数量
* @param orderId
* @return
*/
Integer countByOrderId(@Param("orderId") Long orderId);
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/mapper/OrderMapper.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.mapper;
import com.mall4j.cloud.api.order.bo.EsOrderBO;
import com.mall4j.cloud.api.order.bo.OrderSimpleAmountInfoBO;
import com.mall4j.cloud.api.order.bo.OrderStatusBO;
import com.mall4j.cloud.api.order.vo.OrderAmountVO;
import com.mall4j.cloud.order.bo.SubmitOrderPayAmountInfoBO;
import com.mall4j.cloud.order.model.Order;
import com.mall4j.cloud.order.vo.OrderCountVO;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 订单信息
*
* @author FrozenWatermelon
* @date 2020-12-05 14:13:50
*/
public interface OrderMapper {
/**
* 更新订单信息
*
* @param order 订单信息
*/
void update(@Param("order") Order order);
/**
* 根据订单信息id删除订单信息
*
* @param orderId
*/
void deleteById(@Param("orderId") Long orderId);
/**
* 批量保存订单数据
*
* @param orders
*/
void saveBatch(@Param("orders") List<Order> orders);
/**
* 查询订单状态
*
* @param orderIds 多个订单的订单id
* @return 订单状态列表
*/
List<OrderStatusBO> getOrdersStatus(@Param("orderIds") List<Long> orderIds);
/**
* 计算订单实际金额
*
* @param orderIds 多个订单的订单id
* @return 订单实际金额总和
*/
OrderAmountVO getOrdersActualAmount(@Param("orderIds") List<Long> orderIds);
/**
* 将订单改为已支付状态
*
* @param orderIds 订单ids
*/
void updateByToPaySuccess(@Param("orderIds") List<Long> orderIds);
/**
* 获取订单中的金额信息
*
* @param orderIds 多个订单的订单id
* @return 获取订单中的金额信息
*/
List<OrderSimpleAmountInfoBO> getOrdersSimpleAmountInfo(@Param("orderIds") List<Long> orderIds);
/**
* 取消订单
*
* @param orderIds 订单ids
*/
void cancelOrders(@Param("orderIds") List<Long> orderIds);
/**
* 根据订单号和用户id获取订单
*
* @param orderId orderId
* @param userId userId
* @return Order
*/
Order getOrderByOrderIdAndUserId(@Param("orderId") Long orderId, @Param("userId") Long userId);
/**
* 确认收货
* @param orderId
* @return
*/
int receiptOrder(@Param("orderId") Long orderId);
/**
* 根据订单号删除订单
*
* @param orderId 订单号
*/
void deleteOrder(@Param("orderId") Long orderId);
/**
* 根据订单号和店铺id获取订单
*
* @param orderId orderId
* @param shopId shopId
* @return Order
*/
Order getOrderByOrderIdAndShopId(@Param("orderId") Long orderId, @Param("shopId") Long shopId);
/**
* 获取订单和订单项的数据
*
* @param orderId
* @param shopId
* @return
*/
Order getOrderAndOrderItemData(@Param("orderId") Long orderId, @Param("shopId") Long shopId);
/**
* 根据订单id列表获取订单金额信息
*
* @param orderIdList 订单id列表
* @return
*/
SubmitOrderPayAmountInfoBO getSubmitOrderPayAmountInfo(@Param("orderIdList") long[] orderIdList);
/**
* 获取订单需要保存到es中的数据
*
* @param orderId 订单id
* @return
*/
EsOrderBO getEsOrder(@Param("orderId") Long orderId);
/**
* 计算每个订单状态的状态数量
*
* @param userId 用户id
* @return
*/
OrderCountVO countNumberOfStatus(@Param("userId") Long userId);
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/mapper/OrderPayInfoMapper.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.mapper;
import com.mall4j.cloud.order.model.OrderPayInfo;
import org.apache.ibatis.annotations.Param;
/**
* 订单支付记录
*
* @author FrozenWatermelon
* @date 2020-12-04 11:27:35
*/
public interface OrderPayInfoMapper {
/**
* 保存订单支付记录
* @param orderPayInfo 订单支付记录
*/
void save(@Param("orderPayInfo") OrderPayInfo orderPayInfo);
/**
* 更新订单支付记录
* @param orderPayInfo 订单支付记录
*/
void update(@Param("orderPayInfo") OrderPayInfo orderPayInfo);
/**
* 根据订单支付记录id删除订单支付记录
* @param payId
*/
void deleteById(@Param("payId") Long payId);
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/model/Order.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.model;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
import com.mall4j.cloud.common.model.BaseModel;
/**
* 订单信息
*
* @author FrozenWatermelon
* @date 2020-12-05 14:13:50
*/
public class Order extends BaseModel implements Serializable{
private static final long serialVersionUID = 1L;
public static final String DISTRIBUTED_ID_KEY = "mall4cloud-order";
/**
* 订单ID
*/
private Long orderId;
/**
* 店铺id
*/
private Long shopId;
/**
* 用户ID
*/
private Long userId;
/**
* 店铺名称
*/
private String shopName;
/**
* 总值
*/
private Long total;
/**
* 订单状态 1:待付款 2:待发货 3:待收货(已发货) 5:成功 6:失败
*/
private Integer status;
/**
* 配送类型 3：无需快递
*/
private Integer deliveryType;
/**
* 用户订单地址Id
*/
private Long orderAddrId;
/**
* 订单地址
*/
private OrderAddr orderAddr;
/**
* 订单关闭原因 1-超时未支付 4-买家取消 15-已通过货到付款交易
*/
private Integer closeType;
/**
* 订单商品总数
*/
private Integer allCount;
/**
* 付款时间
*/
private Date payTime;
/**
* 发货时间
*/
private Date deliveryTime;
/**
* 完成时间
*/
private Date finallyTime;
/**
* 取消时间
*/
private Date cancelTime;
/**
* 是否已支付，1.已支付0.未支付
*/
private Integer isPayed;
/**
* 用户订单删除状态，0：没有删除， 1：回收站， 2：永久删除
*/
private Integer deleteStatus;
/**
* 订单项
*/
private List<OrderItem> orderItems;
public Long getOrderAddrId() {
return orderAddrId;
}
public void setOrderAddrId(Long orderAddrId) {
this.orderAddrId = orderAddrId;
}
public Long getOrderId() {
return orderId;
}
public void setOrderId(Long orderId) {
this.orderId = orderId;
}
public Long getShopId() {
return shopId;
}
public void setShopId(Long shopId) {
this.shopId = shopId;
}
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
public Long getTotal() {
return total;
}
public void setTotal(Long total) {
this.total = total;
}
public Integer getStatus() {
return status;
}
public void setStatus(Integer status) {
this.status = status;
}
public Integer getDeliveryType() {
return deliveryType;
}
public void setDeliveryType(Integer deliveryType) {
this.deliveryType = deliveryType;
}
public OrderAddr getOrderAddr() {
return orderAddr;
}
public void setOrderAddr(OrderAddr orderAddr) {
this.orderAddr = orderAddr;
}
public Integer getCloseType() {
return closeType;
}
public void setCloseType(Integer closeType) {
this.closeType = closeType;
}
public Integer getAllCount() {
return allCount;
}
public void setAllCount(Integer allCount) {
this.allCount = allCount;
}
public Date getPayTime() {
return payTime;
}
public void setPayTime(Date payTime) {
this.payTime = payTime;
}
public Date getDeliveryTime() {
return deliveryTime;
}
public void setDeliveryTime(Date deliveryTime) {
this.deliveryTime = deliveryTime;
}
public Date getFinallyTime() {
return finallyTime;
}
public void setFinallyTime(Date finallyTime) {
this.finallyTime = finallyTime;
}
public Date getCancelTime() {
return cancelTime;
}
public void setCancelTime(Date cancelTime) {
this.cancelTime = cancelTime;
}
public Integer getIsPayed() {
return isPayed;
}
public void setIsPayed(Integer isPayed) {
this.isPayed = isPayed;
}
public Integer getDeleteStatus() {
return deleteStatus;
}
public void setDeleteStatus(Integer deleteStatus) {
this.deleteStatus = deleteStatus;
}
public List<OrderItem> getOrderItems() {
return orderItems;
}
public void setOrderItems(List<OrderItem> orderItems) {
this.orderItems = orderItems;
}
public String getShopName() {
return shopName;
}
public void setShopName(String shopName) {
this.shopName = shopName;
}
@Override
public String toString() {
return "Order{" +
"orderId=" + orderId +
", shopId=" + shopId +
", userId=" + userId +
", shopName='" + shopName + '\'' +
", total=" + total +
", status=" + status +
", deliveryType=" + deliveryType +
", orderAddrId=" + orderAddrId +
", orderAddr=" + orderAddr +
", closeType=" + closeType +
", allCount=" + allCount +
", payTime=" + payTime +
", deliveryTime=" + deliveryTime +
", finallyTime=" + finallyTime +
", cancelTime=" + cancelTime +
", isPayed=" + isPayed +
", deleteStatus=" + deleteStatus +
", orderItems=" + orderItems +
'}';
}
}
mall4cloud-order/src/main/java/com/mall4j/cloud/order/model/OrderAddr.java 0 → 100644
View file @ 7abfefba
package com.mall4j.cloud.order.model;
import com.mall4j.cloud.common.model.BaseModel;
import java.io.Serializable;
/**
* 用户订单配送地址
*
* @author FrozenWatermelon
* @date 2020-12-05 14:13:50
*/
public class OrderAddr extends BaseModel implements Serializable{
private static final long serialVersionUID = 1L;
/**
* ID
*/
private Long orderAddrId;
/**
* 用户ID
*/
private Long userId;
/**
* 收货人
*/
private String consignee;
/**
* 省ID
*/
private Long provinceId;
/**
* 省
*/
private String province;
/**
* 城市ID
*/
private Long cityId;
/**
* 城市
*/
private String city;
/**
* 区域ID
*/
private Long areaId;
/**
* 区
*/
private String area;
/**
* 地址
*/
private String addr;
/**
* 邮编
*/
private String postCode;
/**
* 手机
*/
private String mobile;
public Long getOrderAddrId() {
return orderAddrId;
}
public void setOrderAddrId(Long orderAddrId) {
this.orderAddrId = orderAddrId;
}
public Long getUserId() {
return userId;
}
public void setUserId(Long userId) {
this.userId = userId;
}
public String getConsignee() {
return consignee;
}
public void setConsignee(String consignee) {
this.consignee = consignee;
}
public Long getProvinceId() {
return provinceId;
}
public void setProvinceId(Long provinceId) {
this.provinceId = provinceId;
}
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
public Long getCityId() {
return cityId;
}
public void setCityId(Long cityId) {
this.cityId = cityId;
}
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public Long getAreaId() {
return areaId;
}
public void setAreaId(Long areaId) {
this.areaId = areaId;
}
public String getArea() {
return area;
}
public void setArea(String area) {
this.area = area;
}
public String getAddr() {
return addr;
}
public void setAddr(String addr) {
this.addr = addr;
}
public String getPostCode() {
return postCode;
}
public void setPostCode(String postCode) {
this.postCode = postCode;
}
public String getMobile() {
return mobile;
}
public void setMobile(String mobile) {
this.mobile = mobile;
}
@Override
public String toString() {
return "OrderAddr{" +
"orderAddrId=" + orderAddrId +
",createTime=" + createTime +
",updateTime=" + updateTime +
",userId=" + userId +
",consignee=" + consignee +
",provinceId=" + provinceId +
",province=" + province +
",cityId=" + cityId +
",city=" + city +
",areaId=" + areaId +
",area=" + area +
",addr=" + addr +
",postCode=" + postCode +
",mobile=" + mobile +
'}';
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment