jsowell-charger-web/jsowell-quartz/src/main/java/com/jsowell/quartz/task/JsowellTask.java

package com.jsowell.quartz.task;

import com.google.common.collect.Lists;
import com.jsowell.common.constant.CacheConstants;
import com.jsowell.common.constant.Constants;
import com.jsowell.common.core.redis.RedisCache;
import com.jsowell.common.enums.thirdparty.ThirdPlatformTypeEnum;
import com.jsowell.common.util.DateUtils;
import com.jsowell.common.util.StringUtils;
import com.jsowell.pile.domain.OrderBasicInfo;
import com.jsowell.pile.domain.PileMerchantInfo;
import com.jsowell.pile.domain.PileStationInfo;
import com.jsowell.pile.domain.ykcCommond.PublishPileBillingTemplateCommand;
import com.jsowell.pile.domain.ykcCommond.StartChargingCommand;
import com.jsowell.pile.service.*;
import com.jsowell.pile.vo.base.StationInfoVO;
import com.jsowell.pile.vo.web.BillingTemplateVO;
import com.jsowell.thirdparty.amap.service.AMapService;
import com.jsowell.thirdparty.platform.service.ThirdPartyPlatformService;
import com.jsowell.thirdparty.platform.service.impl.GuiZhouPlatformServiceImpl;
import com.jsowell.thirdparty.service.ThirdpartySecretInfoService;
import org.apache.commons.collections4.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@Component("jsowellTask")
public class JsowellTask {

	private final Logger log = LoggerFactory.getLogger(JsowellTask.class);

	@Autowired
	private OrderBasicInfoService orderBasicInfoService;

	@Autowired
	private PileBillingTemplateService pileBillingTemplateService;

	@Autowired
	private YKCPushCommandService ykcPushCommandService;

	@Autowired
	private PileMerchantInfoService pileMerchantInfoService;

	@Autowired
	private PileStationInfoService pileStationInfoService;

	@Autowired
	private RedisCache redisCache;

	@Autowired
	private AMapService aMapService;

	@Autowired
	private SettleOrderReportService settleOrderReportService;

	@Autowired
	private ThirdPartyStationRelationService thirdPartyStationRelationService;

	/**
	 * 关闭15分钟未支付的订单
	 * close15MinutesOfUnpaidOrders
	 */
	public void close15MinutesOfUnpaidOrders() {
		// log.info("关闭15分钟未支付的订单");
		orderBasicInfoService.close15MinutesOfUnpaidOrders();
	}

	/**
	 * 关闭启动失败的订单
	 * 订单支付成功，在15分钟内未启动，
	 */
	public void closeStartFailedOrder() {
		// 查询出最近2天支付成功，并且订单状态为未启动的订单
		String startTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, DateUtils.addDays(new Date(), -2));
		String endTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, new Date());
		orderBasicInfoService.closeStartFailedOrder(startTime, endTime);
	}

	/**
	 * 查询预约充电的订单并启动
	 */
	public void appointmentOrderStart() {
		// 查询出 已支付 设置预约充电 未启动 的订单
		LocalDateTime now = LocalDateTime.now();
		List<OrderBasicInfo> list = orderBasicInfoService.getReservedOrder(now);
		if (CollectionUtils.isEmpty(list)) {
			return;
		}
		log.info("待启动充电订单:{}", list);
		for (OrderBasicInfo orderInfo : list) {
			// 下发充电桩设置指令
			String pileSn = orderInfo.getPileSn();
			// 发送启动充电指令前，再次下发计费模板
			BillingTemplateVO billingTemplateVO = pileBillingTemplateService.selectBillingTemplateDetailByPileSn(pileSn);
			if (billingTemplateVO != null) {
				PublishPileBillingTemplateCommand command = PublishPileBillingTemplateCommand.builder()
						.billingTemplateVO(billingTemplateVO)
						.pileSn(pileSn)
						.build();
				ykcPushCommandService.pushPublishPileBillingTemplate(command);
			}
			// 发送启动指令
			String connectorCode = orderInfo.getConnectorCode();
			String transactionCode = orderInfo.getTransactionCode();
			BigDecimal payAmount = orderInfo.getPayAmount();

			if (StringUtils.isEmpty(pileSn) || StringUtils.isEmpty(connectorCode)) {
				log.warn("appointmentOrderStart-远程启动充电, 充电桩编号和枪口号不能为空");
				return;
			}
			log.info("appointmentOrderStart 远程启动充电, 桩号：{}, 枪口号：{}", pileSn, connectorCode);
			StartChargingCommand startChargingCommand = StartChargingCommand.builder()
					.pileSn(pileSn)
					.connectorCode(connectorCode)
					.transactionCode(transactionCode)
					.chargeAmount(payAmount)
					.build();
			ykcPushCommandService.pushStartChargingCommand(startChargingCommand);
		}
	}

	/**
	 * 计算站点订单报表
	 * jsowellTask.calculateTheSiteOrdersReport()
	 */
	public void calculateTheSiteOrdersReport() {
		// 查询出所有站点
		PileStationInfo pileStationInfo = new PileStationInfo();
		pileStationInfo.setDelFlag(Constants.ZERO);
		// 查询未删除的站点列表
		List<PileStationInfo> list = pileStationInfoService.selectPileStationInfoList(pileStationInfo);
		if (CollectionUtils.isEmpty(list)) {
			return;
		}
		LocalDate yesterday = LocalDate.now().plusDays(-1);
		// 计算每个站点前一天的报表
		for (PileStationInfo stationInfo : list) {
			try {
				settleOrderReportService.generateDailyOrderReports(stationInfo.getId() + "", yesterday.toString());
			} catch (Exception e) {
				log.error("计算站点订单报表 发生异常 stationId:{}", stationInfo.getId(), e);
			}
		}
	}

	/**
	 * 站点的枪口数据推送到高德
	 * jsowellTask.pushToAMap()
	 */
	public void pushToAMap() {
		Set<String> stationIds = redisCache.getCacheSet(CacheConstants.PUSH_STATION_CONNECTOR);
		if (CollectionUtils.isEmpty(stationIds)) {
			return;
		}
		log.info("推送到高德的stationId:{}", stationIds);
		for (String stationId : stationIds) {
			try {
				aMapService.pushChargingDeviceDynamics(stationId);
			} catch (Exception e) {
				log.error("推送到高德error", e);
			}
		}
		// 删除缓存
		redisCache.deleteObject(CacheConstants.PUSH_STATION_CONNECTOR);
	}

	/**
	 * 贵州省平台推送充电站实时功率
	 */
	public void pushStationRealTimePowerInfo(){
		// 查询出要推送的站点（贵州、）
		String thirdPartyType = ThirdPlatformTypeEnum.GUI_ZHOU_PLATFORM.getTypeCode();
		List<StationInfoVO> stationInfoVOS = thirdPartyStationRelationService.selectStationList(thirdPartyType);

		List<String> stationIdList = stationInfoVOS.stream()
				.map(StationInfoVO::getStationId)
				.collect(Collectors.toList());

		GuiZhouPlatformServiceImpl guiZhouPlatformService = new GuiZhouPlatformServiceImpl();
		guiZhouPlatformService.notificationPowerInfo(stationIdList);
	}

	/**
	 * 定时任务，处理订单分账
	 * jsowellTask.processOrderSplitting()
	 */
	public void processOrderSplitting() {
		// 查询运营商列表
		List<PileMerchantInfo> pileMerchantInfos = pileMerchantInfoService.selectPileMerchantInfoList(null);
		if (CollectionUtils.isEmpty(pileMerchantInfos)) {
			log.info("定时任务，处理订单分账, 未查询到运营商列表，直接返回");
			return;
		}
		// 获取日期
		LocalDate yesterday = LocalDate.now().plusDays(-1);

		// 设置挡板，8月1号之后的订单按照实际进行分账
		LocalDateTime now = LocalDateTime.now();
		LocalDateTime dateTime = LocalDateTime.of(2023, 8, 2, 0, 0, 0);
		if (now.isBefore(dateTime)) {
			log.info("当前时间:{}早于:{}, 不进行分账处理", DateUtils.formatDateTime(now), DateUtils.formatDateTime(dateTime));
			return;
		}

		// 调分账方法
		pileMerchantInfos.parallelStream().forEach(merchant -> {
			try {
				orderBasicInfoService.orderSplittingOperations(merchant.getId()+"", yesterday.toString());
			} catch (Exception e) {
				log.error("处理订单分账异常, merchantId:{}", merchant.getId(), e);
			}
		});
	}
}