微信点餐系统

订单部分业务逻辑开发

一、订单部分

1、订单接口

public interface OrderMasterRepository extends JpaRepository<OrderMaster,String> {
    Page<OrderMaster> findByBuyerOpenid(String openId, Pageable pageable);
}

这里要用到分页，根据openid查找改用户的OrderMaster（订单）信息

//根据orderid查询订单详情
public interface OrderDetailRepository extends JpaRepository<OrderDetail,String> {
    List<OrderDetail> findByOrderId(String orderId);
}

其中OrderMaster和OrderDetail:

@Entity
@Data
public class OrderDetail {
    @Id
    private String detailId;

    private String orderId;

    private String productId;

    private String productName;

    private BigDecimal productPrice;

    private Integer productQuantity;

    private String productIcon;

}

@Entity
@Data
public class OrderDetail {
    @Id
    private String detailId;

    private String orderId;

    private String productId;

    private String productName;

    private BigDecimal productPrice;

    private Integer productQuantity;

    private String productIcon;

}

2、service：

public interface OrderService {
    /**
     * 创建订单
     */
    OrderDTO create(OrderDTO orderDTO);

    /**
     * 查询订单
     */
    OrderDTO findOrder(String orderId);

    /**
     * 查询订单列表
     * @param buyerOpenid
     * @param pageable
     * @return
     */
    Page<OrderDTO> findList(String buyerOpenid, Pageable pageable);

    /**
     * 取消订单
     *
     */
    OrderDTO cancle(OrderDTO orderDTO);

    /**
     * 完结订单
     */
    OrderDTO finish(OrderDTO orderDTO);

    /**
     * 支付订单
     */
    OrderDTO pay(OrderDTO orderDTO);
}

其中OrderDTO为Controller层传的数据bean

@Data
public class OrderDTO {

    /**
     * 订单编号
     */
    @Id
    private String orderId;
    /**
     * 订单名
     */
    private String buyerName;

    /**
     * 手机
     */
    private String buyerPhone;
    /**
     * 买家地址
     */
    private String buyerAddress;
    /**
     * 买家微信openid
     */
    private String buyerOpenid;
    /**
     * 订单总金额
     */
    private BigDecimal orderAmount;
    /**
     * 订单状态
     */
    private Integer orderStatus= OrderStatusEnum.NEW.getCode();
    /**
     * 支付状态
     */
    private Integer payStatus= PayStatusEnum.WAIT.getCode();

    @JsonSerialize(using = Data2LongSerializer.class)//将返回给前台的时间参数做处理
    private Date createTime;
    @JsonSerialize(using = Data2LongSerializer.class)
    private Date updateTime;
    //orderDetailList订单详情列表
    List<OrderDetail> orderDetailList;
}

service实现：

@Service
@Slf4j
public class OrderServiceImpl implements OrderService {

    @Autowired
    private OrderDetailRepository orderDetailRepository;
    @Autowired
    private OrderMasterRepository orderMasterRepository;
    @Autowired
    private ProductInfoService productInfoService;
    /*
    创建订单，逻辑：
                    1、遍历所有的OrderDetail(与从数据库中查出的OrderDetail不同，这是用户传过来 数据)，从orderDetail中取出orderId，根据orderId查询出ProduceInfo信息
                    2、根据Product Info的信息（Price和Quantity）计算出总金额
                    3、将从数据库中查出的ProduceInfo信息拷贝到OrderDetail对象中，并生成openid与detailid设置到OrderDetail中，保存到数据库。
                    4、遍历完OrderDTO中所有的OrdeDetail。
                    5、新建OrderMaster对象，将OrderDTO属性设置到OrderMaste，补齐其他属性，保存到数据库
                    6、扣库存：遍历cartList中所有的Cart对象，一个一个的减去库存
                    @Override
                    @Transactional
                    public void decreStock(List<Cart> cartList) {
                        for (Cart cart:cartList
                             ) {
                            ProductInfo productInfo = repository.findOne(cart.getProductId());
                            if (productInfo==null) {
                
                                throw new SellException(ResultEums.PRODUCT_NOT_EXIST);
                            }
                            Integer stock = productInfo.getProductStock()-cart.getProductQuantity();;
                            if (stock<0){
                                throw new SellException(ResultEums.PRODUCT_STOCK_ERROR);
                            }
                            productInfo.setProductStock(stock);
                            repository.save(productInfo);
                
                        }
                    }
     */
    @Override
    @Transactional
    public OrderDTO create(OrderDTO orderDTO) {

        String orderId = KeyUtils.genUniqueKey();
        BigDecimal ordrAmount = new BigDecimal(BigInteger.ZERO);
        //查询商品,从前台传来得OrderDTO中获取商品详细列表，遍历列表得中得所有OrderDetail，
        for (OrderDetail orderDetail:orderDTO.getOrderDetailList()) {
            //计算订单总价：（1）、从orderDetail中获取商品Id，查出商品信息，主要是为了获取ProducePrie和ProductQuantity
            ProductInfo productInfo = productInfoService.findOne(orderDetail.getProductId());
            if (productInfo==null) {
                throw new SellException(ResultEums.PRODUCT_NOT_EXIST);
            }
            //（2）、根据获取得到得ProducePrie和ProductQuantity计算商品总价ordrAmount
            ordrAmount = productInfo.getProductPrice().multiply(new BigDecimal(orderDetail.getProductQuantity()))
                    .add(ordrAmount);

            //订单详情入库：要将从数据库中查出得productInfo复制到orderDetail，productInfo必须从数据库获取,
            // 并且设置detailId与orderId

            BeanUtils.copyProperties(productInfo,orderDetail);
            orderDetail.setDetailId(KeyUtils.genUniqueKey());
            orderDetail.setOrderId(orderId);

            orderDetailRepository.save(orderDetail);
        }
        //写入订单数据库：将订单信息，即OrderMaster信息入库,要将OrderDTO中的信息复制到OrderMaster对象中
        // ，同时设置orderId，总金额ordrAmount，支付状态，订单状态,并保存入库
        OrderMaster orderMaster = new OrderMaster();
        orderDTO.setOrderId(orderId);
        BeanUtils.copyProperties(orderDTO,orderMaster);
        orderMaster.setOrderAmount(ordrAmount);
        orderMaster.setPayStatus(PayStatusEnum.WAIT.getCode());
        orderMaster.setOrderStatus(OrderStatusEnum.NEW.getCode());
        orderMasterRepository.save(orderMaster);

        //扣库存
        List<Cart> cartList = orderDTO.getOrderDetailList().stream()
                .map(e ->new Cart(e.getProductId(),e.getProductQuantity()))
                .collect(Collectors.toList());
        productInfoService.decreStock(cartList);

        return orderDTO;
    }

    @Override
    public OrderDTO findOrder(String orderId) {
    OrderDTO orderDTO = new OrderDTO();

    OrderMaster orderMaster = orderMasterRepository.findOne(orderId);
    if (orderMaster==null) {
        throw new SellException(ResultEums.PRODUCT_NOT_EXIST);
    }
    List<OrderDetail> orderDetails = orderDetailRepository.findByOrderId(orderId);
    if (CollectionUtils.isEmpty(orderDetails)) {
        throw new SellException(ResultEums.ORDER_DETAIL_NOT_EXIT);
    }
    BeanUtils.copyProperties(orderMaster,orderDTO);
    orderDTO.setOrderDetailList(orderDetails);
    return orderDTO;
    }

    @Override
    public Page<OrderDTO> findList(String buyerOpenid, Pageable pageable) {
       Page<OrderMaster> orderMasters = orderMasterRepository.findByBuyerOpenid(buyerOpenid,pageable);

       Page<OrderDTO> orderDTOPage = new PageImpl<OrderDTO>(OrderMaster2OrderDetailUtils
               .convert(orderMasters.getContent()),pageable,orderMasters.getTotalElements());

        return orderDTOPage;
    }

    @Override
    @Transactional
    public OrderDTO cancle(OrderDTO orderDTO) {
        //判断订单状态
        if (!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())){
            log.error("【取消订单】订单状态不正确，orderId={}，orderStatus={}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
            throw new SellException(ResultEums.ORDER_STATUS_ERROR);
        }
        //修改订单状态
        OrderMaster orderMaster = new OrderMaster();

        orderDTO.setOrderStatus(OrderStatusEnum.CANCEL.getCode());
        BeanUtils.copyProperties(orderDTO,orderMaster);
        OrderMaster orderResult = orderMasterRepository.save(orderMaster);
        if (orderResult==null) {
            log.error("【取消订单】订单取更新败，orderMaster={}",orderMaster);
            throw new SellException(ResultEums.ORDER_UPDATE_FAIL);

        }
        //归还库存

       List<OrderDetail> orderDetails =  orderDTO.getOrderDetailList();
        if (orderDetails==null) {
            log.error("【取消订单】，订单中无商品详情，orderDTO={}",orderDTO);

        }
        List<Cart> cartList = orderDetails.stream()
                .map(e ->new Cart(e.getProductId(),e.getProductQuantity()))
                .collect(Collectors.toList());
        productInfoService.increStock(cartList);
        //如果已支付，退款
        if (orderDTO.getPayStatus().equals(PayStatusEnum.PAY.getCode())) {

            //TODO
        }

        return orderDTO;
    }

    @Override
    @Transactional
    public OrderDTO finish(OrderDTO orderDTO) {

        //判断订单状态
        if (!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) {
            log.error("【完结订单】,订单状态不正确 orderId={},orderStatus={}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
            throw new SellException(ResultEums.ORDER_STATUS_ERROR);
        }

        //修改订单状态
        OrderMaster orderMaster = new OrderMaster();
        orderDTO.setOrderStatus(OrderStatusEnum.FINISH.getCode());
        BeanUtils.copyProperties(orderDTO,orderMaster);

        OrderMaster result = orderMasterRepository.save(orderMaster);
        if (result==null) {
            log.error("【完结订单】订单状态更新失败 orderId={},orderStatus={}",orderMaster.getOrderId(),orderMaster.getOrderStatus());
        }
        return orderDTO;
    }

    @Override
    @Transactional
    public OrderDTO pay(OrderDTO orderDTO) {
        //判断订单状态
        if (!orderDTO.getOrderStatus().equals(OrderStatusEnum.NEW.getCode())) {
            log.error("【完结订单】,订单状态不正确 orderId={},orderStatus={}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
            throw new SellException(ResultEums.ORDER_STATUS_ERROR);
        }
        //判断支付状态
        if (!orderDTO.getPayStatus().equals(PayStatusEnum.WAIT.getCode())) {
            log.error("【完结订单】,支付状态不正确 orderId={},orderStatus={}",orderDTO.getOrderId(),orderDTO.getOrderStatus());
            throw new SellException(ResultEums.PAY_STATUS_ERROR);
        }
        // 去支付 TODO

        // 修改订单支付状态

        OrderMaster orderMaster = new OrderMaster();

        orderDTO.setPayStatus(PayStatusEnum.PAY.getCode());
        BeanUtils.copyProperties(orderDTO,orderMaster);
        OrderMaster result = orderMasterRepository.save(orderMaster);
        if (result==null) {
            log.error("【完结订单】订单支付支付状态更新失败,orderId={},orderPayStatus={}",orderMaster.getOrderId(),orderMaster.getPayStatus());
            throw new SellException(ResultEums.PAY_STATUS_ERROR);
        }

        return orderDTO;
    }
}

3、Controller

@RestController
@RequestMapping("/buyer/order")
@Slf4j
public class BuyerOrderController {

    @Autowired
    private OrderService orderService;
    @Autowired
    private BuyerOrderService buyerOrderService;

    //创建订单
    @PostMapping("/create")
    public ResultVO<Map<String,String>> create(@Valid OrderForm orderForm, BindingResult result) {
        if (result.hasErrors()) {
            log.error("【创建订单】创建订单参数错误 orderForm={}",orderForm);
            throw new SellException(ResultEums.PARAM_ERROR,result.getFieldError().getDefaultMessage());
        }
        OrderDTO orderDTO = OrderForm2OrderDTOUtils.convert(orderForm);
        if (CollectionUtils.isEmpty(orderDTO.getOrderDetailList())) {
            log.error("【创建订单】购物车不能为空 Cart={}",orderDTO.getOrderDetailList());
            throw new SellException(ResultEums.CART_NULL);
        }
        OrderDTO orderResult = orderService.create(orderDTO);
        Map<String,String> map =new HashMap<>();
        map.put("orderId",orderResult.getOrderId());
        return ResultVOUtils.success(map);
    }

    //订单列表
    @GetMapping("/list")
    public ResultVO<List<OrderDTO>> list(@RequestParam(value = "openid") String opneid,
                                            @RequestParam(value = "page",defaultValue = "0")Integer page,
                                            @RequestParam(value = "size",defaultValue = "10") Integer size) {
        if (StringUtils.isEmpty(opneid)){
            log.error("【查询订单列表】查询参数错误 openid={}",opneid);
            throw new SellException(ResultEums.PARAM_ERROR);
        }
        PageRequest pageRequest = new PageRequest(page,size);
        Page<OrderDTO> orderDetailList = orderService.findList(opneid,pageRequest);
        return ResultVOUtils.success(orderDetailList.getContent());
    }

    //订单详情
    @GetMapping("/detail")
    public ResultVO<OrderDTO> findDetail(@RequestParam("openid") String openid,
                                            @RequestParam("orderid") String orderid) {

        if (StringUtils.isEmpty(orderid)) {
            log.info("【订单详情查询】订单参数错误, openid={}",openid);

            throw new SellException(ResultEums.PARAM_ERROR);
        }


        OrderDTO orderDTO = buyerOrderService.findOrderOne(openid,orderid);
        return ResultVOUtils.success(orderDTO);
    }


    //取消订单
    @PostMapping("/cancel")
    public ResultVO cancel(String openid,String orderid) {
        if (StringUtils.isEmpty(orderid)) {
            log.info("【订单取消】订单参数错误, openid={}",openid);

            throw new SellException(ResultEums.PARAM_ERROR);
        }

        OrderDTO orderDTO = buyerOrderService.cancelOrder(openid,orderid);
       
        return ResultVOUtils.success();
    }
}