devbox
小丑西瓜9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

家居建材商城|商家店铺|基于Springboot+Vue实现家居建材商城_vue商城商家端

作者：小丑西瓜9 | 2024-06-17 05:28:56

赞

踩

vue商城商家端

作者主页：编程指南针

 

作者简介：Java领域优质创作者、CSDN博客专家 、掘金特邀作者、多年架构师设计经验、腾讯课堂常驻讲师

主要内容：Java项目、毕业设计、简历模板、学习资料、面试题库、技术互助

收藏点赞不迷路  关注作者有好处

文末获取源码 

项目编号：BS-SC-041

一，项目简介

   

    本系统采用前后端分离开发模式。项目技术应用广泛，涵盖全栈、集群、分布式、高并发；技术应用场景合理，并非多技术的盲目堆叠；业务场景贴近实际，完全按照市场需求开发。 项目前端部分采用html5结合Thymeleaf和vue进行开发，利用WebSocket技术实现用户与商家聊天功能。在前后端数据交互时，使用JavaScript结合axios进行异步调用等进行开发。 项目后端利用MySQL数据库管理系统对数据进行管理。利用Redis数据库存储缓存信息。系统采用SpringBoot框架、MyBatis、MyBatisPlus、lombok日志、druid等进行开发。 ​

本项目主要分为三个模块，分别是系统管理员模块，商家模块以及普通用户模块。

管理员模块：

商家管理：对商家账户信息进行管理，审核新店铺的申请。

用户管理：可以对用户的信息进行修改、删除、添加。

商品管理：对所有的商品进行管理，包括强制下架。

订单管理：对所有的订单进行统一管理。

商家模块：

商品管理：对已经商家的商品进行修改或者上架和下架管理

商铺信息管理：用于商家对本商铺的信息进行管理，比如商店员工和销售情况等。

订单管理：用户商家对商品订单进行发货处理

商家信息维护：商家可以修改商铺的消息策略。

售后管理：用户商家处理一些订单售后申请。

普通用户模块：

登录注册：用户通过该功能进行手机号验证码注册账号与手机验证码账号登录。

商品搜索：用户可以输入需要购买的商品关键词进行查询，系统会查询所有商品信息反馈给用户。

商品查看：选择一个商品后，用户可以点进去查看商品详细信息，包括商家信息、商品图片或者商品。

商品购买：选择好需要的商品及可以下单，填写相关地址信息完，付款后即可完成购买。

与商家在线沟通：在商品详情页面，用户可以选择与商家在线沟通，询问商品的详细情况，比如商品质量以及发货地点，发货时间等。

订单查询：包括查看订单详情、申请售后、取消订单、删除订单等功能。

图 1系统功能模块图

 

本系统采用的是单库单应用架构。前端框架主要利用vue结合elementui进行。利用vue-router将前台页面进行路由。用户触发不同事件的时候，先判断用户是否具有浏览该页面的权限，如果没有权限则拦截页面跳转，同时提示用户没有权限。当用户拥有该权限或者该页面不需要权限的时候，利用Ajax发送异步请求到后台接口，请求后台数据。

请求到达后台后，会被Springmvc的前端控制器进行拦截。然后在业务层找到相应的controller进行处理。然后调用service层处理逻辑事务。然后会调用mybatis的方法对mysql数据库中的数据进行操作。最后将得到得数据一路返回，回到前端经过前台的渲染呈现给用户最终的页面效果。

二，环境介绍

语言环境：Java:  jdk1.8

数据库：Mysql: mysql5.7

应用服务器：Tomcat:  tomcat8.5.31

开发工具：IDEA或eclipse

后台开发：Springboot+Mybatis

前台开发：Vue+Nodejs+ElementUI

第三方技术：支付宝沙箱、阿里云OSS存储、腾讯云短信发送、邮箱发送等

三，系统展示

前端首页

详情展示

购物车

 我的订单

 个人中心

商家登陆：统计销售情况

商铺基本 信息管理

商品管理

 品牌管理

 商品规格

 查询入库记录

 订单管理

 退换货处理

后台管理员登陆

商铺管理

 商品管理

订单管理

 营销管理-轮播图管理

 营销管理-分类推荐

 用户-角色-权限管理

四，核心代码展示

  1. package com.qiu.controller;
  2.  
  3. import com.qiu.entity.Role;
  4. import com.qiu.service.RoleService;
  5. import com.qiu.util.general.CommonResult;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.CrossOrigin;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10.  
  11. import java.util.List;
  12.  
  13. /**
  14.  * 用户授权等相关业务
  15.  */
  16. @CrossOrigin
  17. @RestController
  18. public class RoleController {
  19.     @Autowired
  20.     private RoleService roleService;
  21.  
  22.     /**
  23.      * 根据id查询角色信息
  24.      *
  25.      * @param roleId 角色编号
  26.      */
  27.     @RequestMapping(value = "/role/findById")
  28.     public CommonResult findById(Integer roleId) {
  29.         Role role = roleService.selectById(roleId);
  30.         if (role != null) {
  31.             return CommonResult.success("查询成功", role);
  32.         }
  33.         return CommonResult.error("查询失败");
  34.     }
  35.  
  36.     /**
  37.      * 根据角色名称查询角色
  38.      *
  39.      * @param roleName 角色名称
  40.      */
  41.     @RequestMapping(value = "/role/findByKey")
  42.     public CommonResult findByKey(String roleName) {
  43.         Role role = roleService.selectByKey(roleName);
  44.         if (role != null) {
  45.             return CommonResult.success("查询成功", role);
  46.         }
  47.         return CommonResult.error("查询失败");
  48.     }
  49.  
  50.     /**
  51.      * 判断角色是否存在
  52.      *
  53.      * @param roleId   角色编号
  54.      * @param roleName 角色名称
  55.      */
  56.     @RequestMapping(value = "/role/existRoleName")
  57.     public CommonResult existRoleName(Integer roleId, String roleName) {
  58.         boolean exist = roleService.existsRoleName(roleId, roleName);
  59.         return CommonResult.success("查询成功", exist);
  60.     }
  61.  
  62.     /**
  63.      * 查询所有角色信息
  64.      */
  65.     @RequestMapping(value = "/role/findAll")
  66.     public CommonResult findAll() {
  67.         List<Role> roles = roleService.selectAll();
  68.         if (roles != null) {
  69.             return CommonResult.success("查询成功", roles);
  70.         }
  71.         return CommonResult.error("查询失败");
  72.     }
  73.  
  74.     /**
  75.      * 查询所有可用的角色信息
  76.      */
  77.     @RequestMapping(value = "/role/findAllUsable")
  78.     public CommonResult findAllUsable() {
  79.         List<Role> roles = roleService.selectAllUsable();
  80.         if (roles != null) {
  81.             return CommonResult.success("查询成功", roles);
  82.         }
  83.         return CommonResult.error("查询失败");
  84.     }
  85.  
  86.     /**
  87.      * 查询角色数量
  88.      */
  89.     @RequestMapping(value = "/role/count")
  90.     public CommonResult findCount() {
  91.         int count = roleService.selectCount();
  92.         return CommonResult.success("查询成功", count);
  93.     }
  94.  
  95.     /**
  96.      * 新增角色信息
  97.      *
  98.      * @param role 角色信息
  99.      */
  100.     @RequestMapping(value = "/role/add")
  101.     public CommonResult add(Role role) {
  102.         if (role != null) {
  103.             if (roleService.insertData(role)) {
  104.                 return CommonResult.success("添加成功", role);
  105.             }
  106.             return CommonResult.error("添加失败");
  107.         }
  108.         return CommonResult.error("角色信息不存在");
  109.     }
  110.  
  111.     /**
  112.      * 更新角色信息
  113.      *
  114.      * @param role 角色信息
  115.      */
  116.     @RequestMapping(value = "/role/update")
  117.     public CommonResult update(Role role) {
  118.         if (roleService.updateById(role)) {
  119.             return CommonResult.success("更新成功", role);
  120.         }
  121.         return CommonResult.error("更新失败");
  122.     }
  123.  
  124.     /**
  125.      * 删除角色信息
  126.      *
  127.      * @param roleId 角色编号
  128.      */
  129.     @RequestMapping(value = "/role/delete")
  130.     public CommonResult delete(Integer roleId) {
  131.         if (roleService.deleteById(roleId)) {
  132.             return CommonResult.success("删除成功", roleId);
  133.         }
  134.         return CommonResult.error("删除失败");
  135.     }
  136. }
  1. package com.qiu.controller;
  2.  
  3. import com.qiu.entity.ShoppingCart;
  4. import com.qiu.service.ShoppingCartService;
  5. import com.qiu.util.general.CommonResult;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.web.bind.annotation.CrossOrigin;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.RestController;
  10.  
  11. import java.util.List;
  12. import java.util.Map;
  13.  
  14. /**
  15.  * 购物车业务类
  16.  */
  17. @RestController
  18. @CrossOrigin
  19. public class ShoppingCartController {
  20.  
  21.     @Autowired
  22.     private ShoppingCartService shoppingCartService;
  23.  
  24.     /**
  25.      * 新增商品到购物车
  26.      *
  27.      * @param shoppingCart 购物车商品信息
  28.      */
  29.     @RequestMapping(value = "/shoppingCart/add")
  30.     public CommonResult addShoppingCart(ShoppingCart shoppingCart) {
  31.         if (shoppingCartService.insertData(shoppingCart)) {
  32.             return CommonResult.success("购物车添加成功", shoppingCart);
  33.         }
  34.         return CommonResult.error("购物车添加失败");
  35.     }
  36.  
  37.     /**
  38.      * 更新购物车商品
  39.      *
  40.      * @param shoppingCart 购物车商品信息
  41.      */
  42.     @RequestMapping(value = "/shoppingCart/update")
  43.     public CommonResult updateShoppingCart(ShoppingCart shoppingCart) {
  44.         if (shoppingCartService.updateById(shoppingCart)) {
  45.             return CommonResult.success("购物车修改成功", shoppingCart);
  46.         }
  47.         return CommonResult.error("购物车修改失败");
  48.     }
  49.  
  50.     /**
  51.      * 购物车移除商品
  52.      *
  53.      * @param cartId 购物车商品编号
  54.      */
  55.     @RequestMapping(value = "/shoppingCart/deleteById")
  56.     public CommonResult deleteShoppingCart(Integer cartId) {
  57.         if (shoppingCartService.deleteById(cartId)) {
  58.             return CommonResult.success("购物车删除成功", "cartId: " + cartId);
  59.         }
  60.         return CommonResult.error("购物车删除失败");
  61.     }
  62.  
  63.     /**
  64.      * 根据用户移除购物车
  65.      *
  66.      * @param account 用户账户
  67.      */
  68.     @RequestMapping(value = "/shoppingCart/deleteByUser")
  69.     public CommonResult deleteByUser(String account) {
  70.         if (shoppingCartService.deleteByUser(account)) {
  71.             return CommonResult.success("购物车删除成功", account);
  72.         }
  73.         return CommonResult.error("购物车删除失败");
  74.     }
  75.  
  76.  
  77.     /**
  78.      * 查询用户账号下的购物车信息
  79.      *
  80.      * @param account 用户账户
  81.      */
  82.     @RequestMapping(value = "/shoppingCart/findAll")
  83.     public CommonResult findAllShoppingCart(String account) {
  84.         List<Map<String, Object>> shoppingInfo = shoppingCartService.selectAll(account);
  85.         if (shoppingInfo != null) {
  86.             return CommonResult.success("购物车查询成功", shoppingInfo);
  87.         }
  88.         return CommonResult.error("购物车查询失败");
  89.     }
  90.  
  91.     /**
  92.      * 根据购物车商品编号查询购物车商品信息
  93.      *
  94.      * @param cartId 购物车商品编号
  95.      */
  96.     @RequestMapping(value = "/shoppingCart/findById")
  97.     public CommonResult findById(Integer cartId) {
  98.         ShoppingCart shoppingCart = shoppingCartService.selectById(cartId);
  99.         if (shoppingCart != null) {
  100.             return CommonResult.success("购物车查询成功", shoppingCart);
  101.         }
  102.         return CommonResult.error("购物车查询失败");
  103.     }
  104. }
  1. package com.qiu.controller;
  2.  
  3. import com.qiu.entity.Product;
  4. import com.qiu.entity.Purchase;
  5. import com.qiu.entity.StoreEntity;
  6. import com.qiu.service.ProductService;
  7. import com.qiu.service.PurchaseService;
  8. import com.qiu.service.StoreService;
  9. import com.qiu.util.general.CommonResult;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.web.bind.annotation.CrossOrigin;
  12. import org.springframework.web.bind.annotation.RequestMapping;
  13. import org.springframework.web.bind.annotation.RestController;
  14. import java.util.List;
  15.  
  16. /**
  17.  *  商铺管理和商品入库
  18.  */
  19. @CrossOrigin
  20. @RestController
  21. public class StoreController {
  22.  
  23.     @Autowired
  24.     private StoreService storeService;
  25.  
  26.     @Autowired
  27.     private PurchaseService purchaseService;
  28.  
  29.     @Autowired
  30.     private ProductService productService;
  31.  
  32.     /**
  33.      * 查询商铺信息
  34.      */
  35.     @RequestMapping(value = "/store/findByStore")
  36.     public CommonResult findByNumber(StoreEntity store) {
  37.         StoreEntity storeEntity = storeService.selectByStore(store);
  38.         if (storeEntity != null) {
  39.             return CommonResult.success("商铺查询成功", storeEntity);
  40.         }
  41.         return CommonResult.error("商铺查询失败");
  42.     }
  43.  
  44.     /**
  45.      * 查询全部商铺
  46.      */
  47.     @RequestMapping(value = "/store/findAll")
  48.     public CommonResult findAll() {
  49.         List<StoreEntity> stores = storeService.selectAll();
  50.         if (stores != null) {
  51.             return CommonResult.success("商铺查询成功", stores);
  52.         }
  53.         return CommonResult.error("商铺查询失败");
  54.     }
  55.  
  56.     /**
  57.      * 商铺入驻申请
  58.      * @param store 商铺信息
  59.      */
  60.     @RequestMapping(value = "/store/addStore")
  61.     public CommonResult addStore(StoreEntity store) {
  62.         if (store != null) {
  63.             if (storeService.insertData(store)) {
  64.                 return CommonResult.success("店铺入驻申请已发送", store);
  65.             }
  66.             return CommonResult.error("申请发送失败");
  67.         }
  68.         return CommonResult.error("商铺注册数据不存在");
  69.     }
  70.  
  71.     /**
  72.      * 通过商铺编号更新商铺信息
  73.      *
  74.      * @param store 商铺信息
  75.      */
  76.     @RequestMapping(value = "/store/updateStore")
  77.     public CommonResult updateStoreEntity(StoreEntity store) {
  78.         if (store != null) {
  79.             if (storeService.updateByStore(store)) {
  80.                 return CommonResult.success("更新成功", store);
  81.             }
  82.             return CommonResult.error("更新失败");
  83.         }
  84.         return CommonResult.error("商铺数据不存在");
  85.     }
  86.  
  87.     /**
  88.      * 更新商铺状态
  89.      * @param store 商铺信息
  90.      * @return
  91.      */
  92.     @RequestMapping(value = "/store/updateStoreStatus")
  93.     public CommonResult updateStoreStatus(StoreEntity store) {
  94.         if (store != null) {
  95.             if (storeService.updateStoreStatus(store)) {
  96.                 return CommonResult.success("更新成功");
  97.             }
  98.             return CommonResult.error("更新失败");
  99.         }
  100.         return CommonResult.error("商铺数据不存在");
  101.     }
  102.  
  103.     /**
  104.      * 删除供应商
  105.      * @param storeNumber 供应商编号
  106.      */
  107.     @RequestMapping(value = "/store/deleteStore")
  108.     public CommonResult deleteStoreById(Integer storeNumber) {
  109.         if (storeNumber != null) {
  110.             if (storeService.deleteById(storeNumber)) {
  111.                 return CommonResult.success("删除成功", storeNumber);
  112.             }
  113.             return CommonResult.error("删除失败");
  114.         }
  115.         return CommonResult.error("商铺数据不存在");
  116.     }
  117.  
  118.     //-------------------------------------------商品入库操作------------------------------------------------
  119.     /**
  120.      * 查询入库信息
  121.      * @param purchaseId 入库编号
  122.      */
  123.     @RequestMapping(value = "/purchase/findPurchaseById")
  124.     public CommonResult findPurchaseById(Integer purchaseId) {
  125.         Purchase purchase = purchaseService.selectById(purchaseId);
  126.         if (purchase != null) {
  127.             return CommonResult.success("入库信息查询成功", purchase);
  128.         }
  129.         return CommonResult.error("入库信息查询失败");
  130.     }
  131.  
  132.     /**
  133.      * 查询全部入库信息
  134.      */
  135.     @RequestMapping(value = "/purchase/findPurchaseAll")
  136.     public CommonResult findPurchaseAll(String accountNumber) {
  137.         List<Purchase> purchases = purchaseService.selectAll(accountNumber);
  138.         if (purchases != null) {
  139.             return CommonResult.success("入库信息查询成功", purchases);
  140.         }
  141.         return CommonResult.error("入库信息查询失败");
  142.     }
  143.  
  144.     /**
  145.      * 添加入库记录
  146.      * @param purchase 入库信息
  147.      */
  148.     @RequestMapping(value = "/purchase/addPurchase")
  149.     public CommonResult addPurchase(Purchase purchase) {
  150.         if (purchase != null) {
  151.             //1.添加商品库存
  152.             Integer productId = productService.selectIdByKey(purchase.getProductNo());
  153.             Product product = productService.selectById(productId);
  154.             Integer lowestStock = product.getLowestStock();
  155.             Integer productStock = product.getProductStock();
  156.             Integer purchaseNumber =Integer.parseInt(purchase.getPurchaseNumber());
  157.             product.setProductStock(productStock + purchaseNumber);
  158.             product.setIsStockOut(product.getProductStock() < lowestStock);
  159.             if (productService.updateById(product)) {//库存信息更新成功
  160.                 purchaseService.insertData(purchase);//插入一条入库记录
  161.                 return CommonResult.success("商品入库成功", purchase);
  162.             }
  163.             return CommonResult.error("商品库存更新失败");
  164.         }
  165.         return CommonResult.error("系统繁忙，请稍后再试！");
  166.     }
  167.  
  168.     /**
  169.      * 删除入库记录
  170.      *
  171.      * @param purchaseId 入库id
  172.      */
  173.     @RequestMapping(value = "/purchase/deletePurchase")
  174.     public CommonResult deletePurchase(Integer purchaseId) {
  175.         if (purchaseId != null) {
  176.             if (purchaseService.deleteById(purchaseId)) {
  177.                 return CommonResult.success("删除成功", purchaseId);
  178.             }
  179.             return CommonResult.error("删除失败");
  180.         }
  181.         return CommonResult.error("入库信息数据不存在,请刷新重试");
  182.     }
  183.  
  184. }

  1. package com.qiu.controller;
  2.  
  3. import com.qiu.constant.UserStatusEnum;
  4. import com.qiu.entity.User;
  5. import com.qiu.entity.UserRole;
  6. import com.qiu.entity.Vip;
  7. import com.qiu.service.UserRoleService;
  8. import com.qiu.service.UserService;
  9. import com.qiu.service.VipService;
  10. import com.qiu.util.general.CommonResult;
  11. import org.springframework.beans.factory.annotation.Autowired;
  12. import org.springframework.web.bind.annotation.CrossOrigin;
  13. import org.springframework.web.bind.annotation.RequestMapping;
  14. import org.springframework.web.bind.annotation.RequestParam;
  15. import org.springframework.web.bind.annotation.RestController;
  16.  
  17. import java.util.Calendar;
  18. import java.util.Date;
  19. import java.util.List;
  20.  
  21. /**
  22.  *  用户相关业务
  23.  */
  24. @CrossOrigin
  25. @RestController
  26. public class UserController {
  27.  
  28.     @Autowired
  29.     private UserService userService;
  30.  
  31.     @Autowired
  32.     private UserRoleService userRoleService;
  33.  
  34.     @Autowired
  35.     private VipService vipService;
  36.  
  37.     /**
  38.      * 根据id查询用户
  39.      *
  40.      * @param id 用户编号
  41.      */
  42.     @RequestMapping(value = "/user/findById")
  43.     public CommonResult findById(Integer id) {
  44.         User user = userService.selectById(id);
  45.         if (user != null) {
  46.             return CommonResult.success("查询成功", user);
  47.         } else {
  48.             return CommonResult.error("查询失败");
  49.         }
  50.     }
  51.  
  52.     /**
  53.      * 根据账号查询用户
  54.      *
  55.      * @param key 账号
  56.      */
  57.     @RequestMapping(value = "/user/findByKey")
  58.     public CommonResult findByKey(String key) {
  59.         User user = userService.selectByKey(key);
  60.         if (user != null) {
  61.             return CommonResult.success("查询成功", user);
  62.         }
  63.         return CommonResult.error("查询失败");
  64.     }
  65.  
  66.     /**
  67.      * 查询所有顾客
  68.      */
  69.     @RequestMapping(value = "/user/findAll/customer")
  70.     public CommonResult findAllCustomer() {
  71.         List<User> users = userService.queryAllByStatus(UserStatusEnum.CUSTOMER);
  72.         if (users != null) {
  73.             return CommonResult.success("查询成功", users);
  74.         }
  75.         return CommonResult.error("查询失败");
  76.     }
  77.  
  78.     /**
  79.      * 查询所有管理员
  80.      */
  81.     @RequestMapping(value = "/user/findAll/admin")
  82.     public CommonResult findAllAdmin() {
  83.         List<User> users = userService.queryAllByStatus(UserStatusEnum.ADMIN);
  84.         if (users != null) {
  85.             return CommonResult.success("查询成功", users);
  86.         }
  87.         return CommonResult.error("查询失败");
  88.     }
  89.  
  90. //    /**
  91. //     * 查询商家的商铺编号
  92. //     */
  93. //    @RequestMapping(value = "/user/storeNumber")
  94. //    public CommonResult findStoreNumber(String accountNumber) {
  95. //        String storeNumber= userService.selectStoreNumber(accountNumber);
  96. //        if (storeNumber != null) {
  97. //            return CommonResult.success("商铺编号查询成功", storeNumber);
  98. //        }
  99. //        return CommonResult.error("商铺编号查询失败");
  100. //    }
  101.  
  102.     /**
  103.      * 判断某个用户是否还存在
  104.      *
  105.      * @param key 账号
  106.      */
  107.     @RequestMapping(value = "/user/existKey")
  108.     public CommonResult existKey(String key) {
  109.         boolean exist = userService.existsWithPrimaryKey(key);
  110.         return CommonResult.success("查询成功", exist);
  111.     }
  112.  
  113.     /**
  114.      * 查询用户状态
  115.      *
  116.      * @param accountNumber 用户账号
  117.      */
  118.     @RequestMapping(value = "/user/userState")
  119.     public CommonResult userState(String accountNumber) {
  120.         boolean state = userService.selectUserState(accountNumber);
  121.         return CommonResult.success("查询成功", state);
  122.     }
  123.  
  124.     /**
  125.      * 查询用户记录的总个数
  126.      */
  127.     @RequestMapping(value = "/user/count")
  128.     public CommonResult findCount() {
  129.         int count = userService.selectCount();
  130.         return CommonResult.success("查询成功", count);
  131.  
  132.     }
  133.  
  134.     /**
  135.      * 通过用户账号查询用户ID
  136.      *
  137.      * @param key 用户账号
  138.      */
  139.     @RequestMapping(value = "/user/findIdByKey")
  140.     public CommonResult findIdByKey(String key) {
  141.         Integer id = userService.selectIdByKey(key);
  142.         if (id != null) {
  143.             return CommonResult.success("查询成功", id);
  144.         }
  145.         return CommonResult.error("未查询到");
  146.     }
  147.  
  148.     /**
  149.      * 删除用户
  150.      *
  151.      * @param userId 用户编号
  152.      */
  153.     @RequestMapping(value = "/user/delete")
  154.     public CommonResult delete(Integer userId) {
  155.         if (userService.deleteById(userId)) {
  156.             return CommonResult.success("删除成功", userId);
  157.         }
  158.         return CommonResult.error("删除失败");
  159.     }
  160.  
  161.     /**
  162.      * 角色授权
  163.      *
  164.      * @param userId 用户编号
  165.      * @param roleId 角色编号列表
  166.      */
  167.     @RequestMapping(value = "/user/author")
  168.     public CommonResult author(Integer userId, @RequestParam List<Integer> roleId) {
  169.         if (userId != null && roleId != null && !roleId.isEmpty()) {
  170.             if (userRoleService.deleteById(userId)) {
  171.                 UserRole userRole = new UserRole();
  172.                 userRole.setUserId(userId);
  173.                 for (Integer id : roleId) {
  174.                     userRole.setRoleId(id);
  175.                     userRoleService.insertData(userRole);
  176.                 }
  177.             }
  178.             User user = new User();
  179.             user.setUserId(userId);
  180.             user.setStatus(UserStatusEnum.ADMIN);
  181.             userService.updateById(user);
  182.             return CommonResult.success("授权成功");
  183.         } else {
  184.             return CommonResult.error("角色授权数据不完整！");
  185.         }
  186.     }
  187.  
  188.     /**
  189.      * 查询所有VIP用户
  190.      */
  191.     @RequestMapping(value = "/vip/findAllVip")
  192.     public CommonResult findAllVip() {
  193.         List<Vip> vips = vipService.selectAll();
  194.         if (vips != null) {
  195.             return CommonResult.success("查询成功", vips);
  196.         }
  197.         return CommonResult.error("查询失败");
  198.     }
  199.  
  200.     /**
  201.      * 查询VIP用户信息根据id
  202.      *
  203.      * @param vipId 会员编号
  204.      */
  205.     @RequestMapping(value = "/vip/findVipById")
  206.     public CommonResult findVipById(Integer vipId) {
  207.         Vip vip = vipService.selectById(vipId);
  208.         if (vip != null) {
  209.             return CommonResult.success("查询成功", vip);
  210.         }
  211.         return CommonResult.error("查询失败");
  212.     }
  213.  
  214.     /**
  215.      * 查询VIP用户信息根据id
  216.      *
  217.      * @param accountNumber 用户账号
  218.      */
  219.     @RequestMapping(value = "/vip/findVipByKey")
  220.     public CommonResult findVipByKey(String accountNumber) {
  221.         Vip vip = vipService.selectByKey(accountNumber);
  222.         if (vip != null) {
  223.             return CommonResult.success("查询成功", vip);
  224.         }
  225.         return CommonResult.error("查询失败");
  226.     }
  227.  
  228.     /**
  229.      * 判断用户信息是否存在
  230.      *
  231.      * @param accountNumber 用户账号
  232.      */
  233.     @RequestMapping(value = "/vip/existsVip")
  234.     public CommonResult existsVip(String accountNumber) {
  235.         boolean exist = vipService.existsVip(accountNumber);
  236.         return CommonResult.success("查询成功", exist);
  237.     }
  238.  
  239.     /**
  240.      * 增加会员信息
  241.      *
  242.      * @param vip 会员信息
  243.      */
  244.     @RequestMapping(value = "/vip/addVip")
  245.     public CommonResult addVip(Vip vip) {
  246.         Date date = new Date();
  247.         Calendar cal = Calendar.getInstance();
  248.         //设置起时间
  249.         cal.setTime(date);
  250.         //增加一年
  251.         cal.add(Calendar.YEAR, 1);
  252.         vip.setOverdueTime(cal.getTime());
  253.         if (vipService.insertData(vip)) {
  254.             return CommonResult.success("会员信息添加成功", vip);
  255.         }
  256.         return CommonResult.error("会员信息添加失败");
  257.     }
  258.  
  259.     /**
  260.      * 更新会员信息
  261.      *
  262.      * @param vip 会员信息
  263.      */
  264.     @RequestMapping(value = "/vip/updateVip")
  265.     public CommonResult updateVip(Vip vip) {
  266.         if (vipService.updateById(vip)) {
  267.             return CommonResult.success("会员信息更新成功", vip);
  268.         }
  269.         return CommonResult.error("会员信息更新失败");
  270.     }
  271.  
  272.     /**
  273.      * 清除信息
  274.      *
  275.      * @param vipId 会员编号
  276.      */
  277.     @RequestMapping(value = "/vip/deleteVip")
  278.     public CommonResult deleteVip(Integer vipId) {
  279.         if (vipService.deleteById(vipId)) {
  280.             return CommonResult.success("删除成功", vipId);
  281.         }
  282.         return CommonResult.error("删除失败");
  283.     }
  284. }

五，项目总结

 表结构及ER图

本系统用到了18张表存储数据，分别是banner（商品广告轮播图表）、

Logistics（物流表）、order（订单表）、product（商品表）、product_brand（商品品牌表）、product_review（商品评价表）、product_specs（商品规格表）、product_type（商品类型推荐表）、purchase（商品入库记录表）、return_goods（商品退货表）、return_reason（退货原因表）、role（角色表）、shopping_cart（购物车表）、specs（商品规格表）、store（商铺信息表）、sys_commodity_type（商品类型表）、user（用户表）、user_role（用户角色表）。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/小丑西瓜9/article/detail/729810
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号