基于javaweb+mysql的springboot前后端分离网上商城项目设计和实现(java+ssm+springboot+vue+redis)

于 2023-08-22 19:52:45 发布
阅读量293 收藏
点赞数
文章标签： java mysql spring boot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_71097188/article/details/132434761
版权

基于javaweb+mysql的springboot前后端分离网上商城项目设计和实现(java+ssm+springboot+vue+redis)

运行环境

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

开发工具

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

前端：WebStorm/VSCode/HBuilderX等均可

适用

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

功能说明

基于javaweb+mysql的SpringBoot前后端分离网上商城项目设计和实现(java+ssm+springboot+vue+redis)

主要实现技术：Java、springmvc、springboot、mybatis、mysql、tomcat、shiro权限框架、vue、jquery、node.js 、redis数据库、邮箱相关等技术。

主要功能实现：

用户登录、注册、商城浏览、购买、订单、购物车、退货、用户、个人中心、修改密码、角色等管理

前端主页面：商品关键字搜索和分类搜索功能以及首页轮播图配置展示

首页个人中心主要功能：密码修改、订单、购物车、商品详情模块、可以购买、加入购物车

购买时需要填写用户手机号和收获地址等信息、注册时默认生成支付宝模拟账号密码：

后台管理员主要对商品数据进行管理、分类管理、订单管理以及用户管理扥。

商品列表数据管理、后台添加商品信息、商品基础数据的维护管理、商品订单详情管理：根据关键字查询以及查看每一个订单的详情信息

首页轮播图配置展示、用户角色和权限管理控制：

前后端源码结构：

数据库图：


    @RequestMapping(value = "/role/findIdByKey")
    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("删除失败");
        }
    }
}


            e.printStackTrace();
        }

    }

    @ResponseBody
    @PostMapping(value = "/vip", produces = "text/html;charset=utf-8")
    public String create(@RequestParam("orderNo") String orderNo,
                         @RequestParam("orderName") String orderName,
                         @RequestParam("payPrice") String payPrice,
                         @RequestParam("serialNumber") String serialNumber) {

        //开通vip的序列号暂时存入redis中
        redisTemplate.opsForValue().set(orderNo,serialNumber,2, TimeUnit.HOURS);
        //发起支付
        return alipayService.create(orderNo, orderName, payPrice);
    }

    /*
    https://qiustudy.utools.club/alipay/refund?orderNo=10060&payPrice=4000
     */
    @ResponseBody
    @RequestMapping(value = "/refund")
    public CommonResult refund(@RequestParam("orderNo") String orderNo,
                               @RequestParam("payPrice") String payPrice) {
        //发起支付
        try {
            alipayService.refund(orderNo,payPrice);

    @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("删除失败");
        }
    }

}


/**
 * @email qiudb.top@aliyun.com
 * @description 购物车业务类
 */
@RestController
@CrossOrigin
public class ShoppingCartController {
    final ShoppingCartService shoppingCartService;
    public ShoppingCartController(ShoppingCartService shoppingCartService){
        this.shoppingCartService = shoppingCartService;
    }

    /*商品类别*/
    @RequestMapping(value = "/shoppingCart/add")
    private CommonResult addShoppingCart(ShoppingCart shoppingCart) {
        if(shoppingCartService.insertData(shoppingCart)){
            return CommonResult.success("购物车添加成功",shoppingCart);
        }else{
            return CommonResult.error("购物车添加失败");
        }
    }

    @RequestMapping(value = "/shoppingCart/update")
    private CommonResult updateShoppingCart(ShoppingCart shoppingCart) {
        if(shoppingCartService.updateById(shoppingCart)){
            return CommonResult.success("购物车修改成功",shoppingCart);
        }else{
            return CommonResult.error("购物车修改失败");
        }
    }

    @RequestMapping(value = "/shoppingCart/deleteById")
    private CommonResult deleteShoppingCart(Integer cartId) {
        if(shoppingCartService.deleteById(cartId)){
            return CommonResult.success("购物车删除成功","cartId: "+cartId);
        }else{
            return CommonResult.error("购物车删除失败");
        }
    }
    @RequestMapping(value = "/shoppingCart/deleteByUser")
    private CommonResult deleteByUser(String accountNumber) {
        if(shoppingCartService.deleteByUser(accountNumber)){
            return CommonResult.success("购物车删除成功","accountNumber: "+accountNumber);
        }else{
            return CommonResult.error("购物车删除失败");

                for (String orderNo1 : ordersNo) {
                    Integer orderId = orderService.selectIdByKey(orderNo1);
                    Order order = new Order();
                    order.setOrderId(orderId);
                    order.setOrderState("待发货");
                    orderService.updateById(order);
                }
                response.sendRedirect("http://"+hostAddress+"/?#/myOrder");
            }
        }catch (IOException e) {
            e.printStackTrace();
        }

    }

    @ResponseBody
    @PostMapping(value = "/vip", produces = "text/html;charset=utf-8")
    public String create(@RequestParam("orderNo") String orderNo,
                         @RequestParam("orderName") String orderName,
                         @RequestParam("payPrice") String payPrice,
                         @RequestParam("serialNumber") String serialNumber) {

        //开通vip的序列号暂时存入redis中
        redisTemplate.opsForValue().set(orderNo,serialNumber,2, TimeUnit.HOURS);
        //发起支付
        return alipayService.create(orderNo, orderName, payPrice);
    }



    @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("删除失败");
        }
    }

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

    /*查询所有商品规格对应信息*/
    @RequestMapping(value = "/productSpecs/findAll")
    private CommonResult findAll() {
        List<ProductSpecs> productSpecs = productSpecsService.selectAll();
        if(productSpecs!=null){
            return CommonResult.success("查询成功",productSpecs);
        }else{
            return CommonResult.error("查询失败");
        }

    @RequestMapping(value = "/banner/deleteById")
    private CommonResult deleteTypeById(Integer bannerId) {
        if(bannerService.deleteById(bannerId)){
            return CommonResult.success("商品轮播图删除成功","bannerId: "+bannerId);
        }else{
            return CommonResult.error("商品轮播图删除失败");
        }
    }

    @RequestMapping(value = "/banner/findAll")
    private CommonResult findAllType() {
        List<Banner> banners = bannerService.selectAll();
        if(banners!=null){
            return CommonResult.success("商品轮播图查询成功",banners);
        }else{
            return CommonResult.error("商品轮播图查询失败");
        }
    }

    @RequestMapping(value = "/banner/findById")
    private CommonResult findById(Integer bannerId) {
        Banner banner = bannerService.selectById(bannerId);
        if(banner!=null){
            return CommonResult.success("商品轮播图查询成功",banner);
        }else{
            return CommonResult.error("商品轮播图查询失败");
        }
    }

}
@CrossOrigin
@Controller
public class OssController {

            return CommonResult.error("验证码发送失败，请稍后重试~");
        }
    }
}

/**
 * @email qiudb.top@aliyun.com
 * @description 商品规格、商品与商品规格的关联
 */

@RestController
@CrossOrigin
public class SpecsController {
    final SpecsService specsService;
    final ProductSpecsService productSpecsService;
    public SpecsController(SpecsService specsService,ProductSpecsService productSpecsService) {
        this.specsService = specsService;
        this.productSpecsService = productSpecsService;
    }
    /*根据id查询规格*/
    @RequestMapping(value = "/specs/findById")
    private CommonResult findById(Integer specsId) {
        Specs specs = specsService.selectById(specsId);
        if(specs!=null){
            return CommonResult.success("查询成功",specs);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    /*查询所有规格信息*/
    @RequestMapping(value = "/specs/findAll")
    private CommonResult findAllSpecs() {

        if(banners!=null){
            return CommonResult.success("商品轮播图查询成功",banners);
        }else{
            return CommonResult.error("商品轮播图查询失败");
        }
    }

    @RequestMapping(value = "/banner/findById")
    private CommonResult findById(Integer bannerId) {
        Banner banner = bannerService.selectById(bannerId);
        if(banner!=null){
            return CommonResult.success("商品轮播图查询成功",banner);
        }else{
            return CommonResult.error("商品轮播图查询失败");
        }
    }

}
@CrossOrigin
@Controller
public class OssController {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    private final AliyunOssUtil ossUtil;
    public OssController(AliyunOssUtil ossUtil) {
        this.ossUtil = ossUtil;
    }
    @RequestMapping("/uploadImage")
    @ResponseBody
    public CommonResult upload(@RequestParam("name") String folderName, @RequestParam("file") MultipartFile file) {
        String path = null;
        try {
            if (file != null) {

    public ReturnProductController(ProductService productService,OrderService orderService,ReturnReasonService returnReasonService,ReturnGoodsService returnGoodsService,LogisticsService logisticsService){
        this.returnReasonService = returnReasonService;
        this.returnGoodsService = returnGoodsService;
        this.logisticsService = logisticsService;
        this.orderService = orderService;
        this.productService = productService;
    }
    /*退货原因*/
    @RequestMapping(value = "/returnReason/findReasonById")
    private CommonResult findReasonById(Integer reasonId) {
        ReturnReason returnReason = returnReasonService.selectById(reasonId);
        if(returnReason!=null){
            return CommonResult.success("退货原因查询成功",returnReason);
        }else{
            return CommonResult.error("退货原因查询失败");
        }
    }
    /*查询全部退货原因*/
    @RequestMapping(value = "/returnReason/findAllReason")
    private CommonResult findAllReason() {
        List<ReturnReason> returnReasons = returnReasonService.selectAll();
        if(returnReasons!=null){
            return CommonResult.success("退货原因查询成功",returnReasons);
        }else{
            return CommonResult.error("退货原因查询失败");
        }
    }
    /*查询全部退货原因名称*/
    @RequestMapping(value = "/returnReason/findReasonName")
    private CommonResult findReasonName() {
        List<String> names = returnReasonService.selectAllName();
        if(names!=null){
            return CommonResult.success("退货原因查询成功",names);
        }else{
            return CommonResult.error("退货原因查询失败");
        }
    }
    /*查询退货原因是否存在*/
    @RequestMapping(value = "/returnReason/existReasonName")
    private CommonResult existReasonName(Integer reasonId,String reasonName) {
        Boolean isExist = returnReasonService.existsWithReasonName(reasonId,reasonName);
        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }

    @RequestMapping(value = "/returnReason/addReason")
    private CommonResult addReason(ReturnReason returnReason) {
        if(returnReason!=null){
            if(returnReasonService.insertData(returnReason)){
                return CommonResult.success("添加成功",returnReason);
            }else{

    }

    /*查询全部物流信息*/
    @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("物流信息添加失败");
            }
        }
        return CommonResult.error("物流信息数据不存在");
    }

    @RequestMapping(value = "/logistics/deleteInfo")
    private CommonResult deleteInfo(Integer logisticId) {
        if(logisticId!=null){
            if(logisticsService.deleteById(logisticId)){
                return CommonResult.success("物流信息删除成功",logisticId);
            }else{
                return CommonResult.error("物流信息删除失败");
            }
        }
        return CommonResult.error("物流信息数据不存在");
    }

    @RequestMapping(value = "/orderDetail/returnInfo")
    private CommonResult returnInfo(String orderNo) {
        ArrayList<Object> resultList = new ArrayList<>();
        Map<String, Object> returnGoods = returnGoodsService.selectOrderNo(orderNo);
        Logistics logistics = logisticsService.selectOrderNo(orderNo);
        if(returnGoods!=null){
            resultList.add(returnGoods);
        }
        if(logistics!=null){
            resultList.add(logistics);
        }

        if(resultList.size()!=0){
            return CommonResult.success("退货订单详情查询成功",resultList);

        }else{
            return CommonResult.error("订单信息查询失败");
        }
    }
    @RequestMapping(value = "/order/findOrderInfo")
    private CommonResult findOrderInfo(String userAccount) {
        List<Map<String, Object>> orderMap = orderService.selectAllOrder(userAccount);
        if(orderMap!=null){
            return CommonResult.success("订单信息查询成功",orderMap);
        }else{
            return CommonResult.error("订单信息查询失败");
        }
    }

    @RequestMapping(value = "/order/findAll")
    private CommonResult findAllOrder() {
        List<Order> orders = orderService.selectAll();
        System.out.println(orders);
        if(orders!=null){
            return CommonResult.success("订单信息查询成功",orders);
        }else{
            return CommonResult.error("订单信息查询失败");
        }
    }

    @RequestMapping(value = "/order/findCount")
    private CommonResult findCount() {
        Integer count = orderService.selectCount();
        if(count!=null){
            return CommonResult.success("订单数量查询成功",count);
        }else{
            return CommonResult.error("订单数量查询失败");
        }
    }

    @RequestMapping(value = "/order/add")
    private CommonResult addOrder(Order order) {
        if(order!=null){
            if(order.getProductNo().contains("Vip")){
                if(orderService.insertData(order)){
                    return CommonResult.success("创建订单成功",order);
                }else{
                    return CommonResult.error("创建订单失败");
                }

            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("删除失败");
        }
    }

}

/**
 * @email qiudb.top@aliyun.com
 * @description 数据分析，商品数量，订单数量等分析业务

        if(isExist!=null){
            return CommonResult.success("查询成功",isExist);
        }else{
            return CommonResult.error("查询失败");
        }
    }
    @RequestMapping(value = "/product/findAll")
    private CommonResult findAll() {
        List<Product> products = productService.selectAll();
        if(products!=null){
            return CommonResult.success("全部商品信息查询成功",products);
        }else{
            return CommonResult.error("全部商品信息查询失败");
        }
    }
    @RequestMapping(value = "/product/findAllSale")
    private CommonResult findAllSale() {
        List<Product> products = productService.selectAllSale();
        if(products!=null){
            return CommonResult.success("全部商品信息查询成功",products);
        }else{
            return CommonResult.error("全部商品信息查询失败");
        }
    }
    @RequestMapping(value = "/product/findAllLikeName")
    private CommonResult findAllLikeName(String keyWord) {
        List<Product> products = productService.selectAllLikeName(keyWord);
        if(products!=null){
            return CommonResult.success("全部商品信息查询成功",products);
        }else{
            return CommonResult.error("全部商品信息查询失败");
        }
    }
    @RequestMapping(value = "/product/findAllLikeType")
    private CommonResult findAllLikeType(String keyWord) {
        List<Product> products = productService.selectAllLikeType(keyWord);
        if(products!=null){
            return CommonResult.success("全部商品信息查询成功",products);
        }else{
            return CommonResult.error("全部商品信息查询失败");
        }
    }
    @RequestMapping(value = "/product/findAllLikeBrand")
    private CommonResult findAllLikeBrand(String keyWord) {
        List<Product> products = productService.selectAllLikeBrand(keyWord);

            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("更新失败");
            }
        }
        return CommonResult.error("商品退款数据不存在");
    }

    /*拒绝买家退款申请*/
    @RequestMapping(value = "/returnGoods/rejectRefund")
    private CommonResult rejectRefund(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.setOrderState("待发货");
            if(orderService.updateById(order)){
                if(returnGoodsService.updateById(returnGoods)){
                    return CommonResult.success("更新成功",returnGoods);
                }else{
                    return CommonResult.error("更新失败");

        }
    }
    /*查询全部供应商*/
    @RequestMapping(value = "/supplier/findAll")
    private CommonResult findAll() {
        List<Supplier> suppliers = supplierService.selectAll();
        if(suppliers!=null){
            return CommonResult.success("供货商查询成功",suppliers);
        }else{
            return CommonResult.error("供货商查询失败");
        }
    }
    /*查询全部供应商*/
    @RequestMapping(value = "/supplier/findAllUsable")
    private CommonResult findAllUsable() {
        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("添加失败");

        }
    }

    @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) {

            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("更新失败");
            }
        }
        return CommonResult.error("商品退款数据不存在");
    }

    /*拒绝买家退款申请*/
    @RequestMapping(value = "/returnGoods/rejectRefund")
    private CommonResult rejectRefund(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.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){

请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述
请添加图片描述

请添加图片描述
请添加图片描述
请添加图片描述

m0_71097188
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值