基于javaweb+mysql的ssm+maven在线点餐系统(java+ssm+jsp+mysql+maven+layui)

基于javaweb+mysql的ssm+maven在线点餐系统(java+ssm+jsp+mysql+maven+layui)

运行环境

Java≥8、MySQL≥5.7、Tomcat≥8

开发工具

eclipse/idea/myeclipse/sts等均可配置运行

适用

课程设计，大作业，毕业设计，项目练习，学习演示等

功能说明

基于javaweb+mysql的SSM+Maven在线点餐系统(java+ssm+jsp+mysql+maven+layui)

一、项目简述

功能包括： 前台实现：用户浏览菜单、菜品分类筛选、查看菜单详 情、添加购物车、购物车结算、会员券、个人订单查询等 等。 后台实现：餐系管理、菜品管理、订单管理、系统管理、 酉己备员管理等。 系统分为：高或管理员、顾客、厨师、配送员等等。

二、项目运行

环境配置： Jdk1.8 + Tomcat8.5 + mysql + Eclispe (IntelliJ IDEA,Eclispe,MyEclispe,Sts 都支持)

项目技术： JSP +Spring + SpringMVC + MyBatis + html+ css + JavaScript + JQuery + Ajax + layui+ maven等等。

                //将user信息保存到session中
                session.setAttribute(SystemConstant.USERLOGIN, userLogin);
                map.put(SystemConstant.LOGINFLAG, true);
            }else {
                //密码错误
                map.put(SystemConstant.LOGINFLAG, false);
                map.put(SystemConstant.MESSAGE, "密码错误！");
            }
        }else {
            //用户名不存在
            map.put(SystemConstant.LOGINFLAG, false);
            map.put(SystemConstant.MESSAGE, "用户名不存在！");
        }
        return map;
    }

    /**
     * 用户退出登录时的业务逻辑
     * @param session
     */
    @Override
    public void exit(HttpSession session) {
        UserEntity user = (UserEntity)session.getAttribute(SystemConstant.USERLOGIN);
        //保存用户登出信息
        userMapper.setLogoutSuccessInfo(user.getUserId());
        session.removeAttribute(SystemConstant.USERLOGIN);
    }

    /**
     * 根据页面条件查询用户列表
     * @param vo
     * @return
     */
    @Override
    public LayuiTableDataResult findUserListByPage(UserVo vo) {
        //设置分页信息
        PageHelper.startPage(vo.getPage(), vo.getLimit());
        //调用分页查询的方法
        List<UserEntity> userList = userMapper.findUserListByPage(vo);
        //创建分页对象，将查询到的数据放进去
        PageInfo<UserEntity> pageInfo = new PageInfo<>(userList);
        //返回数据
        return new LayuiTableDataResult(pageInfo.getTotal(), pageInfo.getList());
    }

    /**
     * 后台添加用户
     * @param vo
     * @return
     */
    @Override
    public Map<String, Object> addUser(UserVo vo) {

                map.put(SystemConstant.FLAG, true);
                map.put(SystemConstant.MESSAGE, "新增菜品SPU信息成功，请尽快完善该菜品的SKU信息");
            }else {
                map.put(SystemConstant.FLAG, false);
                map.put(SystemConstant.MESSAGE, "新增菜品SPU信息失败!");
            }
        }else {
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "新增菜品SPU信息失败");
        }
        return map;
    }

    /**
     * 生成菜品规格信息和SKU信息
     * @param foodParamList
     * @param foodId
     * @return
     */
    @Override
    public boolean generateSku(List<Map<String, Object>> foodParamList, Long foodId, String foodName) {
        try{
            //生成一个二维数组
            String[][] foodattrArr = new String[foodParamList.size()][];
            for (int i = 0; i < foodParamList.size(); i++) {
                //将Map映射转换成json字符串
                String json = JSON.toJSONString(foodParamList.get(i), true);
                Long attrId = Long.parseLong(foodParamList.get(i).get("attrId").toString());
                //将json数组转换成List集合
                List<String> foodvalueList = JSON.parseArray(JSON.parseObject(json).getString("foodvalueArr"), String.class);
                foodattrArr[i] = new String[foodvalueList.size()];
                for (String foodvalueName : foodvalueList) {
                    //将菜品规格添加到规格表中
                    String name = ((String) JSONObject.parseObject(foodvalueName).get("foodvalueName"));
                    foodvalueMapper.addFoodvalue(foodId, attrId, name);
                    foodattrArr[i][foodvalueList.indexOf(foodvalueName)] = name;
                }
            }
            //遍历二维数组，拼接SKU名称，生成菜品SKU信息
            List<StringBuilder> skuName = new ArrayList<>();
            List<StringBuilder> skuNameList = FoodSkuUtil.buildSku(foodattrArr, foodName, skuName);
            for (StringBuilder sb : skuNameList) {
                foodSkuMapper.addFoodSku(sb.toString(), foodId);
            }
            return true;
        }catch (Exception e) {
            return false;
        }
    }

 */
@Service
@Transactional
public class TicketTypeServiceImpl implements TicketTypeService {

    @Autowired
    private TicketTypeMapper ticketTypeMapper;

    /**
     * 根据页面条件查询优惠券类型集合
     * @param vo
     * @return
     */
    @Override
    public LayuiTableDataResult findTicketTypeListByPage(TicketTypeVo vo) {
        PageHelper.startPage(vo.getPage(), vo.getLimit());
        List<TicketTypeEntity> ticketTypeListByPage = ticketTypeMapper.findTicketTypeListByPage(vo);
        PageInfo<TicketTypeEntity> pageInfo = new PageInfo<>(ticketTypeListByPage);
        return new LayuiTableDataResult(pageInfo.getTotal(), pageInfo.getList());
    }

    /**
     * 新增优惠券类型
     * @param vo
     * @param session
     * @return
     */
    @Override
    public Map<String, Object> addTicketType(TicketTypeVo vo, HttpSession session) {
        Map<String, Object> map = new HashMap<>(16);
        String username = ((UserEntity) session.getAttribute(SystemConstant.USERLOGIN)).getUsername();
        vo.setLastModifyBy(username);
        if (ticketTypeMapper.addTicketType(vo) > 0) {
            map.put(SystemConstant.FLAG, true);
            map.put(SystemConstant.MESSAGE, "新增优惠券类型成功");
        }else {
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "新增优惠券类型失败");
        }
        return map;
    }

    /**
     * 修改优惠券类型
     * @param vo
     * @param session
     * @return

        Map<String, Object> map = new HashMap<>(16);
        //不可以父级菜单就是本身，直接返回修改错误
        if (vo.getPid().equals(vo.getId())){
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "修改菜单失败，您不可以选择本身作为父级菜单");
            return map;
        }
        if (menuMapper.modifyMenu(vo) >= 1){
            map.put(SystemConstant.FLAG, true);
            map.put(SystemConstant.MESSAGE, "【" + vo.getTitle() + "】菜单信息修改成功");
        } else {
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "【" + vo.getTitle() + "】菜单信息修改失败");
        }
        return map;
    }

    /**
     * 删除菜单
     * @param menuId
     * @return
     */
    @Override
    public Map<String, Object> deleteMenu(Integer menuId) {
        Map<String, Object> map = new HashMap<>(16);
        //删除菜单前先查询是否还有角色仍有使用该菜单的权限
        if (menuMapper.countRoleByMenuId(menuId) == 0){
            //删除菜单
            menuMapper.deleteMenu(menuId);
            map.put(SystemConstant.FLAG, true);
            map.put(SystemConstant.MESSAGE, "菜单删除成功");
        }else {
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "仍有角色拥有该菜单的使用权限，删除失败");
        }
        return map;
    }

}

            treeNodes.add(treeNode);
        }
        return new LayuiTableDataResult(treeNodes);
    }

    /**
     * 对该角色的菜单权限进行授权
     * @param menuIds
     * @param roleId
     * @return
     */
    @Override
    public Map<String, Object> grantMenu(String menuIds, Long roleId) {
        Map<String, Object> map = new HashMap<>(16);
        try {
            //将菜单ID拆分出来
            String[] menuIdArr = menuIds.split(",");
            //删除该角色的所有已有菜单权限
            roleMapper.deleteAllMenuByRoleId(roleId);
            for (String menuId : menuIdArr) {
                //对角色进行菜单授权
                roleMapper.grantMenu(roleId, Integer.parseInt(menuId));
            }
            map.put(SystemConstant.MESSAGE, "角色菜单关系授权成功");
        } catch (Exception e) {
            map.put(SystemConstant.MESSAGE, "角色菜单关系授权失败");
        }
        return map;
    }

    /**
     * 删除角色
     * @param roleId
     * @return
     */
    @Override
    public Map<String, Object> deleteRole(Long roleId) {
        Map<String, Object> map = new HashMap<>(16);
        //判断角色下是否还有用户，有的话不准删除
        if (roleMapper.countUserByRoleId(roleId) == 0){
            //删除该角色的所有菜单授权

    public Map<String, Object> findAllShopcartByUserId(HttpSession session) {
        Map<String, Object> map = new HashMap<>(16);
        Long userId = ((UserEntity) session.getAttribute(SystemConstant.USERLOGIN)).getUserId();
        List<ShopcartEntity> shopcartByUserId = shopcartMapper.findAllShopcartByUserId(userId);
        map.put("shopcart", shopcartByUserId);
        return map;
    }

    /**
     * 新增该用户某个SKU菜品的数量
     * @param shopcartId
     * @return
     */
    @Override
    public Map<String, Object> addNumCountOne(Long shopcartId) {
        Map<String, Object> map = new HashMap<>(16);
        if (shopcartMapper.addNumCountOne(shopcartId) > 0) {
            map.put(SystemConstant.FLAG, true);
        }else {
            map.put(SystemConstant.FLAG, false);
        }
        return map;
    }

    /**
     * 减少该用户某个SKU菜品的数量
     * @param shopcartId
     * @return
     */
    @Override
    public Map<String, Object> reduceNumCountOne(Long shopcartId) {
        Map<String, Object> map = new HashMap<>(16);
        if (shopcartMapper.reduceNumCountOne(shopcartId) > 0) {
            map.put(SystemConstant.FLAG, true);
        }else {
            map.put(SystemConstant.FLAG, false);
        }
        return map;
    }

    /**
     * 删除购物车的某一个条目
     * @param shopcartId
     * @return
     */
    @Override
    public Map<String, Object> deleteShopcart(Long shopcartId) {
        Map<String, Object> map = new HashMap<>(16);

                        }
                        //4. 添加投诉记录
                        if (complaintMapper.addComplaint(vo) <= 0){
                            throw new RuntimeException();
                        }
                        map.put(SystemConstant.FLAG, true);
                        map.put(SystemConstant.MESSAGE, "您的投诉已收到，很抱歉为您造成困扰，我们将针对您的投诉尽快做出处理");
                        return map;
                    }
                }
                //2.2 投诉类型为菜品投诉
                case 2:{
                    //根据SKU编号查询菜品信息
                    FoodSkuEntity sku = skuMapper.findFoodSkuBySkuId(Long.parseLong(vo.getTarget()));
                    if (foodMapper.addFaultCountOne(sku.getFoodId()) <= 0){
                        throw new RuntimeException();
                    }else {
                        //3. 修改订单为已投诉
                        if (orderMapper.complainted(order.getOrderId()) <= 0){
                            throw new RuntimeException();
                        }
                        //4. 修改投诉对象为sku名称而不是sku编号
                        vo.setTarget(sku.getSkuName());
                        //5. 添加投诉记录
                        if (complaintMapper.addComplaint(vo) <= 0){
                            throw new RuntimeException();
                        }
                        map.put(SystemConstant.FLAG, true);
                        map.put(SystemConstant.MESSAGE, "您的投诉已收到，很抱歉为您造成困扰，我们将针对您的投诉尽快做出处理");
                        return map;
                    }
                }
                //2.3 投诉类型为其他
                default:
                    //1. 修改订单为已投诉
                    if (orderMapper.complainted(order.getOrderId()) <= 0){
                        throw new RuntimeException();
                    }
                    //2. 添加投诉记录
                    if (complaintMapper.addComplaint(vo) <= 0){
                        throw new RuntimeException();
                    }
                    map.put(SystemConstant.FLAG, true);
                    map.put(SystemConstant.MESSAGE, "您的投诉已收到，很抱歉为您造成困扰，我们将针对您的投诉尽快做出处理");
                    return map;
            }
        }catch (RuntimeException e){
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "投诉失败");
        }
        return map;

    /**
     * 菜品图片上传
     * @param foodImage
     * @return
     */
    @Override
    public Map<String, Object> uploadFile(MultipartFile foodImage) {
        //用于存储LayUI文件上传所必须的键值
        Map<String, Object> map = new HashMap<>(16);
        //判断一下文件是否为空
        if (!foodImage.isEmpty()) {
            //将文件重命名
            String newFileName = FileUploadUtil.rename(foodImage);
            //全部文件都放在一个文件夹下不好管理，所以以日期作为文件夹进行管理
            //组装路径
            String finalPath = new SimpleDateFormat("yyyyMMdd").format(new Date()) + "/" + newFileName;
            //获得文件对象，参数1：文件上传的路径，参数2：文件名称（包括文件夹）
            File path = new File(SystemConstant.UPLOADPATH + SystemConstant.FOODPATH, finalPath);
            if (!path.getParentFile().exists()) {
                //如果文件夹不存在，就创建文件夹
                path.getParentFile().mkdirs();
            }
            try {
                //将文件保存到磁盘中
                foodImage.transferTo(path);
                /*
                 * 严格按照LayUI规定传递所必须的参数
                 */
                map.put("code", 0);
                map.put("msg", "文件上传成功");
                Map<String, Object> dataMap = new HashMap<>(16);
                //图片路径
                dataMap.put("src", "/meal/upload/food/" + finalPath);
                //鼠标悬停时显示的文本
                dataMap.put("title", newFileName);
                //保存图片路径，不包括前面的文件夹，从模块文件夹起始
                dataMap.put("imagePath", SystemConstant.FOODPATH + finalPath);
                map.put("data", dataMap);
            } catch (IOException e) {
                e.printStackTrace();
            }

/**
 * 评论服务层实现类
 */
@Service
@Transactional
public class CommentServiceImpl implements CommentService {

    @Autowired
    private CommentMapper commentMapper;
    @Autowired
    private OrderDetailMapper orderDetailMapper;
    @Autowired
    private FoodMapper foodMapper;
    @Autowired
    private UserMapper userMapper;

    /**
     * 用户发表评论
     * @param session
     * @param vo
     * @return
     */
    @Override
    public Map<String, Object> addComment(CommentVo vo, HttpSession session) {
        Map<String, Object> map = new HashMap<>(16);
        Long userId = ((UserEntity) session.getAttribute(SystemConstant.USERLOGIN)).getUserId();
        vo.setUserId(userId);
        try {
            //1. 增加评论
            if (commentMapper.addComment(vo) <= 0) {
                throw new RuntimeException();
            }
            //2.1 根据细则编号查询对应细则
            OrderDetailEntity orderDetail = orderDetailMapper.findOrderDetailById(vo.getOrderDetailId());
            //2.2 增加一条该菜品的评论数（一定要先加一条，否则如果是没人评价的菜品会报除零异常 直接GG）

     * @param ticketTypeId
     * @return
     */
    @Override
    public Map<String, Object> deleteTicketType(Long ticketTypeId) {
        Map<String, Object> map = new HashMap<>(16);
        if (ticketTypeMapper.deleteTicketType(ticketTypeId) > 0) {
            map.put(SystemConstant.FLAG, true);
            map.put(SystemConstant.MESSAGE, "优惠券类型删除成功");
        }else {
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "优惠券类型删除失败，仍有用户已领取该券未使用");
        }
        return map;
    }

}

/**
 * 用户地址管理服务层实现类
 */
@Service
@Transactional
public class AddressServiceImpl implements AddressService {

    @Autowired
    private AddressMapper addressMapper;

    /**
     * 查找该角色的所有地址信息

    @Override
    public Map<String, Object> addShopcart(Long skuId, Integer numCount, HttpSession session) {
        Map<String, Object> map = new HashMap<>(16);
        Long userId = ((UserEntity) session.getAttribute(SystemConstant.USERLOGIN)).getUserId();
        //先要查询一下该用户的购物车中是否有该菜品SKU信息，有的话合并，没有的话才加上去
        ShopcartEntity record = shopcartMapper.findShopcartRecord(userId, skuId);
        if (record==null) {
            //封装实体类
            ShopcartEntity shopcart = new ShopcartEntity();
            shopcart.setNumCount(numCount);shopcart.setUserId(userId);shopcart.setSkuId(skuId);
            if (shopcartMapper.addShopcart(shopcart) > 0) {
                map.put(SystemConstant.FLAG, true);
                map.put(SystemConstant.MESSAGE, "菜品已经添加到购物车中啦！");
            }else {
                map.put(SystemConstant.FLAG, false);
                map.put(SystemConstant.MESSAGE, "菜品添加到购物车失败");
            }
        }else {
            if (shopcartMapper.addNumCount(record.getShopcartId(), numCount) > 0) {
                map.put(SystemConstant.FLAG, true);
                map.put(SystemConstant.MESSAGE, "购物车中该菜品数量修改成功！");
            }else {
                map.put(SystemConstant.FLAG, false);
                map.put(SystemConstant.MESSAGE, "菜品添加到购物车失败");
            }
        }
        return map;
    }

    /**
     * 查找该用户下的所有购物车信息
     * @param session
     * @return
     */
    @Override
    public Map<String, Object> findAllShopcartByUserId(HttpSession session) {
        Map<String, Object> map = new HashMap<>(16);
        Long userId = ((UserEntity) session.getAttribute(SystemConstant.USERLOGIN)).getUserId();
        List<ShopcartEntity> shopcartByUserId = shopcartMapper.findAllShopcartByUserId(userId);
        map.put("shopcart", shopcartByUserId);

    public Map<String, Object> receiveTicket(Long ticketTypeId, HttpSession session) {
        Map<String, Object> map = new HashMap<>(16);
        //根据编号查询优惠券类别
        TicketTypeEntity ticketType = ticketTypeMapper.findTicketTypeById(ticketTypeId);
        UserEntity user = (UserEntity) session.getAttribute(SystemConstant.USERLOGIN);
        //判断用户的积分够不够领取
        if (user.getScore() < ticketType.getNeedScore()){
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "很抱歉，您的积分不足以兑换该优惠券");
            return map;
        }
        //如果剩余不足返回失败
        if ((ticketType.getTicketNum()-ticketType.getReceive()) <= 0) {
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "很抱歉，该优惠券被抢光啦");
            return map;
        }
        //领取成功添加优惠券领取记录，扣除用户积分,优惠券类别已领取数+1
        if (ticketMapper.addTicket(ticketTypeId, ticketType.getLiveTime(), user.getUserId())>0 &&
            userMapper.modifyUserScore(-ticketType.getNeedScore(), user.getUserId())>0 &&
            ticketTypeMapper.addReceiveOne(ticketTypeId)>0) {
            user.setScore(user.getScore()-ticketType.getNeedScore());
            session.setAttribute(SystemConstant.USERLOGIN, user);
            map.put(SystemConstant.FLAG, true);
            map.put(SystemConstant.MESSAGE, "优惠券领取成功");
        }else {
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "优惠券领取失败");
        }
        return map;
    }

    /**
     * 根据页面信息查询优惠券领取记录
     * @param vo
     * @return
     */
    @Override
    public LayuiTableDataResult findTicketListByPage(TicketVo vo) {
        //查询过期的优惠券，设置其状态为过期
        List<Long> ticketOutTime = ticketMapper.findTicketIdListOutTime();
        for (Long ticketId : ticketOutTime) {
            ticketMapper.setOutTime(ticketId);
        }
        PageHelper.startPage(vo.getPage(), vo.getLimit());

@Service
@Transactional
public class RoleServiceImpl implements RoleService {

    @Autowired
    private RoleMapper roleMapper;

    @Autowired
    private MenuMapper menuMapper;

    /**
     * 根据页面的条件查询角色列表
     * @param vo
     * @return
     */
    @Override
    public LayuiTableDataResult findRoleListByPage(RoleVo vo) {

     * @return
     */
    @Override
    public boolean generateSku(List<Map<String, Object>> foodParamList, Long foodId, String foodName) {
        try{
            //生成一个二维数组
            String[][] foodattrArr = new String[foodParamList.size()][];
            for (int i = 0; i < foodParamList.size(); i++) {
                //将Map映射转换成json字符串
                String json = JSON.toJSONString(foodParamList.get(i), true);
                Long attrId = Long.parseLong(foodParamList.get(i).get("attrId").toString());
                //将json数组转换成List集合
                List<String> foodvalueList = JSON.parseArray(JSON.parseObject(json).getString("foodvalueArr"), String.class);
                foodattrArr[i] = new String[foodvalueList.size()];
                for (String foodvalueName : foodvalueList) {
                    //将菜品规格添加到规格表中
                    String name = ((String) JSONObject.parseObject(foodvalueName).get("foodvalueName"));
                    foodvalueMapper.addFoodvalue(foodId, attrId, name);
                    foodattrArr[i][foodvalueList.indexOf(foodvalueName)] = name;
                }
            }
            //遍历二维数组，拼接SKU名称，生成菜品SKU信息
            List<StringBuilder> skuName = new ArrayList<>();
            List<StringBuilder> skuNameList = FoodSkuUtil.buildSku(foodattrArr, foodName, skuName);
            for (StringBuilder sb : skuNameList) {
                foodSkuMapper.addFoodSku(sb.toString(), foodId);
            }
            return true;
        }catch (Exception e) {
            return false;
        }
    }

    /**
     * 修改菜品SPU信息
     * @param vo
     * @param session
     * @return
     */
    @Override
    public Map<String, Object> modifyFood(FoodVo vo, HttpSession session) {
        Map<String, Object> map = new HashMap<>(16);

        return map;
    }

    /**
     * 新增该用户某个SKU菜品的数量
     * @param shopcartId
     * @return
     */
    @Override
    public Map<String, Object> addNumCountOne(Long shopcartId) {
        Map<String, Object> map = new HashMap<>(16);
        if (shopcartMapper.addNumCountOne(shopcartId) > 0) {
            map.put(SystemConstant.FLAG, true);
        }else {
            map.put(SystemConstant.FLAG, false);
        }
        return map;
    }

    /**
     * 减少该用户某个SKU菜品的数量
     * @param shopcartId
     * @return
     */
    @Override
    public Map<String, Object> reduceNumCountOne(Long shopcartId) {
        Map<String, Object> map = new HashMap<>(16);
        if (shopcartMapper.reduceNumCountOne(shopcartId) > 0) {
            map.put(SystemConstant.FLAG, true);
        }else {
            map.put(SystemConstant.FLAG, false);
        }
        return map;
    }

    /**
     * 删除购物车的某一个条目
     * @param shopcartId
     * @return
     */

    @RequestMapping("/menuManage.html")
    public String menuManage(){
        return "menu/menuManage";
    }

    /**
     * 跳转到配送员管理界面
     * @return
     */
    @RequestMapping("/deliverManage.html")
    public String deliverManage(){
        return "deliver/deliverManage";
    }

    /**
     * 跳转到菜品类别管理界面
     * @return
     */
    @RequestMapping("/foodtypeManage.html")
    public String foodtypeManage(){
        return "food/foodtypeManage";
    }

    /**
     * 跳转到菜品规格组管理界面
     * @return
     */
    @RequestMapping("/foodattrManage.html")
    public String foodattrManage(){
        return "food/foodattrManage";
    }

    /**
     * 跳转到菜品SPU管理界面
     * @return
     */
    @RequestMapping("/foodManage.html")
    public String foodManage(){
        return "food/foodManage";
    }

    /**
     * 跳转到菜品SKU管理界面
     * @return
     */
    @RequestMapping("/foodSkuManage.html")
    public String foodSkuManage(){
        return "food/foodSkuManage";
    }

    /**
     * 跳转到优惠券类别管理界面
     * @return

@Service
@Transactional
public class ComplaintServiceImpl implements ComplaintService {

    @Autowired
    private ComplaintMapper complaintMapper;
    @Autowired
    private DeliverMapper deliverMapper;
    @Autowired
    private OrderMapper orderMapper;
    @Autowired
    private FoodMapper foodMapper;
    @Autowired
    private FoodSkuMapper skuMapper;

    /**
     * 用户发表投诉
     * @param vo
     * @param session
     * @return
     */
    @Override
    public Map<String, Object> addComplaint(ComplaintVo vo, HttpSession session) {
        Map<String, Object> map = new HashMap<>(16);
        Long userId = ((UserEntity) session.getAttribute(SystemConstant.USERLOGIN)).getUserId();
        vo.setUserId(userId);
        //1. 根据订单编号查询订单
        OrderEntity order = orderMapper.findOrderById(vo.getOrderId());
        //2. 判断投诉的类型
        try {
            switch (vo.getComplaintType()){
                //2.1 投诉类型为配送员投诉
                case 1:{
                    if (deliverMapper.addFaultCountOne(order.getDeliverId()) <= 0){
                        map.put(SystemConstant.FLAG, false);
                        map.put(SystemConstant.MESSAGE, "投诉失败，该订单还无配送员接单");
                        return map;
                    }else {
                        //3. 修改订单为已投诉
                        if (orderMapper.complainted(order.getOrderId()) <= 0){
                            throw new RuntimeException();
                        }
                        //4. 添加投诉记录
                        if (complaintMapper.addComplaint(vo) <= 0){
                            throw new RuntimeException();
                        }

            //删除该角色
            if (roleMapper.deleteRole(roleId) >= 1){
                map.put(SystemConstant.FLAG, true);
                map.put(SystemConstant.MESSAGE, "角色删除成功");
                return map;
            }
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "角色删除失败");
        }else {
            map.put(SystemConstant.FLAG, false);
            map.put(SystemConstant.MESSAGE, "仍有用户使用该角色，角色删除失败");
        }
        return map;
    }

}

/**
 * 投诉 服务层实现类
 */
@Service
@Transactional
public class ComplaintServiceImpl implements ComplaintService {

    @Autowired
    private ComplaintMapper complaintMapper;
    @Autowired
    private DeliverMapper deliverMapper;