基于javaweb+mysql的springboot前后端分离网上手机商城平台系统设计和实现(java+vue+redis+springboot+mysql+ssm)

基于javaweb+mysql的springboot前后端分离网上手机商城平台系统设计和实现(java+vue+redis+springboot+mysql+ssm)

运行环境

Java≥8、MySQL≥5.7、Node.js≥10

开发工具

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

前端：WebStorm/VSCode/HBuilderX等均可

适用

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

功能说明

基于javaweb+mysql的SpringBoot前后端分离网上手机商城平台系统设计和实现(java+vue+redis+springboot+mysql+ssm)

主要模块设计如下： 前后端主要技术：Java springboot springMVC mybatis mysql vue jquery node.js redis

1. 用户注册和登录功能：。

2. 用户信息的管理以及角色的管理、不同用户角色具有不同的功能权限操作。

3. 商品的操作、包括商品列表信息、商品的分离、商品的详情、品牌和规格等操作。

4. 购物车的管理操作：

5. 订单管理操作：

6）用户退货管理

7）手机商品类型的管理

8）手机商品信息的预览、查看、搜索

9）修改密码、退出登录等功能

        if(accountNumber!=null && password!=null){
//            SimpleHash md5 = new SimpleHash("MD5", password, ByteSource.Util.bytes(accountNumber), 2);
//            password=md5.toHex();
            Integer id = userService.selectIdByKey(accountNumber);
            User user = new User();
            user.setUserId(id);
            user.setPassword(password);
            if(userService.updateById(user)){
                return CommonResult.success("重置密码成功",user);
            }else{
                return CommonResult.error("重置密码失败");
            }
        }
        return CommonResult.error("用户数据不存在");
    }

    /*用于注册新用户*/
    @RequestMapping(value = "/allow/add")
    private CommonResult add(User user) {
        if(user.getPassword()!=null && user.getUserName()!=null){
//            SimpleHash md5 = new SimpleHash("MD5", user.getPassword(), ByteSource.Util.bytes(user.getAccountNumber()), 2);
//            user.setPassword(md5.toHex());
            user.setUserState(true);
            user.setCreatTime(Timestamp.valueOf(LocalDateTime.now()));
            if(userService.insertData(user)){
                logger.info("成功添加了一个新用户");
                return CommonResult.success("注册成功",user);
            }else{
                return CommonResult.error("注册失败");
            }
        }
        return CommonResult.error("用户数据不存在");
    }

    //更新用户信息
    @RequestMapping(value = "/allow/update")
    private CommonResult update(User user) {
        System.out.println(user);
        if(userService.updateById(user)){
            return CommonResult.success("信息保存成功",user);
        }else{
            return CommonResult.error("信息保存失败");
        }
    }

}
package com.qiu.controller;

            ReturnGoods returnGoods = new ReturnGoods();
            returnGoods.setReturnId(returnId);
            returnGoods.setReturnState("待收货");
            returnGoods.setDealTime(new Date());
            if(returnGoodsService.updateById(returnGoods)){
                return CommonResult.success("更新成功",returnGoods);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退货数据不完整");
    }

    /*商家收到寄回的商品*/
    @RequestMapping(value = "/returnGoods/receipt")
    private CommonResult receipt(Integer returnId) {
        if(returnId!=null){
            ReturnGoods returnGoods = new ReturnGoods();
            returnGoods.setReturnId(returnId);
            returnGoods.setReturnState("退货完成");
            returnGoods.setDealTime(new Date());
            if(returnGoodsService.updateById(returnGoods)){
                return CommonResult.success("更新成功",returnGoods);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退货数据不完整");
    }

    @RequestMapping(value = "/returnGoods/deleteReturn")
    private CommonResult deleteReturn(Integer returnId) {
        if(returnId!=null){
            if(returnGoodsService.deleteById(returnId)){
                return CommonResult.success("删除成功",returnId);
            }else{
                return CommonResult.error("删除失败");
            }
        }
        return CommonResult.error("商品退货数据不存在");
    }

                if(returnGoodsService.updateById(returnGoods)){
                    return CommonResult.success("更新成功",returnGoods);
                }else{
                    return CommonResult.error("更新失败");
                }
            }else {
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退货数据不存在");
    }

    /*同意买家退货*/
    @RequestMapping(value = "/returnGoods/dealRefund")
    private CommonResult dealRefund(Integer returnId,String operatorNumber,String operatorName) {
        if(returnId!=null){
            ReturnGoods returnGoods = returnGoodsService.selectById(returnId);
            returnGoods.setReturnState("退款完成");
            returnGoods.setDealTime(new Date());
            returnGoods.setOperatorNumber(operatorNumber);
            returnGoods.setOperatorName(operatorName);
            String orderNo = returnGoods.getOrderNo();
            Integer orderId = orderService.selectIdByKey(orderNo);
            Order order = new Order();
            order.setOrderId(orderId);
            order.setReturnState(true);
            order.setOrderState("已退款");
            Logistics logistics = logisticsService.selectOrderNo(orderNo);
            if(logistics!=null){
                logisticsService.deleteById(logistics.getLogisticId());
            }
            if(orderService.updateById(order)){
                if(returnGoodsService.updateById(returnGoods)){
                    return CommonResult.success("更新成功",returnGoods);
                }else{
                    return CommonResult.error("更新失败");
                }
            }else{
                return CommonResult.error("更新失败");
            }
        }

        List<Supplier> suppliers = supplierService.selectAllUsable();
        if(suppliers!=null){
            return CommonResult.success("供货商查询成功",suppliers);
        }else{
            return CommonResult.error("供货商查询失败");
        }
    }
    /*查询全部供应商名称*/
    @RequestMapping(value = "/supplier/findAllName")
    private CommonResult findAllName() {
        List<String> names = supplierService.selectAllName();
        if(names!=null){
            return CommonResult.success("供货商名称查询成功",names);
        }else{
            return CommonResult.error("供货商名称查询失败");
        }
    }
    /*查询供应商是否存在*/
    @RequestMapping(value = "/supplier/existSupplier")
    private CommonResult existSupplier(Integer supplierId,String supplierName) {
        Boolean isExist = supplierService.existsWithSupplierName(supplierId,supplierName);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    /*添加供应商*/
    @RequestMapping(value = "/supplier/addSupplier")
    private CommonResult addSupplier(Supplier supplier) {
        if(supplier!=null){
            if(supplierService.insertData(supplier)){
                return CommonResult.success("添加成功",supplier);
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("供应商数据不存在");
    }
    /*修改供应商*/
    @RequestMapping(value = "/supplier/updateSupplier")
    private CommonResult updateSupplier(Supplier supplier) {
        if(supplier!=null){
            if(supplierService.updateById(supplier)){
                return CommonResult.success("更新成功",supplier);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("供应商数据不存在");
    }
    /*删除供应商*/
    @RequestMapping(value = "/supplier/deleteSupplier")

    @RequestMapping(value = "/productBrand/update")
    private CommonResult updateBrand(ProductBrand productBrand) {
        if(productBrandService.updateById(productBrand)){
            return CommonResult.success("商品品牌修改成功",productBrand);
        }else{
            return CommonResult.error("商品品牌修改失败");
        }
    }

    @RequestMapping(value = "/productBrand/deleteById")
    private CommonResult deleteBrandById(Integer brandId) {
        if(productBrandService.deleteById(brandId)){
            return CommonResult.success("商品品牌删除成功","brandId: "+brandId);
        }else{
            return CommonResult.error("商品品牌删除失败");
        }
    }

    @RequestMapping(value = "/productBrand/deleteByName")
    private CommonResult deleteBrandByName(String brandName) {
        if(productBrandService.deleteByName(brandName)){
            return CommonResult.success("商品品牌删除成功","brandName: "+brandName);
        }else{
            return CommonResult.error("商品品牌删除失败");
        }
    }

    @RequestMapping(value = "/productBrand/findAll")
    private CommonResult findAllBrand() {
        List<ProductBrand> productBrands = productBrandService.selectAll();
        if(productBrands!=null){
            return CommonResult.success("商品品牌查询成功",productBrands);
        }else{
            return CommonResult.error("商品品牌查询失败");
        }
    }

    @RequestMapping(value = "/productBrand/existsBrandName")
    private CommonResult existsBrandName(Integer brandId,String brandName) {
        Boolean isExist = productBrandService.existsWithBrandName(brandId,brandName);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{

            order.setOrderState("待发货");
            if(orderService.updateById(order)){
                if(returnGoodsService.updateById(returnGoods)){
                    return CommonResult.success("更新成功",returnGoods);
                }else{
                    return CommonResult.error("更新失败");
                }
            }else {
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退款数据不存在");
    }

    /*同意买家退货*/
    @RequestMapping(value = "/returnGoods/dealWithReturn")
    private CommonResult dealWithReturn(Integer returnId,String operatorNumber,String operatorName) {
        if(returnId!=null){
            ReturnGoods returnGoods = returnGoodsService.selectById(returnId);
            returnGoods.setReturnState("允许退货");
            returnGoods.setDealTime(new Date());
            returnGoods.setOperatorNumber(operatorNumber);
            returnGoods.setOperatorName(operatorName);
            String orderNo = returnGoods.getOrderNo();
            Integer orderId = orderService.selectIdByKey(orderNo);
            Order order = new Order();
            order.setOrderId(orderId);
            order.setReturnState(true);
            order.setOrderState("已退货");
            Logistics logistics = logisticsService.selectOrderNo(orderNo);
            if(logistics!=null){
                logisticsService.deleteById(logistics.getLogisticId());
            }
            if(orderService.updateById(order)){
                if(returnGoodsService.updateById(returnGoods)){
                    return CommonResult.success("更新成功",returnGoods);
                }else{
                    return CommonResult.error("更新失败");
                }
            }else{
                return CommonResult.error("更新失败");
            }
        }

            mailService.sendAttachmentsMail(sendTo, "文件操作", content, filePath);
            return "发送成功！";
        } catch (Exception e) {
            e.printStackTrace();
            return "发送邮件时发生异常,稍后请重新发送！";
        }
    }

    /**
     * 验证输入的验证码是否正确
     *
     * @param key  验证的依据
     * @param code 验证码
     */
    @RequestMapping(value = "/allow/checkCode")
    public CommonResult checkCode(String key, String code) {
        String codeK = redisTemplate.opsForValue().get(key);
        if (codeK == null) {
            return CommonResult.error("验证码不存在或已过期，请重新发送！");
        }
        if (codeK.equals(code)) {
            redisTemplate.delete(key);
            return CommonResult.success("验证码成功！", true);
        } else {
            return CommonResult.success("验证码错误！", false);
        }
    }

    /**
     * 用于绑定手机号操作，发送验证码
     *
     * @param phone 发送的手机号
     */
    @RequestMapping(value = "/util/smsCode")
    public CommonResult aliYunSmsCode(String phone) {
        String code = redisTemplate.opsForValue().get(phone);
        if (!StringUtils.isEmpty(code)) {
            return CommonResult.error(phone + "的验证码还未过期！");
        }
        //生成验证码并存储到redis中
        code = MyUtils.getCode(6);
        boolean isSend = aliYunSmsService.sendSms(phone, code);
        if (isSend) {
            redisTemplate.opsForValue().set(phone, code, 10, TimeUnit.MINUTES);
            return CommonResult.success("验证码已发送，网络有延迟请稍等~");
        } else {
            return CommonResult.error("验证码发送失败，请稍后重试~");

 */

@RestController
@CrossOrigin
public class UtilController {
    private final RedisTemplate<String, String> redisTemplate;
    private final AliYunSmsService aliYunSmsService;
    private final IMailService mailService;
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    public UtilController(RedisTemplate<String, String> redisTemplate, IMailService mailService, AliYunSmsService aliYunSmsService) {
        this.mailService = mailService;
        this.aliYunSmsService = aliYunSmsService;
        this.redisTemplate = redisTemplate;
    }

    /**
     * 发送一个简单的文本邮件
     *
     * @param sendTo 收件人
     */
    @RequestMapping(value = "/util/send")
    public String sendmail(String sendTo) {
        mailService.sendSimpleMail(sendTo, "主题：你好普通邮件", "内容：第一封邮件");
        return "发送成功！";
    }

    /**
     * 发送一个邮箱随机验证码
     *
     * @param sendTo 收件人
     */
    @RequestMapping(value = "/allow/sendHtmlCode")
    public CommonResult sendHtmlCode(String sendTo) {
//        long startTime = System.currentTimeMillis(); //获取开始时间
        try {
            String code = MyUtils.getCode(6);
//            long oneTime = System.currentTimeMillis(); //获取第一阶段时间
            Map<String, Object> data = new HashMap<>();
            data.put("code", code);
            data.put("year", Calendar.getInstance().get(Calendar.YEAR));
            redisTemplate.opsForValue().set(sendTo, code, 10, TimeUnit.MINUTES);
            System.out.println("验证码是：" + code);
//          long twoTime = System.currentTimeMillis(); //获取第二阶段时间
            mailService.sendTemplateMail(sendTo, "操作验证码", "mail", data);
//          long threeTime = System.currentTimeMillis(); //获取第三阶段时间
//          MyUtils.speedTest(startTime,oneTime,twoTime,threeTime);

            return CommonResult.error("查询失败");
        }
    }

    /*查询所有用户*/
    @RequestMapping(value = "/userRole/findAll")
    private CommonResult findAll() {
        List<UserRole> userRoles = userRoleService.selectAll();
        if(userRoles!=null){
            return CommonResult.success("查询成功",userRoles);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*查询所有用户*/
    @RequestMapping(value = "/userRole/existsRole")
    private CommonResult existsRole(Integer roleId) {
        Boolean isExist = userRoleService.existsRole(roleId);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/userRole/add")
    private CommonResult add(UserRole userRole) {
        if(userRole!=null){
            if(userRoleService.insertData(userRole)){
                return CommonResult.success("添加成功",userRole);
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("用户数据不存在");
    }

    @RequestMapping(value = "/userRole/delete")
    private CommonResult delete(Integer userId) {
        Boolean bool = userRoleService.deleteById(userId);
        System.out.println(bool);
        if(bool){
            return CommonResult.success("删除成功",userId);
        }else{
            return CommonResult.error("删除失败");
        }
    }

        if(maps!=null){
            return CommonResult.success("查询成功",maps);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*查询所有用户*/
    @RequestMapping(value = "/userRole/findAll")
    private CommonResult findAll() {
        List<UserRole> userRoles = userRoleService.selectAll();
        if(userRoles!=null){
            return CommonResult.success("查询成功",userRoles);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*查询所有用户*/
    @RequestMapping(value = "/userRole/existsRole")
    private CommonResult existsRole(Integer roleId) {
        Boolean isExist = userRoleService.existsRole(roleId);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/userRole/add")
    private CommonResult add(UserRole userRole) {
        if(userRole!=null){
            if(userRoleService.insertData(userRole)){
                return CommonResult.success("添加成功",userRole);
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("用户数据不存在");
    }

    @RequestMapping(value = "/userRole/delete")
    private CommonResult delete(Integer userId) {
        Boolean bool = userRoleService.deleteById(userId);
        System.out.println(bool);

            ReturnGoods returnGoods = new ReturnGoods();
            returnGoods.setReturnId(returnId);
            returnGoods.setReturnState("退货完成");
            returnGoods.setDealTime(new Date());
            if(returnGoodsService.updateById(returnGoods)){
                return CommonResult.success("更新成功",returnGoods);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退货数据不完整");
    }

    @RequestMapping(value = "/returnGoods/deleteReturn")
    private CommonResult deleteReturn(Integer returnId) {
        if(returnId!=null){
            if(returnGoodsService.deleteById(returnId)){
                return CommonResult.success("删除成功",returnId);
            }else{
                return CommonResult.error("删除失败");
            }
        }
        return CommonResult.error("商品退货数据不存在");
    }

    /*查询物流信息*/
    @RequestMapping(value = "/logistics/findInfoById")
    private CommonResult findInfoById(Integer logisticId) {
        Logistics logistics = logisticsService.selectById(logisticId);
        if(logistics!=null){
            return CommonResult.success("物流信息查询成功",logistics);
        }else{
            return CommonResult.error("物流信息查询失败");
        }
    }

    /*查询全部物流信息*/
    @RequestMapping(value = "/logistics/findAllInfo")
    private CommonResult findAllInfo() {
        List<Logistics> logistics = logisticsService.selectAll();
        if(logistics!=null){
            return CommonResult.success("物流信息查询成功",logistics);
        }else{
            return CommonResult.error("物流信息查询失败");
        }
    }

/**
 * @email qiudb.top@aliyun.com
 * @description 登录、退出、修改个人信息等业务操作
 */
@RestController
@CrossOrigin
public class OperateController {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    final RoleService roleService;
    final UserService userService;
    final UserRoleService userRoleService;
    public OperateController(UserService userService, RoleService roleService, UserRoleService userRoleService) {
        this.userService = userService;
        this.roleService = roleService;

                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退货数据不完整");
    }

    @RequestMapping(value = "/returnGoods/deleteReturn")
    private CommonResult deleteReturn(Integer returnId) {
        if(returnId!=null){
            if(returnGoodsService.deleteById(returnId)){
                return CommonResult.success("删除成功",returnId);
            }else{
                return CommonResult.error("删除失败");
            }
        }
        return CommonResult.error("商品退货数据不存在");
    }

    /*查询物流信息*/
    @RequestMapping(value = "/logistics/findInfoById")
    private CommonResult findInfoById(Integer logisticId) {
        Logistics logistics = logisticsService.selectById(logisticId);
        if(logistics!=null){
            return CommonResult.success("物流信息查询成功",logistics);
        }else{
            return CommonResult.error("物流信息查询失败");
        }
    }

    /*查询全部物流信息*/
    @RequestMapping(value = "/logistics/findAllInfo")
    private CommonResult findAllInfo() {
        List<Logistics> logistics = logisticsService.selectAll();
        if(logistics!=null){
            return CommonResult.success("物流信息查询成功",logistics);
        }else{
            return CommonResult.error("物流信息查询失败");
        }
    }

    @RequestMapping(value = "/logistics/addInfo")
    private CommonResult addInfo(Logistics logistics) {
        if(logistics!=null){
            if(logisticsService.insertData(logistics)){
                return CommonResult.success("物流信息添加成功",logistics);
            }else{
                return CommonResult.error("物流信息添加失败");
            }

    //删除vip信息
    @RequestMapping(value = "/vip/deleteVip")
    private CommonResult deleteVip(Integer vipId) {
        if(vipService.deleteById(vipId)){
            return CommonResult.success("删除成功",vipId);
        }else{
            return CommonResult.error("删除失败");
        }
    }
}
package com.qiu.controller;

@CrossOrigin
@RequestMapping("/alipay")
@Slf4j
@Controller
public class AlipayController {
    private final AlipayService alipayService;
    private final OrderService orderService;
    private final RedisTemplate<String,String> redisTemplate;
    private final String hostAddress;
    public AlipayController(AlipayService alipayService,OrderService orderService,RedisTemplate<String,String> redisTemplate) {
        this.alipayService = alipayService;
        this.orderService = orderService;
        this.redisTemplate = redisTemplate;
        this.hostAddress= PropertiesUtil.getServerHost() +":"+PropertiesUtil.getPort();
    }

    @RequestMapping("/")
    private String index(){
        return "index.html";
    }

    /*
    https://qiustudy.utools.club/alipay/create?orderNo=10060&orderName=花卷商城-华为手机支付订单&payPrice=4000

        }else{
            return CommonResult.error("删除失败");
        }
    }

    @RequestMapping(value = "/user/author")
    private CommonResult author(Integer userId,@RequestParam List<Integer> roleId) {
        System.out.println(userId);
        System.out.println(roleId);
        if(userId!=null && roleId!=null && roleId.size()!=0){
            if(userRoleService.deleteById(userId)){
                UserRole userRole = new UserRole();
                userRole.setUserId(userId);
                for (Integer id : roleId) {
                    userRole.setRoleId(id);
                    userRoleService.insertData(userRole);
                }
            }
            return CommonResult.success("授权成功");
        }else{
            return CommonResult.error("角色授权数据不完整！");
        }
    }

    /*查询所有VIP用户*/
    @RequestMapping(value = "/vip/findAllVip")
    private CommonResult findAllVip() {
        List<Vip> vips = vipService.selectAll();
        if(vips!=null){
            return CommonResult.success("查询成功",vips);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    /*查询VIP用户信息根据id*/
    @RequestMapping(value = "/vip/findVipById")
    private CommonResult findVipById(Integer vipId) {
        Vip vip = vipService.selectById(vipId);
        if(vip!=null){
            return CommonResult.success("查询成功",vip);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    /*查询VIP用户信息根据id*/
    @RequestMapping(value = "/vip/findVipByKey")
    private CommonResult findVipByKey(String accountNumber) {
        Vip vip = vipService.selectByKey(accountNumber);
        if(vip!=null){
            return CommonResult.success("查询成功",vip);
        }else{

                return CommonResult.success("添加成功",userRole);
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("用户数据不存在");
    }

    @RequestMapping(value = "/userRole/delete")
    private CommonResult delete(Integer userId) {
        Boolean bool = userRoleService.deleteById(userId);
        System.out.println(bool);
        if(bool){
            return CommonResult.success("删除成功",userId);
        }else{
            return CommonResult.error("删除失败");
        }
    }

}
package com.qiu.controller;

/**
 * @email qiudb.top@aliyun.com
 * @description 数据分析，商品数量，订单数量等分析业务
 */
@CrossOrigin
@RestController
public class OverViewController {
    final OrderService orderService;
    final ProductService productService;
    final ReturnGoodsService returnGoodsService;
    public OverViewController(OrderService orderService,ProductService productService,ReturnGoodsService returnGoodsService) {

        if(returnId!=null){
            ReturnGoods returnGoods = new ReturnGoods();
            returnGoods.setReturnId(returnId);
            returnGoods.setReturnState("退货完成");
            returnGoods.setDealTime(new Date());
            if(returnGoodsService.updateById(returnGoods)){
                return CommonResult.success("更新成功",returnGoods);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("商品退货数据不完整");
    }

    @RequestMapping(value = "/returnGoods/deleteReturn")
    private CommonResult deleteReturn(Integer returnId) {
        if(returnId!=null){
            if(returnGoodsService.deleteById(returnId)){
                return CommonResult.success("删除成功",returnId);
            }else{
                return CommonResult.error("删除失败");
            }
        }
        return CommonResult.error("商品退货数据不存在");
    }

    /*查询物流信息*/
    @RequestMapping(value = "/logistics/findInfoById")
    private CommonResult findInfoById(Integer logisticId) {
        Logistics logistics = logisticsService.selectById(logisticId);
        if(logistics!=null){
            return CommonResult.success("物流信息查询成功",logistics);
        }else{
            return CommonResult.error("物流信息查询失败");
        }
    }

    /*查询全部物流信息*/
    @RequestMapping(value = "/logistics/findAllInfo")
    private CommonResult findAllInfo() {
        List<Logistics> logistics = logisticsService.selectAll();

            return CommonResult.success("查询成功",resultMap);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/view/orderChartDATE")
    private CommonResult orderChartDATE(String startTime,String endTime) {
        Map<String, Object> data = new HashMap<>();
        List<Map<String, Object>> lineData = orderService.selectChartDATE(startTime,endTime);
        List<Map<String, Object>> ringData = orderService.selectProductTypeChart(startTime, endTime);
        Map<String, Object> countData = orderService.selectCountAndAmount(startTime,endTime);
        if(lineData.size()!=0){
            data.put("lineData",lineData);
        }
        if(ringData.size()!=0){
            data.put("ringData",ringData);
        }
        if(countData.size()!=0){
            data.put("countData",countData);
        }
        if(data.size()!=0){
            return CommonResult.success("查询成功",data);
        }else{
            return CommonResult.error("查询失败");
        }
    }

}
package com.qiu.controller;

/**
 * @email qiudb.top@aliyun.com
 * @description 描述
 */
@RestController
@CrossOrigin
public class BannerController {

        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/userRole/add")
    private CommonResult add(UserRole userRole) {
        if(userRole!=null){
            if(userRoleService.insertData(userRole)){
                return CommonResult.success("添加成功",userRole);
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("用户数据不存在");
    }

    @RequestMapping(value = "/userRole/delete")
    private CommonResult delete(Integer userId) {
        Boolean bool = userRoleService.deleteById(userId);
        System.out.println(bool);
        if(bool){
            return CommonResult.success("删除成功",userId);
        }else{
            return CommonResult.error("删除失败");
        }
    }

}
package com.qiu.controller;

            if(purchaseService.updateById(purchase)){
                return CommonResult.success("更新成功",purchase);
            }else{
                return CommonResult.error("更新失败");
            }
        }
        return CommonResult.error("采购信息数据不存在");
    }
    /*删除采购信息*/
    @RequestMapping(value = "/purchase/deletePurchase")
    private CommonResult deletePurchase(Integer purchaseId) {
        if(purchaseId!=null){
            if(purchaseService.deleteById(purchaseId)){
                return CommonResult.success("删除成功",purchaseId);
            }else{
                return CommonResult.error("删除失败");
            }
        }
        return CommonResult.error("采购信息数据不存在");
    }

    /*收货*/
    @RequestMapping(value = "/purchase/receipts")
    private CommonResult deletePurchase(String productNo,Integer purchaseId,Integer purchaseNumber) {
        Integer productId = productService.selectIdByKey(productNo);
        Product product = productService.selectById(productId);
        Integer lowestStock = product.getLowestStock();
        Integer productStock = product.getProductStock();
        product.setProductStock(productStock+purchaseNumber);
        product.setIsStockOut(product.getProductStock()<lowestStock);
        if(productService.updateById(product)){
            Purchase purchase = new Purchase();
            purchase.setPurchaseId(purchaseId);
            purchase.setReceiptStatus(true);
            purchase.setReceiptTime(new Date());
            if(purchaseService.updateById(purchase)){
                return CommonResult.success("收货成功",purchaseId);
            }else{
                return CommonResult.error("采购信息更新失败");
            }
        }else{
            return CommonResult.error("商品库存更新失败");
        }
    }
}
package com.qiu.controller;

            return CommonResult.success("查询成功",users);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*判断某个用户是否还存在*/
    @RequestMapping(value = "/user/existKey")
    private CommonResult existKey(String key) {
        Boolean isExist = userService.existsWithPrimaryKey(key);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*查询用户状态*/
    @RequestMapping(value = "/user/userState")
    private CommonResult userState(String accountNumber) {
        Boolean state = userService.selectUserState(accountNumber);
        if(state!=null){
            return CommonResult.success("查询成功",state);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*查询用户记录的总条数*/
    @RequestMapping(value = "/user/count")
    private CommonResult findCount() {
        Integer count = userService.selectCount();
        if(count!=null){
            if(count!=0){
                return CommonResult.success("查询成功",count);
            }else{
                return CommonResult.error("查询失败");
            }
        }else{
            return CommonResult.error("查询失败");
        }

    }

    //通过用户帐号去查询用户的id
    @RequestMapping(value = "/user/findIdByKey")
    private CommonResult findIdByKey(String key) {

                    newProduct.setIsSale(newStock>0);
                    if(productService.updateById(newProduct)){
                        if(orderService.insertData(order)){
                            redisTemplate.opsForValue().set(order.getOrderNo(),order.getOrderNo(),24, TimeUnit.HOURS);
                            return CommonResult.success("创建订单成功",order);
                        }else{
                            return CommonResult.error("创建订单失败");
                        }
                    }else{
                        return CommonResult.error("创建订单失败");
                    }
                }else{
                    return CommonResult.error("商品库存不足");
                }
            }
        }else{
            return CommonResult.error("订单数据不完整");
        }
    }

    @RequestMapping(value = "/order/cartOrder")
    private CommonResult cartOrder(String orderNo,String ordersInfo) {
        JSONArray jsonArray = JSON.parseArray(ordersInfo);
        List<Order> orders = JSONObject.parseArray(jsonArray.toJSONString(), Order.class);
        if(orders!=null){
            ArrayList<String> orderInfo = new ArrayList<>();
            ArrayList<String> productInfo = new ArrayList<>();
            for (Order order : orders) {
                Product product = productService.selectByKey(order.getProductNo());
                Integer productStock = product.getProductStock();
                Integer payAmount = order.getPayAmount();
                boolean isOk =productStock >= payAmount;
                if(isOk){
                    Product newProduct = new Product();
                    newProduct.setProductId(product.getProductId());
                    int newStock = productStock - payAmount;
                    newProduct.setProductStock(newStock);
                    newProduct.setIsStockOut(newStock<product.getLowestStock());
                    // 如果库存小于等于0，自动下架
                    newProduct.setIsSale(newStock>0);
                    if(productService.updateById(newProduct)){
                        if(orderService.insertData(order)){

                        }else{
                            return CommonResult.error("创建订单失败");
                        }
                    }else{
                        return CommonResult.error("创建订单失败");
                    }
                }else{
                    return CommonResult.error("商品库存不足");
                }
            }
        }else{
            return CommonResult.error("订单数据不完整");
        }
    }

    @RequestMapping(value = "/order/cartOrder")
    private CommonResult cartOrder(String orderNo,String ordersInfo) {
        JSONArray jsonArray = JSON.parseArray(ordersInfo);
        List<Order> orders = JSONObject.parseArray(jsonArray.toJSONString(), Order.class);
        if(orders!=null){
            ArrayList<String> orderInfo = new ArrayList<>();
            ArrayList<String> productInfo = new ArrayList<>();
            for (Order order : orders) {
                Product product = productService.selectByKey(order.getProductNo());
                Integer productStock = product.getProductStock();
                Integer payAmount = order.getPayAmount();
                boolean isOk =productStock >= payAmount;
                if(isOk){
                    Product newProduct = new Product();
                    newProduct.setProductId(product.getProductId());
                    int newStock = productStock - payAmount;
                    newProduct.setProductStock(newStock);
                    newProduct.setIsStockOut(newStock<product.getLowestStock());
                    // 如果库存小于等于0，自动下架
                    newProduct.setIsSale(newStock>0);
                    if(productService.updateById(newProduct)){
                        if(orderService.insertData(order)){
                            orderInfo.add(order.getOrderNo());
                            productInfo.add(order.getProductNo());
                        }
                    }
                }
            }
            if(orderInfo.size()!=0){

    private CommonResult findIdByKey(String key) {
        Integer id = roleService.selectIdByKey(key);
        if(id!=null){
            return CommonResult.success("查询成功","id: "+id);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/role/add")
    private CommonResult add(Role role) {
        if(role!=null){
            if(roleService.insertData(role)){
                return CommonResult.success("添加成功",role);
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("用户数据不存在");
    }

    @RequestMapping(value = "/role/update")
    private CommonResult update(Role role) {
        System.out.println(role);
        if(roleService.updateById(role)){
            return CommonResult.success("更新成功",role);
        }else{
            return CommonResult.error("更新失败");
        }
    }

    @RequestMapping(value = "/role/delete")
    private CommonResult delete(Integer roleId) {
        if(roleService.deleteById(roleId)){
            return CommonResult.success("删除成功",roleId);
        }else{
            return CommonResult.error("删除失败");
        }
    }
}
package com.qiu.controller;

            return CommonResult.success("新密码信息发送成功");
        } catch (Exception e) {
            return CommonResult.error("新密码信息发送失败");
        }
    }

    /**
     * 发送一个邮箱附件
     *
     * @param sendTo 收件人
     */
    @RequestMapping(value = "/util/sendFile")
    public String sendmailFile(String sendTo, String content) {
        try {
            String filePath = "F:\\IDEA\\JAVA_Program\\Springboot-Mall\\src\\main\\resources\\static\\1.zip";
            mailService.sendAttachmentsMail(sendTo, "文件操作", content, filePath);
            return "发送成功！";
        } catch (Exception e) {
            e.printStackTrace();
            return "发送邮件时发生异常,稍后请重新发送！";
        }
    }

    /**
     * 验证输入的验证码是否正确
     *
     * @param key  验证的依据
     * @param code 验证码
     */
    @RequestMapping(value = "/allow/checkCode")
    public CommonResult checkCode(String key, String code) {
        String codeK = redisTemplate.opsForValue().get(key);
        if (codeK == null) {
            return CommonResult.error("验证码不存在或已过期，请重新发送！");
        }
        if (codeK.equals(code)) {
            redisTemplate.delete(key);
            return CommonResult.success("验证码成功！", true);
        } else {
            return CommonResult.success("验证码错误！", false);
        }
    }

        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/specs/findAllByType")
    private CommonResult findAllSpecsByType(String productType) {
        List<Specs> specs = specsService.selectAllByType(productType);
        if(specs!=null){
            return CommonResult.success("查询成功",specs);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/specs/add")
    private CommonResult addSpecs(Specs specs) {
        if(specs!=null){
            if(specsService.insertData(specs)){
                return CommonResult.success("添加成功",specs);
            }else{
                return CommonResult.error("添加失败");
            }
        }
        return CommonResult.error("数据不存在");
    }

    @RequestMapping(value = "/specs/update")
    private CommonResult updateSpecs(Specs specs) {
        if(specsService.updateById(specs)){
            return CommonResult.success("更新成功",specs);
        }else{
            return CommonResult.error("更新失败");
        }
    }

    @RequestMapping(value = "/specs/delete")
    private CommonResult deleteSpecs(Integer specsId) {
        if(specsService.deleteById(specsId)){
            return CommonResult.success("删除成功",specsId);
        }else{
            return CommonResult.error("删除失败");
        }
    }

    /*商品 与 规格 的关联表*/

    /*查询所有商品规格对应信息*/