package com.doumee.service.business.impl;
|
|
import com.baomidou.mybatisplus.core.conditions.Wrapper;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.doumee.biz.system.SystemDictDataBiz;
|
import com.doumee.core.constants.ResponseStatus;
|
import com.doumee.core.exception.BusinessException;
|
import com.doumee.core.model.LoginUserInfo;
|
import com.doumee.core.model.PageData;
|
import com.doumee.core.model.PageWrap;
|
import com.doumee.core.utils.*;
|
import com.doumee.core.utils.kuaidi100.DeliveryDTO;
|
import com.doumee.core.utils.kuaidi100.ExpressUtils;
|
import com.doumee.core.wx.SendWxMessage;
|
import com.doumee.core.wx.WxMiniConfig;
|
import com.doumee.core.wx.WxMiniUtilService;
|
import com.doumee.dao.business.*;
|
import com.doumee.dao.business.join.GoodsorderDetailJoinMapper;
|
import com.doumee.dao.business.join.GoodsorderJoinMapper;
|
import com.doumee.dao.business.join.PlanorderDetailJoinMapper;
|
import com.doumee.dao.business.model.*;
|
import com.doumee.dao.web.dto.CouponDTO;
|
import com.doumee.dao.web.request.DealIntegralRequest;
|
import com.doumee.dao.web.request.OrderPayRequest;
|
import com.doumee.dao.web.request.PayDetailRequest;
|
import com.doumee.dao.web.request.ShopOrderPayRequest;
|
import com.doumee.dao.web.request.goods.MemberOrderRequest;
|
import com.doumee.dao.web.request.goods.DealOrderRequest;
|
import com.doumee.dao.web.request.goods.OrderCommentRequest;
|
import com.doumee.dao.web.request.goods.OrderGoodsCommentRequest;
|
import com.doumee.dao.web.response.MyPageResponse;
|
import com.doumee.dao.web.response.goods.*;
|
import com.doumee.service.business.AreasService;
|
import com.doumee.service.business.GoodsorderService;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.metadata.IPage;
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.doumee.service.business.IntegralService;
|
import com.github.binarywang.wxpay.bean.request.BaseWxPayRequest;
|
import com.github.binarywang.wxpay.bean.request.WxPayUnifiedOrderRequest;
|
import com.github.binarywang.wxpay.bean.result.WxPayRefundResult;
|
import com.github.binarywang.wxpay.exception.WxPayException;
|
import com.github.xiaoymin.knife4j.core.util.CollectionUtils;
|
import com.github.yulichang.wrapper.MPJLambdaWrapper;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.shiro.SecurityUtils;
|
import org.checkerframework.checker.units.qual.C;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.data.redis.core.RedisTemplate;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.context.request.RequestContextHolder;
|
import org.springframework.web.context.request.ServletRequestAttributes;
|
|
import javax.servlet.http.HttpServletRequest;
|
import java.math.BigDecimal;
|
import java.net.InetAddress;
|
import java.net.UnknownHostException;
|
import java.util.*;
|
import java.util.Date;
|
import java.util.stream.Collectors;
|
|
/**
|
* 商品订单信息表Service实现
|
* @author 江蹄蹄
|
* @date 2023/03/21 15:48
|
*/
|
@Service
|
public class GoodsorderServiceImpl implements GoodsorderService {
|
|
@Autowired
|
private RedisTemplate<String, Object> redisTemplate;
|
@Autowired
|
private GoodsorderMapper goodsorderMapper;
|
@Autowired
|
private ActivitySignMapper activitySignMapper;
|
@Autowired
|
private AftersaleMapper aftersaleMapper;
|
|
@Autowired
|
private MemberMapper memberMapper;
|
|
@Autowired
|
private GoodsorderDetailMapper goodsorderDetailMapper;
|
|
@Autowired
|
private GoodsSkuMapper goodsSkuMapper;
|
|
@Autowired
|
private GoodsMapper goodsMapper;
|
|
@Autowired
|
private AddrMapper addrMapper;
|
|
@Autowired
|
private ShopMapper shopMapper;
|
|
@Autowired
|
private MemberCouponMapper memberCouponMapper;
|
|
@Autowired
|
private WxMiniUtilService wxMiniUtilService;
|
|
@Autowired
|
private IntegralService integralService;
|
|
@Autowired
|
private OrderUrgeMapper orderUrgeMapper;
|
|
@Autowired
|
private OrderCommentMapper orderCommentMapper;
|
|
@Autowired
|
private ShopcartMapper shopcartMapper;
|
|
@Autowired
|
private GoodsorderJoinMapper goodsorderJoinMapper;
|
|
@Autowired
|
private SystemDictDataBiz systemDictDataBiz;
|
|
@Autowired
|
private PlanorderDetailJoinMapper planorderDetailJoinMapper;
|
|
@Autowired
|
private FundMapper fundMapper;
|
|
@Autowired
|
private AreasService areasService;
|
|
@Autowired
|
private GoodsorderDetailJoinMapper goodsorderDetailJoinMapper;
|
|
@Autowired
|
private IntegralMapper integralMapper;
|
|
@Override
|
public Integer create(Goodsorder goodsorder) {
|
goodsorderMapper.insert(goodsorder);
|
return goodsorder.getId();
|
}
|
|
@Override
|
public void deleteById(Integer id) {
|
goodsorderMapper.deleteById(id);
|
}
|
|
@Override
|
public void delete(Goodsorder goodsorder) {
|
UpdateWrapper<Goodsorder> deleteWrapper = new UpdateWrapper<>(goodsorder);
|
goodsorderMapper.delete(deleteWrapper);
|
}
|
|
@Override
|
public void deleteByIdInBatch(List<Integer> ids) {
|
if (CollectionUtils.isEmpty(ids)) {
|
return;
|
}
|
goodsorderMapper.deleteBatchIds(ids);
|
}
|
|
@Override
|
public void updateById(Goodsorder goodsorder) {
|
goodsorderMapper.updateById(goodsorder);
|
}
|
/**
|
* 备注
|
* @param goodsorder
|
*/
|
@Override
|
public void orderRemark(Goodsorder goodsorder) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
|
Goodsorder query=goodsorderMapper.selectById(goodsorder.getId());
|
if(query==null){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),ResponseStatus.DATA_EMPTY.getMessage());
|
}
|
if(StringUtils.isBlank(goodsorder.getSysInfo())){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST.getCode(),ResponseStatus.BAD_REQUEST.getMessage());
|
}
|
|
goodsorder.setEditDate(new Date());
|
goodsorder.setEditor(user.getId());
|
goodsorderMapper.updateById(goodsorder);
|
}
|
|
@Override
|
public IPage<Shop> getShopPage(PageWrap<Shop> pageWrap) {
|
IPage<Shop> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
|
Shop model = pageWrap.getModel();
|
if(Objects.isNull(model.getLatitude())||Objects.isNull(model.getLongitude())){
|
throw new BusinessException(ResponseStatus.BAD_REQUEST);
|
}
|
return shopMapper.selectPage(page,new MPJLambdaWrapper<Shop>()
|
.selectAll(Shop.class)
|
.select(" case when LONGITUDE IS NULL OR LATITUDE IS NULL THEN 0 " +
|
" when t.TYPE = 0 then CONVERT( ST_Distance_Sphere ( POINT ( LONGITUDE, LATITUDE ), POINT ( "+model.getLongitude()+", "+model.getLatitude()+" )) /1000,DECIMAL(15,2)) " +
|
" when t.TYPE = 1 then CONVERT( ST_Distance_Sphere ( POINT ( LONGITUDE, LATITUDE ), POINT ( "+model.getLongitude()+", "+model.getLatitude()+" )) /1000,DECIMAL(15,2)) " +
|
" else CONVERT( ST_Distance_Sphere ( POINT ( LONGITUDE, LATITUDE ), POINT ( "+model.getLongitude()+", "+model.getLatitude()+" )) /1000,DECIMAL(15,2)) end " , Shop::getDistance)
|
.eq(Shop::getIsdeleted,Constants.ZERO)
|
.eq(Shop::getStatus,Constants.ZERO)
|
.like(StringUtils.isNotBlank(model.getAddr()),Shop::getAddr,model.getAddr())
|
.like(StringUtils.isNotBlank(model.getName()),Shop::getName,model.getName())
|
.orderByAsc(" distance ")
|
);
|
}
|
|
|
/**
|
* 咖豆 商城订单发货
|
* @param goodsorder
|
*/
|
@Override
|
public void orderSendOutGoods(Goodsorder goodsorder) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
|
Goodsorder query=goodsorderMapper.selectById(goodsorder.getId());
|
if(query==null){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),ResponseStatus.DATA_EMPTY.getMessage());
|
}
|
if(!Constants.equalsInteger(query.getStatus(),Constants.ONE)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"订单状态已流转，请刷新页面！");
|
}
|
goodsorder.setEditDate(new Date());
|
goodsorder.setEditor(user.getId());
|
goodsorder.setKdDate(new Date());
|
goodsorder.setKdUser(user.getId());
|
goodsorder.setStatus(Constants.OrderStatus.WAIT_RECEIVE.getKey());
|
goodsorderMapper.updateById(goodsorder);
|
|
// TODO 发送微信模板消息
|
Member member=memberMapper.selectById(query.getMemberId());
|
MPJLambdaWrapper<GoodsorderDetail> queryWrapper = new MPJLambdaWrapper<>();
|
queryWrapper.eq(GoodsorderDetail::getIsdeleted,Constants.ZERO);
|
queryWrapper.eq(GoodsorderDetail::getOrderId,goodsorder.getId());
|
queryWrapper.orderByDesc(GoodsorderDetail::getCreateDate);
|
queryWrapper.last("limit 1");
|
GoodsorderDetail goodsorderDetail=goodsorderDetailMapper.selectOne(queryWrapper);
|
SendWxMessage.orderSendNotice(goodsorder,goodsorderDetail!=null?goodsorderDetail.getName():"",member);
|
}
|
|
|
|
/**
|
* 咖啡计划取消订单，代发货（调用退款接口，并记录资金流水表），待支付支持取消订单
|
* @param goodsorder
|
*/
|
@Override
|
@Transactional(rollbackFor = {BusinessException.class,Exception.class})
|
public void coffeePlanCancelOrder(Goodsorder goodsorder) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
|
Goodsorder query=goodsorderMapper.selectById(goodsorder.getId());
|
if(query==null){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),ResponseStatus.DATA_EMPTY.getMessage());
|
}
|
if(!(Constants.equalsInteger(query.getStatus(),Constants.ZERO)||Constants.equalsInteger(query.getStatus(),Constants.ONE))){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"仅支持代发货/待支付订单取消订单！");
|
}
|
if(!Constants.equalsInteger(query.getType(),Constants.TWO)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),ResponseStatus.DATA_EMPTY.getMessage());
|
}
|
|
//代发货，记录资金流水表
|
if(Constants.equalsInteger(query.getStatus(),Constants.ONE)){
|
//微信现金退款
|
String refundCode = wxMiniUtilService.wxRefund(query.getCode().toString(), query.getPrice(), query.getPrice());
|
Fund fund = new Fund();
|
fund.setCreator(user.getId());
|
fund.setCreateDate(new Date());
|
fund.setIsdeleted(Constants.ZERO);
|
fund.setRemark(query.getId().toString());
|
fund.setMemberId(goodsorder.getMemberId());
|
fund.setTitle("订单取消");
|
fund.setContent(goodsorder.getCancelInfo());
|
fund.setObjId(query.getId());
|
fund.setObjType(Constants.ONE);
|
fund.setType(Constants.ZERO);
|
fund.setNum(goodsorder.getPrice());
|
fund.setOrderCode(refundCode);
|
fundMapper.insert(fund);
|
|
//TODO 查询优惠券信息记录
|
if(!Objects.isNull(query.getCouponId())){
|
MemberCoupon memberCoupon = memberCouponMapper.selectById(query.getCouponId());
|
if(!Objects.isNull(memberCoupon)){
|
memberCoupon.setStatus(Constants.ZERO);
|
memberCouponMapper.updateById(memberCoupon);
|
}
|
}
|
}
|
|
Date today=new Date();
|
goodsorder.setEditor(user.getId());
|
goodsorder.setEditDate(today);
|
goodsorder.setCancelDate(today);
|
goodsorder.setCancelUser(user.getId());
|
goodsorderMapper.updateById(goodsorder);
|
|
PlanorderDetail planorderDetail=new PlanorderDetail();
|
planorderDetail.setEditor(user.getId());
|
planorderDetail.setEditDate(today);
|
planorderDetail.setStatus(Constants.TWO);
|
planorderDetail.setCancelDate(today);
|
planorderDetail.setCancelUser(user.getId());
|
planorderDetail.setCancelInfo(goodsorder.getCancelInfo());
|
|
PlanorderDetail up=new PlanorderDetail();
|
UpdateWrapper<PlanorderDetail> updateWrapper = new UpdateWrapper<>(up);
|
updateWrapper.lambda().eq(PlanorderDetail::getId,goodsorder.getId());
|
updateWrapper.lambda().eq(PlanorderDetail::getIsdeleted,Constants.ZERO);
|
planorderDetailJoinMapper.update(planorderDetail ,updateWrapper );
|
}
|
|
|
/**
|
* 咖豆/商品取消订单，代发货（调用退款接口，并记录资金流水表），待支付支持取消订单 ,并返还优惠券、咖豆
|
* @param goodsorder
|
*/
|
@Override
|
@Transactional(rollbackFor = {BusinessException.class,Exception.class})
|
public void orderPlanCancelOrder(Goodsorder goodsorder) {
|
LoginUserInfo user = (LoginUserInfo) SecurityUtils.getSubject().getPrincipal();
|
|
Goodsorder query=goodsorderMapper.selectById(goodsorder.getId());
|
if(query==null){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),ResponseStatus.DATA_EMPTY.getMessage());
|
}
|
if(!(Constants.equalsInteger(query.getStatus(),Constants.ZERO)||Constants.equalsInteger(query.getStatus(),Constants.ONE))){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"仅支持代发货/待支付订单取消订单！");
|
}
|
if(Constants.equalsInteger(query.getType(),Constants.TWO)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),ResponseStatus.DATA_EMPTY.getMessage());
|
}
|
|
cancelOrder( query.getId(), user.getId(),goodsorder.getCancelInfo() );
|
|
}
|
|
|
@Override
|
public void updateByIdInBatch(List<Goodsorder> goodsorders) {
|
if (CollectionUtils.isEmpty(goodsorders)) {
|
return;
|
}
|
for (Goodsorder goodsorder: goodsorders) {
|
this.updateById(goodsorder);
|
}
|
}
|
|
@Override
|
public Goodsorder findById(Integer id) {
|
Goodsorder result=goodsorderJoinMapper.selectById(id);
|
if(Objects.nonNull(result)){
|
MPJLambdaWrapper<GoodsorderDetail> queryWrapper = new MPJLambdaWrapper<>();
|
queryWrapper.selectAll(GoodsorderDetail.class);
|
queryWrapper.selectAs(Labels::getName,GoodsorderDetail::getLablesName);
|
queryWrapper.eq(GoodsorderDetail::getIsdeleted,Constants.ZERO);
|
queryWrapper.eq(GoodsorderDetail::getOrderId,result.getId());
|
queryWrapper.leftJoin(GoodsSku.class,GoodsSku::getId,GoodsorderDetail::getGoodsSkuId);
|
queryWrapper.leftJoin(Goods.class,Goods::getId,GoodsSku::getGoodsId);
|
queryWrapper.leftJoin(Labels.class,Labels::getId,Goods::getCategoryId);
|
List<GoodsorderDetail> goodsorderDetailList=goodsorderDetailMapper.selectList(queryWrapper);
|
String path = systemDictDataBiz.queryByCode(Constants.OSS, Constants.RESOURCE_PATH).getCode() + systemDictDataBiz.queryByCode(Constants.OSS, Constants.ACTIVITY_FILE).getCode();
|
|
for(GoodsorderDetail model:goodsorderDetailList){
|
if(StringUtils.isNotBlank(model.getImgurl())){
|
model.setImgurl(path+ model.getImgurl());
|
}
|
}
|
result.setGoodsorderDetailList(goodsorderDetailList);
|
|
//查询咖啡计划订阅周期
|
if(Constants.equalsInteger(result.getType(),Constants.TWO)){
|
MPJLambdaWrapper<PlanorderDetail> queryplan = new MPJLambdaWrapper<>();
|
queryplan.eq(PlanorderDetail::getOrderId,result.getId());
|
queryplan.last("limit 1");
|
PlanorderDetail planorderDetail= planorderDetailJoinMapper.selectOne( queryplan);
|
result.setPlanorderDetail(planorderDetail);
|
}
|
}
|
return result;
|
}
|
|
@Override
|
public Goodsorder findOne(Goodsorder goodsorder) {
|
QueryWrapper<Goodsorder> wrapper = new QueryWrapper<>(goodsorder);
|
return goodsorderMapper.selectOne(wrapper);
|
}
|
|
@Override
|
public List<Goodsorder> findList(Goodsorder goodsorder) {
|
QueryWrapper<Goodsorder> wrapper = new QueryWrapper<>(goodsorder);
|
return goodsorderMapper.selectList(wrapper);
|
}
|
|
@Override
|
public PageData<Goodsorder> findPage(PageWrap<Goodsorder> pageWrap) {
|
IPage<Goodsorder> page = new Page<>(pageWrap.getPage(), pageWrap.getCapacity());
|
MPJLambdaWrapper<Goodsorder> queryWrapper = new MPJLambdaWrapper<>();
|
Utils.MP.blankToNull(pageWrap.getModel());
|
|
queryWrapper.selectAll(Goodsorder.class);
|
queryWrapper.selectAs(Member::getNickname,Goodsorder::getNickName);
|
queryWrapper.selectAs(Member::getPhone,Goodsorder::getPhone);
|
queryWrapper.selectAs(Addr::getAddr,Goodsorder::getAddr);
|
// queryWrapper.select("(select CREATE_DATE from order_urge where ORDER_ID=t.id and ISDELETED=0 ORDER BY CREATE_DATE desc limit 1) as urgeCreateDate ");
|
queryWrapper.leftJoin(Member.class,Member::getId,Goodsorder::getMemberId);
|
queryWrapper.leftJoin(Addr.class,Addr::getMemberId,Member::getId);
|
queryWrapper.eq(Addr::getIsDefault,Constants.ONE);
|
|
queryWrapper.eq(pageWrap.getModel().getCode()!=null,Goodsorder::getCode,pageWrap.getModel().getCode());
|
queryWrapper.and(StringUtils.isNotBlank(pageWrap.getModel().getNickName()),ms->ms.like(Goodsorder::getLinkname,pageWrap.getModel().getNickName())
|
.or().like(Goodsorder::getLinkphone,pageWrap.getModel().getNickName())
|
);
|
queryWrapper.ge(pageWrap.getModel().getStarttime()!=null,Goodsorder::getCreateDate,pageWrap.getModel().getStarttime());
|
queryWrapper.le(pageWrap.getModel().getEndtime()!=null,Goodsorder::getCreateDate, pageWrap.getModel().getEndtime());
|
|
queryWrapper.eq(pageWrap.getModel().getPayOrderId()!=null,Goodsorder::getPayOrderId,pageWrap.getModel().getPayOrderId());
|
queryWrapper.eq(pageWrap.getModel().getStatus()!=null,Goodsorder::getStatus,pageWrap.getModel().getStatus());
|
queryWrapper.eq(pageWrap.getModel().getIsdeleted()==null,Goodsorder::getIsdeleted,Constants.ZERO);
|
queryWrapper.eq(pageWrap.getModel().getIsdeleted()!=null,Goodsorder::getIsdeleted,pageWrap.getModel().getIsdeleted());
|
queryWrapper.orderByDesc(Goodsorder::getCreateDate);
|
|
IPage<Goodsorder> result = goodsorderJoinMapper.selectJoinPage(page, Goodsorder.class, queryWrapper);
|
|
String path = systemDictDataBiz.queryByCode(Constants.OSS, Constants.RESOURCE_PATH).getCode() + systemDictDataBiz.queryByCode(Constants.OSS, Constants.GOODS_FILE).getCode();
|
|
for(Goodsorder model:result.getRecords()){
|
model.setResourcePath(path);
|
//订单总金额等于实付金额加优惠金额，再减去退款金额
|
BigDecimal sumMoney=new BigDecimal(0);
|
if(model.getPrice()!=null){
|
if(model.getIntegral()!=null){
|
sumMoney=model.getPrice().add(model.getIntegral());
|
if(Constants.equalsInteger(model.getIsAftersale(),Constants.ONE)&&model.getAftersaleMoney()!=null){
|
sumMoney.subtract(model.getAftersaleMoney());
|
model.setOrderMoneyCount(sumMoney);
|
}else{
|
model.setOrderMoneyCount(sumMoney);
|
}
|
}else{
|
model.setOrderMoneyCount(model.getPrice());
|
}
|
}else if(model.getIntegral()!=null){
|
sumMoney=model.getIntegral();
|
if(Constants.equalsInteger(model.getIsAftersale(),Constants.ONE)&&model.getAftersaleMoney()!=null){
|
sumMoney.subtract(model.getAftersaleMoney());
|
model.setOrderMoneyCount(sumMoney);
|
}else{
|
model.setOrderMoneyCount(sumMoney);
|
}
|
}
|
|
|
MPJLambdaWrapper<GoodsorderDetail> queryGoods = new MPJLambdaWrapper<>();
|
queryGoods.selectAll(GoodsorderDetail.class);
|
queryGoods.selectAs(Goods::getImgurl,GoodsorderDetail::getGoodsImgurl);
|
queryGoods.selectAs(Labels::getName, GoodsorderDetail::getCategoryName);
|
queryGoods.select("ls.name as parentName ");
|
|
queryGoods.leftJoin(GoodsSku.class,GoodsSku::getId,GoodsorderDetail::getGoodsSkuId);
|
queryGoods.leftJoin(Goods.class,Goods::getId,GoodsSku::getGoodsId);
|
|
queryGoods.leftJoin(Labels.class, Labels::getId, Goods::getCategoryId);
|
queryGoods.leftJoin("labels ls on ls.id=t2.PARENT_CATEGORY_ID");
|
queryGoods.eq(GoodsorderDetail::getOrderId,model.getId());
|
queryGoods.eq(GoodsorderDetail::getIsdeleted,Constants.ZERO);
|
List<GoodsorderDetail> goodsorderDetailList=goodsorderDetailJoinMapper.selectList(queryGoods);
|
goodsorderDetailList.stream().forEach(s ->{
|
if(StringUtils.isBlank(s.getImgurl())){
|
s.setImgurl(s.getGoodsImgurl());
|
}
|
});
|
model.setGoodsorderDetailList(goodsorderDetailList);
|
}
|
return PageData.from(result);
|
}
|
|
|
@Override
|
public List<Goodsorder> exportExcel(Goodsorder pageWrap) {
|
|
MPJLambdaWrapper<Goodsorder> queryWrapper = new MPJLambdaWrapper<>();
|
|
|
queryWrapper.selectAll(Goodsorder.class);
|
queryWrapper.selectAs(GoodsorderDetail::getName,Goodsorder::getGoodsName);
|
queryWrapper.selectAs(GoodsorderDetail::getSkuName,Goodsorder::getSkuName);
|
queryWrapper.selectAs(GoodsorderDetail::getGoodsNum,Goodsorder::getGoodsNum);
|
queryWrapper.selectAs(GoodsorderDetail::getPrice,Goodsorder::getGoodsPrice);
|
queryWrapper.selectAs(Member::getNickname,Goodsorder::getNickName);
|
queryWrapper.selectAs(Member::getPhone,Goodsorder::getPhone);
|
queryWrapper.selectAs(Addr::getAddr,Goodsorder::getAddr);
|
queryWrapper.select("(select CREATE_DATE from order_urge where ORDER_ID=t.id and ISDELETED=0 ORDER BY CREATE_DATE desc limit 1) as urgeCreateDate ");
|
queryWrapper.leftJoin(Member.class,Member::getId,Goodsorder::getMemberId);
|
queryWrapper.leftJoin(Addr.class,Addr::getMemberId,Member::getId);
|
queryWrapper.leftJoin(GoodsorderDetail.class,GoodsorderDetail::getOrderId,Goodsorder::getId);
|
queryWrapper.eq(GoodsorderDetail::getIsdeleted,Constants.ZERO);
|
queryWrapper.eq(Addr::getIsDefault,Constants.ONE);
|
|
queryWrapper.eq(pageWrap.getCode()!=null,Goodsorder::getCode,pageWrap.getCode());
|
queryWrapper.and(StringUtils.isNotBlank(pageWrap.getNickName()),ms->ms.like(Goodsorder::getLinkname,pageWrap.getNickName())
|
.or().like(Goodsorder::getLinkphone,pageWrap.getNickName())
|
);
|
queryWrapper.ge(pageWrap.getStarttime()!=null,Goodsorder::getCreateDate,pageWrap.getStarttime());
|
queryWrapper.le(pageWrap.getEndtime()!=null,Goodsorder::getCreateDate, pageWrap.getEndtime());
|
|
queryWrapper.eq(pageWrap.getStatus()!=null,Goodsorder::getStatus,pageWrap.getStatus());
|
queryWrapper.eq(pageWrap.getIsdeleted()==null,Goodsorder::getIsdeleted,Constants.ZERO);
|
queryWrapper.eq(pageWrap.getIsdeleted()!=null,Goodsorder::getIsdeleted,pageWrap.getIsdeleted());
|
queryWrapper.orderByDesc(Goodsorder::getCreateDate);
|
|
List<Goodsorder> result = goodsorderJoinMapper.selectJoinList(Goodsorder.class, queryWrapper);
|
|
|
return result;
|
}
|
|
@Override
|
public long count(Goodsorder goodsorder) {
|
QueryWrapper<Goodsorder> wrapper = new QueryWrapper<>(goodsorder);
|
return goodsorderMapper.selectCount(wrapper);
|
}
|
|
|
/****************************************移动端接口开始********************************************************************/
|
|
|
@Override
|
@Transactional(rollbackFor = {Exception.class,BusinessException.class})
|
public PayResponse orderPay(OrderPayRequest orderPayRequest){
|
Member member = memberMapper.selectById(orderPayRequest.getMemberId());
|
//查询收货地址
|
Addr addr = addrMapper.selectById(orderPayRequest.getAddressId());
|
if(Objects.isNull(addr)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到收货地址信息！");
|
}
|
Areas area = areasService.findById(addr.getAreaId(), Constants.TWO);
|
if(Objects.isNull(area)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"收货地址区划信息发生变化，请更新后下单！");
|
}
|
Goodsorder goodsorder = new Goodsorder();
|
goodsorder.setCreator(orderPayRequest.getMemberId());
|
goodsorder.setIntegral(BigDecimal.ZERO);
|
goodsorder.setCreateDate(new Date());
|
goodsorder.setIsdeleted(Constants.ZERO);
|
goodsorder.setMemberInfo(orderPayRequest.getRemark());
|
goodsorder.setAddrId(addr.getId());
|
goodsorder.setLinkaddr(area.getProvinceName()+area.getCityName() + area.getName() + addr.getAddr());
|
goodsorder.setLinkphone(addr.getPhone());
|
goodsorder.setLinkname(addr.getName());
|
goodsorder.setMemberId(member.getId());
|
goodsorder.setType(orderPayRequest.getOrderType());
|
//单据编号 自增
|
goodsorder.setCode(getNextInCode());
|
//计算订单总金额
|
BigDecimal sumPrice = BigDecimal.ZERO;
|
//存储记录明细
|
List<PayDetailRequest> payDetailRequestList = orderPayRequest.getPayDetailRequestList();
|
if(Objects.isNull(payDetailRequestList)||payDetailRequestList.size()==Constants.ZERO){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"无明细数据,请检查选择数据！");
|
}
|
List<GoodsorderDetail> goodsOrderDetailList = new ArrayList<>();
|
for (PayDetailRequest payDetailRequest:payDetailRequestList) {
|
//查询商品
|
GoodsSku goodsSku = goodsSkuMapper.selectById(payDetailRequest.getGoodsSkuId());
|
if(Objects.isNull(goodsSku)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到商品SKU信息！");
|
}
|
Goods goods = goodsMapper.selectById(goodsSku.getGoodsId());
|
if(Objects.isNull(goods)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到商品信息！");
|
}
|
if(goods.getStatus().equals(Constants.ONE)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"存在商品已删除或已下架，无法下单");
|
}
|
if(goodsSku.getStock().compareTo(new BigDecimal(Constants.formatIntegerNum(payDetailRequest.getGoodsNum())))<Constants.ZERO){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"存在商品库存不足，无法下单！");
|
}
|
//商品库存扣除
|
goodsSku.setStock(goodsSku.getStock().subtract(new BigDecimal(Constants.formatIntegerNum(payDetailRequest.getGoodsNum()))));
|
goodsSkuMapper.updateById(goodsSku);
|
GoodsorderDetail goodsOrderDetail = new GoodsorderDetail();
|
goodsOrderDetail.setCreator(member.getId());
|
goodsOrderDetail.setCreateDate(new Date());
|
goodsOrderDetail.setImgurl(StringUtils.isBlank(goodsSku.getImgurl())?goods.getImgurl():goodsSku.getImgurl());
|
goodsOrderDetail.setName(goods.getName());
|
goodsOrderDetail.setGoodsSkuId(goodsSku.getId().toString());
|
goodsOrderDetail.setSkuName(goodsSku.getName());
|
goodsOrderDetail.setPrice(goodsSku.getPrice());
|
goodsOrderDetail.setGoodsNum(payDetailRequest.getGoodsNum());
|
goodsOrderDetailList.add(goodsOrderDetail);
|
sumPrice = sumPrice.add(goodsSku.getPrice().multiply(new BigDecimal(payDetailRequest.getGoodsNum())));
|
//购物车支付 删除购物车商品
|
if(orderPayRequest.getIsShopChart().equals(Constants.ONE)){
|
shopcartMapper.deleteById(payDetailRequest.getShopCartId());
|
}
|
}
|
|
//订单支付现金金额
|
goodsorder.setPrice((sumPrice.subtract(orderPayRequest.getDeductionBalance())));
|
MemberCoupon memberCoupon = new MemberCoupon();
|
if(!Objects.isNull(orderPayRequest.getCouponId())){
|
memberCoupon = memberCouponMapper.selectById(orderPayRequest.getCouponId());
|
if(Objects.isNull(memberCoupon)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到优惠券信息！");
|
}
|
if(sumPrice.compareTo(memberCoupon.getLimitPrice())<Constants.ZERO){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"订单金额小于优惠券总金额，无法使用！");
|
}
|
if(memberCoupon.getStatus().equals(Constants.ONE)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"优惠券已使用！");
|
}
|
sumPrice = sumPrice.subtract(memberCoupon.getPrice());
|
goodsorder.setCouponId(orderPayRequest.getCouponId());
|
goodsorder.setCouponPrice(memberCoupon.getPrice());
|
}
|
|
goodsorder.setCode(getNextInCode());
|
if(!Objects.isNull(memberCoupon)){
|
memberCoupon.setStatus(Constants.ONE);
|
memberCouponMapper.updateById(memberCoupon);
|
}
|
//咖豆商城订单 单独处理 扣减积分 添加积分变动记录
|
if(orderPayRequest.getOrderType().equals(Constants.ONE)){
|
if(member.getIntegral().compareTo(sumPrice)<=Constants.ZERO){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(), "咖豆不足,无法兑换！");
|
}
|
goodsorder.setStatus(Constants.OrderStatus.PAY_DONE.getKey());
|
goodsorder.setPayStatus(Constants.ZERO);
|
goodsorder.setPayDate(new Date());
|
goodsorderMapper.insert(goodsorder);
|
//更新用户积分
|
memberMapper.subtractIntegral(member.getId(),sumPrice);
|
PayResponse payResponse = new PayResponse();
|
payResponse.setOrderId(goodsorder.getId());
|
return payResponse;
|
}
|
goodsorder.setIntegral(orderPayRequest.getDeductionBalance());
|
goodsorderMapper.insert(goodsorder);
|
//数据存储
|
BigDecimal total = Constants.formatBigdecimal(goodsorder.getPrice()).add(Constants.formatBigdecimal(goodsorder.getIntegral())).add(Constants.formatBigdecimal(goodsorder.getCouponPrice()));
|
BigDecimal rate =Constants.formatBigdecimal(goodsorder.getCouponPrice()).divide(total,4,BigDecimal.ROUND_HALF_UP);
|
BigDecimal totalWxMoney = new BigDecimal(0);
|
BigDecimal totalIntegral = new BigDecimal(0);
|
for (int i =0;i< goodsOrderDetailList.size();i++) {
|
GoodsorderDetail goodsOrderDetail= goodsOrderDetailList.get(i);
|
goodsOrderDetail.setOrderId(goodsorder.getId());
|
BigDecimal wxMoney ;
|
BigDecimal integral;
|
if(i!=0 && i == goodsOrderDetailList.size() -1){
|
//处理因为四舍五入造成的可退金额损失
|
wxMoney = Constants.formatBigdecimal(goodsorder.getPrice()).subtract(totalWxMoney);
|
integral = Constants.formatBigdecimal(goodsorder.getIntegral()).subtract(totalIntegral);;
|
}else{
|
//当前明细实际价格
|
BigDecimal detialTotal = Constants.formatBigdecimal(goodsOrderDetail.getPrice()).multiply(new BigDecimal(Constants.formatIntegerNum(goodsOrderDetail.getGoodsNum())));
|
//折算优惠券后支付价格（包含现金和余额部分）
|
BigDecimal actDetialTotal = detialTotal.subtract(detialTotal.multiply(rate));
|
//按现金和积分支付比例，折算每个明细现金和积分支付的数量
|
BigDecimal rate1 = detialTotal .divide(total,4,BigDecimal.ROUND_HALF_UP);
|
//可退现金金额
|
wxMoney = Constants.formatBigdecimal(goodsorder.getPrice()).multiply(rate1);
|
//剩下的是余额抵扣
|
integral =actDetialTotal.subtract(wxMoney);
|
totalWxMoney = totalWxMoney.add(wxMoney);//累计
|
totalIntegral= totalIntegral.add(integral);//累计
|
}
|
goodsOrderDetail.setMoney(wxMoney);
|
goodsOrderDetail.setIntegral(integral);
|
goodsorderDetailMapper.insert(goodsOrderDetail);
|
}
|
//如果抵扣金额大于 0 则进行余额业务处理
|
if(orderPayRequest.getDeductionBalance().compareTo(BigDecimal.ZERO)>Constants.ZERO){
|
//抵扣金额小于会员剩余余额
|
if(orderPayRequest.getDeductionBalance().compareTo(member.getIntegral())<=Constants.ZERO){
|
//更新余额信息 添加积分变动记录
|
DealIntegralRequest dealIntegralRequest = new DealIntegralRequest();
|
dealIntegralRequest.setIntegralNum(orderPayRequest.getDeductionBalance());
|
dealIntegralRequest.setDealType(Constants.ONE);
|
dealIntegralRequest.setMemberId(member.getId());
|
dealIntegralRequest.setObjId(goodsorder.getId());
|
dealIntegralRequest.setOrderCode(goodsorder.getCode().toString());
|
dealIntegralRequest.setIntegralObjType(Constants.IntegralObjType.SHOP_ORDER);
|
integralService.dealIntegral(dealIntegralRequest);
|
//发送微信小程序订阅消息
|
SendWxMessage.integralChangeNotice(member,orderPayRequest.getDeductionBalance());
|
//余额全部抵扣
|
if(goodsorder.getPrice().compareTo(BigDecimal.ZERO)==Constants.ZERO){
|
goodsorder.setStatus(Constants.OrderStatus.PAY_DONE.getKey());
|
goodsorder.setPayStatus(Constants.ONE);
|
goodsorder.setPayDate(new Date());
|
goodsorderMapper.updateById(goodsorder);
|
PayResponse payResponse = new PayResponse();
|
payResponse.setOrderId(goodsorder.getId());
|
return payResponse;
|
}
|
}else{
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"余额不足，无法进行支付，当前剩余余额：【"+member.getIntegral()+"】！");
|
}
|
}
|
if(goodsorder.getPrice().compareTo(orderPayRequest.getTitlePrice())!=Constants.ZERO){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"商品价格发生变化，请刷新后重新支付！");
|
}
|
return this.wxPay(goodsorder,member);
|
}
|
|
|
|
@Transactional(rollbackFor = {Exception.class,BusinessException.class})
|
public PayResponse orderPay(ShopOrderPayRequest orderPayRequest,MemberCouponServiceImpl memberCouponService){
|
Member member = memberMapper.selectById(orderPayRequest.getMemberId());
|
|
Goodsorder goodsorder = new Goodsorder();
|
goodsorder.setCreator(orderPayRequest.getMemberId());
|
goodsorder.setIntegral(BigDecimal.ZERO);
|
goodsorder.setCreateDate(new Date());
|
goodsorder.setIsdeleted(Constants.ZERO);
|
goodsorder.setMemberInfo(orderPayRequest.getRemark());
|
goodsorder.setMemberId(member.getId());
|
goodsorder.setType(Constants.ZERO);
|
goodsorder.setStatus(Constants.ZERO);
|
|
if(Constants.equalsInteger(orderPayRequest.getReceiveType(),Constants.ZERO)){
|
//查询收货地址
|
Addr addr = addrMapper.selectById(orderPayRequest.getAddressId());
|
if(Objects.isNull(addr)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到收货地址信息！");
|
}
|
Areas area = areasService.findById(addr.getAreaId(), Constants.TWO);
|
if(Objects.isNull(area)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"收货地址区划信息发生变化，请更新后下单！");
|
}
|
|
goodsorder.setAddrId(addr.getId());
|
goodsorder.setLinkaddr(area.getProvinceName()+area.getCityName() + area.getName() + addr.getAddr());
|
goodsorder.setLinkphone(addr.getPhone());
|
goodsorder.setLinkname(addr.getName());
|
if(Objects.nonNull(member.getBindShopId())){
|
goodsorder.setDistributionShopId(member.getBindShopId());
|
}
|
}else{
|
if(Objects.isNull(orderPayRequest.getShopId())){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"请选择正确的自提门店！");
|
}
|
Shop shop = shopMapper.selectById(orderPayRequest.getShopId());
|
if(Objects.isNull(shop)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"请选择正确的自提门店！");
|
}
|
goodsorder.setPickUpShopId(shop.getId());
|
goodsorder.setDistributionShopId(shop.getId());
|
if(Objects.isNull(member.getBindShopId())){
|
member.setBindShopId(shop.getId());
|
}
|
}
|
//单据编号 自增
|
goodsorder.setCode(getNextInCode());
|
//计算订单总金额
|
BigDecimal sumPrice = BigDecimal.ZERO;
|
|
//存储记录明细
|
OrderPayConfirmResponse orderPayConfirmResponse = this.orderPayConfirm(orderPayRequest.getReceiveType(),orderPayRequest.getPayDetailRequestList(),orderPayRequest.getAddressId(),memberCouponService,member.getId());
|
if(Objects.isNull(orderPayConfirmResponse)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"系统支付错误,请联系管理员");
|
}
|
goodsorder.setPrice(orderPayConfirmResponse.getPayAmount());
|
goodsorder.setTotalPrice(orderPayConfirmResponse.getAmount());
|
goodsorder.setUseIntegral(orderPayConfirmResponse.getDeductIntegral());
|
goodsorder.setIntegralPrice(orderPayConfirmResponse.getIntegralAmount());
|
|
if(Objects.nonNull(orderPayConfirmResponse.getMemberCoupon())){
|
MemberCoupon memberCoupon = memberCouponMapper.selectById(orderPayConfirmResponse.getMemberCoupon().getId());
|
if(Objects.isNull(memberCoupon)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到优惠券信息！");
|
}
|
if(memberCoupon.getStatus().equals(Constants.ONE)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"优惠券已使用！");
|
}
|
sumPrice = sumPrice.subtract(memberCoupon.getPrice());
|
goodsorder.setCouponId(memberCoupon.getId());
|
goodsorder.setCouponPrice(orderPayConfirmResponse.getMemberCoupon().getValidAmount());
|
|
memberCouponMapper.update(null,new UpdateWrapper<MemberCoupon>().lambda()
|
.set(MemberCoupon::getStatus,Constants.ONE)
|
.set(MemberCoupon::getUseDate,DateUtil.getCurrDateTime())
|
.eq(MemberCoupon::getId,memberCoupon.getId())
|
);
|
}
|
|
goodsorderMapper.insert(goodsorder);
|
List<OrderGoodsCalculateResponse> goodsCalculateList = orderPayConfirmResponse.getGoodsCalculateList();
|
if(CollectionUtils.isEmpty(goodsCalculateList)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"无明细数据,请检查选择数据！");
|
}
|
List<GoodsorderDetail> goodsOrderDetailList = new ArrayList<>();
|
for (OrderGoodsCalculateResponse payDetailRequest:goodsCalculateList) {
|
//查询商品
|
GoodsSku goodsSku = goodsSkuMapper.selectById(payDetailRequest.getSkuId());
|
if(Objects.isNull(goodsSku)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到商品SKU信息！");
|
}
|
Goods goods = goodsMapper.selectById(goodsSku.getGoodsId());
|
if(Objects.isNull(goods)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到商品信息！");
|
}
|
if(goods.getStatus().equals(Constants.ONE)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"存在商品已删除或已下架，无法下单");
|
}
|
if(goodsSku.getStock().compareTo(new BigDecimal(Constants.formatIntegerNum(payDetailRequest.getGoodsNum())))<Constants.ZERO){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"存在商品库存不足，无法下单！");
|
}
|
//商品库存扣除
|
goodsSku.setStock(goodsSku.getStock().subtract(new BigDecimal(Constants.formatIntegerNum(payDetailRequest.getGoodsNum()))));
|
goodsSkuMapper.updateById(goodsSku);
|
GoodsorderDetail goodsOrderDetail = new GoodsorderDetail();
|
goodsOrderDetail.setCreator(member.getId());
|
goodsOrderDetail.setCreateDate(new Date());
|
goodsOrderDetail.setImgurl(StringUtils.isBlank(goodsSku.getImgurl())?goods.getImgurl():goodsSku.getImgurl());
|
goodsOrderDetail.setName(goods.getName());
|
goodsOrderDetail.setGoodsSkuId(goodsSku.getId().toString());
|
goodsOrderDetail.setSkuName(goodsSku.getName());
|
goodsOrderDetail.setPrice(goodsSku.getPrice());
|
goodsOrderDetail.setGoodsNum(payDetailRequest.getGoodsNum());
|
goodsOrderDetail.setGoodsWeight(payDetailRequest.getWeight());
|
goodsOrderDetail.setCouponDeduct(payDetailRequest.getCouponDeductCash());
|
goodsOrderDetail.setIntegralDeduct(payDetailRequest.getIntegralDeductCash());
|
goodsOrderDetail.setOrderId(goodsorder.getId());
|
goodsOrderDetailList.add(goodsOrderDetail);
|
//删除购物车商品
|
shopcartMapper.delete(new QueryWrapper<Shopcart>().lambda()
|
.eq(Shopcart::getMemberId,member.getId())
|
.eq(Shopcart::getGoodsSkuId,goodsOrderDetail.getGoodsSkuId())
|
);
|
}
|
//积分变动记录
|
Integral integral =Integral.createIntegral(member.getId(),Constants.INTEGRAL_TYPE.ORDER_PAY,goodsorder.getId());
|
integral.setNum(goodsorder.getUseIntegral());
|
integral.setTotalNum(member.getIntegral().subtract(goodsorder.getUseIntegral()));
|
integralMapper.insert(integral);
|
//更新用户积分
|
memberMapper.subtractIntegral(member.getId(),goodsorder.getUseIntegral());
|
if(goodsorder.getPrice().compareTo(orderPayRequest.getTitlePrice())!=Constants.ZERO){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"商品价格发生变化，请刷新后重新支付！");
|
}
|
|
return this.wxPay(goodsorder,member);
|
}
|
|
|
/**
|
* 重新支付
|
* @param orderId
|
* @return
|
*/
|
@Override
|
@Transactional(rollbackFor = {BusinessException.class,Exception.class})
|
public PayResponse replayPay(Integer orderId){
|
Goodsorder goodsorder = goodsorderMapper.selectById(orderId);
|
if(!goodsorder.getStatus().equals(Constants.ZERO)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"订单状态错误,无法重新支付！");
|
}
|
Member member = memberMapper.selectById(goodsorder.getMemberId());
|
//更换订单号
|
goodsorder.setCode(getNextInCode());
|
goodsorder.setEditDate(new Date());;
|
goodsorder.setEditor(member.getId());
|
goodsorderMapper.updateById(goodsorder);
|
return this.wxPay(goodsorder,member);
|
}
|
|
|
|
/**
|
* 调起微信支付
|
* @param goodsorder
|
* @param member
|
* @return
|
*/
|
public PayResponse wxPay(Goodsorder goodsorder,Member member){
|
try {
|
//--------微信小程序支付--------
|
Object response = null;
|
WxPayUnifiedOrderRequest request = new WxPayUnifiedOrderRequest();
|
request.setBody("平台商城");
|
request.setAttach("terraceMall");
|
request.setOutTradeNo(goodsorder.getCode().toString());
|
request.setTotalFee(BaseWxPayRequest.yuanToFen(goodsorder.getPrice().toString()));
|
// request.setTotalFee(2);
|
request.setTimeStart(DateUtil.DateToString(new Date(), "yyyyMMddHHmmss"));
|
request.setSpbillCreateIp(this.getIpAddr());
|
//微信小程序
|
request.setOpenid(member.getOpenId());
|
response = WxMiniConfig.wxPayService.createOrder(request);
|
PayResponse payResponse = new PayResponse();
|
payResponse.setResponse(response);
|
payResponse.setOrderId(goodsorder.getId());
|
return payResponse;
|
} catch (WxPayException e) {
|
e.printStackTrace();
|
}
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"支付失败！");
|
}
|
|
/**
|
* 订单列表接口
|
* @param pageWrap
|
* @return
|
*/
|
@Override
|
public IPage<MemberOrderResponse> getGoodsOrderPage(PageWrap<MemberOrderRequest> pageWrap) {
|
IPage<MemberOrderResponse> page = goodsorderMapper.goodsOrderPage(pageWrap.toPage(),new QueryWrapper<MemberOrderRequest>()
|
.eq(!Objects.isNull(pageWrap.getModel())&&!Objects.isNull(pageWrap.getModel().getMemberId()),"g.MEMBER_ID",pageWrap.getModel().getMemberId())
|
.eq("g.ISDELETED",Constants.ZERO)
|
.eq(!Objects.isNull(pageWrap.getModel())&&!Objects.isNull(pageWrap.getModel().getOrderStatus()),"g.STATUS",pageWrap.getModel().getOrderStatus())
|
.orderByDesc("g.CREATE_DATE")
|
);
|
String fullUrl = systemDictDataBiz.queryByCode(Constants.OSS,Constants.RESOURCE_PATH).getCode()+
|
systemDictDataBiz.queryByCode(Constants.OSS,Constants.GOODS_FILE).getCode();
|
page.getRecords().forEach(i->{
|
List<MemberOrderDetailResponse> memberOrderDetailResponseList = goodsorderDetailMapper.getDetailList(i.getOrderId());
|
memberOrderDetailResponseList.forEach(j->{
|
j.setImgUrl(fullUrl + j.getImgUrl());
|
});
|
i.setMemberOrderDetailResponseList(memberOrderDetailResponseList);
|
});
|
return page;
|
}
|
|
|
/**
|
* 查询订单详情
|
* @param id
|
* @return
|
*/
|
@Override
|
public MemberOrderResponse getGoodsOrderDetail(Integer id) {
|
MemberOrderResponse memberOrderResponse = goodsorderMapper.goodsOrderDetail(id);
|
if(Objects.isNull(memberOrderResponse)){
|
throw new BusinessException(ResponseStatus.DATA_EMPTY.getCode(),"未查询到订单信息");
|
}
|
if(memberOrderResponse.getOrderStatus().equals(Constants.OrderStatus.WAIT_PAY.getKey())){
|
memberOrderResponse.setCountdown(memberOrderResponse.getCancelDate().getTime()-System.currentTimeMillis());
|
}
|
List<MemberOrderDetailResponse> memberOrderDetailResponseList = goodsorderDetailMapper.getDetailList(memberOrderResponse.getOrderId());
|
String fullUrl = systemDictDataBiz.queryByCode(Constants.OSS,Constants.RESOURCE_PATH).getCode()+
|
systemDictDataBiz.queryByCode(Constants.OSS,Constants.GOODS_FILE).getCode();
|
memberOrderDetailResponseList.forEach(j->{
|
j.setImgUrl(fullUrl + j.getImgUrl());
|
});
|
memberOrderResponse.setMemberOrderDetailResponseList(memberOrderDetailResponseList);
|
return memberOrderResponse;
|
}
|
|
/**
|
* 更新收货地址
|
* @param updAddressRequest
|
*/
|
@Override
|
public void updAddress(DealOrderRequest updAddressRequest){
|
Goodsorder goodsorder = goodsorderMapper.selectById(updAddressRequest.getOrderId());
|
if(!goodsorder.getMemberId().equals(updAddressRequest.getMemberId())){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"订单修改失败：用户信息匹配失败！");
|
}
|
if(!(goodsorder.getStatus().equals(Constants.ZERO)||goodsorder.getStatus().equals(Constants.ONE))){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"订单修改失败：订单已发货！");
|
}
|
if(updAddressRequest.getAddressId().equals(goodsorder.getAddrId())){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"订单修改失败：订单地址相同！");
|
}
|
Addr addr = addrMapper.selectById(updAddressRequest.getAddressId());
|
if(Objects.isNull(addr)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"订单修改失败：未查询到新地址信息！");
|
}
|
goodsorder.setAddrId(addr.getId());
|
goodsorder.setLinkname(addr.getName());
|
goodsorder.setLinkaddr(addr.getAddr());
|
goodsorder.setLinkphone(addr.getPhone());
|
goodsorder.setEditor(updAddressRequest.getMemberId());
|
goodsorder.setEditDate(new Date());
|
goodsorderMapper.updateById(goodsorder);
|
}
|
|
|
/**
|
* 取消订单
|
* @param orderId
|
* @param optUserId
|
* @param cancelInfo
|
*/
|
@Override
|
public void cancelOrder(Integer orderId,Integer optUserId,String cancelInfo){
|
Goodsorder goodsorder = goodsorderMapper.selectById(orderId);
|
if(!(goodsorder.getStatus().equals(Constants.ZERO)||goodsorder.getStatus().equals(Constants.ONE))){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"订单取消失败：订单已发货！");
|
}
|
if(!(goodsorder.getType().equals(Constants.ZERO)||goodsorder.getType().equals(Constants.ONE))){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"订单取消失败：该类型订单不支持取消！");
|
}
|
if(goodsorder.getStatus().equals(Constants.ONE)){
|
//已支付 待发货状态 取消订单 根据订单类别处理
|
if(goodsorder.getType().equals(Constants.ZERO)){
|
if(goodsorder.getPrice().compareTo(BigDecimal.ZERO)>Constants.ZERO){
|
//微信现金退款
|
String refundCode = WxMiniUtilService.wxRefund(goodsorder.getCode().toString(), goodsorder.getPrice(), goodsorder.getPrice());
|
Fund fund = new Fund();
|
fund.setOrderCode(refundCode);
|
fund.setCreator(optUserId);
|
fund.setCreateDate(new Date());
|
fund.setIsdeleted(Constants.ZERO);
|
fund.setRemark(orderId.toString());
|
fund.setMemberId(goodsorder.getCreator());
|
fund.setTitle("订单取消");
|
fund.setContent(cancelInfo);
|
fund.setObjId(orderId);
|
fund.setObjType(Constants.ONE);
|
fund.setType(Constants.ONE);
|
fund.setNum(goodsorder.getPrice());
|
fundMapper.insert(fund);
|
}
|
}
|
}
|
if(goodsorder.getIntegral().compareTo(BigDecimal.ZERO)>Constants.ZERO){
|
//更新余额信息 添加积分变动记录
|
DealIntegralRequest dealIntegralRequest = new DealIntegralRequest();
|
dealIntegralRequest.setIntegralNum(goodsorder.getIntegral());
|
dealIntegralRequest.setDealType(Constants.ZERO);
|
dealIntegralRequest.setMemberId(goodsorder.getMemberId());
|
dealIntegralRequest.setObjId(goodsorder.getId());
|
dealIntegralRequest.setOrderCode(goodsorder.getCode().toString());
|
dealIntegralRequest.setIntegralObjType(Constants.IntegralObjType.SHOP_ORDER_CANCEL);
|
integralService.dealIntegral(dealIntegralRequest);
|
}
|
//订单信息取消
|
goodsorder.setStatus(Constants.OrderStatus.CLOSE.getKey());
|
goodsorder.setCancelDate(new Date());
|
goodsorder.setCancelInfo(cancelInfo);
|
goodsorder.setCancelUser(optUserId);
|
goodsorderMapper.updateById(goodsorder);
|
String goodsName = "";
|
List<GoodsorderDetail> goodsorderDetailList = goodsorderDetailMapper.selectList(new QueryWrapper<GoodsorderDetail>().eq("ORDER_ID",goodsorder.getId()));
|
if(!Objects.isNull(goodsorderDetailList)&&goodsorderDetailList.size()>Constants.ZERO){
|
for (GoodsorderDetail goodsorderDetail:goodsorderDetailList) {
|
GoodsSku goodsSku = goodsSkuMapper.selectById(goodsorderDetail.getGoodsSkuId());
|
if(StringUtils.isBlank(goodsName)){
|
Goods goods = goodsMapper.selectById(goodsSku.getGoodsId());
|
goodsName = goods.getName();
|
}
|
if(!Objects.isNull(goodsSku)){
|
goodsSku.setStock(goodsSku.getStock().add(new BigDecimal(Constants.formatIntegerNum(goodsorderDetail.getGoodsNum()))));
|
goodsSkuMapper.updateById(goodsSku);
|
}
|
}
|
}
|
|
SendWxMessage.orderCancel(goodsorder,memberMapper.selectById(goodsorder.getMemberId()),goodsName);
|
|
|
|
//查询优惠券信息记录
|
if(!Objects.isNull(goodsorder.getCouponId())){
|
MemberCoupon memberCoupon = memberCouponMapper.selectById(goodsorder.getCouponId());
|
if(!Objects.isNull(memberCoupon)){
|
memberCoupon.setStatus(Constants.ZERO);
|
memberCouponMapper.updateById(memberCoupon);
|
}
|
}
|
}
|
|
public BigDecimal getDeductAmount(List<PayDetailRequest> requestList){
|
List<MemberCoupon> memberCouponList = new ArrayList<>();
|
|
List<GoodsSku> goodsSkuList = goodsSkuMapper.selectList(new QueryWrapper<GoodsSku>()
|
.lambda()
|
.eq(GoodsSku::getIsdeleted,Constants.ZERO)
|
.in(GoodsSku::getId,requestList.stream().map(i->i.getGoodsSkuId()).collect(Collectors.toList()))
|
);
|
if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isEmpty(goodsSkuList)||!Constants.equalsInteger(goodsSkuList.size(),requestList.size())){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"商品SKU信息错误,请刷新重试");
|
}
|
|
//查询商品列表
|
List<Goods> goodsList = goodsMapper.selectJoinList(Goods.class,
|
new MPJLambdaWrapper<Goods>()
|
.selectAs(GoodsSku::getPrice,Goods::getSkuPrice)
|
.selectAs(GoodsSku::getId,Goods::getSkuId)
|
.leftJoin(GoodsSku.class,GoodsSku::getGoodsId,Goods::getId)
|
.in(GoodsSku::getId,requestList.stream().map(i->i.getGoodsSkuId()).collect(Collectors.toList())));
|
if(Objects.isNull(goodsList)){
|
return BigDecimal.ZERO;
|
}
|
//获取选择的商品总金额 与 单个商品金额
|
BigDecimal deductAmount = BigDecimal.ZERO;
|
for (Goods goods:goodsList) {
|
List<PayDetailRequest> request = requestList.stream().filter(i->Constants.equalsInteger(i.getGoodsSkuId(), goods.getSkuId())).collect(Collectors.toList());
|
if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isNotEmpty(request)){
|
goods.setSkuAmount(goods.getSkuPrice().multiply(new BigDecimal(request.get(Constants.ZERO).getGoodsNum()+"")));
|
deductAmount = deductAmount.add(goods.getSkuAmount().multiply(goods.getDeductRata()));
|
}
|
}
|
return deductAmount;
|
}
|
|
|
/**
|
* 订单确认接口
|
* @param receiveType 0=快递配送 1=自提
|
* @param requestList
|
* @param addressId
|
* @param memberCouponService
|
* @param memberId
|
*/
|
public OrderPayConfirmResponse orderPayConfirm(Integer receiveType,List<PayDetailRequest> requestList,Integer addressId,
|
MemberCouponServiceImpl memberCouponService,Integer memberId){
|
OrderPayConfirmResponse orderPayConfirmResponse = new OrderPayConfirmResponse();
|
List<Goods> goodsList = goodsMapper.selectJoinList(Goods.class,
|
new MPJLambdaWrapper<Goods>()
|
.selectAs(GoodsSku::getPrice,Goods::getSkuPrice)
|
.selectAs(GoodsSku::getId,Goods::getSkuId)
|
.selectAs(GoodsSku::getIntegralRate,Goods::getDeductRata)
|
.selectAs(GoodsSku::getWeight,Goods::getWeight)
|
.selectAs(GoodsSku::getImgurl,Goods::getSkuImg)
|
.leftJoin(GoodsSku.class,GoodsSku::getGoodsId,Goods::getId)
|
.in(GoodsSku::getId,requestList.stream().map(i->i.getGoodsSkuId()).collect(Collectors.toList())));
|
if(CollectionUtils.isEmpty(goodsList)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"未匹配到商品信息");
|
}
|
|
List<OrderGoodsCalculateResponse> goodsCalculateList = ListUtil.copyProperties(goodsList,OrderGoodsCalculateResponse::new);
|
|
//订单总金额
|
BigDecimal amount = BigDecimal.ZERO;
|
//优惠券抵扣金额
|
BigDecimal couponAmount = BigDecimal.ZERO;
|
//积分抵扣金额
|
BigDecimal integralAmount = BigDecimal.ZERO;
|
//抵扣积分值
|
BigDecimal deductIntegral = BigDecimal.ZERO;
|
//邮费金额
|
BigDecimal mailAmount = BigDecimal.ZERO;
|
for (OrderGoodsCalculateResponse response:goodsCalculateList) {
|
List<PayDetailRequest> request = requestList.stream().filter(i->Constants.equalsInteger(i.getGoodsSkuId(), response.getSkuId())).collect(Collectors.toList());
|
if(com.github.xiaoymin.knife4j.core.util.CollectionUtils.isNotEmpty(request)){
|
PayDetailRequest payDetailRequest = request.get(Constants.ZERO);
|
response.setSkuAmount(response.getSkuPrice().multiply(new BigDecimal(payDetailRequest.getGoodsNum()+"")));
|
response.setGoodsNum(payDetailRequest.getGoodsNum());
|
amount = amount.add(response.getSkuAmount());
|
}
|
}
|
//获取优惠券优惠金额
|
List<MemberCoupon> memberCouponList = memberCouponService.getApplyCoupon(requestList,memberId);
|
MemberCoupon memberCoupon = new MemberCoupon();
|
if(CollectionUtils.isNotEmpty(memberCouponList)){
|
memberCoupon = memberCouponList.get(Constants.ZERO);
|
couponAmount = memberCoupon.getValidAmount();
|
memberCouponService.calculateCouponRata(memberCoupon,goodsCalculateList,amount);
|
orderPayConfirmResponse.setMemberCoupon(memberCoupon);
|
}
|
//积分抵扣金额
|
//查询用户总积分
|
Member member = memberMapper.selectById(memberId);
|
//积分大于0 且大于可用积分配置项 才可以使用
|
if(member.getIntegral().compareTo(BigDecimal.ZERO)>Constants.ZERO){
|
//最低可用启用积分
|
BigDecimal minimumIntegral = new BigDecimal(systemDictDataBiz.queryByCode(Constants.SHOP_CONFIG,Constants.MINIMUM_AVAILABLE_INTEGRAL).getCode());
|
if(member.getIntegral().compareTo(minimumIntegral)>=Constants.ZERO){
|
this.calculateIntegralRata(goodsCalculateList,member.getIntegral());
|
}
|
}
|
//邮费金额
|
if(Constants.equalsInteger(receiveType,Constants.ZERO)){
|
//TODO 根据收货地址 查询运费配置
|
|
//计算商品信息总重量
|
BigDecimal totalWeight = goodsCalculateList.stream().map(i->
|
i.getWeight().multiply(new BigDecimal(i.getGoodsNum().toString()))
|
).reduce(BigDecimal.ZERO,BigDecimal::add);
|
|
}
|
|
orderPayConfirmResponse.setAmount(amount);
|
orderPayConfirmResponse.setCouponAmount(couponAmount);
|
orderPayConfirmResponse.setDeductIntegral(deductIntegral);
|
orderPayConfirmResponse.setMailAmount(mailAmount);
|
orderPayConfirmResponse.setIntegralAmount(integralAmount);
|
orderPayConfirmResponse.setPayAmount(amount.subtract(couponAmount).subtract(mailAmount).subtract(integralAmount));
|
orderPayConfirmResponse.setGoodsCalculateList(goodsCalculateList);
|
BigDecimal cashToIntegralRata = new BigDecimal(systemDictDataBiz.queryByCode(Constants.SHOP_CONFIG,Constants.CASH_EXCHANGE_INTEGRAL_RATA).getCode());
|
orderPayConfirmResponse.setIntegralBack(
|
orderPayConfirmResponse.getPayAmount().multiply(cashToIntegralRata)
|
);
|
|
return orderPayConfirmResponse;
|
}
|
|
/**
|
*
|
* @param goodsCalculateList 商品集合
|
* @param totalIntegral 用户总积分
|
*/
|
public void calculateIntegralRata(List<OrderGoodsCalculateResponse> goodsCalculateList,BigDecimal totalIntegral){
|
//当前选择商品最大可用积分抵扣的金额
|
BigDecimal maxDeductionCash = goodsCalculateList.stream().map(i->i.getSkuAmount().subtract(i.getCouponDeductCash())
|
.multiply(i.getDeductRata())).reduce(BigDecimal.ZERO,BigDecimal::add);
|
//积分 - 现金 比例
|
BigDecimal cashToIntegralRata = new BigDecimal(systemDictDataBiz.queryByCode(Constants.SHOP_CONFIG,Constants.INTEGRAL_EXCHANGE_CASH_RATA).getCode());
|
//当前选择商品抵扣需要使用的积分
|
BigDecimal maxDeductionIntegral = maxDeductionCash.multiply(cashToIntegralRata).multiply(new BigDecimal("100"));
|
BigDecimal deductionRata = BigDecimal.ONE;
|
//如果实际积分少于最大需要积分 需要计算比例占比 去对应添加至对应的商品里
|
if(totalIntegral.compareTo(maxDeductionIntegral)<=Constants.ZERO) {
|
deductionRata = totalIntegral.divide(maxDeductionIntegral, 2, BigDecimal.ROUND_HALF_UP);
|
}
|
//获取总的抵扣金额 与 每个商品可抵扣金额
|
//已用占比比例值
|
BigDecimal rata = BigDecimal.ZERO;
|
//剩余可分配金额
|
BigDecimal surplusValidAmount = maxDeductionCash;
|
for (int j = 0; j < goodsCalculateList.size(); j++) {
|
if(Constants.equalsInteger(j+1,goodsCalculateList.size())){
|
goodsCalculateList.get(j).setIntegralMaxDeductCash(surplusValidAmount);
|
goodsCalculateList.get(j).setOrderIntegralRata(new BigDecimal("1").subtract(rata));
|
}else{
|
//积分最大可抵扣金额
|
goodsCalculateList.get(j).setIntegralMaxDeductCash(
|
goodsCalculateList.get(j).getSkuAmount()
|
.subtract(goodsCalculateList.get(j).getCouponDeductCash())
|
.multiply(goodsCalculateList.get(j).getDeductRata()));
|
//订单中积分金额实际占比
|
goodsCalculateList.get(j).setOrderIntegralRata(
|
goodsCalculateList.get(j)
|
.getIntegralMaxDeductCash().divide(maxDeductionCash,2,BigDecimal.ROUND_DOWN)
|
);
|
rata = rata.add(goodsCalculateList.get(j).getOrderIntegralRata());
|
surplusValidAmount = surplusValidAmount.subtract(goodsCalculateList.get(j).getIntegralMaxDeductCash());
|
}
|
//如果用户积分大于本次需要使用的最大积分 则直接使用否则需要重新计算
|
goodsCalculateList.get(j).setIntegralDeductCash(goodsCalculateList.get(j).getIntegralMaxDeductCash().multiply(deductionRata));
|
goodsCalculateList.get(j).setIntegralDeduct(goodsCalculateList.get(j).getIntegralMaxDeductCash().multiply(cashToIntegralRata).multiply(deductionRata));
|
}
|
|
}
|
|
|
|
|
/**
|
* 催发货
|
* @param orderId
|
* @param memberId
|
*/
|
@Override
|
public void urgeSend(Integer orderId,Integer memberId){
|
Goodsorder goodsorder = goodsorderMapper.selectById(orderId);
|
if(!goodsorder.getMemberId().equals(memberId)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：用户信息匹配失败！");
|
}
|
if(!(goodsorder.getStatus().equals(Constants.ZERO)||goodsorder.getStatus().equals(Constants.ONE))){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：订单已发货！");
|
}
|
if(!(goodsorder.getType().equals(Constants.ZERO)||goodsorder.getType().equals(Constants.ONE))){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：该类型订单不支持！");
|
}
|
if(DateUtil.daysBetweenDates(new Date(),goodsorder.getCreateDate())<Constants.ONE){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：商品将于下单后24小时内发货！");
|
}
|
//查询最后一次催发货时间
|
OrderUrge oldOrderUrge = orderUrgeMapper.selectOne(new QueryWrapper<OrderUrge>()
|
.eq("ORDER_ID",goodsorder.getId())
|
);
|
if(!Objects.isNull(oldOrderUrge)){
|
if(DateUtil.daysBetweenDates(new Date(),oldOrderUrge.getCreateDate())<Constants.ONE){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：24小时内已催发货！");
|
}
|
}
|
OrderUrge orderUrge = new OrderUrge();
|
orderUrge.setCreator(memberId);
|
orderUrge.setCreateDate(new Date());
|
orderUrge.setIsdeleted(Constants.ZERO);
|
orderUrge.setOrderId(orderId);
|
orderUrge.setStatus(Constants.ZERO);
|
orderUrgeMapper.insert(orderUrge);
|
}
|
|
|
/**
|
* 订单确认收货
|
* @param orderId
|
* @param memberId
|
*/
|
@Override
|
public void affirmOrder(Integer orderId,Integer memberId){
|
Goodsorder goodsorder = goodsorderMapper.selectById(orderId);
|
if(!goodsorder.getMemberId().equals(memberId)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：用户信息匹配失败！");
|
}
|
if(!goodsorder.getStatus().equals(Constants.OrderStatus.WAIT_RECEIVE.getKey())){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：订单未发货，无法进行确认！");
|
}
|
if(!(goodsorder.getType().equals(Constants.ZERO)||goodsorder.getType().equals(Constants.ONE))){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：该类型订单不支持！");
|
}
|
goodsorder.setStatus(Constants.OrderStatus.DONE.getKey());
|
goodsorder.setDoneDate(new Date());
|
goodsorderMapper.updateById(goodsorder);
|
}
|
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void orderComment(OrderCommentRequest orderCommentRequest){
|
Goodsorder goodsorder = goodsorderMapper.selectById(orderCommentRequest.getOrderId());
|
if(!goodsorder.getMemberId().equals(goodsorder.getMemberId())){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：用户信息匹配失败！");
|
}
|
if(!goodsorder.getStatus().equals(Constants.OrderStatus.DONE.getKey())){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：订单未完成，无法进行评论！");
|
}
|
if(!(goodsorder.getType().equals(Constants.ZERO)||goodsorder.getType().equals(Constants.ONE))){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：该类型订单不支持！");
|
}
|
if(goodsorder.getIsComment().equals(Constants.ONE)){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：订单已评论，无法再次评论！");
|
}
|
List<OrderGoodsCommentRequest> orderGoodsCommentRequestList = orderCommentRequest.getOrderGoodsCommentRequestList();
|
if(Objects.isNull(orderGoodsCommentRequestList)||orderGoodsCommentRequestList.size()==Constants.ZERO){
|
throw new BusinessException(ResponseStatus.NOT_ALLOWED.getCode(),"操作失败：无商品评论信息！");
|
}
|
for (OrderGoodsCommentRequest orderGoodsCommentRequest:orderGoodsCommentRequestList) {
|
OrderComment orderComment = new OrderComment();
|
orderComment.setCreateDate(new Date());
|
orderComment.setCreator(orderCommentRequest.getMemberId());
|
orderComment.setIsdeleted(Constants.ZERO);
|
orderComment.setMemberId(orderCommentRequest.getMemberId());
|
orderComment.setOrderId(orderCommentRequest.getOrderId());
|
orderComment.setGoodsId(orderGoodsCommentRequest.getGoodsId());
|
orderComment.setOrderScore(orderCommentRequest.getOrderScore());
|
orderComment.setScore(orderGoodsCommentRequest.getScore());
|
orderComment.setContent(orderCommentRequest.getContent());
|
orderComment.setKdScore(orderCommentRequest.getKdScore());
|
orderComment.setShScore(orderCommentRequest.getShScore());
|
orderCommentMapper.insert(orderComment);
|
}
|
goodsorder.setIsComment(Constants.ONE);
|
goodsorderMapper.updateById(goodsorder);
|
}
|
|
|
@Override
|
public MyPageResponse ordersStatistics(Integer memberId){
|
MyPageResponse myPageResponse = new MyPageResponse();
|
//待支付订单
|
myPageResponse.setWaitPayOrders(goodsorderMapper.selectCount(new QueryWrapper<Goodsorder>()
|
.eq("MEMBER_ID",memberId)
|
.eq("STATUS",Constants.OrderStatus.WAIT_PAY.getKey())
|
));
|
myPageResponse.setWaitOrders(goodsorderMapper.selectCount(new QueryWrapper<Goodsorder>()
|
.eq("MEMBER_ID",memberId)
|
.eq("STATUS",Constants.OrderStatus.PAY_DONE.getKey())
|
));
|
myPageResponse.setWaitReceivedOrders(goodsorderMapper.selectCount(new QueryWrapper<Goodsorder>()
|
.eq("MEMBER_ID",memberId)
|
.eq("STATUS",Constants.OrderStatus.WAIT_RECEIVE.getKey())
|
));
|
myPageResponse.setFinishOrders(goodsorderMapper.selectCount(new QueryWrapper<Goodsorder>()
|
.eq("MEMBER_ID",memberId)
|
.eq("STATUS",Constants.OrderStatus.DONE.getKey())
|
));
|
myPageResponse.setAfterOrders(aftersaleMapper.selectCount(new QueryWrapper<Aftersale>()
|
.apply(" ID in ( select g.id from goodsorder g where g.MEMBER_ID = '"+memberId+"' ) ")
|
.notIn("STATUS",Constants.AftersaleStatus.DONE,Constants.AftersaleStatus.SHOP_REFUSE,Constants.AftersaleStatus.CANCEL)
|
));
|
|
|
return myPageResponse;
|
}
|
|
|
/**
|
* 订单自动取消
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void autoCancel(){
|
//查询订单数据
|
List<Goodsorder> goodsOrderList = goodsorderMapper.selectList(
|
new QueryWrapper<Goodsorder>()
|
.eq("STATUS",Constants.ZERO)
|
.in("TYPE",Constants.ZERO, Constants.ONE)
|
.apply(" now() >= SUBDATE(CREATE_DATE,interval - 15 minute) ")
|
);
|
if(!Objects.isNull(goodsOrderList)&&goodsOrderList.size()>Constants.ZERO){
|
goodsOrderList.forEach(i->{
|
this.cancelOrder(i.getId(),null,"超时未支付自动取消");
|
});
|
}
|
}
|
|
|
/**
|
* 订单自动确认
|
*/
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
public void autoAffirm(){
|
//查询订单数据
|
goodsorderMapper.update(null,new UpdateWrapper<Goodsorder>()
|
.set("DONE_INFO","发货15天后系统自动确认")
|
.set("STATUS",Constants.OrderStatus.DONE.getKey())
|
.set("DONE_DATE",new Date())
|
.eq("STATUS",Constants.OrderStatus.WAIT_RECEIVE.getKey())
|
.apply(" now() >= date_sub(CREATE_DATE,interval - 15 day) ")
|
);
|
}
|
|
@Override
|
public void resetOrderCodes(){
|
//加入redis缓存，刷新今天报名编号0开始
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.ACTIVITY_SIGN_KEY,0);
|
//加入redis缓存，刷新今天订单编号0开始
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.GOODSORDER_KEY,0);
|
//加入redis缓存，刷新今天售后编号0开始
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.AFTERSALE_KEY,0);
|
}
|
@Override
|
public void refreshOrderCodes(){
|
long countOrder = 0,countSign=0,countSale=0;
|
|
QueryWrapper<Goodsorder> order = new QueryWrapper<>();
|
order.apply(true, "TO_DAYS(NOW())=TO_DAYS(create_date)");
|
order.orderByDesc(" CODE ");
|
order.last(" limit 1 ");
|
Goodsorder maxOrder = goodsorderMapper.selectOne(order);
|
if(!Objects.isNull(maxOrder)){
|
countOrder = Integer.valueOf(maxOrder.getCode().toString().substring(8,12));
|
}
|
//加入redis缓存，刷新今天订单编号0开始
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.GOODSORDER_KEY,countOrder);
|
|
QueryWrapper<ActivitySign> sign = new QueryWrapper<>();
|
sign.apply(true, "TO_DAYS(NOW())=TO_DAYS(create_date)");
|
countSign = activitySignMapper.selectCount(sign);
|
//加入redis缓存，刷新今天报名编号0开始
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.ACTIVITY_SIGN_KEY,countSign);
|
|
QueryWrapper<Aftersale> sale = new QueryWrapper<>();
|
sale.apply(true, "TO_DAYS(NOW())=TO_DAYS(create_date)");
|
sale.orderByDesc(" CODE ");
|
sale.last(" limit 1 ");
|
Aftersale maxAfterOrder = aftersaleMapper.selectOne(sale);
|
if(!Objects.isNull(maxAfterOrder)){
|
countSale = Integer.valueOf(maxOrder.getCode().toString().substring(8,12));
|
}
|
//加入redis缓存，刷新今天售后编号0开始
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.AFTERSALE_KEY,countSale);
|
}
|
|
|
public synchronized Long getNextInCode(){
|
String prefix = DateUtil.getDate(new Date(),"yyyyMMdd") ;
|
Integer countNum = RedisUtil.getObject(redisTemplate, Constants.RedisKeys.GOODSORDER_KEY,Integer.class);
|
countNum = Constants.formatIntegerNum(countNum)+1;
|
//更新缓存
|
RedisUtil.addObject(redisTemplate,Constants.RedisKeys.GOODSORDER_KEY,countNum);
|
String nextIndex =Long.toString( countNum);
|
return Long.parseLong(prefix + StringUtils.leftPad(nextIndex,4,"0"));
|
}
|
|
|
|
/**
|
* 得到request对象
|
*
|
* @return
|
*/
|
public HttpServletRequest getRequest() {
|
HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
|
return request;
|
}
|
|
|
public String getIpAddr() {
|
HttpServletRequest request = this.getRequest();
|
String ipAddress = null;
|
try {
|
ipAddress = request.getHeader("x-forwarded-for");
|
if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
|
ipAddress = request.getHeader("Proxy-Client-IP");
|
}
|
if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
|
ipAddress = request.getHeader("WL-Proxy-Client-IP");
|
}
|
if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
|
ipAddress = request.getRemoteAddr();
|
if (ipAddress.equals("127.0.0.1")) {
|
// 根据网卡取本机配置的IP
|
InetAddress inet = null;
|
try {
|
inet = InetAddress.getLocalHost();
|
} catch (UnknownHostException e) {
|
e.printStackTrace();
|
}
|
ipAddress = inet.getHostAddress();
|
}
|
}
|
// 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
|
if (ipAddress != null && ipAddress.length() > 15) { // "***.***.***.***".length()
|
// = 15
|
if (ipAddress.indexOf(",") > 0) {
|
ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
|
}
|
}
|
} catch (Exception e) {
|
ipAddress = "127.0.0.1";
|
}
|
// ipAddress = this.getRequest().getRemoteAddr();
|
|
return ipAddress;
|
}
|
|
|
|
}
|
