zsElectric-boot/src/main/java/com/zsElectric/boot/business/service/impl/ChargeOrderInfoServiceImpl.java

package com.zsElectric.boot.business.service.impl;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Assert;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.zsElectric.boot.business.converter.ChargeOrderInfoConverter;
import com.zsElectric.boot.business.mapper.*;
import com.zsElectric.boot.business.model.dto.ChargeOrderInfoExportDTO;
import com.zsElectric.boot.business.model.entity.*;
import com.zsElectric.boot.business.model.form.ChargeOrderInfoForm;
import com.zsElectric.boot.business.model.form.applet.AppInvokeChargeForm;
import com.zsElectric.boot.business.model.form.applet.AppStopChargeForm;
import com.zsElectric.boot.business.model.query.ChargeOrderInfoQuery;
import com.zsElectric.boot.business.model.query.applet.AppChargeOrderInfoQuery;
import com.zsElectric.boot.business.model.vo.ChargeOrderInfoVO;
import com.zsElectric.boot.business.model.vo.applet.AppChargeVO;
import com.zsElectric.boot.business.model.vo.applet.AppUserInfoVO;
import com.zsElectric.boot.business.service.AppletHomeService;
import com.zsElectric.boot.business.service.ChargeOrderInfoService;
import com.zsElectric.boot.business.service.UserAccountService;
import com.zsElectric.boot.charging.dto.StartChargingRequestDTO;
import com.zsElectric.boot.charging.dto.StartChargingResponseVO;
import com.zsElectric.boot.charging.service.ChargingBusinessService;
import com.zsElectric.boot.charging.vo.EquipmentAuthResponseVO;
import com.zsElectric.boot.charging.vo.StopChargingOperationResponseVO;
import com.zsElectric.boot.common.constant.ConnectivityConstants;
import com.zsElectric.boot.common.constant.SystemConstants;
import com.zsElectric.boot.core.exception.BusinessException;
import com.zsElectric.boot.security.util.SecurityUtils;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Objects;

/**
 * 充电订单信息服务实现类
 *
 * @author zsElectric
 * @since 2025-12-17 19:13
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class ChargeOrderInfoServiceImpl extends ServiceImpl<ChargeOrderInfoMapper, ChargeOrderInfo> implements ChargeOrderInfoService {

    private final ChargeOrderInfoConverter chargeOrderInfoConverter;

    private final ChargingBusinessService chargingBusinessService;

    private final UserInfoMapper userInfoMapper;

    private final FirmInfoMapper firmInfoMapper;

    private final CouponMapper couponMapper;

    private final CouponTemplateMapper couponTemplateMapper;

    private final UserAccountService userAccountService;

    private final AppletHomeService appletHomeService;

    private final UserFirmMapper userFirmMapper;

    //充电订单号前缀
    private final String ORDER_NO_PREFIX = "CD";
    //设备流水号前缀
    private final String EQUIPMENT_NO_PREFIX = "SB";

    /**
    * 获取充电订单信息分页列表
    *
    * @param queryParams 查询参数
    * @return {@link IPage <ChargeOrderInfoVO>} 充电订单信息分页列表
    */
    @Override
    public IPage<ChargeOrderInfoVO> getChargeOrderInfoPage(ChargeOrderInfoQuery queryParams) {
        Page<ChargeOrderInfoVO> pageVO = this.baseMapper.getChargeOrderInfoPage(
                new Page<>(queryParams.getPageNum(), queryParams.getPageSize()),
                queryParams
        );
        return pageVO;
    }
    
    /**
     * 获取充电订单信息表单数据
     *
     * @param id 充电订单信息ID
     * @return 充电订单信息表单数据
     */
    @Override
    public ChargeOrderInfoForm getChargeOrderInfoFormData(Long id) {
        ChargeOrderInfo entity = this.getById(id);
        return chargeOrderInfoConverter.toForm(entity);
    }
    
    /**
     * 新增充电订单信息
     *
     * @param formData 充电订单信息表单对象
     * @return 是否新增成功
     */
    @Override
    public boolean saveChargeOrderInfo(ChargeOrderInfoForm formData) {
        ChargeOrderInfo entity = chargeOrderInfoConverter.toEntity(formData);
        return this.save(entity);
    }
    
    /**
     * 更新充电订单信息
     *
     * @param id   充电订单信息ID
     * @param formData 充电订单信息表单对象
     * @return 是否修改成功
     */
    @Override
    public boolean updateChargeOrderInfo(Long id,ChargeOrderInfoForm formData) {
        ChargeOrderInfo entity = chargeOrderInfoConverter.toEntity(formData);
        return this.updateById(entity);
    }
    
    /**
     * 删除充电订单信息
     *
     * @param ids 充电订单信息ID，多个以英文逗号(,)分割
     * @return 是否删除成功
     */
    @Override
    public boolean deleteChargeOrderInfos(String ids) {
        Assert.isTrue(StrUtil.isNotBlank(ids), "删除的充电订单信息数据为空");
        // 逻辑删除
        List<Long> idList = Arrays.stream(ids.split(","))
                .map(Long::parseLong)
                .toList();
        return this.removeByIds(idList);
    }

    @Override
    public IPage<ChargeOrderInfoVO> getPage(AppChargeOrderInfoQuery queryParams) {
        queryParams.setUserId(SecurityUtils.getUserId());

        Page<ChargeOrderInfoVO> pageVO = this.baseMapper.getPage(
                new Page<>(queryParams.getPageNum(), queryParams.getPageSize()),
                queryParams
        );
        return pageVO;
    }

    @Override
    public AppChargeVO invokeCharge(AppInvokeChargeForm formData) {

        log.info("启动充电开始,用户ID:{},设备认证流水号:{},充电桩编号:{}", SecurityUtils.getUserId(), formData.getEquipAuthSeq(), formData.getEquipmentId());

        try {
            AppChargeVO appInvokeChargeVO = new AppChargeVO();

            //渠道方启动充电
            if (Objects.equals(formData.getOrderType(), SystemConstants.CHARGE_ORDER_TYPE_CHANNEL)) {

                String orderNo = channelInvokeCharge(formData);
                appInvokeChargeVO.setChargeOrderNo(orderNo);
                return appInvokeChargeVO;
            }

            //必要校验
            Long userId = SecurityUtils.getUserId();
            Assert.isTrue(userId != null, "用户ID不能为空");

            AppUserInfoVO userInfo = userInfoMapper.getAppletUserInfo(userId);
            Assert.isTrue(userInfo != null, "用户信息不存在");

            //判断有没有正在进行中的订单
            Long count = this.baseMapper.selectCount(Wrappers.lambdaQuery(ChargeOrderInfo.class).eq(ChargeOrderInfo::getUserId, userId).in(ChargeOrderInfo::getStatus, SystemConstants.STATUS_ZERO, SystemConstants.STATUS_ONE, SystemConstants.STATUS_TWO));
            if (count > 0){
                throw new BusinessException("您有正在进行中的订单，请先停止充电");
            }
            //生成系统充电订单号及互联互通充电订单号 startChargeSeq equipAuthSeq （格式"运营商ID+唯一编号"）
            assert userId != null;
            String chargeOrderNo = generateNo(ORDER_NO_PREFIX, userId);
            String seq = ConnectivityConstants.OPERATOR_ID + chargeOrderNo;

            //请求设备认证
            EquipmentAuthResponseVO equipmentAuthResponseVO = chargingBusinessService.queryEquipAuth(seq,
                    formData.getConnectorId());

            if (Objects.equals(equipmentAuthResponseVO.getSuccStat(), SystemConstants.STATUS_ONE)) {
                throw new BusinessException("设备认证失败，请检查枪是否正确接入充电槽！");
            }else {
                log.info("设备认证成功,设备认证流水号:{}", equipmentAuthResponseVO.getEquipAuthSeq());
            }

            //创建订单
            ChargeOrderInfo chargeOrderInfo = new ChargeOrderInfo();
            chargeOrderInfo.setUserId(userId);
            chargeOrderInfo.setConnectorId(formData.getConnectorId());
            chargeOrderInfo.setEquipmentId(formData.getEquipmentId());
            chargeOrderInfo.setEquipAuthSeq(seq);
            chargeOrderInfo.setChargeOrderNo(chargeOrderNo);
            chargeOrderInfo.setStartChargeSeq(seq);
            chargeOrderInfo.setPhoneNum(userInfo.getPhone());
            chargeOrderInfo.setThirdPartyStationId(formData.getStationId());
            chargeOrderInfo.setOrderType(formData.getOrderType());
            //预支付金额
            BigDecimal preAmt = appletHomeService.calculateAvailableChargingAmount(formData.getConnectorId());
            chargeOrderInfo.setPreAmt(preAmt);

            //判断用户是否绑定企业
            if (ObjectUtil.isNotEmpty(userInfo.getFirmId())) {
                FirmInfo firmInfo = firmInfoMapper.selectById(userInfo.getFirmId());
                if(firmInfo != null && Objects.equals(firmInfo.getStatus(), SystemConstants.STATUS_ONE)) {
                    chargeOrderInfo.setFirmId(firmInfo.getId());
                    chargeOrderInfo.setOrderType(SystemConstants.STATUS_ONE);
                }
            }
            //优惠券
            if(ObjectUtil.isNotEmpty(formData.getCouponId())) {
                Coupon coupon = couponMapper.selectById(formData.getCouponId());
                if(coupon != null && Objects.equals(coupon.getStatus(), SystemConstants.STATUS_ONE)) {
                    CouponTemplate couponTemplate = couponTemplateMapper.selectById(coupon.getTemplateId());
                    chargeOrderInfo.setCouponId(coupon.getId());
                    chargeOrderInfo.setCouponPrice(couponTemplate.getDiscountPrice());
                }
            }

            //启动充电
            StartChargingRequestDTO requestDTO = new StartChargingRequestDTO();
            requestDTO
                    .setStartChargeSeq(seq)
                    .setConnectorID(formData.getConnectorId())
                    .setPhoneNum(userInfo.getPhone())
                    //预支付金额
                    .setChargingAmt(preAmt.toString())
            ;
            StartChargingResponseVO startChargingResponseVO = chargingBusinessService.startCharging(requestDTO);
            if (!Objects.equals(startChargingResponseVO.getSuccStat(), SystemConstants.STATUS_ZERO)) {
                throw new BusinessException(startChargingResponseVO.getFailReasonMsg());
            }

            //保存订单
            this.save(chargeOrderInfo);

            appInvokeChargeVO.setChargeOrderNo(chargeOrderNo);
            appInvokeChargeVO.setChargeOrderId(chargeOrderInfo.getId());
            return appInvokeChargeVO;
        } catch (Exception e) {
            log.error("启动充电失败，系统错误", e);
            throw new BusinessException("启动充电失败 ！" + e.getMessage());
        }
    }

    /**
     * 渠道方启动充电
     *
     * @param formData
     * @return
     */
    public String channelInvokeCharge(AppInvokeChargeForm formData) throws JsonProcessingException {

        String seq = ConnectivityConstants.OPERATOR_ID + formData.getChannelOrderNo();

        //请求设备认证
        EquipmentAuthResponseVO equipmentAuthResponseVO = chargingBusinessService.queryEquipAuth(seq,
                formData.getConnectorId());

        if (Objects.equals(equipmentAuthResponseVO.getSuccStat(), SystemConstants.STATUS_ONE)) {
            throw new BusinessException("设备认证失败，请检查枪是否正确接入充电槽！");
        } else {
            log.info("设备认证成功,设备认证流水号:{}", equipmentAuthResponseVO.getEquipAuthSeq());
        }

        Long userId = SecurityUtils.getUserId();
        UserFirm userFirm = userFirmMapper.selectOne(Wrappers.lambdaQuery(UserFirm.class).eq(UserFirm::getUserId, userId).last("limit 1"));

        //创建订单
        ChargeOrderInfo chargeOrderInfo = new ChargeOrderInfo();
        chargeOrderInfo.setUserId(userId);
        chargeOrderInfo.setFirmId(userFirm.getFirmId());
        chargeOrderInfo.setOrderType(SystemConstants.CHARGE_ORDER_TYPE_CHANNEL);
        chargeOrderInfo.setConnectorId(formData.getConnectorId());
        chargeOrderInfo.setEquipmentId(formData.getEquipmentId());
        chargeOrderInfo.setEquipAuthSeq(seq);
        chargeOrderInfo.setChargeOrderNo(formData.getChannelOrderNo());
        chargeOrderInfo.setStartChargeSeq(seq);
        chargeOrderInfo.setPhoneNum(formData.getChannelUserPhone());
        chargeOrderInfo.setThirdPartyStationId(formData.getStationId());
        //预支付金额
        chargeOrderInfo.setPreAmt(formData.getChannelPreAmt());

        //启动充电
        StartChargingRequestDTO requestDTO = new StartChargingRequestDTO();
        requestDTO
                .setStartChargeSeq(seq)
                .setConnectorID(formData.getConnectorId())
                .setPhoneNum(formData.getChannelUserPhone())
                //预支付金额
                .setChargingAmt(formData.getChannelPreAmt().toString())
        ;
        StartChargingResponseVO startChargingResponseVO = chargingBusinessService.startCharging(requestDTO);
        if (!Objects.equals(startChargingResponseVO.getSuccStat(), SystemConstants.STATUS_ZERO)) {
            throw new BusinessException(startChargingResponseVO.getFailReasonMsg());
        }

        //保存订单
        this.save(chargeOrderInfo);

        return chargeOrderInfo.getChargeOrderNo();
    }

    @Override
    public AppChargeVO stopCharge(AppStopChargeForm formData) {
        try {
            AppChargeVO appInvokeChargeVO = new AppChargeVO();

            //订单
            ChargeOrderInfo chargeOrderInfo = this.getOne(Wrappers.lambdaQuery(ChargeOrderInfo.class).eq(ChargeOrderInfo::getChargeOrderNo,
                    formData.getChargeOrderNo()).last("limit 1"));
            if(ObjectUtil.isEmpty(chargeOrderInfo)){
                throw new BusinessException("订单不存在");
            }
            StopChargingOperationResponseVO stopChargingOperationResponseVO = chargingBusinessService.stopCharging(chargeOrderInfo.getStartChargeSeq(), chargeOrderInfo.getConnectorId());

            if (!Objects.equals(stopChargingOperationResponseVO.getSuccStat(), SystemConstants.STATUS_ZERO)) {
                throw new BusinessException("停止充电失败，请切换设备或稍后再重试！");
            }

            // 更新订单状态为停止中（状态3）
            chargeOrderInfo.setStatus(SystemConstants.STATUS_THREE);
            chargeOrderInfo.setStopType(1); // 1-主动停止
            this.updateById(chargeOrderInfo);

            appInvokeChargeVO.setChargeOrderId(chargeOrderInfo.getId());
            appInvokeChargeVO.setChargeOrderNo(chargeOrderInfo.getChargeOrderNo());
            return appInvokeChargeVO;
        } catch (Exception e) {
            log.error("停止充电失败，系统错误", e);
            throw new BusinessException("停止充电失败，请切换设备或稍后再重试！");
        }
    }

    @Override
    public void orderSettlement(Long chargeOrderId) {

        ChargeOrderInfo chargeOrderInfo = this.getById(chargeOrderId);
        Long userId = chargeOrderInfo.getUserId();

        //平台收费总金额
        BigDecimal totalCharge = chargeOrderInfo.getRealCost();

        //加积分
        userAccountService.update(Wrappers.lambdaUpdate(UserAccount.class)
                .eq(UserAccount::getUserId, userId)
                .setSql("`integral` = `integral` +" + totalCharge)
        );

        //账户变动及日志记录
        userAccountService.updateAccountBalanceAndLog(
                userId,
                totalCharge,
                SystemConstants.CHANGE_TYPE_REDUCE,
                SystemConstants.CHARGE_DEDUCT_NOTE,
                chargeOrderInfo.getId()
        );
    }

    @Override
    public ChargeOrderInfoVO queryOrder(String chargeOrderNo) {
        return baseMapper.queryOrder(chargeOrderNo);
    }

    /**
     * 获取充电订单信息导出列表
     *
     * @param queryParams 查询参数
     * @return 充电订单信息导出列表
     */
    @Override
    public List<ChargeOrderInfoExportDTO> listExportChargeOrderInfo(ChargeOrderInfoQuery queryParams) {
        return baseMapper.listExportChargeOrderInfo(queryParams);
    }

    /**
     * 创建商户订单号
     * 要求 32个字符内，只能是数字、大小写字母_-|*且在同一个商户号下唯一
     * 组成 两位前缀 + 17位时间戳 + 9位id补零 + 4位随机数 合计32位
     *
     * @param head 例如 商品-SP 退款-TK 等等
     * @param id   用户id
     * @return
     */
    public String generateNo(String head, Long id) {
        StringBuilder uid = new StringBuilder(id.toString());
        Date date = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMddHHmmssSSS");
        int length = uid.length();
        for (int i = 0; i < 9 - length; i++) {
            uid.insert(0, "0");
        }
        return head + sdf.format(date) + uid + (int) ((Math.random() * 9 + 1) * 1000);
    }

}