采用Springboot+MyBatis框架技术开发,使用MySQL数据库管理数据的开发方案;再次,采用UML建模技术对系统进行需求分析、功能设计以及类的设计;最后,实现一个具有校园划分、物品搜索、发布闲置、发布动态、闲置交易、面对面交易、地点选择、联系买家和联系客服的高校闲置物品交易平台。经过测试和运行,高校闲置物品交易平台不仅可以避免校园内闲置物品的大量闲置,又可以提高资源的利用效率,符合了当代可持续发展的大趋势要求。
关键词:闲置物品 微信小程序 SpringBoot
package com.oyhp.esyu.web;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.oyhp.esyu.comparator.*;
import com.oyhp.esyu.pojo.*;
import com.oyhp.esyu.quartz.manager.QuartzJobManager;
import com.oyhp.esyu.quartz.service.QuartzJobService;
import com.oyhp.esyu.service.*;
import com.oyhp.esyu.util.Result;
import com.oyhp.esyu.util.WXProduct;
import com.oyhp.esyu.util.WXUtil;
import org.apache.commons.lang.math.RandomUtils;
import org.quartz.JobKey;
import org.quartz.SchedulerException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.text.SimpleDateFormat;
import java.util.*;
/**
* 微信小程序控制器
*/
@RestController
public class WXForeController {
@Autowired
UserService userService;
@Autowired
SchoolService schoolService;
@Autowired
ThemeService themeService;
@Autowired
CategoryService categoryService;
@Autowired
ProductService productService;
@Autowired
ProductImageService productImageService;
@Autowired
ReviewService reviewService;
@Autowired
PropertyValueService propertyValueService;
@Autowired
PropertyService propertyService;
@Autowired
AddressService addressService;
@Autowired
OrderItemService orderItemService;
@Autowired
OrderService orderService;
@Autowired
SecondaryCategoryService secondaryCategoryService;
@Autowired
EvaluationService evaluationService;
@Resource
private QuartzJobService quartzJobService;
/**
* 微信小程序登录
* 需要判断用户是否是新用户,根据用户的openid去查是否有这个用户
* 1、有,不做任何动作
* 2、没有,新建用户
* @param userInfo 用户信息,微信传过来的code country province name gender city
* @return 登录成功,返回openid
*/
@PostMapping("/wxlogin")
public Object wx_login(@RequestBody User userInfo,HttpServletRequest request){
Map<String,Object> userKeyMap = WXUtil.getOpenidSessionKeyAndToken(userInfo.getCode());
String openid = (String)userKeyMap.get("openid");
//获取了openid保存到userInfo中
userInfo.setOpenid(openid);
System.out.println(userInfo);
//判断拿到数据是否正确
if(openid==null)
return Result.fail("error");
//微信小程序用户是否为第一次登录
if(userService.isLoginFirst(userInfo)){
//随便设置一下院校,默认城市学院
School school = schoolService.get(1);
userInfo.setSchool(school);
userInfo.setCreateDate(new Date());
userInfo.setUpdateDate(new Date());
userService.add(userInfo);
//保存用户头像到服务器,以后不再保存到数据库
String localUrl = request.getServletContext().getRealPath("img/user/")+userInfo.getId()+".jpg";
WXUtil.downloadPicture(userInfo.getAvatarUrl(),localUrl);
}
//返回openid要求小程序端加入到缓存,用户小程序的其它业务,比如发布
return Result.success(openid);
}
/**
* 根据openid获取User信息
* @param user
* @return
*/
@PostMapping("/wxUser")
public Object wx_user(@RequestBody User user){
String openid = user.getOpenid();
//判断openid是否有效
if(openid != null){
User my = userService.getUserByOpenid(openid);
//在售商品
my.setOnSellProduct(productService.onSellProduct(my));
//累计交易,我卖出的
List<Product> products = productService.getProductsByUser(my);
my.setOnOrderProduct(orderItemService.onOrderTraded(products));
//我买到的
my.setOnMyBought(orderService.OnOrderProduct(my));
return Result.success(my);
}
else
return Result.fail("用户未登录");
}
/**
* 获取Token访问
* @return
*/
@GetMapping("wxAccessToken")
public Object getAccessToken(){
return Result.success(WXUtil.getAccessToken());
}
/**
* wx小程序首页
* 7个分类,一个全部
* 所有分类下的产品
*/
@GetMapping("/wx/home")
public Object home(School school){
/**
* 1、获取所有一级分类
* 2、填充一级分类中的所有产品
* 4、移除产品中的分类,因为在fill(cs)中,根据分类查找产品,将product中的category属性填充
* 导致json死循环,即category实例中有product,而product实例有category
*/
List<Category> cs = categoryService.list();
productService.wxFillBySchool(cs,school);
categoryService.removeCategoryFromProduct(cs);
categoryService.removeCategoryFromSC(cs);
for (Category c: cs) {
c.setSecondaryCategories(null);
}
return cs;
}
/**
* 首页
* 获取所有主题,并将产品放入到首页中
*/
@GetMapping("/wx/themes")
public Object wxThemes(School school){
System.out.println(school);
//获取所有主题
List<Theme> themes = themeService.list();
//设置主题中产品
themeService.wxFill(themes,school);
return themes;
}
/**
* 1. 获取参数pid
* 2. 根据pid获取Product 对象product
* 3. 判断改产品是否下架或这库存不足 isOfflineOrLackStock
* 4. 根据对象product,获取这个产品对应的详情图片集合
* 5. 获取产品的所有属性值
* 6. 获取产品对应的所有的评价
* 8. 把上述取值放在 map 中
* 9. 通过 Result 把这个 map 返回到浏览器去
* 为什么要用Map呢? 因为返回出去的数据是多个集合,而非一个集合,所以通过 map返回给浏览器,浏览器更容易识别
* @param pid
* @return
*/
@GetMapping("/wx/product/{pid}")
public Object product(@PathVariable("pid") int pid) {
Product product = productService.get(pid);
//在售商品
product.getUser().setOnSellProduct(productService.onSellProduct(product.getUser()));
//累计交易,我卖出的
List<Product> products = productService.getProductsByUser(product.getUser());
product.getUser().setOnOrderProduct(orderItemService.onOrderTraded(products));
//我买到的
// product.getUser().setOnOrderProduct(orderService.OnOrderProduct(product.getUser()));
List<ProductImage> productDetailImages = productImageService.listDetailProductImages(product);
List<PropertyValue> pvs = propertyValueService.list(product);
for (PropertyValue p:
pvs) {
p.setProduct(null);
}
Map<String,Object> map= new HashMap<>();
map.put("onSellProduct",product.getUser().getOnSellProduct());
map.put("onOrderProduct",product.getUser().getOnOrderProduct());
map.put("productDetailImages", productDetailImages);
map.put("pvs", pvs);
map.put("isOfflineOrLackStock", productService.isOfflineOrLackStock(product));
return Result.success(map);
}
/**
* 商品搜索模糊查询
* @param key 关键字
* @return
*/
@GetMapping("/wx/search")
public Object search(@RequestParam("key") String key,
@RequestParam(name = "sort",defaultValue = "none")String sort){
List<Product> products = productService.search(key,0,5);
for (Product p: products) {
p.setCategory(null);
p.setSecondaryCategory(null);
}
productImageService.setWXFirstProductImages(products);
//防止不支持异常
products = new ArrayList<>(products);
if(null!=sort){
switch(sort){
case "price":
Collections.sort(products,new ProductPriceComparator());
break;
}
}
return Result.success(products);
}
/**
* 预搜索
*/
@PutMapping("/wx/preSearch")
public Object preSearch(@RequestParam("key") String key){
List<String> strings = new ArrayList<>();
List<Product> products = productService.search(key,0,5);
for (Product p: products) {
strings.add(p.getName());
}
return strings;
}
/**
* 首页中的全部分类
* 获取所有分类
* @return
*/
@GetMapping("/wx/category/all")
public Object getAllCategories(){
List<Category> categories = categoryService.list();
secondaryCategoryService.fill(categories);
secondaryCategoryService.removeCategoryFromSecondCategory(categories);
return Result.success(categories);
}
/**
* 发布页面
* 获取所有一级分类和所有主题
*/
@GetMapping("/wx/categoriesAndThemes")
public Object listCategory(){
List<Category> categories = categoryService.list();
List<Theme> themes = themeService.list();
Map<String,Object> map = new HashMap<>();
map.put("categories",categories);
map.put("themes",themes);
return Result.success(map);
}
/**
* 筛选页面
* 获取一级分类下的所有产品
* 1. 获取参数cid
* 2. 根据cid获取分类Category对象 c
* 3. 为c填充二级分类和产品
* 4. 为产品填充销量和评价数据
* 5. 获取参数sort
* 5.1 如果sort==null,即不排序
* 5.2 如果sort!=null,则根据sort的值,从5个Comparator比较器中选择一个对应的排序器进行排序
6. 返回对象 c
*/
@GetMapping("/wx/secondaryCategory/{scid}")
public Object category(@PathVariable("scid")int scid,School school,
@RequestParam(name = "sort",defaultValue = "none") String sort){
//二级分类
SecondaryCategory sc = secondaryCategoryService.get(scid);
//填充二级级分类
productService.wxFillSCBySchool(sc,school);
secondaryCategoryService.removeSecondCategoryFromProduct(sc);
productImageService.setWXFirstProductImages(sc.getProductList());
if(null!=sort){
switch(sort){
case "review":
Collections.sort(sc.getProductList(),new ProductReviewComparator());
break;
case "date" :
Collections.sort(sc.getProductList(),new ProductDateComparator());
break;
case "saleCount" :
Collections.sort(sc.getProductList(),new ProductSaleCountComparator());
break;
case "price":
Collections.sort(sc.getProductList(),new ProductPriceComparator());
break;
case "all":
Collections.sort(sc.getProductList(),new ProductAllComparator());
break;
}
}
return sc;
}
/**
* 获取主题中的商品
*/
@GetMapping("/wx/theme/{tid}/products")
public Object wxProductByTheme(@PathVariable("tid")int tid,School school,
@RequestParam(name = "sort",defaultValue = "none") String sort){
Theme theme = themeService.get(tid);
themeService.wxFill(theme,school);
if(null!=sort){
switch(sort){
case "price":
Collections.sort(theme.getProducts(),new ProductPriceComparator());
break;
}
}
return theme.getProducts();
}
/**
* 发布页面
* 根据分类id获取所有属性
*/
@GetMapping("/wx/categories/{cid}/properties")
public Object getPropertiesByCid(@PathVariable("cid")int cid){
Category category = categoryService.get(cid);
List<Property> properties = propertyService.listByCategory(category);
/**防止浪费空间*/
for (Property p: properties) {
p.setCategory(null);
}
return properties;
}
/**
* 发布产品-必须使用post传送而且要@RequestBody不然数组内容接受不正确
* 1、openid用户、分类cid、内容content、imgs产品图片、price价格、pvs属性参数、title标题
* 2、工具类创建了一个wxproduct,在赋值给product
* 3、找到数据中最大的pid,是指pid
* 注意对三个表同时操作要进行回滚 !!!还没有实现回滚
* 4、发布产品
* 5、设置产品属性值
* 6、设置产品详细图片
* 7、设置产品主题
* */
@Transactional(propagation= Propagation.REQUIRED,rollbackForClassName="Exception")
@PostMapping("/wx/issueProduct/{scid}/theme/{tid}")
public Object getProduct(@PathVariable("scid")int scid,
@RequestBody WXProduct wxproduct,
@PathVariable("tid")int tid){
System.out.println(wxproduct);
Product product = new Product();
User u = userService.getUserByOpenid(wxproduct.getOpenid());
SecondaryCategory secondaryCategory = secondaryCategoryService.get(scid);
Category c = secondaryCategory.getCategory();
/** 用户、分类、创建时间 */
product.setUser(u);
product.setCategory(c);
product.setSecondaryCategory(secondaryCategory);
product.setCreateDate(new Date());
/** 库存 在线 标题、内容、原价、二手价、运费、属性值、图片集合 */
product.setStock(1);
product.setOnline("T");
product.setName(wxproduct.getName());
product.setSubTitle(wxproduct.getSubTitle());
product.setPromotePrice(wxproduct.getPromotePrice());
product.setOriginalPrice(wxproduct.getOriginalPrice());
product.setCarriagePrice(wxproduct.getCarriagePrice());
String[] pvs = wxproduct.getPvs();
/**设置产品可以交易的方式*/
String[] selects = wxproduct.getSelect();
for (String s:selects) {
if(s.equals("school"))
product.setIsSchool("T");
if(s.equals("change"))
product.setIsChange("T");
if(s.equals("express"))
product.setIsExpress("T");
}
//发布产品
productService.add(product);
//添加主题产品表
Theme theme = themeService.get(tid);
ThemeProduct themeProduct = new ThemeProduct();
themeProduct.setProduct(product);
themeProduct.setTheme(theme);
themeService.addThemeProduct(themeProduct);
// System.out.println(product); //打印
//初始化属性值,即写入属性值到数据库
propertyValueService.init(product,pvs);
return Result.success(product.getId()); //返回产品id,让前端继续上传图片
}
/**
* pid 产品id、imgs用户上传的图片,有以下两种方案
* 1、只要存储detail 2、两种都要存储比如single 这样就不会报错了 修改多一个WXFill了
* 选择了方案一
*/
@PostMapping("/wx/productImgs")
public Object add(@RequestParam("pid") int pid, @RequestParam(value = "imgs") MultipartFile image,
HttpServletRequest request){
ProductImage bean = new ProductImage();
Product product = productService.get(pid);
bean.setProduct(product);
bean.setType("detail"); //锁定详细
//添加图片
productImageService.add(bean);
//上传图片
WXUtil.upFile(bean.getId(),"productDetail",image,request);
return Result.success("图片上传成功");
}
/**
* 商品库存是否足够,是否下架?true继续,否则错误
* order订单生成
* pid:产品id, uid:用户id,address:收货地址,post:邮政编号,receiver:收货人,mobile:移动电话, number:1 数量
* 订单项生成(id,uid,oid,pid,number)
* 定时任务: 10分钟未支付取消订单
*/
@PutMapping("/wx/order/{pid}")
public Object createWxOrder(@PathVariable("pid")int pid,@RequestParam(value = "uid")String uid,@RequestBody Order order){
User user = userService.getById(Integer.parseInt(uid));
Product product = productService.get(pid);
//用户是否登录
if(null == user)
return Result.fail("未登录");
//商品未下架且库存>0
if(!(product.getOnline().equals("T") && (product.getStock()>0))){
return Result.fail("无效商品");
}
//商品库存-1
product.setStock(product.getStock() - 1);
productService.update(product);
//先创建订单项
OrderItem oi = new OrderItem();
oi.setUser(user);
oi.setProduct(product);
oi.setNumber(1);
orderItemService.add(oi);
//后生成订单
String orderCode = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date()) + RandomUtils.nextInt(10000);
order.setOrderCode(orderCode);
order.setCreateDate(new Date());
order.setUser(user);
order.setStatus(OrderService.waitPay);
//设置订单项中的订单 这里价格没有用到
orderService.wxAdd(order,oi);
//设置订单定时任务
JobKey jobKey = JobKey.jobKey(String.valueOf(order.getId()),"waitPayOrder");
String desc = "待支付订单,超过十分钟取消订单";
Map<String,String> jobMap = new HashMap<>();
jobMap.put("oid",String.valueOf(order.getId()));
jobMap.put("pid",String.valueOf(product.getId()));
jobMap.put("status","waitPayOrder");
try {
QuartzJobManager.startQuartzJob(quartzJobService,jobKey,jobMap,desc);
} catch (SchedulerException e) {
e.printStackTrace();
}
//返回数据
Map<String,Object> map = new HashMap<>();
map.put("oid", order.getId());
map.put("orderCode",order.getOrderCode());
map.put("tradeWay",order.getTradeWay());
map.put("total", order.getTotalPrice());
return Result.success(map);
}
/**
* 获取订单详细信息
*/
@GetMapping("/wx/order/{oid}/orderDetail")
public Object onOrderDetail(@PathVariable("oid") int oid){
Order order = orderService.get(oid);
//填充order
orderItemService.wxFill(order);
orderService.removeOrderFromOrderItem(order);
return Result.success(order);
}
/**
* 立即支付
* 1 获取参数oid
* 2 根据oid获取到订单对象order
* 3 修改订单对象的状态和支付时间
* 4 取消待支付订单计时
* 5 更新这个订单对象到数据库
* 6 返回订单
*/
@PutMapping("/wx/payed/{oid}")
public Object payed(@PathVariable("oid") int oid) {
Order order = orderService.get(oid);
//买家账号
User user = order.getUser();
//余额不足
if(user.getMoney() < Float.parseFloat(order.getTotalPrice())){
return Result.fail("余额不足");
}
//扣除买家金额
user.setMoney(user.getMoney() - Float.parseFloat(order.getTotalPrice()));
//更新用户账号
userService.update(user);
//取消待支付定时10分钟
JobKey jobKey = JobKey.jobKey(String.valueOf(order.getId()),"waitPayOrder");
try {
QuartzJobManager.pauseQuartzJob(quartzJobService,jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
order.setStatus(OrderService.waitDelivery);
order.setPayDate(new Date());
//更新订单
orderService.update(order);
return Result.success("支付成功");
}
/**
* 确认发货
* 1 获取参数oid
* 2 根据oid获取到订单对象order
* 3 修改订单对象的状态和发货时间
* 4 更新这个订单对象到数据库
* 5 返回订单
*/
@GetMapping("/wx/delivery/{oid}")
public Object waitDelivery(@PathVariable("oid") int oid){
Order order = orderService.get(oid);
System.out.println(order);
order.setStatus(OrderService.waitConfirm);
order.setDeliveryDate(new Date());
orderService.update(order);
return Result.success("发货成功");
}
/**
* 确认收货
* 1 获取参数oid
* 2 根据oid获取到订单对象order
* 3 修改订单对象的状态和收货时间
* 4 更新卖家账号金额
* 5 更新这个订单对象到数据库
* 6 返回订单
*/
@GetMapping("/wx/receive/{oid}")
public Object waitConfirmReceive(@PathVariable("oid") int oid){
Order order = orderService.get(oid);
System.out.println(order);
//找到卖家,更新账户
OrderItem orderItem = orderItemService.getByOrderId(order.getId());
Product product = orderItem.getProduct();
User user = product.getUser();
user.setMoney(user.getMoney() + Float.parseFloat(order.getTotalPrice()));
userService.update(user);
order.setStatus(OrderService.waitReview);
order.setConfirmDate(new Date());
orderService.update(order);
return Result.success("收货成功");
}
/**获取order订单*/
@GetMapping("/wx/getOrder/{oid}")
public Object getOrder(@PathVariable("oid") int oid){
Order order = orderService.get(oid);
orderItemService.wxFill(order);
orderService.removeOrderFromOrderItem(order);
order.setUser(null);
return Result.success(order);
}
/**
* 获取全部我的订单 微信小程序我买到的
* 1、订单里面的uid是下单者的(我),并不是商家uid,应该用product中的uid
* 1. 通过openid获取用户user
* 2. 查询user所有的状态不是"delete" 的订单集合os
* 3. 为这些订单填充订单项
* 4. 返回 订单集合
*/
@GetMapping("/wx/order/bought")
public Object bought(@RequestParam(value = "openid")String openid) {
User user = userService.getUserByOpenid(openid);
System.out.println(user);
if(null==user)
return Result.fail("未登录");
//微信小程序的获取,由于图片问题没有处理好
List<Order> os= orderService.wxListByUserWithoutDelete(user);
orderService.removeOrderFromOrderItem(os);
return os;
}
/**
* 微信小程序我卖出
* 1. 通过openid获取用户user
* 2. 通过user查找到我发布的产品Product
* 3. 通过我发布的产品找到对应的orderItem
* 4. 返回 订单项orderItems集合
*/
@GetMapping("/wx/order/sell")
public Object mySell(@RequestParam(value = "openid")String openid){
User user = userService.getUserByOpenid(openid);
List<Product> products = productService.getProductsByUser(user);
for(Product p : products){
//设置为空,防止数据冗余
p.setCategory(null);
// System.out.println(p);
}
List<List<OrderItem>> listOrderItems = orderItemService.listByProduct(products);
List<OrderItem> goalOrderItems = new ArrayList<>();
for (List<OrderItem> orderItems: listOrderItems) {
for (OrderItem oi: orderItems) {
goalOrderItems.add(oi);
}
}
//设置第一张图片
productImageService.setWXFirstProductImages(products);
return Result.success(goalOrderItems);
}
/**
* 我发布的
* @param openid
* @return 产品
*/
@GetMapping("/wx/order/release")
public Object myRelease(@RequestParam(value = "openid")String openid){
User user = userService.getUserByOpenid(openid);
List<Product> products = productService.getProductsByUser(user);
for (Product p: products) {
//设置为空,防止数据冗余
p.setCategory(null);
p.setSecondaryCategory(null);
}
//设置第一张图片
productImageService.setWXFirstProductImages(products);
//设置详细图片
return Result.success(products);
}
/**
* 下架商品
* 该商品是否处于交易中,是下架失败,否下架成功
*/
@PutMapping("/wx/my/product/{pid}/offline")
public Object offline(@PathVariable("pid") int pid){
Product product = productService.get(pid);
boolean isTrading = productService.isTrading(product);
if(isTrading){
return Result.fail("无法下架,商品正处于交易");
}
product.setOnline("F");
productService.update(product);
return Result.success();
}
/**
* 重新上架商品
* 该商品是否处于交易中,是下架失败,否下架成功
*/
@PutMapping("/wx/my/product/{pid}/reOnline")
public Object reOnline(@PathVariable("pid") int pid){
Product product = productService.get(pid);
product.setOnline("T");
productService.update(product);
return Result.success();
}
/**
* 取消订单-买家
*/
@GetMapping("/wx/order/{id}/cancel")
public Object orderCancel(@PathVariable("id") int id){
Order order = orderService.get(id);
order.setStatus("waitCancel");
//更新订单
orderService.update(order);
return Result.success("待卖家同意");
}
/**
* 同意取消-卖家
*/
@GetMapping("/wx/order/{id}/agreeCancel/{pid}")
public Object agreeOrderCancel(@PathVariable("id") int id,@PathVariable("pid") int pid){
Order order = orderService.get(id);
User user = order.getUser();
Product product = productService.get(pid);
//更新订单
order.setStatus("cancel");
order.setCancelDate(new Date());
//更新库存+1 买家金额退还
product.setStock(product.getStock()+1);
user.setMoney(user.getMoney() + Float.parseFloat(order.getTotalPrice()));
userService.update(user);
orderService.update(order);
productService.update(product);
return Result.success("同意取消");
}
/**
* 拒绝取消-卖家
* 少了确认收货后
*/
@GetMapping("/wx/order/{id}/refuseCancel")
public Object refuseOrderCancel(@PathVariable("id")int id){
Order order = orderService.get(id);
if(order.getPayDate() == null)
order.setStatus("waitPay");
else if(order.getDeliveryDate() == null)
order.setStatus("waitDelivery");
else if(order.getConfirmDate() == null)
order.setStatus("waitConfirm");
else
return Result.success("拒绝失败");
orderService.update(order);
return Result.success("拒绝取消");
}
/**
* 充值recharge 提现 withdraw
*/
@PutMapping("/wx/my/{id}/wallet")
public Object rechargeOrWithdraw(@PathVariable("id")int id,@RequestBody String data){
JSONObject wallet = JSONUtil.parseObj(data);
User user = userService.getById(id);
float charge = Float.parseFloat((String)wallet.get("charge"));
String type = (String) wallet.get("type");
if(type.equals("recharge")){
user.setMoney(user.getMoney() + charge);
}else if(type.equals("withdraw")){
user.setMoney(user.getMoney() - charge);
}
//更新钱包
userService.update(user);
return Result.success(user);
}
/**
* 卖家在订单中修改收货地址
*/
@PutMapping("/wx/order/{id}/updateOrderAddress")
public Object updateOrderAddress(@PathVariable("id")int id,@RequestBody String address){
JSONObject addrObj = JSONUtil.parseObj(address);
String addr = (String)addrObj.get("address");
//更新订单收货地址
Order order = orderService.get(id);
order.setAddress(addr);
orderService.update(order);
return Result.success();
}
/**
* 订单评价
*/
@PostMapping("/wx/orderItem/{id}/evaluation")
public void orderItemEvaluation(@PathVariable("id")int id,@RequestBody String result){
JSONObject resultObj = JSONUtil.parseObj(result);
String content = (String) resultObj.get("content");
int score = (int) resultObj.get("score");
if(content.equals("")){
content = "此用户没有填写评价";
}
//订单项
OrderItem orderItem = orderItemService.get(id);
Order order = orderItem.getOrder();
//订单评价
EvaluationOrder evaluationOrder = new EvaluationOrder();
evaluationOrder.setContent(content);
evaluationOrder.setScore(score);
evaluationOrder.setCreateDate(new Date());
evaluationOrder.setOrderItem(orderItem);
//添加评价
evaluationService.add(evaluationOrder);
//修改订单状态
order.setStatus("finish");
orderService.update(order);
}
/**
* 查看评价
*/
@GetMapping("/wx/orderItem/{id}/evaluation")
public Object getEvaluationByOrderItem(@PathVariable("id")int id){
EvaluationOrder evaluationOrder = evaluationService.getByOrderItem_Id(id);
evaluationOrder.getOrderItem().setOrder(null);
//设置商品图片
productImageService.setWXFirstProductImage(evaluationOrder.getOrderItem().getProduct());
return Result.success(evaluationOrder);
}
}