瑞吉外卖（九）下单业务开发

package cn.mu00.reggie.entity;

import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 订单
 */
@Data
public class Orders implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;

    //订单号
    private String number;

    //订单状态 1待付款，2待派送，3已派送，4已完成，5已取消
    private Integer status;


    //下单用户id
    private Long userId;

    //地址id
    private Long addressBookId;


    //下单时间
    private LocalDateTime orderTime;


    //结账时间
    private LocalDateTime checkoutTime;


    //支付方式 1微信，2支付宝
    private Integer payMethod;


    //实收金额
    private BigDecimal amount;

    //备注
    private String remark;

    //用户名
    private String userName;

    //手机号
    private String phone;

    //地址
    private String address;

    //收货人
    private String consignee;
}

package cn.mu00.reggie.mapper;

import cn.mu00.reggie.entity.Orders;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface OrdersMapper extends BaseMapper<Orders> {
}

package cn.mu00.reggie.service;

import cn.mu00.reggie.entity.Orders;
import com.baomidou.mybatisplus.extension.service.IService;

public interface OrdersService extends IService<Orders> {
}

package cn.mu00.reggie.service.impl;

import cn.mu00.reggie.entity.Orders;
import cn.mu00.reggie.mapper.OrdersMapper;
import cn.mu00.reggie.service.OrdersService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

@Service
public class OrdersServiceImpl extends ServiceImpl<OrdersMapper, Orders> implements OrdersService {
}

package cn.mu00.reggie.controller;

import cn.mu00.reggie.service.OrdersService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/order")
@Slf4j
public class OrdersController {
    @Autowired
    private OrdersService ordersService;
}

package cn.mu00.reggie.entity;

import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;

/**
 * 订单明细
 */
@Data
public class OrderDetail implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;

    //名称
    private String name;

    //订单id
    private Long orderId;


    //菜品id
    private Long dishId;


    //套餐id
    private Long setmealId;


    //口味
    private String dishFlavor;


    //数量
    private Integer number;

    //金额
    private BigDecimal amount;

    //图片
    private String image;
}

package cn.mu00.reggie.mapper;

import cn.mu00.reggie.entity.OrderDetail;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface OrderDetailMapper extends BaseMapper<OrderDetail> {
}

package cn.mu00.reggie.service;

import cn.mu00.reggie.entity.OrderDetail;
import com.baomidou.mybatisplus.extension.service.IService;

public interface OrderDetailService extends IService<OrderDetail> {
}

package cn.mu00.reggie.service.impl;

import cn.mu00.reggie.entity.OrderDetail;
import cn.mu00.reggie.mapper.OrderDetailMapper;
import cn.mu00.reggie.service.OrderDetailService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

@Service
public class OrderDetailServiceImpl extends ServiceImpl<OrderDetailMapper, OrderDetail> implements OrderDetailService {
}

package cn.mu00.reggie.dto;

import cn.mu00.reggie.entity.OrderDetail;
import cn.mu00.reggie.entity.Orders;
import lombok.Data;
import java.util.List;

@Data
public class OrdersDto extends Orders {

    private String userName;

    private String phone;

    private String address;

    private String consignee;

    private List<OrderDetail> orderDetails;
    
}

/**
 * 提交订单
 * @param orders
 */
public void submit(Orders orders);

@Autowired
private UserService userService;
@Autowired
private AddressBookService addressBookService;
@Autowired
private OrderDetailService orderDetailService;


/**
 * 提交订单
 * @param orders
 */
@Override
@Transactional
public void submit(Orders orders) {
    log.info("订单数据：{}", orders);
    // 用户id
    Long userId = BaseContext.getCurrentId();

    // 购物车数据
    LambdaQueryWrapper<ShoppingCart> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(ShoppingCart::getUserId, userId);
    List<ShoppingCart> shoppingCarts = shoppingCartService.list(queryWrapper);

    if (shoppingCarts == null || shoppingCarts.size() == 0){
        throw new CustomException("购物车为空，不能下单");
    }

    // 查询用户数据
    User user = userService.getById(userId);

    // 地址数据
    Long addressBookId = orders.getAddressBookId();
    AddressBook addressBook = addressBookService.getById(addressBookId);

    if (addressBook == null){
        throw new CustomException("地址信息不能为空！不能下单");
    }

    // 订单表添加数据
    long orderId = IdWorker.getId(); // 订单号

    AtomicInteger amount = new AtomicInteger(0);

    List<OrderDetail> orderDetails = shoppingCarts.stream().map((item) -> {
        OrderDetail orderDetail = new OrderDetail();
        orderDetail.setOrderId(orderId);
        orderDetail.setNumber(item.getNumber());
        orderDetail.setDishFlavor(item.getDishFlavor());
        orderDetail.setDishId(item.getDishId());
        orderDetail.setSetmealId(item.getSetmealId());
        orderDetail.setName(item.getName());
        orderDetail.setImage(item.getImage());
        orderDetail.setAmount(item.getAmount());
        amount.addAndGet(item.getAmount().multiply(new BigDecimal(item.getNumber())).intValue());
        return orderDetail;
    }).collect(Collectors.toList());

    orders.setNumber(String.valueOf(orderId));
    orders.setOrderTime(LocalDateTime.now());
    orders.setCheckoutTime(LocalDateTime.now());
    orders.setStatus(2);
    orders.setAmount(new BigDecimal(amount.get()));//总金额
    orders.setUserId(userId);
    orders.setUserName(addressBook.getPhone());
    orders.setNumber(String.valueOf(orderId));
    orders.setConsignee(addressBook.getConsignee());
    orders.setPhone(addressBook.getPhone());
    orders.setAddress((addressBook.getProvinceName() == null ? "" : addressBook.getProvinceName())
                      + (addressBook.getCityName() == null ? "" : addressBook.getCityName())
                      + (addressBook.getDistrictName() == null ? "" : addressBook.getDistrictName())
                      + (addressBook.getDetail() == null ? "" : addressBook.getDetail()));
    this.save(orders);

    // 订单表明细添加数据
    orderDetailService.saveBatch(orderDetails);

    // 清空购物车数据
    shoppingCartService.remove(queryWrapper);
}

/**
 * 提交订单
 * @return
 */
@PostMapping("/submit")
public R<String> submit(@RequestBody Orders orders){
    ordersService.submit(orders);
    return R.success("下单成功");
}

/**
 * 分页查询订单
 * @param page
 * @param pageSize
 * @return
 */
Page<OrdersDto> userPage(Integer page, Integer pageSize);

/**
 * 分页查询订单
 * @param page
 * @param pageSize
 * @return
 */
@Override
public Page<OrdersDto> userPage(Integer page, Integer pageSize) {
    // 分页构造器
    Page<Orders> ordersPage = new Page<>(page, pageSize);

    // 条件构造器
    LambdaQueryWrapper<Orders> ordersLambdaQueryWrapper = new LambdaQueryWrapper<>();
    ordersLambdaQueryWrapper.orderByDesc(Orders::getOrderTime);

    this.page(ordersPage,ordersLambdaQueryWrapper);

    Page<OrdersDto> ordersDtoPage = new Page<>();

    // 分页的ordersDtoPage，没有records
    BeanUtils.copyProperties(ordersPage, ordersDtoPage, "records");

    // 构造orderDetails
    List<Orders> ordersList = ordersPage.getRecords();

    List<OrdersDto> ordersDtoList = ordersList.stream().map((item) -> {
        OrdersDto ordersDto = new OrdersDto();
        // 订单id
        String orderNum = item.getNumber();
        LambdaQueryWrapper<OrderDetail> orderDetailLambdaQueryWrapper = new LambdaQueryWrapper<>();
        orderDetailLambdaQueryWrapper.eq(OrderDetail::getOrderId, orderNum);

        BeanUtils.copyProperties(item, ordersDto);
        List<OrderDetail> list = orderDetailService.list(orderDetailLambdaQueryWrapper);
        ordersDto.setOrderDetails(list);
        return ordersDto;
    }).collect(Collectors.toList());

    ordersDtoPage.setRecords(ordersDtoList);
    return ordersDtoPage;
}

/**
 * 分页查询订单
 * @param page
 * @param pageSize
 * @return
 */
@GetMapping("/userPage")
public R<Page<OrdersDto>> userPage(Integer page, Integer pageSize){
    Page<OrdersDto> dtoPage = ordersService.userPage(page, pageSize);
    return R.success(dtoPage);
}

/**
 * 再来一单
 * @param orders
 * @return
 */
@PostMapping("/again")
public R<String> again(@RequestBody Orders orders){
    Orders temp = ordersService.getById(orders.getId());
    temp.setId(null);
    temp.setStatus(2);
    long orderId = IdWorker.getId(); // 订单号
    temp.setNumber(String.valueOf(orderId));
    temp.setOrderTime(LocalDateTime.now());
    temp.setCheckoutTime(LocalDateTime.now());
    ordersService.save(temp);
    return R.success("下单成功");
}

package cn.mu00.reggie.dto;

import lombok.Data;

import java.time.LocalDateTime;

/**
 * 多条件分页查询
 */
@Data
public class PageQueryDto {

    int page;
    int pageSize;
    String number;
    String beginTime;
    String endTime;
}

/**
 * 分页多条件查询
 * @param pageQueryDto
 * @return
 */
Page<Orders> queryPage(PageQueryDto pageQueryDto);

/**
 * 分页多条件查询
 * @param pageQueryDto
 * @return
 */
@Override
public Page<Orders> queryPage(PageQueryDto pageQueryDto) {
    // 解构pageQueryDto
    int page = pageQueryDto.getPage();
    int pageSize = pageQueryDto.getPageSize();
    String number = pageQueryDto.getNumber();

    // 订单 分页构造器
    Page<Orders> ordersPage = new Page<>(page, pageSize);

    // 订单 条件构造器
    LambdaQueryWrapper<Orders> ordersQueryWrapper = new LambdaQueryWrapper<>();
    // 根据订单时间，倒序排列
    ordersQueryWrapper.orderByDesc(Orders::getOrderTime);

    // 条件 订单号模糊查询
    ordersQueryWrapper.like(number != null, Orders::getNumber, number);

    // 判空
    if (pageQueryDto.getBeginTime() != null && pageQueryDto.getEndTime() != null){
        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        LocalDateTime beginTime = LocalDateTime.parse(pageQueryDto.getBeginTime(), df);
        LocalDateTime endTime = LocalDateTime.parse(pageQueryDto.getEndTime(), df);
        // 条件 时间区间
        ordersQueryWrapper.between(Orders::getOrderTime, beginTime, endTime);
    }
    // 执行查询
    this.page(ordersPage, ordersQueryWrapper);

    return ordersPage;
}

/**
 * 更新订单状态
 * @param orders
 * @return
 */
@PutMapping()
public R<String> toSend(@RequestBody Orders orders){
    log.info("派送订单：{}",orders.toString());
    ordersService.updateById(orders);
    return R.success("派送成功");
}