package com.panzhihua.service_community.service.impl;
|
|
import cn.binarywang.wx.miniapp.api.WxMaService;
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.date.DatePattern;
|
import cn.hutool.core.date.DateUnit;
|
import cn.hutool.core.date.DateUtil;
|
import cn.hutool.core.util.StrUtil;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
|
import com.panzhihua.common.constants.Constants;
|
import com.panzhihua.common.model.dtos.shop.*;
|
import com.panzhihua.common.model.vos.R;
|
import com.panzhihua.common.model.vos.community.convenient.ConvenientElevatingPointVO;
|
import com.panzhihua.common.model.vos.community.convenient.ConvenientMerchantVO;
|
import com.panzhihua.common.model.vos.shop.*;
|
import com.panzhihua.common.model.vos.user.SysUserVO;
|
import com.panzhihua.common.service.user.UserService;
|
import com.panzhihua.common.utlis.*;
|
import com.panzhihua.common.utlis.wx.WXPayUtil;
|
import com.panzhihua.service_community.dao.*;
|
import com.panzhihua.service_community.model.dos.*;
|
import com.panzhihua.service_community.service.ComShopFlowerOrderService;
|
import com.panzhihua.service_community.util.WxMaConfiguration;
|
import lombok.extern.slf4j.Slf4j;
|
import me.chanjar.weixin.common.error.WxErrorException;
|
import org.springframework.amqp.rabbit.core.RabbitTemplate;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import javax.annotation.Resource;
|
import java.math.BigDecimal;
|
import java.text.DecimalFormat;
|
import java.text.SimpleDateFormat;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
import static java.util.Objects.isNull;
|
import static java.util.Objects.nonNull;
|
|
/**
|
* @auther lyq
|
* @create 2021-04-14 15:03:01
|
* @describe 订单表服务实现类
|
*/
|
@Slf4j
|
@Service
|
public class ComShopFlowerOrderServiceImpl extends ServiceImpl<ComShopFlowerOrderDAO, ComShopFlowerOrderDO>
|
implements ComShopFlowerOrderService {
|
|
@Resource
|
private ComShopFlowerGoodsDAO comShopFlowerGoodsDAO;
|
@Resource
|
private ComShopFlowerGoodsAttrDAO comShopFlowerGoodsAttrDAO;
|
@Resource
|
private ComShopCartDAO comShopCartDAO;
|
@Resource
|
private ConvenientMerchantDAO convenientMerchantDAO;
|
@Resource
|
private ComShopFlowerUserAddressDAO comShopFlowerUserAddressDAO;
|
@Resource
|
private ComShopFlowerOrderOperateDAO comShopFlowerOrderOperateDAO;
|
@Resource
|
private ComShopFlowerOrderGoodsDAO comShopFlowerOrderGoodsDAO;
|
@Resource
|
private ComShopFlowerOrderDAO comShopFlowerOrderDAO;
|
@Resource
|
private ComShopFlowerOrderPayDAO comShopFlowerOrderPayDAO;
|
@Resource
|
private ConvenientElevatingPointDAO convenientElevatingPointDAO;
|
@Resource
|
private ComShopFlowerEvaluateDAO comShopFlowerEvaluateDAO;
|
@Resource
|
private ComShopFlowerRefundOrderDAO comShopFlowerRefundOrderDAO;
|
@Resource
|
private ComShopFlowerOrderDeliveryDAO comShopFlowerOrderDeliveryDAO;
|
@Resource
|
private WxMaConfiguration wxMaConfiguration;
|
@Resource
|
private UserService userService;
|
@Resource
|
private RabbitTemplate rabbitTemplate;
|
|
|
@Value("${hcMin.app.isTest}")
|
private Boolean isTest;
|
@Value("${hcMin.app.appid}")
|
private String appid;
|
@Value("${hcMin.app.payKey}")
|
private String payKey;
|
@Value("${hcMin.app.mchId}")
|
private String mchId;
|
@Value("${hcMin.app.notifyUrl}")
|
private String notifyUrl;
|
|
/**
|
* 订单预览
|
*
|
* @param orderPreviewDTO 请求参数
|
* @return 订单预览数据
|
*/
|
@Override
|
public R orderPreview(ComShopOrderPreviewDTO orderPreviewDTO) {
|
|
// 返回参数
|
ComShopFlowerOrderPreviewVO orderPreviewVO = new ComShopFlowerOrderPreviewVO();
|
// 返回商品列表
|
List<ComShopOrderGoodsVO> orderGoodsList = new ArrayList<>();
|
Long storeId = 0L;
|
BigDecimal orderTotal = BigDecimal.ZERO;
|
Integer orderGoodsTotal = 0;
|
// 判断提交方式
|
if (orderPreviewDTO.getSubmitType().equals(ComShopOrderPreviewDTO.submitType.details)) {// 详情页提交
|
// 查询商品信息
|
ComShopFlowerGoodsDO goodsDO =
|
comShopFlowerGoodsDAO.selectOne(new QueryWrapper<ComShopFlowerGoodsDO>().eq("id", orderPreviewDTO.getGoodsId())
|
.eq("status", ComShopGoodsDO.status.sell).eq("delete_status", ComShopGoodsDO.deleteStatus.no));
|
if (goodsDO == null) {
|
return R.fail("商品已下架或已删除");
|
}
|
// 设置店铺id
|
storeId = goodsDO.getStoreId();
|
|
// 查询商品规格信息
|
ComShopFlowerGoodsAttrDO goodsAttrDO = comShopFlowerGoodsAttrDAO.selectById(orderPreviewDTO.getGoodsAttrId());
|
if (goodsAttrDO == null) {
|
return R.fail("商品规格不存在");
|
}
|
if (goodsAttrDO.getSale() < orderPreviewDTO.getBuyNum()) {
|
return R.fail("该规格库存不足，无法下单");
|
}
|
|
orderTotal = goodsAttrDO.getPrice().multiply(BigDecimal.valueOf(orderPreviewDTO.getBuyNum()));
|
orderGoodsTotal = orderPreviewDTO.getBuyNum();
|
// 商品信息赋值
|
ComShopOrderGoodsVO orderGoodsVO = new ComShopOrderGoodsVO();
|
orderGoodsVO.setGoodsName(goodsDO.getName());
|
orderGoodsVO.setGoodsId(goodsDO.getId());
|
orderGoodsVO.setGoodsAttrId(goodsAttrDO.getId());
|
orderGoodsVO.setGoodsPic(goodsAttrDO.getAttrPic());
|
orderGoodsVO.setPrice(goodsAttrDO.getPrice());
|
orderGoodsVO.setNum(orderPreviewDTO.getBuyNum());
|
orderGoodsList.add(orderGoodsVO);
|
} else if (orderPreviewDTO.getSubmitType().equals(ComShopOrderPreviewDTO.submitType.cart)) {// 购物车提交
|
List<ComShopCartDO> cartList = comShopCartDAO.selectBatchIds(orderPreviewDTO.getCartIds());
|
if (cartList.isEmpty()) {
|
return R.fail("未找到购物车商品信息");
|
}
|
// 设置店铺id
|
storeId = cartList.get(0).getStoreId();
|
// 循环遍历购物车商品信息
|
for (ComShopCartDO cartDO : cartList) {
|
// 商品信息赋值
|
ComShopOrderGoodsVO orderGoodsVO = new ComShopOrderGoodsVO();
|
orderGoodsVO.setGoodsId(cartDO.getGoodsId());
|
orderGoodsVO.setGoodsAttrId(cartDO.getGoodsAttrId());
|
orderGoodsVO.setGoodsPic(cartDO.getGoodsAttrPic());
|
orderGoodsVO.setNum(cartDO.getAmount());
|
orderGoodsVO.setGoodsName(cartDO.getGoodsName());
|
// 查询商品规格
|
ComShopFlowerGoodsAttrDO goodsAttrDO = comShopFlowerGoodsAttrDAO.selectById(cartDO.getGoodsAttrId());
|
if (goodsAttrDO != null) {
|
orderGoodsVO.setPrice(goodsAttrDO.getPrice());
|
} else {
|
orderGoodsVO.setPrice(BigDecimal.ZERO);
|
}
|
orderTotal = orderTotal.add(orderGoodsVO.getPrice().multiply(BigDecimal.valueOf(cartDO.getAmount())));
|
orderGoodsTotal += cartDO.getAmount();
|
orderGoodsList.add(orderGoodsVO);
|
}
|
}
|
orderPreviewVO.setOrderTotal(orderTotal);
|
orderPreviewVO.setOrderGoodsTotal(orderGoodsTotal);
|
|
// 查询店铺信息
|
ConvenientMerchantDO convenientMerchantDO = convenientMerchantDAO.selectById(storeId);
|
if (convenientMerchantDO != null) {
|
ConvenientMerchantVO shopStoreVO = new ConvenientMerchantVO();
|
BeanUtils.copyProperties(convenientMerchantDO, shopStoreVO);
|
orderPreviewVO.setConvenientMerchantVO(shopStoreVO);
|
}
|
|
// 查询默认收货地址
|
ComShopFlowerUserAddressDO userDefaultAddressDO =
|
comShopFlowerUserAddressDAO.selectOne(new QueryWrapper<ComShopFlowerUserAddressDO>().eq("delete_status", 2)
|
.eq("user_id", orderPreviewDTO.getUserId()).eq("is_default", ComShopUserAddressDO.isDefault.yes));
|
|
// 查询用户收货地址中的默认地址
|
if (userDefaultAddressDO != null) {
|
ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
|
BeanUtils.copyProperties(userDefaultAddressDO, userAddressVO);
|
orderPreviewVO.setUserAddressVO(userAddressVO);
|
} else {
|
// 查询上次购买记录的收货地址
|
// 查询到用户上一笔订单
|
List<ComShopFlowerOrderDO> shopOrders = this.baseMapper.selectList(new QueryWrapper<ComShopFlowerOrderDO>()
|
.eq("delete_status", 2).eq("user_id", orderPreviewDTO.getUserId()).orderByDesc("create_at"));
|
if (shopOrders != null && shopOrders.size() > 0) {
|
ComShopFlowerUserAddressDO userAddressDO =
|
comShopFlowerUserAddressDAO.selectById(shopOrders.get(0).getReceiverId());
|
if (userAddressDO != null) {
|
ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
|
BeanUtils.copyProperties(userAddressDO, userAddressVO);
|
orderPreviewVO.setUserAddressVO(userAddressVO);
|
}
|
}
|
}
|
|
return R.ok(orderPreviewVO);
|
}
|
|
/**
|
* 创建订单
|
*
|
* @param orderCreateDTO 创建订单请求参数
|
* @return 创建结果
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public R orderCreate(ComShopOrderCreateDTO orderCreateDTO) {
|
// 创建返回参数
|
ComShopFlowerOrderVO shopOrderVO = new ComShopFlowerOrderVO();
|
// 查询用户收货地址
|
ComShopFlowerUserAddressDO userAddressDO = comShopFlowerUserAddressDAO.selectById(orderCreateDTO.getReceiverId());
|
if (userAddressDO == null || userAddressDO.getDeleteStatus() != 2) {
|
return R.fail("收货地址不存在");
|
}
|
// 用户id
|
Long userId = orderCreateDTO.getUserId();
|
// 店铺id
|
Long storeId = 0L;
|
// 生成订单号
|
String orderNo = OrderNoUtils.NextOrderNoFlower(userId);
|
// 配送方式
|
Integer deliveryType = 1;
|
// 订单总金额
|
BigDecimal orderTotal = BigDecimal.ZERO;
|
// 创建订单商品信息
|
List<ComShopFlowerOrderGoodsDO> orderGoodsDOList = new ArrayList<>();
|
if (!orderCreateDTO.getOrderGoodsList().isEmpty()) {
|
for (ComShopOrderCreateGoodsDTO createGoodsDTO : orderCreateDTO.getOrderGoodsList()) {
|
// 查询当前商品信息
|
ComShopFlowerGoodsDO goodsDO =
|
comShopFlowerGoodsDAO.selectOne(new QueryWrapper<ComShopFlowerGoodsDO>().eq("id", createGoodsDTO.getGoodsId())
|
.eq("delete_status", ComShopGoodsDO.deleteStatus.no).eq("status", ComShopGoodsDO.status.sell));
|
if (goodsDO == null) {
|
log.error("未查询到商品信息,商品已下架活已删除,商品id" + createGoodsDTO.getGoodsId());
|
continue;
|
}
|
storeId = goodsDO.getStoreId();
|
deliveryType = orderCreateDTO.getDeliveryType();
|
ComShopFlowerOrderGoodsDO orderGoodsDO = new ComShopFlowerOrderGoodsDO();
|
orderGoodsDO.setGoodsId(goodsDO.getId());
|
orderGoodsDO.setGoodsName(goodsDO.getName());
|
|
orderGoodsDO.setStoreId(storeId);
|
orderGoodsDO.setUserId(userId);
|
orderGoodsDO.setAmount(createGoodsDTO.getNum());
|
orderGoodsDO.setOrderNo(orderNo);
|
// 查询当前商品规格
|
ComShopFlowerGoodsAttrDO goodsAttrDO = comShopFlowerGoodsAttrDAO.selectById(createGoodsDTO.getGoodsAttrId());
|
if (goodsAttrDO == null) {
|
log.error(
|
"未查询到商品规格信息,商品id" + createGoodsDTO.getGoodsId() + "商品规格id:" + createGoodsDTO.getGoodsAttrId());
|
continue;
|
}
|
|
if (goodsAttrDO.getStock() < createGoodsDTO.getNum()) {
|
return R.fail("该规格库存不足，无法下单");
|
}
|
orderGoodsDO.setGoodsAttrName(goodsAttrDO.getGoodsAttrName());
|
orderGoodsDO.setGoodsAttrId(goodsAttrDO.getId());
|
orderGoodsDO.setGoodsAttrPrice(createGoodsDTO.getPrice());
|
orderGoodsDO.setPrice(goodsAttrDO.getPrice());
|
orderGoodsDO.setCollatePrice(goodsAttrDO.getCollatePrice());
|
orderGoodsDO.setFreeShippingPrice(goodsAttrDO.getFreeShippingPrice());
|
orderGoodsDO.setGoodsAttrPic(goodsAttrDO.getAttrPic());
|
orderGoodsDOList.add(orderGoodsDO);
|
// 将商品金额计算到订单总金额
|
orderTotal = orderTotal
|
.add(createGoodsDTO.getPrice().multiply(BigDecimal.valueOf(createGoodsDTO.getNum())));
|
}
|
}
|
// 创建订单信息
|
ComShopFlowerOrderDO shopOrderDO = new ComShopFlowerOrderDO();
|
shopOrderDO.setOrderNo(orderNo);
|
shopOrderDO.setStoreId(storeId);
|
shopOrderDO.setUserId(userId);
|
//TODO
|
shopOrderDO.setStatus(ComShopFlowerOrderDO.status.dfk);
|
shopOrderDO.setPayStatus(ComShopFlowerOrderDO.payStatus.no);
|
shopOrderDO.setReceiverId(orderCreateDTO.getReceiverId());
|
shopOrderDO.setDeleteStatus(ComShopFlowerOrderDO.deleteStatus.no);
|
shopOrderDO.setTotalAmount(orderTotal);
|
shopOrderDO.setDiscountAmount(BigDecimal.ZERO);
|
shopOrderDO.setDeliveryType(deliveryType);
|
shopOrderDO.setPointId(orderCreateDTO.getPointId());
|
if (StringUtils.isNotEmpty(orderCreateDTO.getRemark())) {
|
shopOrderDO.setRemark(orderCreateDTO.getRemark());
|
}
|
this.baseMapper.insert(shopOrderDO);
|
if (!orderGoodsDOList.isEmpty()) {
|
orderGoodsDOList.forEach(orderGoods -> {
|
orderGoods.setOrderId(shopOrderDO.getId());
|
comShopFlowerOrderGoodsDAO.insert(orderGoods);
|
});
|
}
|
// 创建订单操作记录
|
ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
|
orderOperateDO.setOrderNo(orderNo);
|
orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.create);
|
orderOperateDO.setOperationTime(new Date());
|
if (StringUtils.isNotEmpty(orderCreateDTO.getPhone())) {
|
orderOperateDO.setOperationContent("用户" + orderCreateDTO.getPhone() + "下单");
|
orderOperateDO.setOperationBy("用户" + orderCreateDTO.getPhone());
|
} else {
|
orderOperateDO.setOperationContent("用户下单");
|
orderOperateDO.setOperationBy("用户");
|
}
|
comShopFlowerOrderOperateDAO.insert(orderOperateDO);
|
shopOrderVO.setOrderNo(orderNo);
|
shopOrderVO.setOrderTotal(orderTotal);
|
shopOrderVO.setOrderId(shopOrderDO.getId());
|
|
try {
|
BigDecimal money = orderTotal;
|
if (isTest) {
|
money = BigDecimal.valueOf(0.01);
|
}
|
// 调用wx支付
|
String xml = WxPayUtils.getUnifiedorder(appid, mchId, payKey, notifyUrl, "商品购买", orderCreateDTO.getOpenId(),
|
orderNo, money, null);
|
log.info("微信支付返回参数:" + xml);
|
shopOrderVO.setPayResult(xml);
|
} catch (Exception e) {
|
log.error("调用微信支付异常,异常原因：" + e.getMessage());
|
}
|
//发送消息到mq
|
rabbitTemplate.convertAndSend("huacheng.shop.order.exchange", "huacheng.shop.order.key", shopOrderVO, message -> {
|
//30分钟后
|
message.getMessageProperties().setHeader("x-delay", 1800*1000);
|
return message;
|
});
|
return R.ok(shopOrderVO);
|
}
|
|
/**
|
* 分页查询用户订单列表
|
*
|
* @param comOrderListDTO 请求参数
|
* @return 查询结果
|
*/
|
@Override
|
public R pageOrderList(PageComFlowerOrderListDTO comOrderListDTO) {
|
Page page = new Page<>(comOrderListDTO.getPageNum(), comOrderListDTO.getPageSize());
|
IPage<ComShopFlowerOrderPageVO> orderPageVOIPage = this.baseMapper.pageOrderList(page, comOrderListDTO);
|
if (!orderPageVOIPage.getRecords().isEmpty()) {
|
orderPageVOIPage.getRecords().forEach(orderVo -> {
|
List<ComShopFlowerOrderGoodsVO> orderGoodsVOS = new ArrayList<>();
|
// 查询订单下商品信息
|
List<ComShopFlowerOrderGoodsDO> orderGoodsDOList = comShopFlowerOrderGoodsDAO
|
.selectList(new QueryWrapper<ComShopFlowerOrderGoodsDO>().eq("order_no", orderVo.getOrderNo()));
|
if (!orderGoodsDOList.isEmpty()) {
|
orderGoodsDOList.forEach(orderGoods -> {
|
ComShopFlowerOrderGoodsVO orderGoodsVO = new ComShopFlowerOrderGoodsVO();
|
BeanUtils.copyProperties(orderGoods, orderGoodsVO);
|
// 根据商品规格id查询商品规格
|
// ComShopFlowerGoodsAttrDO goodsAttrDO = comShopFlowerGoodsAttrDAO.selectById(orderGoods.getGoodsAttrId());
|
// if (goodsAttrDO != null) {
|
orderGoodsVO.setGoodsAttr(orderGoods.getGoodsAttrName());
|
// }
|
orderGoodsVO.setNum(orderGoods.getAmount());
|
orderGoodsVO.setGoodsPic(orderGoods.getGoodsAttrPic());
|
orderGoodsVO.setPrice(orderGoods.getGoodsAttrPrice());
|
orderGoodsVOS.add(orderGoodsVO);
|
});
|
orderVo.setGoodsAttrName(orderGoodsDOList.get(0).getGoodsAttrName());
|
}
|
orderVo.setOrderGoodsVOList(orderGoodsVOS);
|
|
ConvenientMerchantVO shopStoreVO = new ConvenientMerchantVO();
|
// 查询店铺信息
|
ConvenientMerchantDO convenientMerchantDO = convenientMerchantDAO.selectById(orderVo.getStoreId());
|
if (convenientMerchantDO != null) {
|
BeanUtils.copyProperties(convenientMerchantDO, shopStoreVO);
|
}
|
orderVo.setConvenientMerchantVO(shopStoreVO);
|
//已完成、已退款才有评论
|
if (ComShopFlowerOrderDO.status.ywc == orderVo.getStatus() || ComShopFlowerOrderDO.status.ytk == orderVo.getStatus()) {
|
ComShopFlowerEvaluateVO comShopFlowerEvaluateVO = comShopFlowerEvaluateDAO.selectByOrderNo(orderVo.getOrderNo());
|
if (nonNull(comShopFlowerEvaluateVO)) {
|
orderVo.setComShopFlowerEvaluateVO(comShopFlowerEvaluateVO);
|
}
|
}
|
|
//判断是否可以退款 订单是否已超过15天 是否已有退款订单
|
int count = comShopFlowerRefundOrderDAO.selectCountRefundNowByOrderId(orderVo.getOrderId());
|
if (count > 0){
|
orderVo.setRefundable(2);
|
}else {
|
if (null == orderVo.getReceivingTime()){
|
orderVo.setRefundable(2);
|
}else {
|
//收货时间往前推15天和当前时间做比较
|
Date date = DateUtils.addDay(orderVo.getReceivingTime(), 15);
|
if(date.before(new Date())){
|
orderVo.setRefundable(2);
|
}
|
}
|
}
|
|
|
});
|
}
|
return R.ok(orderPageVOIPage);
|
}
|
|
/**
|
* 根据订单id查询订单详情
|
*
|
* @param orderId 订单id
|
* @return 订单详情
|
*/
|
@Override
|
public R orderDetail(Long orderId, String phone) {
|
ComShopFlowerOrderPageVO orderVO = new ComShopFlowerOrderPageVO();
|
ComShopFlowerOrderDO shopOrderDO = null;
|
if (StrUtil.isEmpty(phone)) {
|
// 查询订单信息
|
shopOrderDO = this.baseMapper.selectById(orderId);
|
} else {
|
//查询自提点信息
|
ConvenientElevatingPointDO convenientElevatingPointDO = convenientElevatingPointDAO.selectOne(new LambdaQueryWrapper<ConvenientElevatingPointDO>().eq(ConvenientElevatingPointDO::getWechatAccount, phone));
|
if (isNull(convenientElevatingPointDO)) {
|
return R.ok("订单不在该自提点");
|
}
|
Long pointDOId = convenientElevatingPointDO.getId();
|
shopOrderDO = this.baseMapper.selectOne(new LambdaQueryWrapper<ComShopFlowerOrderDO>().eq(ComShopFlowerOrderDO::getId, orderId).eq(ComShopFlowerOrderDO::getPointId, pointDOId));
|
}
|
|
|
if (shopOrderDO == null) {
|
return R.fail("未查询到订单");
|
}
|
BeanUtils.copyProperties(shopOrderDO, orderVO);
|
orderVO.setOrderTotal(shopOrderDO.getTotalAmount());
|
orderVO.setOrderId(orderId);
|
ConvenientMerchantVO shopStoreVO = new ConvenientMerchantVO();
|
// 查询店铺信息
|
ConvenientMerchantDO shopStoreDO = convenientMerchantDAO.selectById(shopOrderDO.getStoreId());
|
if (shopStoreDO != null) {
|
BeanUtils.copyProperties(shopStoreDO, shopStoreVO);
|
}
|
orderVO.setConvenientMerchantVO(shopStoreVO);
|
|
List<ComShopFlowerOrderGoodsVO> orderGoodsVOS = new ArrayList<>();
|
// 查询订单下商品信息
|
List<ComShopFlowerOrderGoodsDO> orderGoodsDOList = comShopFlowerOrderGoodsDAO
|
.selectList(new QueryWrapper<ComShopFlowerOrderGoodsDO>().eq("order_no", shopOrderDO.getOrderNo()));
|
StringBuilder sbr = new StringBuilder();
|
if (!orderGoodsDOList.isEmpty()) {
|
orderGoodsDOList.forEach(orderGoods -> {
|
ComShopFlowerOrderGoodsVO orderGoodsVO = new ComShopFlowerOrderGoodsVO();
|
BeanUtils.copyProperties(orderGoods, orderGoodsVO);
|
orderGoodsVO.setNum(orderGoods.getAmount());
|
orderGoodsVO.setGoodsPic(orderGoods.getGoodsAttrPic());
|
orderGoodsVO.setPrice(orderGoods.getGoodsAttrPrice());
|
// 查询商品信息判断商品状态
|
/* ComShopFlowerGoodsDO goodsDO = comShopFlowerGoodsDAO.selectById(orderGoods.getGoodsId());
|
if (goodsDO == null || goodsDO.getDeleteStatus().equals(ComShopFlowerGoodsDO.deleteStatus.yes)
|
|| goodsDO.getDeleteStatus().equals(ComShopFlowerGoodsDO.status.recovery)) {
|
orderGoodsVO.setGoodsStatus(ComShopFlowerOrderGoodsVO.goodsStatus.ysc);
|
} else if (goodsDO.getStatus().equals(ComShopFlowerGoodsDO.status.lower)) {
|
orderGoodsVO.setGoodsStatus(ComShopFlowerOrderGoodsVO.goodsStatus.yxj);
|
} else if (goodsDO.getStatus().equals(ComShopFlowerGoodsDO.status.sell)) {
|
orderGoodsVO.setGoodsStatus(ComShopFlowerOrderGoodsVO.goodsStatus.csz);
|
}*/
|
|
// 根据商品规格id查询商品规格
|
// ComShopFlowerGoodsAttrDO goodsAttrDO = comShopFlowerGoodsAttrDAO.selectById(orderGoods.getGoodsAttrId());
|
orderGoodsVO.setGoodsAttr(orderGoods.getGoodsAttrName());
|
orderGoodsVOS.add(orderGoodsVO);
|
sbr.append(orderGoods.getGoodsName()).append(" ");
|
});
|
orderVO.setGoodsAttrPic(orderGoodsDOList.get(0).getGoodsAttrPic());
|
orderVO.setGoodsAttrName(orderGoodsDOList.get(0).getGoodsAttrName());
|
}
|
|
orderVO.setOrderGoodsVOList(orderGoodsVOS);
|
orderVO.setGoodsName(sbr.toString());
|
|
ComShopUserAddressVO userAddressVO = new ComShopUserAddressVO();
|
// 查询用户收货地址
|
ComShopFlowerUserAddressDO userAddressDO = comShopFlowerUserAddressDAO.selectById(shopOrderDO.getReceiverId());
|
if (userAddressDO != null) {
|
BeanUtils.copyProperties(userAddressDO, userAddressVO);
|
orderVO.setUserAddressVO(userAddressVO);
|
}
|
|
// 操作日志
|
/* List<ComShopFlowerOrderOperateDO> listOperLog =
|
comShopFlowerOrderOperateDAO.selectList(new LambdaQueryWrapper<ComShopFlowerOrderOperateDO>()
|
.eq(ComShopFlowerOrderOperateDO::getOrderNo, shopOrderDO.getOrderNo()));
|
List<ComShopFlowerOrderOperateVO> listOperLogVO = new ArrayList<>(listOperLog.size());
|
listOperLog.forEach(logDO -> {
|
ComShopFlowerOrderOperateVO copyVO = new ComShopFlowerOrderOperateVO();
|
BeanUtils.copyProperties(logDO, copyVO);
|
listOperLogVO.add(copyVO);
|
});
|
orderVO.setLogs(listOperLogVO);*/
|
Long pointId = shopOrderDO.getPointId();
|
if (null != pointId) {
|
ConvenientElevatingPointDO convenientElevatingPointDO = convenientElevatingPointDAO.selectById(pointId);
|
ConvenientElevatingPointVO convenientElevatingPointVO = new ConvenientElevatingPointVO();
|
BeanUtils.copyProperties(convenientElevatingPointDO, convenientElevatingPointVO);
|
orderVO.setConvenientElevatingPointVO(convenientElevatingPointVO);
|
}
|
//已完成、已退款才有评论
|
if (ComShopFlowerOrderDO.status.ywc == shopOrderDO.getStatus() || ComShopFlowerOrderDO.status.ytk == shopOrderDO.getStatus()) {
|
ComShopFlowerEvaluateVO comShopFlowerEvaluateVO = comShopFlowerEvaluateDAO.selectByOrderNo(shopOrderDO.getOrderNo());
|
if (nonNull(comShopFlowerEvaluateVO)) {
|
orderVO.setComShopFlowerEvaluateVO(comShopFlowerEvaluateVO);
|
}
|
}
|
//设置退款金额
|
ComShopFlowerRefundOrderDO comShopFlowerRefundOrderDO = comShopFlowerRefundOrderDAO.selectOne(new LambdaQueryWrapper<ComShopFlowerRefundOrderDO>().eq(ComShopFlowerRefundOrderDO::getOrderId, shopOrderDO.getId()));
|
if (nonNull(comShopFlowerRefundOrderDO)) {
|
orderVO.setRefundAmount(comShopFlowerRefundOrderDO.getRefundAmount());
|
orderVO.setRefundTime(comShopFlowerRefundOrderDO.getRefundTime());
|
}
|
|
//如果状态时取消状态，更新时间为去取消时间
|
if (shopOrderDO.getStatus() == ComShopFlowerOrderDO.status.yqx) {
|
orderVO.setCancelTime(shopOrderDO.getUpdateAt());
|
}
|
//判断是否可以退款 订单是否已超过15天 是否已有退款订单
|
int count = comShopFlowerRefundOrderDAO.selectCountRefundNowByOrderId(orderId);
|
if (count > 0){
|
orderVO.setRefundable(2);
|
}else {
|
if (null == orderVO.getReceivingTime()){
|
orderVO.setRefundable(2);
|
}else {
|
//收货时间往前推15天和当前时间做比较
|
Date date = DateUtils.addDay(orderVO.getReceivingTime(), 15);
|
if(date.before(new Date())){
|
orderVO.setRefundable(2);
|
}
|
}
|
}
|
|
|
|
return R.ok(orderVO);
|
}
|
|
/**
|
* 根据订单id取消订单
|
*
|
* @param comShopOrderQueryDTO 订单信息
|
* @return 取消结果
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public R orderCancel(ComShopOrderQueryDTO comShopOrderQueryDTO) {
|
// 查询订单
|
ComShopFlowerOrderDO shopOrderDO = this.baseMapper.selectById(comShopOrderQueryDTO.getOrderId());
|
if (shopOrderDO == null) {
|
return R.fail("未查询到订单");
|
}
|
if (shopOrderDO.getStatus().equals(ComShopFlowerOrderDO.status.ddps)||shopOrderDO.getStatus().equals(ComShopFlowerOrderDO.status.dfh)) {
|
// 取消订单
|
shopOrderDO.setStatus(ComShopFlowerOrderDO.status.yqx);
|
//退款
|
String refundNo = WXPayUtil.generateNonceStr();
|
try {
|
String refundStr = WxPayUtils.refund(appid, mchId, shopOrderDO.getOrderNo(), shopOrderDO.getPayAmount(),
|
shopOrderDO.getPayAmount(), refundNo, isTest);
|
log.info("退款请求接口返回参数:{}", refundStr);
|
Map<String, String> mapResult = WXPayUtil.xmlToMap(refundStr);
|
if (CollUtil.isNotEmpty(mapResult)) {
|
String return_code = (String) mapResult.get("return_code");
|
String result_code = (String) mapResult.get("result_code");
|
String return_msg = mapResult.get("return_msg");
|
ComShopFlowerOrderPayDO orderPayDO = new ComShopFlowerOrderPayDO();
|
|
orderPayDO.setOrderNo(shopOrderDO.getOrderNo());
|
orderPayDO.setOrderAmount(shopOrderDO.getTotalAmount());
|
orderPayDO.setPayTime(new Date());
|
orderPayDO.setStoreId(shopOrderDO.getStoreId());
|
orderPayDO.setDeliveryType(shopOrderDO.getDeliveryType());
|
orderPayDO.setOrderId(shopOrderDO.getId());
|
orderPayDO.setPayType(ComShopFlowerOrderPayDO.payType.qx);
|
if ("SUCCESS".equals(return_code) && return_code.equals(result_code)) {
|
//退款成功
|
// 添加订单支付记录表
|
orderPayDO.setPayStatus(ComShopFlowerOrderPayDO.payStatus.yes);
|
orderPayDO.setRefundStatus(ComShopFlowerOrderPayDO.refundStatus.tkcg);
|
|
} else {
|
//退款失败
|
// 添加订单支付记录表
|
orderPayDO.setPayStatus(ComShopFlowerOrderPayDO.payStatus.no);
|
orderPayDO.setRefundStatus(ComShopFlowerOrderPayDO.refundStatus.tksb);
|
shopOrderDO.setRemark(shopOrderDO.getRemark() + "_" + return_msg);
|
}
|
comShopFlowerOrderPayDAO.insert(orderPayDO);
|
}
|
} catch (Exception e) {
|
log.error("申请退款失败，" + e.getMessage());
|
e.printStackTrace();
|
return R.fail("取消订单失败");
|
}
|
if (this.baseMapper.updateById(shopOrderDO) > 0) {
|
// 添加订单操作记录
|
ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
|
orderOperateDO.setOrderNo(shopOrderDO.getOrderNo());
|
orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.cancel);
|
orderOperateDO.setOperationTime(new Date());
|
if (comShopOrderQueryDTO.getIsAdmin()) {
|
orderOperateDO.setOperationContent("管理员" + comShopOrderQueryDTO.getOperUserAccount() + "取消订单");
|
orderOperateDO.setOperationBy("用户" + comShopOrderQueryDTO.getOperUserAccount());
|
} else {
|
orderOperateDO.setOperationContent("用户取消订单");
|
orderOperateDO.setOperationBy("用户");
|
}
|
comShopFlowerOrderOperateDAO.insert(orderOperateDO);
|
return R.ok();
|
} else {
|
return R.fail("取消订单失败");
|
}
|
}else {
|
return R.fail("该订单不可取消");
|
}
|
|
|
}
|
|
/**
|
* 根据订单id删除订单
|
*
|
* @param orderId 订单id
|
* @return 删除结果
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R orderDelete(Long orderId) {
|
// 查询订单
|
ComShopFlowerOrderDO shopOrderDO = this.baseMapper.selectById(orderId);
|
if (shopOrderDO == null) {
|
return R.fail("未查询到订单");
|
}
|
if (!shopOrderDO.getStatus().equals(ComShopFlowerOrderDO.status.ywc)
|
&& !shopOrderDO.getStatus().equals(ComShopFlowerOrderDO.status.yqx)) {
|
return R.fail("该订单状态不可删除");
|
}
|
|
shopOrderDO.setDeleteStatus(ComShopFlowerOrderDO.deleteStatus.yes);
|
if (this.baseMapper.updateById(shopOrderDO) > 0) {
|
return R.ok();
|
} else {
|
return R.fail("取消订单失败");
|
}
|
}
|
|
/**
|
* 根据订单id确认收货
|
*
|
* @param orderId 订单id
|
* @param phone 手机号
|
* @return 确认结果
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public R orderConfirm(Long orderId, String phone) {
|
// 查询订单
|
ComShopFlowerOrderDO shopOrderDO = this.baseMapper.selectById(orderId);
|
if (shopOrderDO == null) {
|
return R.fail("未查询到订单");
|
}
|
if (!shopOrderDO.getStatus().equals(ComShopFlowerOrderDO.status.dsh)) {
|
return R.fail("该订单状态不可确认收货");
|
}
|
// 订单确认收货
|
shopOrderDO.setStatus(ComShopFlowerOrderDO.status.dpj);
|
shopOrderDO.setReceivingTime(new Date());
|
if (this.baseMapper.updateById(shopOrderDO) > 0) {
|
// 添加订单操作记录
|
ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
|
orderOperateDO.setOrderNo(shopOrderDO.getOrderNo());
|
orderOperateDO.setOperationType(ComShopFlowerOrderOperateDO.operationType.complete);
|
orderOperateDO.setOperationTime(new Date());
|
if (StringUtils.isNotEmpty(phone)) {
|
orderOperateDO.setOperationContent("用户" + phone + "确认收货");
|
orderOperateDO.setOperationBy("用户" + phone);
|
} else {
|
orderOperateDO.setOperationContent("用户确认收货");
|
orderOperateDO.setOperationBy("用户");
|
}
|
comShopFlowerOrderOperateDAO.insert(orderOperateDO);
|
|
//一个自提订单算一个货
|
if (ComShopFlowerOrderDO.deliveryType.store == shopOrderDO.getDeliveryType()){
|
ConvenientElevatingPointDO convenientElevatingPointDO = convenientElevatingPointDAO.selectById(shopOrderDO.getPointId());
|
convenientElevatingPointDO.setPrepareGoodsNum(convenientElevatingPointDO.getPrepareGoodsNum() - 1);
|
convenientElevatingPointDO.setAlreadyGoodsNum(convenientElevatingPointDO.getAlreadyGoodsNum() + 1);
|
convenientElevatingPointDAO.updateById(convenientElevatingPointDO);
|
}
|
return R.ok();
|
} else {
|
return R.fail("确认收货失败");
|
}
|
}
|
|
|
/**
|
* 订单发货
|
*
|
* @param orderShipDTO 订单发货信息
|
* @return 发货结果
|
*/
|
@Override
|
public R shipOrder(ComShopOrderShipDTO orderShipDTO) {
|
ComShopFlowerOrderDO comShopOrderDO = comShopFlowerOrderDAO.selectById(orderShipDTO.getOrderId());
|
if (comShopOrderDO == null) {
|
return R.fail("订单不存在");
|
}
|
if (!(comShopOrderDO.getStatus() == ComShopFlowerOrderDO.status.dfh) || (comShopOrderDO.getDeliveryStatus() == ComShopFlowerOrderDO.deliveryStatus.yes)) {
|
return R.fail("订单发货失败,订单状态不允许发货");
|
}
|
|
/* ConvenientMerchantDO convenientMerchantDO = convenientMerchantDAO.selectById(comShopOrderDO.getStoreId());
|
if (convenientMerchantDO.getDeliveryType() != 2) {
|
return R.fail("该商家不支持通过快递物流发货");
|
}*/
|
comShopOrderDO.setDeliveryStatus(2);
|
comShopOrderDO.setDeliveryType(2);
|
comShopOrderDO.setStatus(3);
|
comShopOrderDO.setDeliveryTime(Calendar.getInstance().getTime());
|
comShopOrderDO.setLogisticsCompany(orderShipDTO.getLogisticsCompany());
|
comShopOrderDO.setLogisticsNo(orderShipDTO.getLogisticsNo());
|
int updated = comShopFlowerOrderDAO.updateById(comShopOrderDO);
|
if (updated == 1) {
|
// 创建订单操作记录
|
ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
|
orderOperateDO.setOrderNo(comShopOrderDO.getOrderNo());
|
orderOperateDO.setOperationType(ComShopFlowerOrderOperateDO.operationType.deliver);
|
orderOperateDO.setOperationTime(new Date());
|
|
orderOperateDO.setOperationContent(orderShipDTO.getOperUserAccount() + "已发货");
|
orderOperateDO.setOperationBy(orderShipDTO.getOperUserAccount());
|
int inserted = comShopFlowerOrderOperateDAO.insert(orderOperateDO);
|
if (inserted != 1) {
|
log.error("订单发货日志保存错误");
|
}
|
//发货通知
|
WxMaService maService = wxMaConfiguration.getMaService(Constants.HC_APP_ID);
|
R userOpenId = userService.getUserOpenId(comShopOrderDO.getUserId());
|
if (R.isOk(userOpenId)) {
|
String openid = userOpenId.getData().toString();
|
try {
|
WxUtil.sendDeliverGoodsNotice(openid,maService.getAccessToken(),orderShipDTO.getLogisticsCompany(),orderShipDTO.getLogisticsNo(),comShopOrderDO.getOrderNo(), DateUtil.format(new Date(), "yyyy-MM-dd HH:mm"));
|
} catch (WxErrorException e) {
|
e.printStackTrace();
|
}
|
}
|
return R.ok("发货成功");
|
}
|
return R.fail("发货失败!");
|
}
|
|
@Override
|
public R deliverOrder(ComShopOrderDeliverDTO orderDeliverDTO) {
|
ComShopFlowerOrderDO comShopOrderDO = comShopFlowerOrderDAO.selectById(orderDeliverDTO.getOrderId());
|
if (comShopOrderDO == null) {
|
return R.fail("订单不存在");
|
}
|
if (!(comShopOrderDO.getStatus() == 2) || !(comShopOrderDO.getDeliveryStatus() == 1)) {
|
return R.fail("当前订单不能配送");
|
}
|
|
comShopOrderDO.setDeliveryStatus(4);
|
comShopOrderDO.setDeliveryType(1);
|
comShopOrderDO.setStatus(3);
|
comShopOrderDO.setDeliveryTime(Calendar.getInstance().getTime());
|
int updated = comShopFlowerOrderDAO.updateById(comShopOrderDO);
|
if (updated == 1) {
|
|
// 创建订单操作记录
|
ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
|
orderOperateDO.setOrderNo(comShopOrderDO.getOrderNo());
|
orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.deliver);
|
orderOperateDO.setOperationTime(new Date());
|
if (orderDeliverDTO.getIsAdmin()) {
|
orderOperateDO.setOperationContent(orderDeliverDTO.getOperUserAccount() + "已发货");
|
orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
|
} else {
|
orderOperateDO.setOperationContent(orderDeliverDTO.getOperUserAccount() + "已发货");
|
orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
|
}
|
int inserted = comShopFlowerOrderOperateDAO.insert(orderOperateDO);
|
if (inserted != 1) {
|
log.error("订单发货日志保存错误");
|
}
|
return R.ok("开始配送");
|
}
|
return R.fail("操作失败!");
|
}
|
|
@Override
|
public R finishDeliverOrder(ComShopOrderDeliverDTO orderDeliverDTO) {
|
ComShopFlowerOrderDO comShopOrderDO = comShopFlowerOrderDAO.selectById(orderDeliverDTO.getOrderId());
|
if (comShopOrderDO == null) {
|
return R.fail("订单不存在");
|
}
|
if (comShopOrderDO.getDeliveryStatus() != 4 && comShopOrderDO.getDeliveryStatus() != 3) {
|
return R.fail("订单还未开始配送");
|
}
|
if (!(comShopOrderDO.getStatus() == 3)) {
|
return R.fail("订单还未发货");
|
}
|
// comShopOrderDO.setStatus(4);
|
comShopOrderDO.setDeliveryStatus(2);
|
int updated = comShopFlowerOrderDAO.updateById(comShopOrderDO);
|
if (updated == 1) {
|
// 创建订单操作记录
|
ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
|
orderOperateDO.setOrderNo(comShopOrderDO.getOrderNo());
|
orderOperateDO.setOperationType(ComShopOrderOperateDO.operationType.complete);
|
orderOperateDO.setOperationTime(new Date());
|
if (orderDeliverDTO.getIsAdmin()) {
|
orderOperateDO.setOperationContent("订单已完成");
|
orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
|
} else {
|
orderOperateDO.setOperationContent("订单已完成");
|
orderOperateDO.setOperationBy(orderDeliverDTO.getOperUserAccount());
|
}
|
int inserted = comShopFlowerOrderOperateDAO.insert(orderOperateDO);
|
if (inserted != 1) {
|
log.error("订单发货日志保存错误");
|
}
|
return R.ok("配送完成");
|
}
|
return R.fail("操作失败!");
|
}
|
|
|
@Override
|
public R pageShopOrder(PageComShopOrderSearchDTO pageComShopOrderSearchDTO) {
|
Long pageNum = pageComShopOrderSearchDTO.getPageNum();
|
Long pageSize = pageComShopOrderSearchDTO.getPageSize();
|
Page page = new Page();
|
|
page.setCurrent(pageNum);
|
page.setSize(pageSize);
|
if (pageNum == null || 0 == pageNum.longValue()) {
|
page.setCurrent(1l);
|
}
|
if (pageSize == null || 0 == pageSize.longValue()) {
|
page.setSize(10l);
|
}
|
|
IPage<ComShopOrderSearchVO> ipage = this.baseMapper.pageOrderBy(page, pageComShopOrderSearchDTO);
|
return R.ok(ipage);
|
}
|
|
/**
|
* 微信支付订单回调
|
*
|
* @param wxPayNotifyOrderDTO 订单支付回调参数
|
*/
|
@Transactional(rollbackFor = Exception.class)
|
@Override
|
public void wxOrderPayNotify(WxPayNotifyOrderDTO wxPayNotifyOrderDTO) {
|
log.info("微信订单支付回调开始处理逻辑");
|
if (StringUtils.isEmpty(wxPayNotifyOrderDTO.getOrderTradeNo())) {
|
log.error("微信支付回调失败，订单号为空");
|
return;
|
}
|
|
log.info("微信订单支付回调开始查询订单");
|
// 查询订单
|
ComShopFlowerOrderDO shopOrderDO = this.baseMapper.selectOne(new QueryWrapper<ComShopFlowerOrderDO>().lambda()
|
.eq(ComShopFlowerOrderDO::getOrderNo, wxPayNotifyOrderDTO.getOrderTradeNo()));
|
if (shopOrderDO == null) {
|
log.error("未查询到支付订单,订单回调失败,订单号:" + wxPayNotifyOrderDTO.getOrderTradeNo());
|
return;
|
}
|
if (ComShopFlowerOrderDO.deliveryType.store == shopOrderDO.getDeliveryType()) {
|
shopOrderDO.setStatus(ComShopFlowerOrderDO.status.ddps);
|
} else {
|
shopOrderDO.setStatus(ComShopFlowerOrderDO.status.dfh);
|
}
|
|
shopOrderDO.setPayType(ComShopFlowerOrderDO.payType.wx);
|
shopOrderDO.setPayStatus(ComShopFlowerOrderDO.payStatus.yes);
|
shopOrderDO.setPayAmount(BigDecimal.valueOf(Double.valueOf(wxPayNotifyOrderDTO.getCashFee()) / 100));
|
shopOrderDO.setWxTardeNo(wxPayNotifyOrderDTO.getWxTradeNo());
|
shopOrderDO.setPayTime(
|
DateUtils.stringToDate(wxPayNotifyOrderDTO.getPayTime(), new SimpleDateFormat("yyyyMMddHHmmss")));
|
this.baseMapper.updateById(shopOrderDO);
|
|
// 查询订单商品
|
List<ComShopFlowerOrderGoodsDO> orderGoodsList =
|
comShopFlowerOrderGoodsDAO.selectList(new QueryWrapper<ComShopFlowerOrderGoodsDO>().lambda()
|
.eq(ComShopFlowerOrderGoodsDO::getOrderNo, shopOrderDO.getOrderNo()));
|
|
ConvenientMerchantDO storeDO = convenientMerchantDAO.selectById(shopOrderDO.getStoreId());
|
|
if (!orderGoodsList.isEmpty()) {
|
int goodsNub = 0;
|
for (ComShopFlowerOrderGoodsDO orderGood : orderGoodsList) {
|
goodsNub += orderGood.getAmount();
|
// 更新商品信息
|
ComShopFlowerGoodsDO goodsDO = comShopFlowerGoodsDAO.selectById(orderGood.getGoodsId());
|
if (goodsDO != null) {
|
goodsDO.setSale(goodsDO.getSale() + orderGood.getAmount());
|
comShopFlowerGoodsDAO.updateById(goodsDO);
|
}
|
|
// 更新商品规格
|
ComShopFlowerGoodsAttrDO goodsAttrDO = comShopFlowerGoodsAttrDAO.selectById(orderGood.getGoodsAttrId());
|
if (goodsAttrDO != null) {
|
goodsAttrDO.setSale(goodsAttrDO.getSale() + orderGood.getAmount());
|
//减库存
|
goodsAttrDO.setStock(goodsAttrDO.getStock() - orderGood.getAmount());
|
comShopFlowerGoodsAttrDAO.updateById(goodsAttrDO);
|
}
|
}
|
|
// 更新店铺销量以及销售额
|
if (storeDO != null) {
|
storeDO.setSale(storeDO.getSale() + goodsNub);
|
storeDO.setSaleVolume(storeDO.getSaleVolume().add(shopOrderDO.getTotalAmount()));
|
convenientMerchantDAO.updateById(storeDO);
|
}
|
}
|
|
// 添加订单操作记录
|
ComShopFlowerOrderOperateDO orderOperateDO = new ComShopFlowerOrderOperateDO();
|
orderOperateDO.setOrderNo(shopOrderDO.getOrderNo());
|
orderOperateDO.setOperationType(ComShopFlowerOrderOperateDO.operationType.pay);
|
orderOperateDO.setOperationTime(new Date());
|
orderOperateDO.setOperationContent("用户支付订单");
|
orderOperateDO.setOperationBy("用户");
|
comShopFlowerOrderOperateDAO.insert(orderOperateDO);
|
|
// 添加订单支付记录表
|
ComShopFlowerOrderPayDO orderPayDO = new ComShopFlowerOrderPayDO();
|
orderPayDO.setOrderNo(shopOrderDO.getOrderNo());
|
orderPayDO.setOrderAmount(shopOrderDO.getTotalAmount());
|
orderPayDO.setWxTradeNo(wxPayNotifyOrderDTO.getWxTradeNo());
|
orderPayDO.setPayStatus(ComShopFlowerOrderPayDO.payStatus.yes);
|
orderPayDO.setPayAmount(shopOrderDO.getPayAmount());
|
orderPayDO.setPayTime(shopOrderDO.getPayTime());
|
orderPayDO.setStoreId(shopOrderDO.getStoreId());
|
orderPayDO.setDeliveryType(shopOrderDO.getDeliveryType());
|
orderPayDO.setOrderId(shopOrderDO.getId());
|
orderPayDO.setPayType(ComShopFlowerOrderPayDO.payType.zf);
|
comShopFlowerOrderPayDAO.insert(orderPayDO);
|
if (nonNull(storeDO)){
|
WxMaService maService = wxMaConfiguration.getMaService(Constants.HC_APP_ID);
|
R sysUserVOR = userService.getSysUserVOByPhone(storeDO.getMobilePhone());
|
if (R.isOk(sysUserVOR)) {
|
SysUserVO sysUserVO = JSONObject.parseObject(JSONObject.toJSONString(sysUserVOR.getData()), SysUserVO.class);
|
try {
|
DecimalFormat df = new DecimalFormat("#.00");
|
WxUtil.sendNewOrderNotice(sysUserVO.getOpenid(),maService.getAccessToken(),shopOrderDO.getOrderNo(),
|
shopOrderDO.getDeliveryType()==1?"拼单订单":"快递订单",orderGoodsList.get(0).getGoodsName(),
|
df.format(shopOrderDO.getTotalAmount()),
|
DateUtil.format(shopOrderDO.getCreateAt(),"yyyy-MM-dd HH:mm"));
|
} catch (WxErrorException e) {
|
e.printStackTrace();
|
}
|
}
|
}
|
|
}
|
|
/**
|
* 订单去支付
|
*
|
* @param orderPayDTO 请求参数
|
* @return 支付对象
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public R wxPay(OrderPayDTO orderPayDTO) {
|
// 创建返回参数
|
ComShopFlowerOrderVO shopOrderVO = new ComShopFlowerOrderVO();
|
// 查询订单
|
ComShopFlowerOrderDO orderDO = comShopFlowerOrderDAO.selectOne(
|
new QueryWrapper<ComShopFlowerOrderDO>().lambda().eq(ComShopFlowerOrderDO::getOrderNo, orderPayDTO.getOrderNo()));
|
if (orderDO == null) {
|
return R.fail("订单不存在");
|
}
|
try {
|
BigDecimal money = orderDO.getTotalAmount();
|
if (isTest) {
|
money = BigDecimal.valueOf(0.01);
|
}
|
// 调用wx支付
|
String xml = WxPayUtils.getUnifiedorder(appid, mchId, payKey, notifyUrl, "商品购买", orderPayDTO.getOpenId(),
|
orderDO.getOrderNo(), money, null);
|
log.info("微信支付返回参数:" + xml);
|
shopOrderVO.setPayResult(xml);
|
} catch (Exception e) {
|
log.error("调用微信支付异常,异常原因：" + e.getMessage());
|
}
|
shopOrderVO.setOrderId(orderDO.getId());
|
shopOrderVO.setOrderNo(orderDO.getOrderNo());
|
shopOrderVO.setOrderTotal(orderDO.getTotalAmount());
|
return R.ok(shopOrderVO);
|
}
|
|
@Override
|
public R pageOrderByStoreId(PageComFlowerOrderListDTO pageComFlowerOrderListDTO) {
|
Page page = new Page(pageComFlowerOrderListDTO.getPageNum(), pageComFlowerOrderListDTO.getPageSize());
|
IPage<ComShopFlowerOrderStoreListVO> orderPageVOIPage = this.baseMapper.pageOrderByStoreId(page, pageComFlowerOrderListDTO);
|
if (!orderPageVOIPage.getRecords().isEmpty()) {
|
orderPageVOIPage.getRecords().forEach(orderVo -> {
|
if (null != orderVo.getPointId()) {
|
ConvenientElevatingPointDO convenientElevatingPointDO = convenientElevatingPointDAO.selectById(orderVo.getPointId());
|
ConvenientElevatingPointVO convenientElevatingPointVO = new ConvenientElevatingPointVO();
|
BeanUtils.copyProperties(convenientElevatingPointDO, convenientElevatingPointVO);
|
orderVo.setConvenientElevatingPointVO(convenientElevatingPointVO);
|
|
}
|
});
|
}
|
return R.ok(orderPageVOIPage);
|
}
|
|
@Override
|
public R selectCountByDeliveryType(Integer deliveryType, Long userId) {
|
//1.等待配送 2.配送中 3.待收货 4.待评价 5.已完成 6.已取消 7.已退款 8.待发货
|
String[] statusStr = {"ddps", "psz", "dsh", "dpj", "ywc", "yqx", "ytk", "dfh"};
|
ConvenientMerchantVO convenientMerchantVO = convenientMerchantDAO.selectMerchantByUserId(userId);
|
List<ComShopOrderCountVO> comShopOrderCountVOS = this.baseMapper.selectCountByDeliveryType(deliveryType, convenientMerchantVO.getId());
|
Map<Integer, Integer> collect = comShopOrderCountVOS.stream().collect(Collectors.toMap(ComShopOrderCountVO::getStatus, ComShopOrderCountVO::getAmount));
|
Map<String, Integer> retMap = new HashMap<>();
|
int amountTotal = 0;
|
for (int i = 0; i < statusStr.length; i++) {
|
if (collect.containsKey(i+1)) {
|
Integer amount = collect.get(i+1);
|
amountTotal = amountTotal + amount;
|
retMap.put(statusStr[i], amount);
|
} else {
|
retMap.put(statusStr[i], 0);
|
}
|
}
|
retMap.put("zdd", amountTotal);
|
|
return R.ok(retMap);
|
}
|
|
@Override
|
public R selectCountByUserId(Long userId) {
|
ConvenientMerchantVO convenientMerchantVO = convenientMerchantDAO.selectMerchantByUserId(userId);
|
Long storeId = convenientMerchantVO.getId();
|
Map<String, Object> retMap = new HashMap<>();
|
//查询我的店铺订单量
|
List<ComShopOrderStoreIdCountVO> comShopOrderStoreIdCountVOS = this.baseMapper.selectCountByStoreId(storeId, null);
|
Map<String, Integer> zddlMap = comShopOrderStoreIdCountVOS.stream().collect(Collectors.toMap(ComShopOrderStoreIdCountVO::getCountName, ComShopOrderStoreIdCountVO::getCountNum));
|
retMap.put("zddl", zddlMap);
|
//查询我的店铺拼单订单
|
List<ComShopOrderStoreIdCountVO> comShopOrderStoreIdCountVOS1 = this.baseMapper.selectCountByStoreId(storeId, ComShopFlowerOrderDO.deliveryType.store);
|
Map<String, Integer> pdddMap = comShopOrderStoreIdCountVOS1.stream().collect(Collectors.toMap(ComShopOrderStoreIdCountVO::getCountName, ComShopOrderStoreIdCountVO::getCountNum));
|
retMap.put("pddd", pdddMap);
|
//查询我的店铺快递订单
|
List<ComShopOrderStoreIdCountVO> comShopOrderStoreIdCountVOS2 = this.baseMapper.selectCountByStoreId(storeId, ComShopFlowerOrderDO.deliveryType.express);
|
Map<String, Integer> kdddMap = comShopOrderStoreIdCountVOS2.stream().collect(Collectors.toMap(ComShopOrderStoreIdCountVO::getCountName, ComShopOrderStoreIdCountVO::getCountNum));
|
retMap.put("kddd", kdddMap);
|
|
//拼单订单各状态
|
R r = this.selectCountByDeliveryType(ComShopFlowerOrderDO.deliveryType.store, userId);
|
retMap.put("pdddStatus", r.getData());
|
|
//快递订单各状态
|
R r1 = this.selectCountByDeliveryType(ComShopFlowerOrderDO.deliveryType.express, userId);
|
retMap.put("kdddStatus", r1.getData());
|
//营业额
|
List<ComShopOrderStoreIdNumVO> comShopOrderStoreIdCountVOS3 = this.baseMapper.selectSumAmountByStoreId(storeId);
|
Map<String, BigDecimal> yyeMap = comShopOrderStoreIdCountVOS3.stream().collect(Collectors.toMap(ComShopOrderStoreIdNumVO::getCountName, ComShopOrderStoreIdNumVO::getCountNum));
|
retMap.put("yye", yyeMap);
|
//在售商品
|
Integer countSale = comShopFlowerGoodsDAO.selectCountSaleByStoreId(storeId);
|
retMap.put("countSale", countSale);
|
//退款申请
|
Integer refundOrder = comShopFlowerRefundOrderDAO.selectCountByStoreId(storeId);
|
retMap.put("refundOrder", refundOrder);
|
return R.ok(retMap);
|
}
|
|
|
/**
|
* 获取商家的营业额和可结算金额
|
*
|
* @param storeId
|
* @return
|
*/
|
@Override
|
public R getQuota(Long storeId) {
|
//营业额
|
BigDecimal turnover = this.baseMapper.selectTurnover(storeId);
|
//可结算
|
BigDecimal settlement = this.baseMapper.selectSettlement(storeId);
|
|
Map<String, Object> retMap = new HashMap<>();
|
retMap.put("turnover", turnover);
|
retMap.put("settlement", settlement);
|
return R.ok(retMap);
|
|
}
|
|
|
@Override
|
public R selectSumOrderAndAmountByStoreId(Long storeId) {
|
List<ComShopOrderStoreIdNumVO> comShopOrderStoreIdCountVOS = this.baseMapper.selectSumOrderAndAmountByStoreId(storeId);
|
Map<String, Object> retMap = comShopOrderStoreIdCountVOS.stream().collect(Collectors.toMap(ComShopOrderStoreIdNumVO::getCountName, ComShopOrderStoreIdNumVO::getCountNum));
|
return R.ok(retMap);
|
}
|
|
public R selectOrderLineChart(Long storeId, Integer type, Integer tab) {
|
if (tab == 1) {
|
if (1 == type) {
|
//近15天的订单量
|
int days = 15;
|
return getCountByStoreIdAndDays(storeId, days);
|
} else if (2 == type) {
|
//近30天的订单量
|
int days = 30;
|
return getCountByStoreIdAndDays(storeId, days);
|
} else {
|
//今年所有月份订单量
|
List<ComShopOrderStoreIdCountVO> comShopOrderStoreIdCountVOS = this.baseMapper.selectCountOrderMonthByStoreId(storeId);
|
Map<String, Integer> retMap = comShopOrderStoreIdCountVOS.stream().collect(Collectors.toMap(ComShopOrderStoreIdCountVO::getCountName, ComShopOrderStoreIdCountVO::getCountNum));
|
List<String> yearMonths = DateUtils.getYearMonths();
|
for (String yearMonth : yearMonths) {
|
if (!retMap.containsKey(yearMonth)) {
|
retMap.put(yearMonth, 0);
|
}
|
}
|
return R.ok(retMap);
|
}
|
} else if (2 == tab) {
|
if (1 == type) {
|
//近15天的营收
|
int days = 15;
|
return getSumByStoreIdAndDays(storeId, days);
|
} else if (2 == type) {
|
//近30天的营收
|
int days = 30;
|
return getSumByStoreIdAndDays(storeId, days);
|
} else {
|
//今年所有月份订单量
|
List<ComShopOrderStoreIdNumVO> comShopOrderStoreIdCountVOS = this.baseMapper.selectOrderSumMonthByStoreId(storeId);
|
Map<String, BigDecimal> retMap = comShopOrderStoreIdCountVOS.stream().collect(Collectors.toMap(ComShopOrderStoreIdNumVO::getCountName, ComShopOrderStoreIdNumVO::getCountNum));
|
List<String> yearMonths = DateUtils.getYearMonths();
|
for (String yearMonth : yearMonths) {
|
if (!retMap.containsKey(yearMonth)) {
|
retMap.put(yearMonth, BigDecimal.ZERO);
|
}
|
}
|
return R.ok(retMap);
|
}
|
}
|
return R.ok();
|
|
}
|
|
private R getCountByStoreIdAndDays(Long storeId, int days) {
|
List<ComShopOrderStoreIdCountVO> comShopOrderStoreIdCountVOS = this.baseMapper.selectCountOrderDayByStoreId(storeId, days);
|
Map<String, Integer> retMap = comShopOrderStoreIdCountVOS.stream().collect(Collectors.toMap(ComShopOrderStoreIdCountVO::getCountName, ComShopOrderStoreIdCountVO::getCountNum));
|
List<String> beforeDays = DateUtils.getBeforeDays(days);
|
for (String beforeDay : beforeDays) {
|
if (!retMap.containsKey(beforeDay)) {
|
retMap.put(beforeDay, 0);
|
}
|
}
|
return R.ok(retMap);
|
}
|
|
private R getSumByStoreIdAndDays(Long storeId, int days) {
|
List<ComShopOrderStoreIdNumVO> comShopOrderStoreIdNumVOS = this.baseMapper.selectOrderSumPayDayByStoreId(storeId, days);
|
Map<String, BigDecimal> retMap = comShopOrderStoreIdNumVOS.stream().collect(Collectors.toMap(ComShopOrderStoreIdNumVO::getCountName, ComShopOrderStoreIdNumVO::getCountNum));
|
List<String> beforeDays = DateUtils.getBeforeDays(days);
|
for (String beforeDay : beforeDays) {
|
if (!retMap.containsKey(beforeDay)) {
|
retMap.put(beforeDay, BigDecimal.ZERO);
|
}
|
}
|
return R.ok(retMap);
|
}
|
|
@Override
|
public R pageOrderByDeliveryNo(PageComFlowerOrderListDTO pageComFlowerOrderListDTO) {
|
Page page = new Page(pageComFlowerOrderListDTO.getPageNum(), pageComFlowerOrderListDTO.getPageSize());
|
IPage<ComShopFlowerOrderStoreListVO> orderPageVOIPage = this.baseMapper.pageOrderByDeliveryNo(page, pageComFlowerOrderListDTO);
|
ComShopFlowerOrderDeliveryNoListVO comShopFlowerOrderDeliveryNoListVO = new ComShopFlowerOrderDeliveryNoListVO();
|
ComShopFlowerOrderDeliveryDO comShopFlowerOrderDeliveryDO = comShopFlowerOrderDeliveryDAO.selectById(pageComFlowerOrderListDTO.getDeliveryId());
|
ComShopFlowerOrderDeliveryVO comShopFlowerOrderDeliveryVO = new ComShopFlowerOrderDeliveryVO();
|
BeanUtils.copyProperties(comShopFlowerOrderDeliveryDO, comShopFlowerOrderDeliveryVO);
|
|
Long pointId = comShopFlowerOrderDeliveryDO.getPointId();
|
ConvenientElevatingPointDO convenientElevatingPointDO = convenientElevatingPointDAO.selectById(pointId);
|
ConvenientElevatingPointVO convenientElevatingPointVO = new ConvenientElevatingPointVO();
|
BeanUtils.copyProperties(convenientElevatingPointDO, convenientElevatingPointVO);
|
comShopFlowerOrderDeliveryVO.setConvenientElevatingPointVO(convenientElevatingPointVO);
|
comShopFlowerOrderDeliveryNoListVO.setComShopFlowerOrderDeliveryVO(comShopFlowerOrderDeliveryVO);
|
comShopFlowerOrderDeliveryNoListVO.setPage(orderPageVOIPage);
|
return R.ok(comShopFlowerOrderDeliveryNoListVO);
|
}
|
|
}
|
