瑞吉外卖（五）套餐管理业务开发

package cn.mu00.reggie.entity;

import com.baomidou.mybatisplus.annotation.FieldFill;
import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDateTime;

/**
 * 套餐菜品关系
 */
@Data
public class SetmealDish implements Serializable {

    private static final long serialVersionUID = 1L;

    private Long id;


    //套餐id
    private Long setmealId;


    //菜品id
    private Long dishId;


    //菜品名称 （冗余字段）
    private String name;

    //菜品原价
    private BigDecimal price;

    //份数
    private Integer copies;


    //排序
    private Integer sort;


    @TableField(fill = FieldFill.INSERT)
    private LocalDateTime createTime;


    @TableField(fill = FieldFill.INSERT_UPDATE)
    private LocalDateTime updateTime;


    @TableField(fill = FieldFill.INSERT)
    private Long createUser;


    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Long updateUser;


    //是否删除
    private Integer isDeleted;
}

package cn.mu00.reggie.mapper;

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

@Mapper
public interface SetmealDishMapper extends BaseMapper<SetmealDish> {
}

package cn.mu00.reggie.service;

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

public interface SetmealDishService extends IService<SetmealDish> {
}

package cn.mu00.reggie.service.impl;

import cn.mu00.reggie.entity.SetmealDish;
import cn.mu00.reggie.mapper.SetmealDishMapper;
import cn.mu00.reggie.service.SetmealDishService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;

@Service
public class SetmealDishServiceImpl extends ServiceImpl<SetmealDishMapper, SetmealDish> implements SetmealDishService {
}

package cn.mu00.reggie.dto;

import cn.mu00.reggie.entity.Setmeal;
import cn.mu00.reggie.entity.SetmealDish;
import lombok.Data;
import java.util.List;

@Data
public class SetmealDto extends Setmeal {

    private List<SetmealDish> setmealDishes;

    private String categoryName;
}

package cn.mu00.reggie.controller;

import cn.mu00.reggie.service.SetmealDishService;
import cn.mu00.reggie.service.SetmealService;
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("/setmeal")
@Slf4j
public class SetmealController {
    @Autowired
    private SetmealService setmealService;

    @Autowired
    private SetmealDishService setmealDishService;
}

/**
 * 根据条件查询菜品数据
 * @param dish
 * @return
 */
@GetMapping("/list")
public R<List<Dish>> list(Dish dish){

    // 构造查询条件
    LambdaQueryWrapper<Dish> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(dish.getCategoryId() != null, Dish::getCategoryId, dish.getCategoryId());
    
    // 查询状态为 1（起售）
    queryWrapper.eq(Dish::getStatus, 1);
    
    // 添加排序条件
    queryWrapper.orderByAsc(Dish::getSort).orderByDesc(Dish::getUpdateTime);

    List<Dish> list = dishService.list(queryWrapper);
    return R.success(list);
}

/**
 * 新增套餐，同时保存套餐与菜品的关联关系
 * @param setmealDto
 */
public void saveWithDish(SetmealDto setmealDto);

@Autowired
private SetmealDishService setmealDishService;

/**
 * 新增套餐，同时保存套餐与菜品的关联关系
 * @param setmealDto
 */
@Override
@Transactional
public void saveWithDish(SetmealDto setmealDto) {
    // 保存套餐基本信息
    this.save(setmealDto);

    List<SetmealDish> setmealDishes = setmealDto.getSetmealDishes();
    setmealDishes.stream().map((item) -> {
        item.setSetmealId(setmealDto.getId());
        return item;
    }).collect(Collectors.toList());

    // 保存套餐和菜品的关联信息
    setmealDishService.saveBatch(setmealDishes);
}

/**
 * 新增套餐
 * @param setmealDto
 * @return
 */
@PostMapping
public R<String> save(@RequestBody SetmealDto setmealDto){
    log.info("套餐信息：{}", setmealDto);
    setmealService.saveWithDish(setmealDto);
    return R.success("新增套餐成功");
}

/**
 * 套餐分页查询
 * @param page
 * @param pageSize
 * @param name
 * @return
 */
@GetMapping("/page")
public R<Page<SetmealDto>> page(int page, int pageSize, String name){
    // 分页构造器
    Page<Setmeal> pageInfo = new Page<>(page, pageSize);
    Page<SetmealDto> dtoPage = new Page<>();

    LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>();
    // 添加添加，根据name进行模糊查询
    queryWrapper.like(name != null, Setmeal::getName, name);
    // 添加排序添加
    queryWrapper.orderByDesc(Setmeal::getUpdateTime);

    setmealService.page(pageInfo, queryWrapper);

    // 对象拷贝
    BeanUtils.copyProperties(pageInfo, dtoPage, "records");
    List<Setmeal> records = pageInfo.getRecords();

    List<SetmealDto> list = records.stream().map((item) -> {
        SetmealDto setmealDto = new SetmealDto();
        // 对象拷贝
        BeanUtils.copyProperties(item, setmealDto);

        // 分类id
        Long categoryId = item.getCategoryId();
        // 根据分类id查询分类对象
        Category category = categoryService.getById(categoryId);
        if (category != null){
            // 分类名称
            String categoryName = category.getName();
            setmealDto.setCategoryName(categoryName);

        }
        return setmealDto;
    }).collect(Collectors.toList());

    dtoPage.setRecords(list);
    return R.success(dtoPage);
}

/**
 * 查询指定套餐
 * @param id
 * @return
 */
@GetMapping("/{id}")
public R<SetmealDto> getOneById(@PathVariable Long id){
    SetmealDto setmealDto = new SetmealDto();

    // 查询套餐基本信息
    Setmeal setmeal = setmealService.getById(id);
    // 对象拷贝
    BeanUtils.copyProperties(setmeal, setmealDto);

    // 条件构造器
    LambdaQueryWrapper<SetmealDish> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(SetmealDish::getSetmealId, setmealDto.getId());

    // 查询套餐与菜品的关联关系
    List<SetmealDish> list = setmealDishService.list(queryWrapper);
    setmealDto.setSetmealDishes(list);

    return R.success(setmealDto);
}

/**
 * 修改套餐，同时修改套餐与菜品的关联关系
 * @param setmealDto
 */
public void updateWithDish(SetmealDto setmealDto);

/**
 * 修改套餐，同时修改套餐与菜品的关联关系
 * @param setmealDto
 */
@Override
@Transactional
public void updateWithDish(SetmealDto setmealDto) {
    // 更新套餐基本信息
    this.updateById(setmealDto);

    // 清理当前套餐对应的菜品数据
    LambdaQueryWrapper<SetmealDish> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.eq(SetmealDish::getSetmealId, setmealDto.getId());
    setmealDishService.remove(queryWrapper);

    // 添加当前套餐和菜品的关联信息
    List<SetmealDish> setmealDishes = setmealDto.getSetmealDishes();
    setmealDishes = setmealDishes.stream().map((item) -> {
        item.setSetmealId(setmealDto.getId());
        return item;
    }).collect(Collectors.toList());
    setmealDishService.saveBatch(setmealDishes);
}

/**
 * 更新套餐信息
 * @param setmealDto
 * @return
 */
@PutMapping
public R<String> update(@RequestBody SetmealDto setmealDto){
    setmealService.updateWithDish(setmealDto);
    return R.success("更新套餐信息成功");
}

/**
 * 删除套餐，同时删除套餐与菜品的关联关系
 * @param ids
 */
public void deleteWithDish(List<Long> ids);

/**
 * 删除套餐，同时删除套餐与菜品的关联关系
 * @param ids
 */
@Override
@Transactional
public void deleteWithDish(List<Long> ids) {
    // 查询套餐状态，确定是否可以删除
    LambdaQueryWrapper<Setmeal> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.in(Setmeal::getId, ids);
    queryWrapper.eq(Setmeal::getStatus, 1);

    int count = this.count(queryWrapper);
    if (count > 0){
        // 如果不能删除，抛出业务异常
        throw new CustomException("套餐正在售卖中，不能删除");
    }

    // 如果可以删除，先删除套餐中的数据
    this.removeByIds(ids);

    // 删除关系数据
    LambdaQueryWrapper<SetmealDish> lambdaQueryWrapper = new LambdaQueryWrapper<>();
    lambdaQueryWrapper.in(SetmealDish::getSetmealId, ids);
    setmealDishService.remove(lambdaQueryWrapper);
}

/**
 * 删除套餐
 * @param ids
 * @return
 */
@DeleteMapping
public R<String> delete(@RequestParam List<Long> ids){
    setmealService.deleteWithDish(ids);
    return R.success("套餐信息删除成功");
}

/**
 * 起售/停售套餐
 * @param status
 * @param ids
 * @return
 */
@PostMapping("/status/{status}")
public R<String> status(@PathVariable Integer status, Long[] ids){

    for (Long setmealId : ids) {
        Setmeal setmeal = new Setmeal();
        setmeal.setId(setmealId);
        setmeal.setStatus(status);
        setmealService.updateById(setmeal);
    }
    return R.success("套餐信息更新成功");
}