瑞吉外卖订单后台和用户端功能

项目场景：

在编写瑞吉外卖的订单功能的时候，还是按照惯例，订单的一些功能是我们自己做，毕竟都看了一百多集视频了，自己应该能写一点东西了。

遇到的坑：

后台的订单列表功能，有一个输入订单号查询的功能，看到订单号，我就直接用Long类型接收，结果碰到了一个很离谱的事情。

我们都是用lambdaQueryWrapper去查询数据库的数据的，通过eq方法对比订单号查询订单，因为我是Long类型的订单号，所以我点击搜索的时候，我发现！最后两位数不管怎么输入都能查询到这个订单！很离谱！

例如我的订单号是：1656203934211780609

我输入：

16562039342117806 00 | 16562039342117806 01 | 1656203934211780622 | 16562039342117806 65

类似的订单号

全部能将 1656203934211780609 这个订单号的数据查询出来 ，也就是 16562039342117806XX ！ 很离谱吧！

解决方案：

将Long类型的订单号toString或者直接用String类型接收订单号。

下面贴上我的代码！

 1、这一行代码我使用的是number对比的也就是订单号不是通过订单ID，因为我希望订单号和ID可以区分开来，不将订单ID直接暴露出来。

lambdaQueryWrapper.eq(Orders::getNumber,number);

2、lambdaQueryWrapper的between方法 适用于 时间范围查询

        //如果 开始时间 和 结束时间 都不为空
        if(beginTime != null && endTime != null){
            //SQL : where (orderTime BETWEEN beginTime AND endTime)
            //添加范围内查询条件 筛选出下单时间 大于等于 开始时间 小于等于 结束时间
            lambdaQueryWrapper.between(Orders::getOrderTime,beginTime,endTime);
        }

 

 

 

3、userPage方法在前端的个人中心页面的最新订单和历史订单页面做到了复用！很强！

 注意：    使用了 OrdersDto ，我也是写这个方法的时候看到资料中有这个dto的！哈哈！

(1)、最新订单将page参数和pageSize参数都设置为1，也就是只查询一条数据，且是最新的数据，所以使用orderByDesc方法通过订单时间降序排序  。         

                                                                      

lambdaQueryWrapper.orderByDesc(Orders::getOrderTime);

 

(2)、历史订单中 page 参数 为 1 ，pageSize为5，只查询近5条订单

我们还说通过上面的代码一样进行通过订单时间倒序排序

 

userPage我们还是使用 stream流map的遍历方法编写！

package com.itheima.reggie.controller;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.itheima.reggie.common.BaseContext;
import com.itheima.reggie.common.R;
import com.itheima.reggie.dto.OrdersDto;
import com.itheima.reggie.entity.OrderDetail;
import com.itheima.reggie.entity.Orders;
import com.itheima.reggie.service.OrderDetailService;
import com.itheima.reggie.service.OrdersService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.stream.Collectors;

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

    @Autowired
    private OrdersService ordersService;

    @Autowired
    private OrderDetailService orderDetailService;

    /**
     * 用户下单
     * @param orders
     * @return
     */
    @PostMapping("/submit")
    public R<String> submit(@RequestBody Orders orders) {

        log.info("订单数据：{}",orders);

        ordersService.submit(orders);

        return R.success("下单成功");
    }

    /**
     * 后台分页查询订单
     * @param page
     * @param pageSize
     * @param number
     * @param beginTime
     * @param endTime
     * @return
     */
    @GetMapping("/page")
    public R<Page> page(int page, int pageSize, String number, String beginTime, String endTime) {
        //分页构造器
        Page<Orders> pageInfo = new Page<>(page, pageSize);
        //条件构造器
        LambdaQueryWrapper<Orders> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //添加排序条件,根据订单时间进行排序
        lambdaQueryWrapper.orderByDesc(Orders::getOrderTime);

        //打印订单号
        log.info("订单号：{}",number);

        //如果订单号不为空
        if(number != null){
            //添加订单号比较条件
            lambdaQueryWrapper.eq(Orders::getNumber,number);
        }

        //如果 开始时间 和 结束时间 都不为空
        if(beginTime != null && endTime != null){
            //SQL : where (orderTime BETWEEN beginTime AND endTime)
            //添加范围内查询条件 筛选出下单时间 大于等于 开始时间 小于等于 结束时间
            lambdaQueryWrapper.between(Orders::getOrderTime,beginTime,endTime);
        }

        //进行分页查询
        ordersService.page(pageInfo, lambdaQueryWrapper);

        return R.success(pageInfo);
    }

    /**
     *  更改订单状态
     * @param orders
     * @return
     */
    @PutMapping
    public R<String> status(@RequestBody Orders orders) {

        log.info(orders.toString());

        ordersService.updateById(orders);

        return R.success("派送成功");
    }

    /**
     * 用户订单
     * @param page
     * @param pageSize
     * @return
     */
    @GetMapping("/userPage")
    public R<Page> userPage(int page , int pageSize) {

        //分页构造器
        Page<Orders> pageInfo = new Page<>(page,pageSize);
        Page<OrdersDto> ordersDtoPage = new Page<>();

        //SQL：select * from orders where user_id = ? order by order_time desc

        //条件构造器
        LambdaQueryWrapper<Orders> lambdaQueryWrapper = new LambdaQueryWrapper<>();
        //添加用户ID
        lambdaQueryWrapper.eq(Orders::getUserId, BaseContext.getCurrentId());
        //添加排序条件,根据订单时间进行倒序
        lambdaQueryWrapper.orderByDesc(Orders::getOrderTime);

        //进行分页查询
        ordersService.page(pageInfo,lambdaQueryWrapper);

        //对象拷贝 将pageInfo 拷贝 到 orderDtoPage 忽略 records
        BeanUtils.copyProperties(pageInfo,ordersDtoPage,"records");

        //获取pageInfo的records
        List<Orders> records = pageInfo.getRecords();

        //遍历records
        List<OrdersDto> list = records.stream().map((item) -> {

            OrdersDto ordersDto = new OrdersDto();
            //将 records的数据拷贝到 ordersDto
            BeanUtils.copyProperties(item,ordersDto);

            //SQL：select * from order_detail where order_id = ?

            //条件构造器
            LambdaQueryWrapper<OrderDetail> queryWrapper = new LambdaQueryWrapper<>();
            //通过records里面的订单ID [number] 对比 订单明细表的order_id 查询订单明细
            queryWrapper.eq(OrderDetail::getOrderId,item.getNumber());
            //查询出订单明细信息 列表
            List<OrderDetail> orderDetail = orderDetailService.list(queryWrapper);

            ordersDto.setOrderDetails(orderDetail);
            return ordersDto;
        }).collect(Collectors.toList());

        ordersDtoPage.setRecords(list);

        return R.success(ordersDtoPage);
    }
}

 退出登录：

顺便将退出登录的代码贴出来！就是一个清除session的操作。

    /**
     * 退出登录
     * @param session
     * @return
     */
    @PostMapping("/loginout")
    public R<String> loginout(HttpSession session) {
        session.removeAttribute("user");
        return R.success("退出登录成功");
    }