Night-Fragrance/nightFragrance-massage/src/main/java/com/ylx/massage/service/impl/TOrderServiceImpl.java

package com.ylx.massage.service.impl;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ylx.common.config.WechatAccountConfig;
import com.ylx.common.constant.MassageConstants;
import com.ylx.common.core.domain.R;
import com.ylx.common.exception.ServiceException;
import com.ylx.massage.domain.*;
import com.ylx.massage.domain.vo.CouponReceiveVo;
import com.ylx.massage.domain.vo.HomeBlock;
import com.ylx.massage.domain.vo.OrderVerificationVo;
import com.ylx.massage.enums.BillTypeEnum;
import com.ylx.massage.enums.DiscountTypeEnum;
import com.ylx.massage.enums.JsStatusEnum;
import com.ylx.massage.enums.OrderStatusEnum;
import com.ylx.massage.mapper.TOrderMapper;
import com.ylx.massage.service.*;
import com.ylx.massage.utils.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.compress.utils.Lists;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;


/**
 * 订单表 服务实现类
 */
@Service
@Slf4j
public class TOrderServiceImpl extends ServiceImpl<TOrderMapper, TOrder> implements TOrderService {

    @Resource
    private TOrderMapper orderMapper;

    @Resource
    private WechatAccountConfig wxPayProperties;
    @Resource
    private LocationUtil locationUtil;

    @Resource
    private TWxUserService wxUserService;

    @Resource
    private TRechargeService rechargeService;

    @Resource
    private TXiangmuService xiangmuService;

    @Resource
    private OrderNumberGenerator generator;

    @Resource
    private TJsService jsService;

    @Resource
    private TAddressService addressService;

    @Resource
    private TConsumptionLogService consumptionLogService;

    @Resource
    private MassageUtil massageUtil;

    @Resource
    private CouponReceiveService couponReceiveService;

    @Resource
    private CouponService couponService;

    @Resource
    private WeChatUtil weChatUtil;

    @Resource
    private RefundVoucherService refundVoucherService;


    public Boolean isFree(TJs js, BigDecimal distance) {

        Date date = new Date();
        //白天免车费(07.30-20.00)
        long current = Long.parseLong(DateTimeUtils.numTime(date));
        if (current >= MassageConstants.START_FREE && current <= MassageConstants.END_FREE) {
            if (js.getDaytimeMileage().compareTo(distance) >= 0) {
                //免车费
                return Boolean.TRUE;
            } else {
                return Boolean.FALSE;
            }
        } else {
            //夜间免车费(20.00-07.30)
            if (js.getNigthMileage().compareTo(distance) >= 0) {
                //免车费
                return Boolean.TRUE;
            } else {
                return Boolean.FALSE;
            }
        }
    }

    /**
     * 添加订单
     *
     * @param order
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public TOrder addOrder(TOrder order) {

        if (StringUtils.isBlank(order.getcJsId())) {
            throw new ServiceException("请选择技师");
        }
        if (order.getcGoods().isEmpty()) {
            throw new ServiceException("请选择项目");
        }

        //优惠卷减免
//        List<CouponReceiveVo> coupons = couponReceiveService.getByOpenId(order.getcOpenId());
//        BigDecimal preferential = this.setCoupon(coupons);
//        order.setPreferential(preferential);

        order.setOrderNo(generator.generateNextOrderNumber(OrderNumberGenerator.KEY_PREFIX_ORDER));
        //订单价格
        List<TXiangmu> list = JSONObject.parseArray(order.getcGoods().toJSONString(), TXiangmu.class);
        BigDecimal sum = list.stream().map(TXiangmu::getSum).reduce(BigDecimal.ZERO, BigDecimal::add);
        order.setdTotalMoney(sum);

        //获取用户默认地址
        TAddress address = addressService.getByOpenId(order.getcOpenId());
        if (address == null) {
            throw new ServiceException("请先添加地址");
        }
        TJs js = jsService.getById(order.getcJsId());

        //添加位置信息
        locationUtil.geoAdd(LocationUtil.GEO_KEY_USER, js.getcOpenId() + order.getOrderNo(), Double.parseDouble(js.getLongitude().toString()), Double.parseDouble(js.getLatitude().toString()));
        locationUtil.geoAdd(LocationUtil.GEO_KEY_USER, order.getcOpenId() + order.getOrderNo(), Double.parseDouble(address.getLongitude().toString()), Double.parseDouble(address.getLatitude().toString()));
        double distance = locationUtil.getDistance(js.getcOpenId() + order.getOrderNo(), order.getcOpenId() + order.getOrderNo());
        locationUtil.remove(LocationUtil.GEO_KEY_USER, js.getcOpenId() + order.getOrderNo(), order.getcOpenId() + order.getOrderNo());
        order.setDistance(new BigDecimal(distance));
        //计算车费
        if (order.getDistance() != null && order.getDistance().compareTo(BigDecimal.ZERO) > 0) {
            //判断是否可以免车费
            if (!this.isFree(js, order.getDistance())) {
                BigDecimal bigDecimal = massageUtil.calculateTaxiFare(order.getDistance(), js.getDeptId());
                order.setFare(bigDecimal.setScale(MassageConstants.INTEGER_TWO, RoundingMode.HALF_UP));
            }
        }
        //总价 = 订单 + 车费 - 优惠
        order.setTotalPrice(sum.add(Optional.ofNullable(order.getFare()).orElse(BigDecimal.ZERO)));
        if (order.getParentNo() != null && order.getOrderType() == 2) {
            //升级订单 补差价
            TOrder partOrder = this.getByNo(order.getParentNo());
            order.setPriceDifference(order.getTotalPrice().subtract(partOrder.getTotalPrice()));
        }

        order.setAddress(address.getAddress());
        order.setName(address.getName());
        order.setLatitude(address.getLatitude());
        order.setLongitude(address.getLongitude());
        order.setcPhone(address.getPhone());
        order.setcName(address.getUserName());
        order.setAtlasAdd(address.getAtlasAdd());
        order.setDeptId(js.getDeptId());
        order.setDeptName(js.getCity());
        order.setnStatus(OrderStatusEnum.WAIT_PAY.getCode());
        order.setDtCreateTime(LocalDateTime.now());
        Date date = DateTimeUtils.addMinute(new Date(), 10);
        order.setcTime(DateTimeUtils.formatDate(date, "yyyy-MM-dd HH:mm:ss"));
        save(order);
        return order;
    }

    private BigDecimal setCoupon(List<CouponReceiveVo> coupons) {
        //过滤过期的优惠券
        coupons = coupons.stream().filter(coupon -> coupon.getExpirationTime().after(new Date())).collect(Collectors.toList());
        //无门槛优惠券
        List<CouponReceiveVo> collect = coupons.stream().filter(coupon -> coupon.getDiscountType().equals(DiscountTypeEnum.NO_THRESHOLD.getCode())).collect(Collectors.toList());
        //支付成功 后 删除优惠卷
//        couponReceiveService.removeCoupons(collect);
        //计算优惠金额
        return collect.stream().map(CouponReceiveVo::getDiscountValue).reduce(BigDecimal.ZERO, BigDecimal::add);
    }


    @Override
    public void payNotifyOrder(String outTradeNo) {
        //查询未支付的订单
        LambdaQueryWrapper<TOrder> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TOrder::getOrderNo, outTradeNo).eq(TOrder::getnStatus, OrderStatusEnum.WAIT_PAY.getCode());
        TOrder orderNew = this.getOne(queryWrapper);
        if (orderNew == null) {
            log.error("订单 {} 未支付状态不存在", outTradeNo);
            return;
        }
        orderNew.setPayType(1);
        TWxUser user = wxUserService.getByOpenId(orderNew.getcOpenId());
        orderPayManage(user, orderNew);
    }

    @Override
    public Object updateAddressById(TOrder borrow) {
        TOrder order = this.getById(borrow.getcId());
        if (borrow.getLatitude() != null && borrow.getLatitude() != 0 && borrow.getLongitude() != null && borrow.getLongitude() != 0) {
            order.setAtlasAdd(borrow.getAtlasAdd());
            order.setcName(borrow.getcName());
            order.setcPhone(borrow.getcPhone());
            order.setName(borrow.getName());
            order.setAddress(borrow.getAddress());
            order.setLatitude(borrow.getLatitude());
            order.setLongitude(borrow.getLongitude());
            TJs js = jsService.getById(order.getcJsId());
            //添加位置信息
            locationUtil.geoAdd(LocationUtil.GEO_KEY_USER, js.getcOpenId() + order.getOrderNo(), Double.parseDouble(js.getLongitude().toString()), Double.parseDouble(js.getLatitude().toString()));
            locationUtil.geoAdd(LocationUtil.GEO_KEY_USER, order.getcOpenId() + order.getOrderNo(), Double.parseDouble(borrow.getLongitude().toString()), Double.parseDouble(borrow.getLatitude().toString()));
            double distance = locationUtil.getDistance(js.getcOpenId() + order.getOrderNo(), order.getcOpenId() + order.getOrderNo());
            locationUtil.remove(LocationUtil.GEO_KEY_USER, js.getcOpenId() + order.getOrderNo(), order.getcOpenId() + order.getOrderNo());
            order.setDistance(new BigDecimal(distance));
            //计算车费
            if (order.getDistance() != null && order.getDistance().compareTo(BigDecimal.ZERO) > 0) {
                //判断是否可以免车费
                if (!this.isFree(js, order.getDistance())) {
                    BigDecimal bigDecimal = massageUtil.calculateTaxiFare(order.getDistance(), order.getDeptId());
                    order.setFare(bigDecimal.setScale(MassageConstants.INTEGER_TWO, RoundingMode.HALF_UP));
                }
            }
            order.setTotalPrice(order.getdTotalMoney().add(Optional.ofNullable(order.getFare()).orElse(BigDecimal.ZERO)));
            this.updateById(order);
        }
        return order;
    }

    @Override
    public Object depart(TOrder order) {

        LambdaQueryWrapper<TOrder> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(TOrder::getcId, order.getcId()).eq(TOrder::getnStatus, OrderStatusEnum.RECEIVED_ORDER.getCode());
        order.setnStatus(OrderStatusEnum.DEPART.getCode());
        order.setDepartTime(new Date());
        order.setDepartLatitude(Optional.ofNullable(order.getDepartLatitude()).orElse(BigDecimal.ZERO));
        order.setDepartLongitude(Optional.ofNullable(order.getDepartLongitude()).orElse(BigDecimal.ZERO));
        return this.update(order, wrapper);
    }

    @Override
    public Integer getOrderNum(String jsid, Date startDate, Date endDate) {
        return orderMapper.getOrderNum(jsid, startDate, endDate);
    }

    @Override
    public Integer getAddNum(String jsid, Date startDate, Date endDate) {
        return orderMapper.getAddNum(jsid, startDate, endDate);
    }

    @Override
    public Integer getUpgradeNum(String jsid, Date startDate, Date endDate) {
        return orderMapper.getUpgradeNum(jsid, startDate, endDate);
    }

    @Override
    public BigDecimal getTurnover(String jsid, Date startDate, Date endDate) {
        return orderMapper.getTurnover(jsid, startDate, endDate);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public TOrder transferOrder(TOrder order) {
        if (StringUtils.isBlank(order.getcId())) {
            throw new ServiceException("订单id不能为空");
        }
        if (StringUtils.isBlank(order.getcJsId())) {
            throw new ServiceException("转单技师ID不能为空");
        }
        TOrder oldOrder = this.getById(order.getcId());

        oldOrder.setOldJsId(oldOrder.getcJsId());
        oldOrder.setcJsId(order.getcJsId());
        log.info("新技师:{},老技师{}", oldOrder.getcJsId(), oldOrder.getOldJsId());
        if (!this.updateById(oldOrder)) {
            throw new ServiceException("转单失败");
        }
        //改变新技师服务状态
        TJs tJs = new TJs();
        tJs.setId(oldOrder.getcJsId());
        tJs.setnStatus(JsStatusEnum.JS_SERVICE.getCode());
        jsService.updateById(tJs);
        //改变旧技师服务状态
        TJs oldTJs = new TJs();
        oldTJs.setId(oldOrder.getOldJsId());
        oldTJs.setnStatus(JsStatusEnum.JS_SERVICEABLE.getCode());
        jsService.updateById(oldTJs);

        //通知技师转单
        this.newOrderNotification(oldOrder);
        return oldOrder;
    }

    @Override
    public List<HomeBlock> getBlock(Date start, Date end, String deptId) {
        return orderMapper.getBlock(start, end, deptId);

    }

    @Override
    public OrderVerificationVo verification(TOrder order) {
        if (StringUtils.isBlank(order.getCouponReceiveId())) {
            throw new ServiceException("认领优惠券id为空");
        }
        if (StringUtils.isBlank(order.getcId())) {
            throw new ServiceException("订单id为空");
        }
        OrderVerificationVo orderVerificationVo = new OrderVerificationVo();
        TOrder tOrder = this.getById(order.getcId());
        orderVerificationVo.setCouponReceiveId(order.getCouponReceiveId());
        CouponReceive couponReceive = couponReceiveService.getById(order.getCouponReceiveId());
        Coupon coupon = couponService.getById(couponReceive.getCouponId());
        log.info("订单信息,{}", tOrder);
        log.info("优惠卷信息,{}", coupon);


        //折扣券
        if (coupon.getDiscountType() == 2) {
            //判断门槛金额
            if (tOrder.getTotalPrice().compareTo(coupon.getThresholdAmount()) >= 0) {
                //折扣值
                BigDecimal divide = coupon.getRebValue().divide(new BigDecimal(10));
                //优惠后的金额 = 订单总金额*折扣值
                BigDecimal bigDecimal = tOrder.getTotalPrice().multiply(divide).setScale(MassageConstants.INTEGER_TWO, RoundingMode.HALF_UP);
                //优惠值
                orderVerificationVo.setPreferential(tOrder.getTotalPrice().subtract(bigDecimal));
                orderVerificationVo.setTotalPrice(bigDecimal);
            } else {
                throw new ServiceException("不满足优惠券门槛金额");
            }
        } else {
            if (tOrder.getTotalPrice().compareTo(coupon.getThresholdAmount()) >= 0) {
                //优惠值
                orderVerificationVo.setPreferential(coupon.getDiscountValue());
                orderVerificationVo.setTotalPrice(tOrder.getTotalPrice().subtract(coupon.getDiscountValue()));
            } else {
                throw new ServiceException("不满足优惠券门槛金额");
            }
        }
        if (orderVerificationVo.getTotalPrice().compareTo(BigDecimal.ZERO) < 0) {
            throw new ServiceException("当前项目不可用");
        }
        return orderVerificationVo;
    }

    private TOrder getOrder(TOrder tOrder) {
        if (updateById(tOrder)) {
            return tOrder;
        } else {
            throw new ServiceException("优惠券核销失败");
        }
    }


    /**
     * 支付订单
     *
     * @param order
     */
    @Override
    public R payOrder(TOrder order) throws Exception {
        // 根据orderid查询订单信息
        TOrder orderNew = getById(order.getcId());
        if (!orderNew.getnStatus().equals(OrderStatusEnum.WAIT_PAY.getCode())) {
            throw new ServiceException("该订单已经支付或者超时被取消");
        }
        TJs js = jsService.getById(orderNew.getcJsId());
        if (StringUtils.isBlank(orderNew.getParentNo())) {

            if (null == js || js.getnStatus().equals(JsStatusEnum.JS_SERVICE.getCode())) {
                throw new ServiceException("该技师已在服务中请重新下单");
            }
        }

        orderNew.setPayType(order.getPayType());
        //优惠券核销
        if (StringUtils.isNotBlank(order.getCouponReceiveId())) {
            orderNew.setCouponReceiveId(order.getCouponReceiveId());
            orderNew.setPreferential(order.getPreferential());
            orderNew.setTotalPrice(order.getTotalPrice());
            if (!updateById(orderNew)) {
                throw new ServiceException("支付失败");
            }
        }
        //判断支付方式
        if (order.getPayType().equals(MassageConstants.INTEGER_ONE)) {
            //微信支付
            R resp = rechargeService.getPay(orderNew.getOrderNo(), orderNew.getTotalPrice(), orderNew.getcOpenId(), BillTypeEnum.WX_PAY.getInfo(), BillTypeEnum.WX_PAY.getCode().toString());
            return resp;
        }



        // 从对应账户扣款
        TWxUser user = wxUserService.getByOpenId(orderNew.getcOpenId());
        if (null == user) {
            throw new ServiceException("用户不存在");
        }
        //判断支付方式
        if (order.getPayType().equals(MassageConstants.INTEGER_THREE)) {
            //现金支付
            orderPayManage(user, orderNew);
            return R.ok();
        }
        if (user.getdBalance().compareTo(orderNew.getTotalPrice()) < MassageConstants.INTEGER_ZERO) {
            throw new ServiceException("账户金额不够请充值");
        } else {
            orderPayManage(user, orderNew);
            return R.ok();
        }
    }


    public void newOrderNotification(TOrder order) {

        cn.hutool.json.JSONObject param = JSONUtil.createObj();
        //订单号
        param.set("character_string9", JSONUtil.createObj().set("value", order.getOrderNo()));
        //电话
        param.set("phone_number14", JSONUtil.createObj().set("value", order.getcPhone()));
        param.set("thing18", JSONUtil.createObj().set("value", order.getcName()));
        param.set("time6", JSONUtil.createObj().set("value", DateTimeUtils.formatDate(new Date(), DateTimeUtils.DATE_NUMBER_YEAR_MONTH_FORMAT)));
        param.set("thing27", JSONUtil.createObj().set("value", order.getName()));
        TJs js = jsService.getById(order.getcJsId());
        weChatUtil.notification(js.getcOpenId(), wxPayProperties.getTemplateId1(), param);

    }

    @Transactional(rollbackFor = Exception.class)
    public void orderPayManage(TWxUser user, TOrder orderNew) {
        //更新优惠卷状态
        if (StringUtils.isNotBlank(orderNew.getCouponReceiveId())) {
            CouponReceive couponReceive = new CouponReceive();
            couponReceive.setId(orderNew.getCouponReceiveId());
            couponReceive.setUseState(MassageConstants.INTEGER_TWO);
            if (!couponReceiveService.updateById(couponReceive)) {
                log.error("优惠券状态更新失败id:,{}", orderNew.getCouponReceiveId());
            }
        }

        // 更新用户金额 及下单此时
        TWxUser paramUser = new TWxUser();
        paramUser.setcOpenid(user.getcOpenid());
        if (orderNew.getPayType().equals(MassageConstants.INTEGER_TWO)) {
            paramUser.setdBalance(user.getdBalance().subtract(orderNew.getTotalPrice()));
        }
        paramUser.setdMoney(user.getdMoney().add(orderNew.getTotalPrice()));
        paramUser.setnNum(user.getnNum() + MassageConstants.INTEGER_ONE);
        paramUser.setId(user.getId());
        wxUserService.updateById(paramUser);
        //增加消费记录
        TConsumptionLog tConsumptionLog = new TConsumptionLog();
        tConsumptionLog.setAmount(orderNew.getTotalPrice().negate());
        tConsumptionLog.setBillNo(orderNew.getOrderNo());
        tConsumptionLog.setOpenId(orderNew.getcOpenId());
        if (orderNew.getPayType().equals(MassageConstants.INTEGER_TWO)) {
            tConsumptionLog.setBillType(BillTypeEnum.BALANCE_PAYMENT.getCode());
            tConsumptionLog.setNote("余额支付");
        } else if(orderNew.getPayType().equals(MassageConstants.INTEGER_ONE)){
            tConsumptionLog.setBillType(BillTypeEnum.WX_PAY.getCode());
            tConsumptionLog.setNote("微信支付");
        } else {
            tConsumptionLog.setBillType(BillTypeEnum.CASH_PAYMENT.getCode());
            tConsumptionLog.setNote("现金支付");
        }

        consumptionLogService.save(tConsumptionLog);
        // 更新项目数据
        JSONArray objects = orderNew.getcGoods();
        objects.forEach(item -> {
            UpdateWrapper<TXiangmu> wrapper = new UpdateWrapper<>();
            // 获取参数
            wrapper.lambda().eq(TXiangmu::getcId, ((JSONObject) item).getString("cId"));
            // 设置数量
            wrapper.setSql(" n_sale_number = n_sale_number + " + ((JSONObject) item).getInteger("number"));
            xiangmuService.update(wrapper);
        });
        TOrder orderParam = new TOrder();
        orderParam.setPayType(orderNew.getPayType());
        orderParam.setcId(orderNew.getcId());
        orderParam.setnStatus(OrderStatusEnum.WAIT_JD.getCode());
        orderParam.setPayTime(new Date());
        //加钟的订单支付完直接服务中
        if (StringUtils.isNotBlank(orderNew.getParentNo())) {
            orderParam.setnStatus(OrderStatusEnum.SERVICE.getCode());
        }
//            orderParam.setnStatus(OrderStatusEnum.SERVICE.getCode());
        //更新及技师状态
        updateJs(orderNew);
        updateById(orderParam);
        this.newOrderNotification(orderNew);
        //电话通知
        TJs js = jsService.getById(orderNew.getcJsId());
        Sendvoice.sendPhone(js.getcPhone());
    }

    /**
     * 拒绝订单
     *
     * @param order
     */
    @Override
    public Boolean jujue(TOrder order) {

        TOrder orderNew = getById(order.getcId());

        TWxUser user = wxUserService.getByOpenId(orderNew.getcOpenId());
        // 更新用户金额 及下单此时
        TWxUser paramUser = new TWxUser();
        paramUser.setcOpenid(user.getcOpenid());
        paramUser.setId(user.getId());
        // 余额记录
        TConsumptionLog tConsumptionLog = new TConsumptionLog();
        tConsumptionLog.setAmount(orderNew.getTotalPrice());
        tConsumptionLog.setBillNo(orderNew.getOrderNo());
        tConsumptionLog.setOpenId(orderNew.getcOpenId());
        if (orderNew.getPayType() == 2) {
            // 金额归还对应账户
            paramUser.setdBalance(user.getdBalance().add(orderNew.getTotalPrice()));
            tConsumptionLog.setBillType(BillTypeEnum.REFUSE_ACCEPT_REFUND.getCode());
            tConsumptionLog.setNote("拒绝接单退款到余额");

        } else {
            // 微信支付
            // 生成退款单退款
            RefundVoucher refundVoucher = new RefundVoucher();
            refundVoucher.setRefundNo(generator.generateNextOrderNumber(OrderNumberGenerator.KEY_PREFIX_REFUND));
            refundVoucher.setOrderNo(orderNew.getOrderNo());
            refundVoucher.setMoney(orderNew.getTotalPrice());
            refundVoucher.setOpenId(orderNew.getcOpenId());
            refundVoucher.setReStatus(MassageConstants.INTEGER_ZERO);
            refundVoucher.setReason("技师拒绝接单");
            refundVoucherService.save(refundVoucher);
            tConsumptionLog.setBillType(BillTypeEnum.REFUSE_ACCEPT_REFUND.getCode());
            tConsumptionLog.setNote("拒绝接单退款到余额");
            // 微信退款原路返回
            rechargeService.refund(refundVoucher.getRefundNo(), null, orderNew.getOrderNo(), orderNew.getTotalPrice());
        }
        consumptionLogService.save(tConsumptionLog);
        //退优惠卷
        if (StringUtils.isNotBlank(orderNew.getCouponReceiveId())) {
            CouponReceive couponReceive = couponReceiveService.getById(orderNew.getCouponReceiveId());
            couponReceive.setUseState(MassageConstants.INTEGER_ZERO);
            couponReceiveService.updateById(couponReceive);
        }
        log.info("余额支付退款user:{}", user);

        // 消费金额对应减少
        paramUser.setdMoney(user.getdMoney().subtract(orderNew.getTotalPrice()));
        // 下单次数减一
        paramUser.setnNum(user.getnNum() - MassageConstants.INTEGER_ONE);
        wxUserService.updateById(paramUser);

        // 更新项目数据
        JSONArray objects = orderNew.getcGoods();
        objects.forEach(item -> {
            UpdateWrapper<TXiangmu> wrapper = new UpdateWrapper<>();
            // 获取参数
            wrapper.lambda().eq(TXiangmu::getcId, ((JSONObject) item).getString("cId"));
            // 设置数量
            wrapper.setSql(" n_sale_number = n_sale_number - " + ((JSONObject) item).getInteger("number"));
            xiangmuService.update(wrapper);
        });
        TOrder orderParam = new TOrder();
        orderParam.setcId(orderNew.getcId());
        orderParam.setnStatus(OrderStatusEnum.REFUSE.getCode());
        orderParam.setReasonRefusal(order.getReasonRefusal());
        updateJs(orderNew);
        return updateById(orderParam);
    }

    /**
     * 确认服务完成
     *
     * @param order
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean confirm(TOrder order) {

        // 获取订单信息
        TOrder orderNew = getById(order);
        if (!orderNew.getnStatus().equals(OrderStatusEnum.SERVICE.getCode())) {
            throw new ServiceException("订单状态不是服务中");
        }
        // 更新技师信息
        TJs jsParam = new TJs();
        jsParam.setId(orderNew.getcJsId());
        jsParam.setnStatus(JsStatusEnum.JS_SERVICEABLE.getCode());
        //判断热度标识
        List<TOrder> list = list(new LambdaQueryWrapper<TOrder>().eq(TOrder::getcJsId, orderNew.getcJsId())
                .ge(TOrder::getDtCreateTime, DateTimeUtils.addDays(new Date(), -3))
                .ge(TOrder::getnStatus, OrderStatusEnum.WAIT_EVALUATE.getCode()));
        if (list.size() >= 2) {
            jsParam.setnB3(MassageConstants.INTEGER_ONE);
        }
        // 更新技师状态
        jsService.updateById(jsParam);
        // 更新技师钱包金额
        TJs jsById = jsService.getById(orderNew.getcJsId());
        // 获取技师抽成
        BigDecimal multiply = orderNew.getTotalPrice().multiply(new BigDecimal(jsById.getnBili()));
        multiply = multiply.divide(new BigDecimal(100), MassageConstants.INTEGER_TWO, RoundingMode.HALF_UP);
        // 获取技师所对应的用户
        TWxUser jsUser = wxUserService.getByOpenId(jsById.getcOpenId());
        // 更新余额
        jsUser.setdBalance(jsUser.getdBalance().add(multiply));
        // 更新总钱数
        jsUser.setdAllMoney(jsUser.getdAllMoney().add(multiply));
        wxUserService.updateById(jsUser);

        //增加消费记录
        TConsumptionLog tConsumptionLog = new TConsumptionLog();
        tConsumptionLog.setAmount(multiply);
        tConsumptionLog.setBillNo(orderNew.getOrderNo());
        tConsumptionLog.setOpenId(jsUser.getcOpenid());
        tConsumptionLog.setBillType(BillTypeEnum.INCOME.getCode());
        tConsumptionLog.setNote("技师收益");
        consumptionLogService.save(tConsumptionLog);

        // 如果该技师有推荐人员 一级
        if (StringUtils.isNotBlank(jsUser.getcUpUser())) {
            // 获取技师上级对应的用户
            TWxUser jsUp = wxUserService.getByOpenId(jsUser.getcUpUser());
            extracted(orderNew, jsUp);
            //二级
            if (StringUtils.isNotBlank(jsUp.getcUpUser())) {
                TWxUser jsUpTwo = wxUserService.getByOpenId(jsUp.getcUpUser());
                extracted(orderNew, jsUpTwo);
                //三级
                if (StringUtils.isNotBlank(jsUpTwo.getcUpUser())) {
                    TWxUser jsUpThree = wxUserService.getByOpenId(jsUpTwo.getcUpUser());
                    extracted(orderNew, jsUpThree);
                }
            }
        }
        // 更新订单
        orderNew.setnStatus(OrderStatusEnum.WAIT_EVALUATE.getCode());
        orderNew.setEndTime(LocalDateTime.now());
        return updateById(orderNew);
    }

    private void extracted(TOrder orderNew, TWxUser jsUp) {
        log.info("TOrderServiceImpl->extracted->jsUp,{}", JSONUtil.toJsonStr(jsUp));
        log.info("TOrderServiceImpl->extracted->orderNew,{}",JSONUtil.toJsonStr(orderNew));
        BigDecimal up = orderNew.getdTotalMoney().multiply(new BigDecimal("10"));
        up = up.divide(new BigDecimal(100), 2, RoundingMode.HALF_UP);
        // 更新余额
        jsUp.setdBalance(jsUp.getdBalance().add(up));
        // 更新总钱数
        jsUp.setdAllMoney(jsUp.getdAllMoney().add(up));
        jsUp.setDistributionAmount(up);
        wxUserService.updateById(jsUp);

        //记录分销收益
        TConsumptionLog tConsumptionLog = new TConsumptionLog();
        tConsumptionLog.setAmount(up);
        tConsumptionLog.setBillNo(orderNew.getOrderNo());
        tConsumptionLog.setOpenId(jsUp.getcOpenid());
        tConsumptionLog.setBillType(BillTypeEnum.DISTRIBUTION.getCode());
        tConsumptionLog.setNote("分销收益");
        consumptionLogService.save(tConsumptionLog);
    }

    /**
     * 取消订单
     *
     * @param order
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean cancle(TOrder order) {
        // 获取订单信息
        // 根据orderid查询订单信息
        TOrder orderNew = getById(order.getcId());
        //待接单
        if (Objects.equals(orderNew.getnStatus(), OrderStatusEnum.WAIT_JD.getCode())) {
            TWxUser user = wxUserService.getByOpenId(orderNew.getcOpenId());
            // 更新用户金额 及下单此时
            TWxUser paramUser = new TWxUser();
            paramUser.setId(user.getId());
            paramUser.setcOpenid(user.getcOpenid());

            TConsumptionLog tConsumptionLog = new TConsumptionLog();
            tConsumptionLog.setAmount(orderNew.getTotalPrice());
            tConsumptionLog.setBillNo(orderNew.getOrderNo());
            tConsumptionLog.setOpenId(orderNew.getcOpenId());
            if (orderNew.getPayType() == 2) {
                // 金额归还对应账户
                paramUser.setdBalance(user.getdBalance().add(orderNew.getTotalPrice()));
                // 余额记录
                tConsumptionLog.setBillType(BillTypeEnum.CANCEL_ACCEPT_REFUND.getCode());
                tConsumptionLog.setNote("取消订单退款到余额");
                //自己取消的不退优惠卷
            } else {
                // 微信支付
                // 生成退款单退款
                RefundVoucher refundVoucher = new RefundVoucher();
                refundVoucher.setRefundNo(generator.generateNextOrderNumber(OrderNumberGenerator.KEY_PREFIX_REFUND));
                refundVoucher.setOrderNo(orderNew.getOrderNo());
                refundVoucher.setMoney(orderNew.getTotalPrice());
                refundVoucher.setOpenId(orderNew.getcOpenId());
                refundVoucher.setReStatus(MassageConstants.INTEGER_ZERO);
                refundVoucher.setReason("技师拒绝接单");
                refundVoucherService.save(refundVoucher);
                tConsumptionLog.setBillType(BillTypeEnum.CANCEL_WX_REFUND.getCode());
                tConsumptionLog.setNote("取消订单退款到微信");
                // 微信退款原路返回
                rechargeService.refund(refundVoucher.getRefundNo(), null, orderNew.getOrderNo(), orderNew.getTotalPrice());
            }
            consumptionLogService.save(tConsumptionLog);
            // 消费金额对应减少
            paramUser.setdMoney(user.getdMoney().subtract(orderNew.getTotalPrice()));
            // 下单次数减一
            paramUser.setnNum(user.getnNum() - MassageConstants.INTEGER_ONE);
            wxUserService.updateById(paramUser);

            // 更新项目数据
            JSONArray objects = orderNew.getcGoods();
            objects.forEach(item -> {
                UpdateWrapper<TXiangmu> wrapper = new UpdateWrapper<>();
                // 获取参数
                wrapper.lambda().eq(TXiangmu::getcId, ((JSONObject) item).getString("cId"));
                // 设置数量
                wrapper.setSql(" n_sale_number = n_sale_number - " + ((JSONObject) item).getInteger("number"));
                xiangmuService.update(wrapper);
            });
            TOrder orderParam = new TOrder();
            orderParam.setcId(orderNew.getcId());
            orderParam.setnStatus(OrderStatusEnum.CANCEL.getCode());
            //更新技师状态
            TJs tJs = new TJs();
            tJs.setId(orderNew.getcJsId());
            tJs.setnStatus(JsStatusEnum.JS_SERVICEABLE.getCode());
            jsService.updateById(tJs);
            return updateById(orderParam);

        } else if (Objects.equals(orderNew.getnStatus(), OrderStatusEnum.WAIT_PAY.getCode())) {
            //待付款
            TOrder orderParam = new TOrder();
            orderParam.setcId(orderNew.getcId());
            orderParam.setnStatus(OrderStatusEnum.CANCEL.getCode());
            return updateById(orderParam);
        } else {
            return false;
        }


    }

    @Override
    public TOrder getByNo(String orderNo) {
        LambdaQueryWrapper<TOrder> objectLambdaQueryWrapper = new LambdaQueryWrapper<>();
        return this.getOne(objectLambdaQueryWrapper.eq(TOrder::getOrderNo, orderNo));
    }

//    private TOrder gettOrder(TOrder order) {
//        LambdaUpdateWrapper<TOrder> objectLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
//        objectLambdaUpdateWrapper.eq(TOrder::getOrderNo, order.getOrderNo());
//        return this.getOne(objectLambdaUpdateWrapper);
//    }


    @Override
    public Page<TOrder> getAll(Page<TOrder> page, TOrder param) {
        Page<TOrder> orderPage = orderMapper.getAll(page, param);
        if (orderPage != null && CollectionUtil.isNotEmpty(orderPage.getRecords())) {

            ArrayList<TOrder> orders = Lists.newArrayList();
            orderPage.getRecords().forEach(order -> {
                order.setStatusName(OrderStatusEnum.getDescByCode(order.getnStatus()));
                order.setJsPhone(order.getJs().getcPhone());
                order.setJsName(order.getJs().getcName());
                if (StringUtils.isEmpty(order.getcTime())) {
                    order.setRemainingTime(0L);
                }
                if (StringUtils.isNotBlank(order.getcTime()) && DateTimeUtils.dateStringToStamp(order.getcTime()) > DateTimeUtils.dateToStamp(new Date())) {
                    order.setRemainingTime((DateTimeUtils.dateStringToStamp(order.getcTime()) - DateTimeUtils.dateToStamp(new Date())) / 1000);
                }
                if (StringUtils.isNotBlank(order.getcTime()) && DateTimeUtils.dateStringToStamp(order.getcTime()) < DateTimeUtils.dateToStamp(new Date())) {
                    order.setRemainingTime(0L);
                }
                if (StringUtils.isNotBlank(order.getOldJsId())) {
                    order.setOldJs(jsService.getById(order.getOldJsId()));
                }
                orders.add(order);

            });
            orderPage.setRecords(orders);
        }
        return orderPage;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void takingOrders(TOrder order) {
        if (order == null || StringUtils.isBlank(order.getcId())) {
            throw new IllegalArgumentException("订单对象不能为空");
        }

        TOrder orderNew = this.getById(order);

        // 检查订单对应的技师是否存在
//        updateJs (orderNew);
        // 更新订单状态
        TOrder orderParam = new TOrder();
        orderParam.setcId(order.getcId());
        orderParam.setnStatus(OrderStatusEnum.RECEIVED_ORDER.getCode());
        orderParam.setAcceptanceTime(LocalDateTime.now());
        this.updateById(orderParam);
    }

    private void updateJs(TOrder orderNew) {
        TJs js = jsService.getById(orderNew.getcJsId());
        if (js == null) {
            throw new IllegalStateException("无法找到对应的技师");
        }

        if (Objects.equals(js.getnStatus(), JsStatusEnum.JS_SERVICEABLE.getCode())) {
            // 更新技师状态
            js.setnStatus(JsStatusEnum.JS_SERVICE.getCode());
            // 确保js.getnNum()不为null，避免 NullPointerException
            int num = js.getnNum() == null ? 0 : js.getnNum();
            js.setnNum(num + MassageConstants.INTEGER_ONE);
        } else {
            // 更新技师状态
            js.setnStatus(JsStatusEnum.JS_SERVICEABLE.getCode());
            // 确保js.getnNum()不为null，避免 NullPointerException
            int num = js.getnNum() == null ? 0 : js.getnNum();
            js.setnNum(num - MassageConstants.INTEGER_ONE);
        }
        jsService.updateById(js);
    }

}