package com.ruoyi.order.controller;
|
import cn.afterturn.easypoi.excel.ExcelExportUtil;
|
import cn.afterturn.easypoi.excel.entity.ExportParams;
|
import com.alibaba.fastjson2.JSON;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
|
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.math.RoundingMode;
|
import java.text.DecimalFormat;
|
import java.time.*;
|
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.ruoyi.account.api.feignClient.AppUserCarClient;
|
import com.ruoyi.account.api.feignClient.AppUserClient;
|
import com.ruoyi.account.api.feignClient.AppUserTagClient;
|
import com.ruoyi.account.api.model.TAppUser;
|
import com.ruoyi.account.api.model.TAppUserCar;
|
import com.ruoyi.account.api.model.TAppUserTag;
|
import com.ruoyi.chargingPile.api.domain.SiteMenu;
|
import com.ruoyi.chargingPile.api.dto.GetSiteListDTO;
|
import com.ruoyi.chargingPile.api.feignClient.*;
|
import com.ruoyi.chargingPile.api.model.Partner;
|
import com.ruoyi.chargingPile.api.model.Site;
|
import com.ruoyi.chargingPile.api.model.TChargingGun;
|
import com.ruoyi.chargingPile.api.model.TChargingPile;
|
import com.ruoyi.chargingPile.api.model.TParkingRecord;
|
import com.ruoyi.chargingPile.api.vo.GetChargingGunByChargingPileIdsVo;
|
import com.ruoyi.common.core.domain.R;
|
import com.ruoyi.common.core.dto.ChargingOrderGroup;
|
import com.ruoyi.common.core.dto.ChargingPercentProvinceDto;
|
import com.ruoyi.common.core.utils.StringUtils;
|
import com.ruoyi.common.log.annotation.Log;
|
import com.ruoyi.common.log.enums.BusinessType;
|
import com.ruoyi.common.log.enums.OperatorType;
|
import com.ruoyi.common.redis.service.RedisService;
|
import com.ruoyi.common.security.annotation.Logical;
|
import com.ruoyi.common.security.annotation.RequiresPermissions;
|
import com.ruoyi.common.security.service.TokenService;
|
import com.ruoyi.common.core.web.domain.AjaxResult;
|
import com.ruoyi.common.core.web.page.PageInfo;
|
import com.ruoyi.order.api.dto.ChargingStatisticeDTO;
|
import com.ruoyi.order.api.dto.DeviceStartChargingDTO;
|
import com.ruoyi.order.api.model.*;
|
import com.ruoyi.order.api.query.ChargingOrderQuery;
|
import com.ruoyi.common.core.dto.MongoChargingOrderQuery;
|
import com.ruoyi.order.api.query.TChargingCountQuery;
|
import com.ruoyi.order.api.query.UploadRealTimeMonitoringDataQuery;
|
import com.ruoyi.order.api.vo.*;
|
import com.ruoyi.order.api.vo.ChargingOrderInfoVO;
|
import com.ruoyi.order.api.vo.GetChargingOrderByLicensePlate;
|
import com.ruoyi.order.api.vo.TCharingOrderVO;
|
import com.ruoyi.order.dto.GetMyChargingOrderList;
|
import com.ruoyi.order.dto.GetNoInvoicedOrder;
|
import com.ruoyi.order.dto.MyChargingOrderInfo;
|
import com.ruoyi.order.dto.MyChargingOrderList;
|
import com.ruoyi.order.dto.OrderEvaluateVo;
|
import com.ruoyi.order.dto.*;
|
import com.ruoyi.order.mapper.TChargingOrderMapper;
|
import com.ruoyi.order.export.PayOrderExport;
|
import com.ruoyi.order.export.EnterpriseChargingDetailExport;
|
import com.ruoyi.order.service.*;
|
import com.ruoyi.order.support.FranchiseeUserStatistics;
|
import com.ruoyi.order.util.PreviousSixMonths;
|
import com.ruoyi.order.util.mongodb.service.UploadRealTimeMonitoringDataService;
|
import com.ruoyi.order.vo.EndOfChargePageInfo;
|
import com.ruoyi.order.vo.ChargingSimulationVO;
|
import com.ruoyi.order.vo.IcbcAdminSubOrderVO;
|
import com.ruoyi.order.vo.StatisticsOfBatteryVO;
|
import com.ruoyi.order.vo.ReservationRecommendationVO;
|
import com.ruoyi.order.vo.UpdateOrderPaymentAmountDto;
|
import com.ruoyi.order.vo.WatchChargingOrderVo;
|
import com.ruoyi.other.api.feignClient.RoleSiteClient;
|
import com.ruoyi.other.api.feignClient.UserSiteClient;
|
import com.ruoyi.other.api.feignClient.UserTagClient;
|
import com.ruoyi.other.api.feignClient.VipClient;
|
import com.ruoyi.other.api.feignClient.OtherClient;
|
import com.ruoyi.other.api.domain.TCompany;
|
import com.ruoyi.other.api.domain.TVip;
|
import com.ruoyi.other.api.domain.TUserTag;
|
import com.ruoyi.payment.api.feignClient.AliPaymentClient;
|
import com.ruoyi.payment.api.feignClient.WxPaymentClient;
|
import com.ruoyi.payment.api.vo.IcbcPaymentResp;
|
import com.ruoyi.payment.api.vo.IcbcRefundResp;
|
import com.ruoyi.payment.api.vo.IcbcSubOrderRefundResp;
|
import com.ruoyi.system.api.domain.SysUser;
|
import com.ruoyi.system.api.feignClient.SysUserClient;
|
import com.ruoyi.system.api.feignClient.SysUserRoleClient;
|
import com.ruoyi.system.api.model.SysUserRoleVo;
|
import io.swagger.annotations.*;
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.*;
|
|
import javax.annotation.Resource;
|
import javax.servlet.ServletOutputStream;
|
import javax.servlet.http.HttpServletResponse;
|
import java.net.URLEncoder;
|
import java.time.format.DateTimeFormatter;
|
import java.util.*;
|
import java.util.List;
|
import java.util.concurrent.CompletableFuture;
|
import java.util.concurrent.ExecutorService;
|
import java.util.concurrent.Executors;
|
import java.util.stream.Collectors;
|
|
import com.ruoyi.common.core.utils.DateUtils;
|
import com.ruoyi.common.core.utils.WebUtils;
|
import org.apache.poi.ss.usermodel.Workbook;
|
|
/**
|
* <p>
|
* 前端控制器
|
* </p>
|
*
|
* @author xiaochen
|
* @since 2024-08-07
|
*/
|
@Api(tags = "充电订单")
|
@RestController
|
@RequestMapping("/t-charging-order")
|
public class TChargingOrderController {
|
|
private Logger log = LoggerFactory.getLogger(TChargingOrderController.class);
|
|
@Resource
|
private TChargingOrderService chargingOrderService;
|
@Resource
|
private TCardChargingOrderService cardChargingOrderService;
|
@Resource
|
private TVinChargingOrderService vinChargingOrderService;
|
@Autowired
|
private TokenService tokenService;
|
@Autowired
|
private TOrderEvaluateService orderEvaluateService;
|
@Autowired
|
private TGrantVipService tGrantVipService;
|
@Resource
|
private WxPaymentClient wxPaymentClient;
|
|
@Resource
|
private RedisService redisService;
|
|
@Resource
|
private AliPaymentClient aliPaymentClient;
|
@Resource
|
private TShoppingOrderService shoppingOrderService;
|
|
@Resource
|
private AppUserClient appUserClient;
|
|
|
@Resource
|
private TVipOrderService vipOrderService;
|
@Resource
|
private ParkingLotClient parkingLotClient;
|
@Resource
|
private TChargingOrderRefundService chargingOrderRefundService;
|
|
@Resource
|
private TShoppingOrderRefundService shoppingOrderRefundService;
|
@Resource
|
private TVipOrderRefundService vipOrderRefundService;
|
@Resource
|
private SiteClient siteClient;
|
@Resource
|
private ChargingPileClient chargingPileClient;
|
@Resource
|
private ChargingGunClient chargingGunClient;
|
@Resource
|
private AppUserCarClient appUserCarClient;
|
@Resource
|
private AppUserTagClient appUserTagClient;
|
@Resource
|
private UserTagClient userTagClient;
|
@Resource
|
private TChargingOrderAccountingStrategyService chargingOrderAccountingStrategyService;
|
|
@Resource
|
private TOrderInvoiceService invoiceService;
|
@Resource
|
private TOrderInvoiceDetailService orderInvoiceDetailService;
|
@Resource
|
private UploadRealTimeMonitoringDataService uploadRealTimeMonitoringDataService;
|
@Resource
|
private PartnerClient partnerClient;
|
@Resource
|
private SysUserClient sysUserClient;
|
|
@Resource
|
private UserSiteClient userSiteClient;
|
|
@Resource
|
private RoleSiteClient roleSiteClient;
|
@Resource
|
private VipClient vipClient;
|
@Resource
|
private OtherClient otherClient;
|
@Resource
|
private SysUserRoleClient sysUserRoleClient;
|
|
@Resource
|
private TChargingOrderMapper chargingOrderMapper;
|
|
/** 尖峰平谷反查分块 id 上限：MyCat/druid 对 IN 列表的解析路由成本随 id 数非线性增长
|
* （实测 500 个约 5s、5000 个 70s+ 触发读超时；100 个内约 0.2s/块，约 2ms/个）。 */
|
private static final int PHASE_ID_BATCH_SIZE = 100;
|
/** 尖峰平谷分块反查并发度：46k id 实测 ~20s，典型加盟商 <3s（串行 5000/块 >70s 读超时）。 */
|
private static final ExecutorService PHASE_QUERY_EXECUTOR = Executors.newFixedThreadPool(16);
|
|
@GetMapping("/reservationRecommendation")
|
@ApiOperation(value = "获取站点预约充电推荐时段", tags = {"管理后台-充电桩信息"})
|
public R<ReservationRecommendationVO> getReservationRecommendation(@RequestParam Integer siteId) {
|
return R.ok(chargingOrderService.getReservationRecommendation(siteId));
|
}
|
|
/** 小程序加盟商看板：站点范围始终从登录账号绑定关系解析。聚合查询下推到分片，避免全量拉订单。 */
|
@PostMapping("/app/franchisee/charge-data")
|
public R<Map<String, Object>> franchiseeChargeData(@RequestBody(required = false) Map<String, Object> params) {
|
List<Integer> siteIds = franchiseeSiteIds(params);
|
LocalDateTime[] range = franchiseeRange(params);
|
List<FranchiseeDayStat> dayStats = franchiseeDayStats(siteIds, range);
|
List<Map<String, Object>> managementOrderStats = franchiseeManagementOrderStats(siteIds, range);
|
Map<String, Object> summary = new LinkedHashMap<>();
|
BigDecimal incomeWan = franchiseeIncomeWan(dayStats);
|
BigDecimal totalChargingCapacityWan = sum(dayStats, FranchiseeDayStat::getCapacity).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP);
|
summary.put("incomeWan", incomeWan);
|
summary.put("orderAmountWan", incomeWan);
|
summary.put("serviceFeeWan", sum(dayStats, FranchiseeDayStat::getServiceFee).divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP));
|
summary.put("totalChargingCapacityWan", totalChargingCapacityWan);
|
summary.put("chargingPowerWan", totalChargingCapacityWan);
|
summary.put("chargingAmount", sumManagementOrderField(managementOrderStats, "paymoney"));
|
summary.put("chargingOrderCount", sumManagementOrderField(managementOrderStats, "orderCount").longValue());
|
summary.put("powerUtilizationRate", observedPowerUtilization(dayStats));
|
summary.put("demandPowerSatisfactionRate", demandPowerSatisfaction(dayStats));
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("summary", summary);
|
result.put("keyDataLine", franchiseeDailyTrend(dayStats, range, "收入合计", FranchiseeDayStat::getChargingIncome));
|
result.put("keyDataRing", franchiseePhaseRing(siteIds, range));
|
result.put("orderStats", franchiseeManagementOrderTrend(managementOrderStats));
|
result.put("efficiency", franchiseeEfficiencyTrend(dayStats, range));
|
result.put("powerDistribution", franchiseePowerDistribution(siteIds, range));
|
return R.ok(result);
|
}
|
|
@PostMapping("/app/franchisee/income")
|
public R<Map<String, Object>> franchiseeIncome(@RequestBody(required = false) Map<String, Object> params) {
|
List<Integer> siteIds = franchiseeSiteIds(params);
|
List<SixChargingDto> sixChargingDtos;
|
if (siteIds.isEmpty()) {
|
// 无授权站点：返回近6月全零骨架，避免空 IN 导致全站点统计
|
sixChargingDtos = generateLastSixMonths(LocalDate.now());
|
} else {
|
// 与后台 数据分析-平台总收入分析 电站收入分析口径一致：历史月读结算账单、当月补原始订单
|
LocalDate sixBefore = PreviousSixMonths.get();
|
List<SixChargingDto> chargingDtos = chargingOrderService.charge(sixBefore, siteIds, false);
|
LocalDate statisticsEndMonth = resolveStatisticsEndMonth(LocalDate.now(), chargingDtos);
|
sixChargingDtos = generateLastSixMonths(statisticsEndMonth);
|
for (SixChargingDto sixChargingDto : sixChargingDtos) {
|
for (SixChargingDto chargingDto : chargingDtos) {
|
if (sixChargingDto.getMonth().equals(chargingDto.getMonth())) {
|
BeanUtils.copyProperties(chargingDto, sixChargingDto);
|
}
|
}
|
}
|
}
|
BigDecimal electricity = sixChargingDtos.stream()
|
.filter(Objects::nonNull)
|
.map(SixChargingDto::getElectrovalence)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
BigDecimal service = sixChargingDtos.stream()
|
.filter(Objects::nonNull)
|
.map(SixChargingDto::getServiceCharge)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("totalIncome", electricity.add(service));
|
result.put("electricityFee", electricity);
|
result.put("serviceFee", service);
|
result.put("incomeColumn", franchiseeIncomeTrendFromSix(sixChargingDtos));
|
// 电站收入占比：口径与后台 /six/circle 一致（近6月结算账单按站点分组，电费+服务费-三方佣金）
|
result.put("incomePie", franchiseeIncomePieBySite(siteIds));
|
return R.ok(result);
|
}
|
|
/** 加盟商看板"电站收入占比"：复用 /six/circle 统计口径，按金额降序返回站点占比列表 */
|
private List<Map<String, Object>> franchiseeIncomePieBySite(List<Integer> siteIds) {
|
List<Map<String, Object>> incomePie = new ArrayList<>();
|
if (siteIds == null || siteIds.isEmpty()) {
|
return incomePie;
|
}
|
List<SixCircleDto> circleDtos = chargingOrderService.circle(siteIds, PreviousSixMonths.get(), false);
|
if (circleDtos == null || circleDtos.isEmpty()) {
|
return incomePie;
|
}
|
// 站点名批量映射，避免逐个远程调用
|
Map<Integer, String> siteNameMap = new HashMap<>();
|
R<List<Site>> siteResult = siteClient.getSiteAll();
|
List<Site> sites = siteResult == null ? null : siteResult.getData();
|
if (sites != null) {
|
for (Site site : sites) {
|
if (site != null && site.getId() != null) {
|
siteNameMap.put(site.getId(), site.getName());
|
}
|
}
|
}
|
circleDtos.sort((a, b) -> {
|
BigDecimal amountA = a == null || a.getPaymentAmount() == null ? BigDecimal.ZERO : a.getPaymentAmount();
|
BigDecimal amountB = b == null || b.getPaymentAmount() == null ? BigDecimal.ZERO : b.getPaymentAmount();
|
return amountB.compareTo(amountA);
|
});
|
// 总额用于计算各站点占比，name+value 为服务端拼好的饼图标签文本（站点名 xx.x%）
|
BigDecimal total = BigDecimal.ZERO;
|
for (SixCircleDto dto : circleDtos) {
|
if (dto != null && dto.getPaymentAmount() != null) {
|
total = total.add(dto.getPaymentAmount());
|
}
|
}
|
for (SixCircleDto dto : circleDtos) {
|
if (dto == null || dto.getSiteId() == null || dto.getPaymentAmount() == null) {
|
continue;
|
}
|
Map<String, Object> item = new LinkedHashMap<>();
|
String name = siteNameMap.getOrDefault(dto.getSiteId(), "电站" + dto.getSiteId());
|
item.put("name", name);
|
item.put("value", dto.getPaymentAmount());
|
String percent = total.compareTo(BigDecimal.ZERO) > 0
|
? dto.getPaymentAmount().multiply(BigDecimal.valueOf(100)).divide(total, 1, RoundingMode.HALF_UP).toPlainString()
|
: "0.0";
|
item.put("name+value", name + " " + percent + "%");
|
incomePie.add(item);
|
}
|
return incomePie;
|
}
|
|
@PostMapping("/app/franchisee/user")
|
public R<Map<String, Object>> franchiseeUser(@RequestBody(required = false) Map<String, Object> params) {
|
Partner partner = franchiseePartner();
|
List<Integer> siteIds = partner == null ? Collections.emptyList() : franchiseeSiteIds(params, partner.getId());
|
LocalDateTime[] range = franchiseeRange(params);
|
List<FranchiseeUserAgg> aggs = franchiseeUserAggs(siteIds, range);
|
Map<LocalDate, Set<Long>> chargingUsersByDay = new LinkedHashMap<>();
|
for (FranchiseeUserAgg agg : aggs) {
|
if (agg == null || agg.getAppUserId() == null || agg.getStatDay() == null) {
|
continue;
|
}
|
chargingUsersByDay.computeIfAbsent(agg.getStatDay(), key -> new HashSet<>()).add(agg.getAppUserId());
|
}
|
Map<LocalDate, Long> newUsersByDay = new LinkedHashMap<>();
|
if (siteIds != null && !siteIds.isEmpty() && range != null && range[0] != null && range[1] != null) {
|
List<FranchiseeUserFirstCharge> firstCharges = chargingOrderMapper.franchiseeUserFirstChargedDays(siteIds, range[0], range[1]);
|
if (firstCharges != null) {
|
for (FranchiseeUserFirstCharge fc : firstCharges) {
|
if (fc != null && fc.getAppUserId() != null && fc.getFirstChargedDay() != null) {
|
newUsersByDay.merge(fc.getFirstChargedDay(), 1L, Long::sum);
|
}
|
}
|
}
|
}
|
FranchiseeUserStatistics.Result userStatistics = FranchiseeUserStatistics.calculateByUserDays(
|
chargingUsersByDay, newUsersByDay, range[0], range[1]);
|
|
Set<Long> users = aggs.stream().map(FranchiseeUserAgg::getAppUserId).filter(Objects::nonNull).collect(Collectors.toSet());
|
List<TAppUser> appUsers = Collections.emptyList();
|
if (!users.isEmpty()) {
|
R<List<TAppUser>> userResult = appUserClient.getUserByIds(new ArrayList<>(users));
|
if (userResult != null && userResult.getData() != null) appUsers = userResult.getData();
|
}
|
Map<Long, TAppUser> userMap = appUsers.stream().filter(user -> user.getId() != null)
|
.collect(Collectors.toMap(TAppUser::getId, user -> user, (left, right) -> left));
|
|
List<Long> carIds = aggs.stream().map(FranchiseeUserAgg::getAppUserCarId).filter(Objects::nonNull).distinct().collect(Collectors.toList());
|
List<TAppUserCar> cars = Collections.emptyList();
|
if (!carIds.isEmpty()) {
|
R<List<TAppUserCar>> carResult = appUserCarClient.getCarByIds(carIds);
|
if (carResult != null && carResult.getData() != null) cars = carResult.getData();
|
}
|
|
Map<String, Object> evaluation = franchiseeEvaluation(siteIds);
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("summary", userStatistics.getSummary());
|
result.put("userStats", userStatistics.getTrend());
|
result.put("userTags", franchiseeUserTags(aggs));
|
Map<Integer, String> vipNames = new HashMap<>();
|
R<List<TVip>> vipResult = vipClient.getAllVip();
|
if (vipResult != null && vipResult.getData() != null) vipResult.getData().forEach(vip -> vipNames.put(vip.getId(), vip.getName()));
|
result.put("memberType", franchiseeMemberTypes(appUsers, vipNames));
|
result.put("corpRank", franchiseeCompanyRank(aggs, userMap));
|
result.put("evaluation", evaluation.get("summary"));
|
result.put("goodTags", evaluation.get("goodTags"));
|
result.put("badTags", evaluation.get("badTags"));
|
result.put("traffic", franchiseeTraffic(siteIds, range));
|
result.put("vehicleClass", franchiseeOrderCarGroup(aggs, cars, TAppUserCar::getVehicleUse, "未知用途", 5));
|
result.put("vehicleBrand", franchiseeOrderCarGroup(aggs, cars, TAppUserCar::getVehicleBrand, "其他", 5));
|
return R.ok(result);
|
}
|
|
@PostMapping("/app/franchisee/operation")
|
public R<Map<String, Object>> franchiseeOperation(@RequestBody(required = false) Map<String, Object> params) {
|
Map<String, Object> result = new LinkedHashMap<>();
|
List<Integer> siteIds = franchiseeSiteIds(params);
|
LocalDateTime[] range = franchiseeRange(params);
|
ChargingStatisticsQueryDto query = new ChargingStatisticsQueryDto();
|
String dateType = params == null ? "today" : String.valueOf(params.getOrDefault("dateType", "today"));
|
int dayType = "week".equals(dateType) ? 2 : "month".equals(dateType) ? 3 : "year".equals(dateType) ? 4 : "custom".equals(dateType) ? 5 : 1;
|
query.setDayType(dayType);
|
if (dayType == 5) {
|
query.setStartTime(range[0].toLocalDate());
|
query.setEndTime(range[1].toLocalDate().minusDays(1));
|
}
|
|
List<Map<String, Object>> dcAvailable = safeList(chargingOrderService.equipmentUserType1(siteIds, query));
|
List<Map<String, Object>> acAvailable = safeList(chargingOrderService.equipmentUserType2(siteIds, query));
|
List<Map<String, Object>> dcFault = safeList(chargingOrderService.equipmentMapbroke1(siteIds, query));
|
List<Map<String, Object>> acFault = safeList(chargingOrderService.equipmentMapbroke2(siteIds, query));
|
List<Map<String, Object>> dcOffline = safeList(chargingOrderService.equipmentMapOut1(siteIds, query));
|
List<Map<String, Object>> acOffline = safeList(chargingOrderService.equipmentMapOut2(siteIds, query));
|
List<Map<String, Object>> dcSatisfaction = safeList(chargingOrderService.needElec(siteIds, query));
|
List<Map<String, Object>> acSatisfaction = safeList(chargingOrderService.needElec1(siteIds, query));
|
normalizeOperationPercents(dcAvailable);
|
normalizeOperationPercents(acAvailable);
|
normalizeOperationPercents(dcFault);
|
normalizeOperationPercents(acFault);
|
normalizeOperationPercents(dcOffline);
|
normalizeOperationPercents(acOffline);
|
normalizeOperationPercents(dcSatisfaction);
|
normalizeOperationPercents(acSatisfaction);
|
|
Map<String, Object> summary = new LinkedHashMap<>();
|
summary.put("availableRate", calculateAveragePercent(dcAvailable, acAvailable));
|
summary.put("faultRate", calculateAveragePercent(dcFault, acFault));
|
summary.put("offlineRate", calculateAveragePercent(dcOffline, acOffline));
|
summary.put("powerSatisfactionRate", calculateAveragePercent(dcSatisfaction, acSatisfaction));
|
result.put("summary", summary);
|
result.put("dcCharts", Arrays.asList(
|
operationChart(dcAvailable, "可用率"),
|
operationChart(dcFault, "故障率"),
|
operationChart(dcOffline, "离网率"),
|
operationChart(dcSatisfaction, "需求电流满足率")));
|
result.put("acCharts", Arrays.asList(
|
operationChart(acAvailable, "可用率"),
|
operationChart(acFault, "故障率"),
|
operationChart(acOffline, "离网率"),
|
operationChart(acSatisfaction, "需求电流满足率")));
|
return R.ok(result);
|
}
|
|
private Map<String, Object> operationChart(List<Map<String, Object>> rows, String name) {
|
List<String> categories = rows.stream().map(row -> {
|
String gunName = row.get("name") == null ? "" : String.valueOf(row.get("name"));
|
return StringUtils.isBlank(gunName) ? "未命名充电枪" : gunName;
|
}).collect(Collectors.toList());
|
List<Object> values = rows.stream().map(row -> row.getOrDefault("percent", "0")).collect(Collectors.toList());
|
Map<String, Object> chart = new LinkedHashMap<>();
|
chart.put("categories", categories);
|
Map<String, Object> series = new LinkedHashMap<>();
|
series.put("name", name);
|
series.put("data", values);
|
chart.put("series", Collections.singletonList(series));
|
return chart;
|
}
|
|
private void normalizeOperationPercents(List<Map<String, Object>> rows) {
|
for (Map<String, Object> row : rows) {
|
Object raw = row.get("percent");
|
try {
|
BigDecimal percent = raw == null ? BigDecimal.ZERO : new BigDecimal(String.valueOf(raw));
|
row.put("percent", percent.abs().toPlainString());
|
} catch (NumberFormatException ignored) {
|
row.put("percent", "0");
|
}
|
}
|
}
|
|
/** 加盟商看板按日聚合（siteIds 为空直接返回空，避免空 IN）。 */
|
private List<FranchiseeDayStat> franchiseeDayStats(List<Integer> siteIds, LocalDateTime[] range) {
|
if (siteIds == null || siteIds.isEmpty() || range == null || range[0] == null || range[1] == null) {
|
return Collections.emptyList();
|
}
|
return chargingOrderMapper.franchiseeDayStats(siteIds, range[0], range[1]);
|
}
|
|
/** 加盟商看板用户维度聚合（仅已结束订单；siteIds 为空直接返回空）。 */
|
private List<FranchiseeUserAgg> franchiseeUserAggs(List<Integer> siteIds, LocalDateTime[] range) {
|
if (siteIds == null || siteIds.isEmpty() || range == null || range[0] == null || range[1] == null) {
|
return Collections.emptyList();
|
}
|
return chargingOrderMapper.franchiseeUserAggs(siteIds, range[0], range[1]);
|
}
|
|
private List<Integer> franchiseeSiteIds(Map<String, Object> params) {
|
Partner partner = franchiseePartner();
|
if (partner == null || partner.getId() == null) return Collections.emptyList();
|
return franchiseeSiteIds(params, partner.getId());
|
}
|
|
private Partner franchiseePartner() {
|
if (tokenService.getLoginUserApplet() == null || tokenService.getLoginUserApplet().getUserId() == null) return null;
|
Long appUserId = tokenService.getLoginUserApplet().getUserId();
|
R<Partner> partnerResult = partnerClient.getPartnerByAppUserId(appUserId);
|
return partnerResult == null ? null : partnerResult.getData();
|
}
|
|
private List<Integer> franchiseeSiteIds(Map<String, Object> params, Integer partnerId) {
|
R<List<Site>> siteResult = siteClient.getSiteAll();
|
List<Site> sites = siteResult == null ? null : siteResult.getData();
|
List<Integer> siteIds = sites == null ? new ArrayList<>() : sites.stream().filter(s -> Objects.equals(s.getPartnerId(), partnerId)).map(Site::getId).collect(Collectors.toList());
|
Object requestedSite = params == null ? null : params.get("siteId");
|
if (requestedSite != null && !String.valueOf(requestedSite).isEmpty()) {
|
Integer siteId = Integer.valueOf(String.valueOf(requestedSite)); siteIds = siteIds.contains(siteId) ? Collections.singletonList(siteId) : Collections.singletonList(-1);
|
}
|
return siteIds;
|
}
|
|
private List<Map<String, Object>> franchiseeUserTags(List<FranchiseeUserAgg> aggs) {
|
Set<Long> userIds = aggs.stream()
|
.map(FranchiseeUserAgg::getAppUserId)
|
.filter(Objects::nonNull)
|
.collect(Collectors.toSet());
|
if (userIds.isEmpty()) {
|
return Collections.emptyList();
|
}
|
R<List<TUserTag>> tagResult = userTagClient.getAllUserTag();
|
List<TUserTag> tags = tagResult == null || tagResult.getData() == null
|
? Collections.emptyList() : tagResult.getData();
|
// 单次批量拉取全部用户标签关系（t_app_user_tag 分片键 app_user_id 精确路由），
|
// 避免原先 标签×用户 双层循环逐个远程调用导致接口 40s+。
|
R<List<TAppUserTag>> relationResult = appUserTagClient.listByUserIds(new ArrayList<>(userIds));
|
List<TAppUserTag> relations = relationResult == null || relationResult.getData() == null
|
? Collections.emptyList() : relationResult.getData();
|
Map<Integer, Set<Long>> usersByTag = relations.stream()
|
.filter(relation -> relation.getUserTagId() != null && relation.getAppUserId() != null)
|
.collect(Collectors.groupingBy(TAppUserTag::getUserTagId,
|
Collectors.mapping(TAppUserTag::getAppUserId, Collectors.toSet())));
|
Map<String, Long> counts = new LinkedHashMap<>();
|
for (TUserTag tag : tags) {
|
if (tag == null || tag.getId() == null || StringUtils.isBlank(tag.getName())) {
|
continue;
|
}
|
Set<Long> taggedUsers = usersByTag.get(tag.getId());
|
if (taggedUsers != null && !taggedUsers.isEmpty()) {
|
counts.put(tag.getName(), (long) taggedUsers.size());
|
}
|
}
|
return counts.entrySet().stream()
|
.map(entry -> namedCount(entry.getKey(), entry.getValue()))
|
.collect(Collectors.toList());
|
}
|
|
private List<Map<String, Object>> franchiseeMemberTypes(List<TAppUser> users, Map<Integer, String> vipNames) {
|
long ordinary = users.stream().filter(user -> user.getVipId() == null || user.getVipId() == 0).count();
|
Map<Integer, Long> vipCounts = users.stream().filter(user -> user.getVipId() != null && user.getVipId() != 0)
|
.collect(Collectors.groupingBy(TAppUser::getVipId, Collectors.counting()));
|
List<Map<String, Object>> result = new ArrayList<>();
|
if (ordinary > 0) result.add(namedCount("普通用户", ordinary));
|
vipCounts.forEach((vipId, count) -> result.add(namedCount(vipNames.getOrDefault(vipId, "会员" + vipId), count)));
|
return result;
|
}
|
|
private Map<String, Object> franchiseeCompanyRank(List<FranchiseeUserAgg> aggs, Map<Long, TAppUser> userMap) {
|
Map<Integer, BigDecimal> totals = new HashMap<>();
|
aggs.forEach(agg -> {
|
TAppUser user = userMap.get(agg.getAppUserId());
|
if (user != null && user.getCompanyId() != null) {
|
totals.merge(user.getCompanyId(), value(agg.getCapacity()), BigDecimal::add);
|
}
|
});
|
List<Map.Entry<Integer, BigDecimal>> sorted = totals.entrySet().stream()
|
.sorted(Map.Entry.<Integer, BigDecimal>comparingByValue().reversed()).limit(5).collect(Collectors.toList());
|
Map<String, Object> chart = new LinkedHashMap<>();
|
chart.put("categories", sorted.stream().map(entry -> {
|
R<TCompany> companyResult = otherClient.unitDetail(entry.getKey());
|
TCompany company = companyResult == null ? null : companyResult.getData();
|
return company == null || StringUtils.isBlank(company.getName()) ? "单位" + entry.getKey() : company.getName();
|
}).collect(Collectors.toList()));
|
Map<String, Object> series = new LinkedHashMap<>(); series.put("name", "充电量");
|
series.put("data", sorted.stream().map(Map.Entry::getValue).collect(Collectors.toList()));
|
chart.put("series", Collections.singletonList(series)); return chart;
|
}
|
|
private Map<String, Object> franchiseeEvaluation(List<Integer> siteIds) {
|
if (siteIds == null || siteIds.isEmpty()) {
|
Map<String, Object> emptySummary = new LinkedHashMap<>();
|
emptySummary.put("score", 0D); emptySummary.put("goodCount", 0); emptySummary.put("mediumCount", 0); emptySummary.put("badCount", 0);
|
emptySummary.put("goodRate", BigDecimal.ZERO); emptySummary.put("mediumRate", BigDecimal.ZERO); emptySummary.put("badRate", BigDecimal.ZERO);
|
Map<String, Object> empty = new LinkedHashMap<>(); empty.put("summary", emptySummary); empty.put("goodTags", Collections.emptyList()); empty.put("badTags", Collections.emptyList()); return empty;
|
}
|
Double score = chargingOrderService.getAver(siteIds);
|
List<Map<String, Object>> levels = chargingOrderService.getLevelEvaluate(siteIds);
|
long good = 0, medium = 0, bad = 0;
|
if (levels != null) for (Map<String, Object> level : levels) {
|
String range = String.valueOf(level.get("score_range")); long count = numberValue(level.get("count"));
|
if ("4-5".equals(range)) good += count; else if ("3".equals(range)) medium += count; else if ("1-2".equals(range)) bad += count;
|
}
|
long total = good + medium + bad;
|
Map<String, Object> summary = new LinkedHashMap<>(); summary.put("score", score == null ? 0D : score);
|
summary.put("goodCount", good); summary.put("mediumCount", medium); summary.put("badCount", bad);
|
summary.put("goodRate", ratePercent(good, total)); summary.put("mediumRate", ratePercent(medium, total)); summary.put("badRate", ratePercent(bad, total));
|
Map<String, Object> result = new LinkedHashMap<>(); result.put("summary", summary);
|
result.put("goodTags", safeList(orderEvaluateService.goodTop(siteIds))); result.put("badTags", safeList(orderEvaluateService.badTop(siteIds))); return result;
|
}
|
|
private List<Map<String, Object>> franchiseeTraffic(List<Integer> siteIds, LocalDateTime[] range) {
|
if (siteIds == null || siteIds.isEmpty() || range == null || range[0] == null || range[1] == null) {
|
return Collections.emptyList();
|
}
|
List<Map<String, Object>> result = new ArrayList<>();
|
chargingOrderMapper.franchiseeTrafficStats(siteIds, range[0], range[1]).forEach(stat -> {
|
if (stat == null || stat.getOrderCount() == null || stat.getOrderCount() == 0) {
|
return;
|
}
|
String source = stat.getSource() == null || stat.getSource().isEmpty() ? "明星充电" : stat.getSource();
|
result.add(namedCount(source, stat.getOrderCount()));
|
});
|
return result;
|
}
|
|
private List<Map<String, Object>> franchiseeOrderCarGroup(List<FranchiseeUserAgg> aggs,
|
List<TAppUserCar> cars,
|
java.util.function.Function<TAppUserCar, String> getter,
|
String emptyName,
|
int limit) {
|
Map<Long, TAppUserCar> carsById = cars.stream()
|
.filter(car -> car.getId() != null)
|
.collect(Collectors.toMap(TAppUserCar::getId, car -> car, (left, right) -> left));
|
Map<String, Long> counts = new HashMap<>();
|
aggs.forEach(agg -> {
|
if (agg == null || agg.getOrderCount() == null) {
|
return;
|
}
|
TAppUserCar car = agg.getAppUserCarId() == null ? null : carsById.get(agg.getAppUserCarId());
|
String value = car == null ? null : getter.apply(car);
|
counts.merge(value == null || value.trim().isEmpty() ? emptyName : value, agg.getOrderCount(), Long::sum);
|
});
|
return counts.entrySet().stream().sorted(Map.Entry.<String, Long>comparingByValue().reversed()).limit(limit)
|
.map(entry -> namedCount(entry.getKey(), entry.getValue())).collect(Collectors.toList());
|
}
|
|
private List<Map<String, Object>> namedCounts(String[] names, long[] values) {
|
List<Map<String, Object>> result = new ArrayList<>();
|
for (int i = 0; i < names.length; i++) if (values[i] > 0) result.add(namedCount(names[i], values[i]));
|
return result;
|
}
|
|
private Map<String, Object> namedCount(String name, long value) { Map<String, Object> result = new LinkedHashMap<>(); result.put("name", name); result.put("value", value); return result; }
|
private long numberValue(Object value) { return value instanceof Number ? ((Number) value).longValue() : 0L; }
|
private BigDecimal ratePercent(long numerator, long denominator) { return denominator == 0 ? BigDecimal.ZERO : BigDecimal.valueOf(numerator * 100D / denominator).setScale(2, RoundingMode.HALF_UP); }
|
private <T> List<T> safeList(List<T> values) { return values == null ? Collections.emptyList() : values; }
|
|
private BigDecimal countGuns(List<TChargingGun> guns, int status) { return BigDecimal.valueOf(guns.stream().filter(gun -> Objects.equals(gun.getStatus(), status)).count()); }
|
private boolean isAvailableGun(TChargingGun gun) { return gun.getStatus() != null && gun.getStatus() >= 2 && gun.getStatus() <= 6; }
|
private BigDecimal rate(BigDecimal numerator, BigDecimal denominator) { return denominator.signum() == 0 ? BigDecimal.ZERO : numerator.multiply(BigDecimal.valueOf(100)).divide(denominator, 2, RoundingMode.HALF_UP); }
|
private List<Map<String, Object>> operationCharts(List<TChargingGun> guns, Map<Integer, FranchiseeGunSat> gunSatMap, boolean dc) {
|
List<TChargingGun> selected = guns.stream().filter(gun -> dc ? Objects.equals(gun.getType(), 4) : gun.getType() != null && gun.getType() >= 1 && gun.getType() <= 3).collect(Collectors.toList());
|
List<Map<String, Object>> charts = new ArrayList<>();
|
String[] keys = {"availableRate", "faultRate", "offlineRate", "powerSatisfactionRate"}; int[] statuses = {0, 7, 1, 0};
|
String[] names = {"可用率", "故障率", "离网率", "电量满足率"};
|
for (int i = 0; i < keys.length; i++) {
|
final int status = statuses[i]; Map<String, Object> chart = new LinkedHashMap<>(); chart.put("key", keys[i]);
|
List<String> categories = selected.stream().map(TChargingGun::getName).map(name -> name == null ? "未命名充电枪" : name).collect(Collectors.toList());
|
final int metricIndex = i;
|
List<BigDecimal> values = selected.stream().map(gun -> metricIndex == 3
|
? gunSatisfaction(gunSatMap, gun.getId())
|
: BigDecimal.valueOf(metricIndex == 0 ? (isAvailableGun(gun) ? 100 : 0) : (Objects.equals(gun.getStatus(), status) ? 100 : 0))).collect(Collectors.toList());
|
chart.put("categories", categories);
|
Map<String, Object> series = new LinkedHashMap<>(); series.put("name", names[i]); series.put("data", values); chart.put("series", Collections.singletonList(series)); charts.add(chart);
|
}
|
return charts;
|
}
|
|
private BigDecimal gunSatisfaction(Map<Integer, FranchiseeGunSat> gunSatMap, Integer gunId) {
|
FranchiseeGunSat sat = gunId == null ? null : gunSatMap.get(gunId);
|
if (sat == null || sat.getSatCount() == null || sat.getSatCount() == 0) {
|
return BigDecimal.ZERO;
|
}
|
return value(sat.getSatSum()).divide(BigDecimal.valueOf(sat.getSatCount()), 2, RoundingMode.HALF_UP);
|
}
|
|
private LocalDateTime[] franchiseeRange(Map<String, Object> params) {
|
LocalDate today = LocalDate.now();
|
if (params != null && params.get("startTime") != null && params.get("endTime") != null) {
|
String startText = String.valueOf(params.get("startTime"));
|
String endText = String.valueOf(params.get("endTime"));
|
if (!startText.isEmpty() && !endText.isEmpty()) {
|
try {
|
return new LocalDateTime[]{LocalDate.parse(startText).atStartOfDay(), LocalDate.parse(endText).plusDays(1).atStartOfDay()};
|
} catch (RuntimeException ignored) {
|
// 日期格式异常时回退到快捷日期范围。
|
}
|
}
|
}
|
String type = params == null ? "today" : String.valueOf(params.getOrDefault("dateType", "today"));
|
if ("year".equals(type)) return new LocalDateTime[]{today.withDayOfYear(1).atStartOfDay(), today.plusDays(1).atStartOfDay()};
|
if ("month".equals(type)) return new LocalDateTime[]{today.withDayOfMonth(1).atStartOfDay(), today.plusDays(1).atStartOfDay()};
|
if ("week".equals(type)) { LocalDate start = today.minusDays(today.getDayOfWeek().getValue() - 1); return new LocalDateTime[]{start.atStartOfDay(), today.plusDays(1).atStartOfDay()}; }
|
return new LocalDateTime[]{today.atStartOfDay(), today.plusDays(1).atStartOfDay()};
|
}
|
|
static BigDecimal franchiseeIncomeWan(List<FranchiseeDayStat> stats) {
|
return stats.stream().map(FranchiseeDayStat::getChargingIncome)
|
.map(value -> value == null ? BigDecimal.ZERO : value)
|
.reduce(BigDecimal.ZERO, BigDecimal::add)
|
.divide(BigDecimal.valueOf(10000), 4, RoundingMode.HALF_UP);
|
}
|
|
private <T> BigDecimal sum(List<T> items, java.util.function.Function<T, BigDecimal> getter) { return items.stream().map(getter).map(this::value).reduce(BigDecimal.ZERO, BigDecimal::add); }
|
private BigDecimal value(BigDecimal value) { return value == null ? BigDecimal.ZERO : value; }
|
private Map<LocalDate, FranchiseeDayStat> dayStatByDay(List<FranchiseeDayStat> stats) {
|
return stats.stream().filter(stat -> stat != null && stat.getStatDay() != null)
|
.collect(Collectors.toMap(FranchiseeDayStat::getStatDay, stat -> stat, (left, right) -> left));
|
}
|
private Map<String, Object> franchiseeDailyTrend(List<FranchiseeDayStat> stats, LocalDateTime[] range, String name, java.util.function.Function<FranchiseeDayStat, BigDecimal> getter) {
|
Map<LocalDate, FranchiseeDayStat> byDay = dayStatByDay(stats);
|
List<String> categories = new ArrayList<>(); List<BigDecimal> data = new ArrayList<>();
|
LocalDate start = range[0] == null ? LocalDate.now() : range[0].toLocalDate();
|
LocalDate end = range[1] == null ? start.plusDays(1) : range[1].toLocalDate();
|
for (LocalDate day = start; day.isBefore(end); day = day.plusDays(1)) {
|
categories.add(day.toString().substring(5));
|
FranchiseeDayStat stat = byDay.get(day);
|
data.add(stat == null ? BigDecimal.ZERO : value(getter.apply(stat)));
|
}
|
Map<String, Object> chart = new LinkedHashMap<>(); chart.put("categories", categories);
|
Map<String, Object> series = new LinkedHashMap<>(); series.put("name", name); series.put("data", data); chart.put("series", new ArrayList<>(Collections.singletonList(series))); return chart;
|
}
|
private List<Map<String, Object>> franchiseeManagementOrderStats(List<Integer> siteIds, LocalDateTime[] range) {
|
if (siteIds == null || siteIds.isEmpty() || range == null || range.length < 2
|
|| range[0] == null || range[1] == null || !range[1].isAfter(range[0])) {
|
return Collections.emptyList();
|
}
|
LocalDate start = range[0].toLocalDate();
|
LocalDate end = range[1].minusNanos(1).toLocalDate();
|
return safeList(chargingOrderService.getByDate(start, end, siteIds));
|
}
|
|
private BigDecimal sumManagementOrderField(List<Map<String, Object>> stats, String field) {
|
return safeList(stats).stream()
|
.map(row -> decimalValue(row == null ? null : row.get(field)))
|
.reduce(BigDecimal.ZERO, BigDecimal::add);
|
}
|
|
private BigDecimal decimalValue(Object value) {
|
if (value == null) return BigDecimal.ZERO;
|
try {
|
return new BigDecimal(String.valueOf(value));
|
} catch (NumberFormatException ignored) {
|
return BigDecimal.ZERO;
|
}
|
}
|
|
private Map<String, Object> franchiseeManagementOrderTrend(List<Map<String, Object>> stats) {
|
List<String> categories = new ArrayList<>();
|
List<BigDecimal> amountData = new ArrayList<>();
|
List<BigDecimal> countData = new ArrayList<>();
|
for (Map<String, Object> row : safeList(stats)) {
|
if (row == null) continue;
|
categories.add(String.valueOf(row.get("time")));
|
amountData.add(decimalValue(row.get("paymoney")));
|
countData.add(decimalValue(row.get("orderCount")));
|
}
|
Map<String, Object> amountSeries = new LinkedHashMap<>();
|
amountSeries.put("name", "充电金额"); amountSeries.put("data", amountData); amountSeries.put("type", "column");
|
Map<String, Object> countSeries = new LinkedHashMap<>();
|
countSeries.put("name", "充电订单"); countSeries.put("data", countData); countSeries.put("type", "line");
|
countSeries.put("style", "curve"); countSeries.put("index", 1);
|
Map<String, Object> chart = new LinkedHashMap<>();
|
chart.put("categories", categories);
|
chart.put("series", new ArrayList<>(Arrays.asList(amountSeries, countSeries)));
|
return chart;
|
}
|
|
private Map<String, Object> franchiseePhaseRing(List<Integer> siteIds, LocalDateTime[] range) {
|
Map<Integer, BigDecimal> phase = new LinkedHashMap<>(); phase.put(1, BigDecimal.ZERO); phase.put(2, BigDecimal.ZERO); phase.put(3, BigDecimal.ZERO); phase.put(4, BigDecimal.ZERO);
|
if (siteIds != null && !siteIds.isEmpty() && range != null && range[0] != null && range[1] != null) {
|
List<Long> ids = chargingOrderMapper.franchiseeOrderIds(siteIds, range[0], range[1]);
|
if (!ids.isEmpty()) {
|
// 分块并行反查 strategy 表（分片键 charging_order_id）：MyCat 按 id 路由成本约 2ms/个，
|
// 串行 5000/块在大范围下 70s+ 读超时；100/块 × 16 线程实测 46k id 约 20s（代理并发吞吐有限）。
|
List<CompletableFuture<Void>> futures = new ArrayList<>();
|
for (int from = 0; from < ids.size(); from += PHASE_ID_BATCH_SIZE) {
|
List<Long> chunk = ids.subList(from, Math.min(from + PHASE_ID_BATCH_SIZE, ids.size()));
|
futures.add(CompletableFuture.runAsync(() -> {
|
List<FranchiseePhaseStat> items = chargingOrderMapper.franchiseePhaseStatsByOrderIds(chunk);
|
if (items != null) {
|
synchronized (phase) {
|
items.forEach(item -> {
|
if (item != null && item.getType() != null) {
|
phase.computeIfPresent(item.getType(), (key, total) -> total.add(value(item.getCapacity())));
|
}
|
});
|
}
|
}
|
}, PHASE_QUERY_EXECUTOR));
|
}
|
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0])).join();
|
}
|
}
|
String[] names = {"尖", "峰", "平", "谷"}; List<Map<String, Object>> data = new ArrayList<>();
|
for (int i = 1; i <= 4; i++) { Map<String, Object> item = new LinkedHashMap<>(); item.put("name", names[i - 1]); item.put("value", phase.get(i)); data.add(item); }
|
Map<String, Object> chart = new LinkedHashMap<>(); chart.put("series", Collections.singletonList(Collections.singletonMap("data", data))); return chart;
|
}
|
private Map<String, Object> franchiseeEfficiencyTrend(List<FranchiseeDayStat> stats, LocalDateTime[] range) {
|
Map<LocalDate, FranchiseeDayStat> byDay = dayStatByDay(stats);
|
List<String> categories = new ArrayList<>();
|
List<BigDecimal> powerData = new ArrayList<>(), utilization = new ArrayList<>();
|
LocalDate start = range[0] == null ? LocalDate.now() : range[0].toLocalDate();
|
LocalDate end = range[1] == null ? start.plusDays(1) : range[1].toLocalDate();
|
for (LocalDate day = start; day.isBefore(end); day = day.plusDays(1)) {
|
categories.add(day.toString().substring(5));
|
FranchiseeDayStat stat = byDay.get(day);
|
powerData.add(stat == null ? BigDecimal.ZERO : averagePower(stat));
|
utilization.add(observedPowerUtilization(stat == null ? Collections.emptyList() : Collections.singletonList(stat)));
|
}
|
Map<String, Object> chart = new LinkedHashMap<>(); chart.put("categories", categories);
|
Map<String, Object> powerSeries = new LinkedHashMap<>(); powerSeries.put("name", "功率"); powerSeries.put("data", powerData);
|
Map<String, Object> utilizationSeries = new LinkedHashMap<>(); utilizationSeries.put("name", "功率利用率"); utilizationSeries.put("data", utilization);
|
chart.put("series", new ArrayList<>(Arrays.asList(powerSeries, utilizationSeries))); return chart;
|
}
|
private BigDecimal averagePower(FranchiseeDayStat stat) {
|
if (stat == null || stat.getPowerCount() == null || stat.getPowerCount() == 0 || stat.getTotalPower() == null) {
|
return BigDecimal.ZERO;
|
}
|
return stat.getTotalPower().divide(BigDecimal.valueOf(stat.getPowerCount()), 2, RoundingMode.HALF_UP);
|
}
|
private BigDecimal observedPowerUtilization(List<FranchiseeDayStat> stats) {
|
BigDecimal sum = stats.stream().map(FranchiseeDayStat::getUtilPowerSum).map(this::value).reduce(BigDecimal.ZERO, BigDecimal::add);
|
long count = stats.stream().mapToLong(stat -> numberValue(stat.getUtilPowerCount())).sum();
|
if (count == 0) return BigDecimal.ZERO;
|
BigDecimal maximum = stats.stream().map(FranchiseeDayStat::getMaxPower).filter(Objects::nonNull).max(BigDecimal::compareTo).orElse(BigDecimal.ZERO);
|
if (maximum.signum() == 0) return BigDecimal.ZERO;
|
return sum.divide(BigDecimal.valueOf(count), 4, RoundingMode.HALF_UP).multiply(BigDecimal.valueOf(100)).divide(maximum, 2, RoundingMode.HALF_UP);
|
}
|
private BigDecimal demandPowerSatisfaction(List<FranchiseeDayStat> stats) {
|
BigDecimal total = stats.stream().map(FranchiseeDayStat::getElecSatSum).map(this::value).reduce(BigDecimal.ZERO, BigDecimal::add);
|
long count = stats.stream().mapToLong(stat -> numberValue(stat.getElecSatCount())).sum();
|
if (count == 0) return BigDecimal.ZERO;
|
return total.divide(BigDecimal.valueOf(count), 2, RoundingMode.HALF_UP);
|
}
|
private Map<String, Object> franchiseePowerDistribution(List<Integer> siteIds, LocalDateTime[] range) {
|
String[] names = {"0-30kW", "30-60kW", "60-120kW", "120-300kW", "300kW以上"}; long[] counts = new long[5];
|
if (siteIds != null && !siteIds.isEmpty() && range != null && range[0] != null && range[1] != null) {
|
chargingOrderMapper.franchiseePowerBuckets(siteIds, range[0], range[1]).forEach(bucket -> {
|
if (bucket != null && bucket.getBucket() != null && bucket.getBucket() >= 0 && bucket.getBucket() < 5) {
|
counts[bucket.getBucket()] += numberValue(bucket.getOrderCount());
|
}
|
});
|
}
|
List<Map<String, Object>> data = new ArrayList<>(); for (int i = 0; i < names.length; i++) { Map<String, Object> item = new LinkedHashMap<>(); item.put("name", names[i]); item.put("value", counts[i]); data.add(item); }
|
return Collections.singletonMap("series", Collections.singletonList(Collections.singletonMap("data", data)));
|
}
|
/** 收支分析近6月柱状图：与后台 电站收入分析 一致（历史月结算账单 + 当月原始订单）。 */
|
private Map<String, Object> franchiseeIncomeTrendFromSix(List<SixChargingDto> months) {
|
List<String> categories = new ArrayList<>();
|
List<BigDecimal> electricity = new ArrayList<>(), service = new ArrayList<>();
|
for (SixChargingDto month : months) {
|
if (month == null) {
|
continue;
|
}
|
categories.add(month.getMonth() + "月");
|
electricity.add(month.getElectrovalence() == null ? BigDecimal.ZERO : month.getElectrovalence());
|
service.add(month.getServiceCharge() == null ? BigDecimal.ZERO : month.getServiceCharge());
|
}
|
Map<String, Object> chart = new LinkedHashMap<>();
|
chart.put("categories", categories);
|
Map<String, Object> electricitySeries = new LinkedHashMap<>();
|
electricitySeries.put("name", "充电费");
|
electricitySeries.put("data", electricity);
|
Map<String, Object> serviceSeries = new LinkedHashMap<>();
|
serviceSeries.put("name", "服务费");
|
serviceSeries.put("data", service);
|
chart.put("series", new ArrayList<>(Arrays.asList(electricitySeries, serviceSeries)));
|
return chart;
|
}
|
|
|
|
/**
|
* 远程调用 监管平台查询前一天用能统计
|
* @return
|
*/
|
@ResponseBody
|
@PostMapping(value = "/getChargingStatistics")
|
public R<List<TChargingOrder>> getChargingStatistics(@RequestBody ChargingStatisticeDTO dto) {
|
List<Long> collect = chargingOrderAccountingStrategyService.lambdaQuery().between(TChargingOrderAccountingStrategy::getCreateTime, dto.getStartTime(), dto.getEndTime())
|
.list().stream().map(TChargingOrderAccountingStrategy::getChargingOrderId).collect(Collectors.toList());
|
if (!collect.isEmpty()){
|
List<TChargingOrder> list = chargingOrderService.lambdaQuery()
|
.in(TChargingOrder::getId,collect).list();
|
return R.ok(list);
|
}
|
return R.ok(new ArrayList<TChargingOrder>());
|
}
|
|
/**
|
* 远程调用 增加管理后台赠送会员记录
|
* @return
|
*/
|
@ResponseBody
|
@PostMapping(value = "/management/give/vip")
|
public R managementGiveVip(@RequestBody TGrantVip grantVip) {
|
return R.ok(tGrantVipService.save(grantVip));
|
}
|
|
/**
|
* 远程调用根据枪id 查询最新的订单id 用户后台结束充电
|
* @param id
|
* @return
|
*/
|
@ResponseBody
|
@PostMapping(value = "/queryOrderByGunId/{id}")
|
public R<String> queryOrderByGunId(@PathVariable("id") String id) {
|
List<Integer> integers = new ArrayList<>();
|
integers.add(2);
|
integers.add(3);
|
integers.add(4);
|
TChargingOrder one = chargingOrderService.lambdaQuery()
|
.eq(TChargingOrder::getChargingGunId, id)
|
.in(TChargingOrder::getStatus, integers)
|
.one();
|
if (one!=null){
|
return R.ok(one.getId().toString());
|
}
|
return R.ok();
|
}
|
|
|
@RequiresPermissions(value = {"/chargingUserAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/enterprise/charging/analysis")
|
@ApiOperation(value = "企业用户充电分析", tags = {"管理后台-数据分析-企业用户充电分析"})
|
public R<PageInfo<EnterpriseChargingAnalysisVO>> enterpriseChargingAnalysis(@RequestBody EnterpriseChargingAnalysisQuery query) {
|
return chargingOrderService.enterpriseChargingAnalysis(query);
|
}
|
|
@RequiresPermissions(value = {"/chargingUserAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/enterprise/charging/detail")
|
@ApiOperation(value = "企业用户充电明细", tags = {"管理后台-数据分析-企业用户充电分析"})
|
public R<PageInfo<EnterpriseChargingDetailVO>> enterpriseChargingDetail(@RequestBody EnterpriseChargingAnalysisQuery query) {
|
return chargingOrderService.enterpriseChargingDetail(query);
|
}
|
|
@RequiresPermissions(value = {"/chargingUserAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@PutMapping(value = "/enterprise/charging/detail/export")
|
@ApiOperation(value = "企业用户充电明细导出", tags = {"管理后台-数据分析-企业用户充电分析"})
|
public void exportEnterpriseChargingDetail(@RequestBody EnterpriseChargingAnalysisQuery query) {
|
List<EnterpriseChargingDetailVO> records = chargingOrderService.enterpriseChargingDetailExport(query);
|
List<EnterpriseChargingDetailExport> exports = records.stream().map(this::buildEnterpriseChargingDetailExport).collect(Collectors.toList());
|
Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams(), EnterpriseChargingDetailExport.class, exports);
|
HttpServletResponse response = WebUtils.response();
|
response.setContentType("application/vnd.ms-excel;charset=UTF-8");
|
response.setCharacterEncoding("utf-8");
|
response.setHeader("Pragma", "no-cache");
|
response.setHeader("Cache-Control", "no-cache");
|
try {
|
response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode("企业用户充电明细.xls", "utf-8"));
|
try (ServletOutputStream outputStream = response.getOutputStream()) {
|
workbook.write(outputStream);
|
}
|
workbook.close();
|
} catch (IOException e) {
|
log.error("导出企业用户充电明细失败", e);
|
}
|
}
|
|
private EnterpriseChargingDetailExport buildEnterpriseChargingDetailExport(EnterpriseChargingDetailVO dto) {
|
EnterpriseChargingDetailExport export = new EnterpriseChargingDetailExport();
|
export.setCode(dto.getCode());
|
export.setOrderType(formatEnterpriseOrderType(dto.getOrderType()));
|
export.setOrderClassification(formatOrderClassification(dto.getOrderClassification()));
|
export.setSiteName(dto.getSiteName());
|
export.setTerminalName(dto.getTerminalName());
|
export.setStatus(formatPayOrderStatus(1, dto.getStatus()));
|
export.setChargingSecond(dto.getChargingSecond());
|
export.setTotalAmount(dto.getTotalAmount());
|
export.setCouponDiscountAmount(dto.getCouponDiscountAmount());
|
export.setVipDiscountAmount(dto.getVipDiscountAmount());
|
export.setPaymentAmount(dto.getPaymentAmount());
|
export.setRefundAmount(dto.getRefundAmount());
|
export.setPartnerName(dto.getPartnerName());
|
export.setPhone(dto.getPhone());
|
export.setOrderSource(formatOrderSource(dto.getOrderSource()));
|
export.setCreateTime(dto.getCreateTime() == null ? null : DateUtils.localDateTimeToString(dto.getCreateTime()));
|
export.setStartTime(dto.getStartTime() == null ? null : DateUtils.localDateTimeToString(dto.getStartTime()));
|
export.setEndTime(dto.getEndTime() == null ? null : DateUtils.localDateTimeToString(dto.getEndTime()));
|
export.setLicensePlate(dto.getLicensePlate());
|
export.setChargingCapacity(dto.getChargingCapacity());
|
export.setElectrovalence(dto.getElectrovalence());
|
export.setServiceCharge(dto.getServiceCharge());
|
export.setEndMode(formatChargingEndMode(dto.getEndMode()));
|
export.setPeriodCount(dto.getPeriodCount());
|
return export;
|
}
|
|
private String formatChargingEndMode(Integer endMode) {
|
if (endMode == null) {
|
return "-";
|
}
|
switch (endMode) {
|
case 0:
|
return "异常终止";
|
case 1:
|
return "主动终止";
|
case 2:
|
return "满电终止";
|
case 3:
|
return "费用不足终止";
|
default:
|
return "-";
|
}
|
}
|
|
private String formatEnterpriseOrderType(Integer type) {
|
if (type == null) {
|
return "-";
|
}
|
if (type == 1) {
|
return "充电订单（小程序）";
|
}
|
if (type == 2) {
|
return "充电订单（刷卡）";
|
}
|
return "充电订单";
|
}
|
|
private String formatOrderClassification(Integer type) {
|
if (type == null) {
|
return "-";
|
}
|
return type == 1 ? "线上订单" : "线下订单";
|
}
|
|
private String formatOrderSource(Integer source) {
|
if (source == null) {
|
return "-";
|
}
|
if (source == 0) {
|
return "自有平台";
|
}
|
if (source == 1) {
|
return "第三方平台";
|
}
|
if (source == 2) {
|
return "引流平台";
|
}
|
return "其他";
|
}
|
|
@RequiresPermissions(value = {"/invoiceManagement/select_order", "/paymentOrder/order"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/pay/order/list")
|
@ApiOperation(value = "列表", tags = {"管理后台-支付订单-订单信息"})
|
public R<PageInfo<PayOrderDto>> payOrderList(@RequestBody PayOrderQueryDto payOrderQueryDto) {
|
resolveInvoiceOrderIds(payOrderQueryDto);
|
return chargingOrderService.payOrderQuery(payOrderQueryDto);
|
}
|
|
@RequiresPermissions(value = {"/invoiceManagement/select_order", "/invoiceManagement/export", "/paymentOrder/order"}, logical = Logical.OR)
|
@ResponseBody
|
@PutMapping(value = "/pay/order/export")
|
@ApiOperation(value = "导出查看订单列表", tags = {"管理后台-支付订单-订单信息"})
|
@Log(title = "发票管理查看订单导出", businessType = BusinessType.EXPORT)
|
public void exportPayOrder(@RequestBody PayOrderQueryDto payOrderQueryDto) {
|
resolveInvoiceOrderIds(payOrderQueryDto);
|
payOrderQueryDto.setPageCurr(1);
|
payOrderQueryDto.setPageSize(10000);
|
R<PageInfo<PayOrderDto>> result = chargingOrderService.payOrderQuery(payOrderQueryDto);
|
List<PayOrderDto> records = result.getData() == null || result.getData().getRecords() == null
|
? Collections.emptyList() : result.getData().getRecords();
|
List<PayOrderExport> exports = records.stream().map(this::buildPayOrderExport).collect(Collectors.toList());
|
Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams(), PayOrderExport.class, exports);
|
HttpServletResponse response = WebUtils.response();
|
response.setContentType("application/vnd.ms-excel;charset=UTF-8");
|
response.setCharacterEncoding("utf-8");
|
response.setHeader("Pragma", "no-cache");
|
response.setHeader("Cache-Control", "no-cache");
|
try {
|
response.setHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode("订单列表.xls", "utf-8"));
|
try (ServletOutputStream outputStream = response.getOutputStream()) {
|
workbook.write(outputStream);
|
}
|
workbook.close();
|
} catch (IOException e) {
|
log.error("导出查看订单列表失败", e);
|
}
|
}
|
|
/**
|
* 查看开票订单时以数据库中的开票明细为准，避免前端遗漏或篡改订单 ID。
|
*/
|
private void resolveInvoiceOrderIds(PayOrderQueryDto query) {
|
if (query == null || query.getInvoiceId() == null) {
|
return;
|
}
|
LambdaQueryWrapper<TOrderInvoiceDetail> wrapper = new LambdaQueryWrapper<TOrderInvoiceDetail>()
|
.eq(TOrderInvoiceDetail::getOrderInvoiceId, query.getInvoiceId());
|
if (query.getType() != null) {
|
wrapper.eq(TOrderInvoiceDetail::getOrderType, query.getType());
|
}
|
List<String> orderIds = orderInvoiceDetailService.list(wrapper).stream()
|
.map(TOrderInvoiceDetail::getOrderId)
|
.filter(Objects::nonNull)
|
.map(String::valueOf)
|
.collect(Collectors.toList());
|
query.setIds(orderIds);
|
}
|
|
private PayOrderExport buildPayOrderExport(PayOrderDto dto) {
|
PayOrderExport export = new PayOrderExport();
|
export.setCode(dto.getCode());
|
export.setType(formatPayOrderType(dto.getType()));
|
export.setTitle(dto.getTitle());
|
export.setPhone(dto.getPhone());
|
export.setOrderStatus(dto.getPayTime() != null ? "订单支付成功" : "订单完成");
|
export.setStatus(formatPayOrderStatus(dto.getType(), dto.getStatus()));
|
export.setRefundStatus(dto.getRefundStatus() != null && dto.getRefundStatus() > 0 ? "有退款" : "无退款");
|
export.setRechargeAmount(dto.getRechargeAmount());
|
export.setPaymentAmount(dto.getPaymentAmount());
|
export.setFinalAmount(dto.getFinalAmount());
|
export.setCreateTime(dto.getCreateTime() == null ? null : DateUtils.localDateTimeToString(dto.getCreateTime()));
|
export.setEndTime(dto.getEndTime() == null ? null : DateUtils.localDateTimeToString(dto.getEndTime()));
|
export.setPayTime(dto.getPayTime() == null ? null : DateUtils.localDateTimeToString(dto.getPayTime()));
|
return export;
|
}
|
|
private String formatPayOrderType(Integer type) {
|
if (type == null || type < 1 || type > 4) {
|
return "-";
|
}
|
return new String[]{"充电订单", "购物订单", "vip订单", "停车订单"}[type - 1];
|
}
|
|
private String formatPayOrderStatus(Integer type, Integer status) {
|
if (type == null) {
|
return "-";
|
}
|
if (type == 3) {
|
return "支付成功";
|
}
|
if (status == null) {
|
return "-";
|
}
|
if (type == 1 && status >= 0 && status <= 5) {
|
return new String[]{"未知", "等待中", "启动中", "充电中", "停止中", "已结束"}[status];
|
}
|
if (type == 2 && status >= 1 && status <= 4) {
|
return new String[]{"待发货", "待收货", "已完成", "已取消"}[status - 1];
|
}
|
if (type == 4 && status >= 1 && status <= 3) {
|
return new String[]{"已进场", "已出场", "已缴费出场"}[status - 1];
|
}
|
return "-";
|
}
|
|
|
|
public static List<PayOrderDto> testing5(long total, long current, long size, List<PayOrderDto> str){
|
List<PayOrderDto> result = new ArrayList<>();
|
//获取初始化分页结构
|
com.ruoyi.order.util.Page<PayOrderDto> page = new com.ruoyi.order.util.Page().getPage(total, size, current - 1);
|
//获取集合下标初始值
|
long startIndex = page.getStartIndex();
|
//获取集合下标结束值
|
long endInddex = 0;
|
if(startIndex + page.getCurrent() >= total || size > total){
|
endInddex = total;
|
}else {
|
endInddex = Math.min(startIndex + page.getSize(), total);
|
}
|
//如果输入的开始查询下标大于集合大小，则查询为空值
|
if(startIndex > total){
|
result = Collections.emptyList();
|
}else{
|
result = str.subList((int)startIndex,(int)endInddex);
|
}
|
return result;
|
}
|
|
|
|
@ResponseBody
|
@RequiresPermissions(value = {"/paymentOrder/refund", "/paymentOrder/refund/select"}, logical = Logical.OR)
|
@PostMapping(value = "/pay/order/refund")
|
@ApiOperation(value = "退款", tags = {"管理后台-支付订单-订单信息"})
|
public R refund(@RequestBody PayOrderRefundDto payOrderQueryDto) {
|
return chargingOrderService.payRefund(payOrderQueryDto);
|
}
|
|
@ResponseBody
|
@PostMapping(value = "/pay/order/special/refund/query")
|
@RequiresPermissions(value = {"/paymentOrder/specialRefund", "/paymentOrder/specialRefund/refund"}, logical = Logical.OR)
|
@ApiOperation(value = "特殊退款查询", tags = {"管理后台-支付订单-特殊退款处理"})
|
public R<PayOrderInfoDto> specialRefundQuery(@RequestBody PayOrderRefundDto payOrderQueryDto) {
|
return chargingOrderService.getSpecialRefundOrder(payOrderQueryDto);
|
}
|
|
@ResponseBody
|
@PostMapping(value = "/pay/order/special/refund")
|
@RequiresPermissions(value = {"/paymentOrder/specialRefund/refund"}, logical = Logical.OR)
|
@ApiOperation(value = "特殊退款", tags = {"管理后台-支付订单-特殊退款处理"})
|
public R specialRefund(@RequestBody PayOrderRefundDto payOrderQueryDto) {
|
return chargingOrderService.specialRefund(payOrderQueryDto);
|
}
|
|
|
@RequiresPermissions(value = {"/paymentOrder/order"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/pay/order/pay/detail")
|
@ApiOperation(value = "支付信息", tags = {"管理后台-支付订单-订单信息"})
|
public R<PayOrderInfoDto> payOrderList(Long orderId, Integer type) {
|
switch (type) {
|
case 1:
|
TChargingOrder byId = chargingOrderService.getById(orderId);
|
PayOrderInfoDto payOrderInfoDto = new PayOrderInfoDto();
|
payOrderInfoDto.setOrderId(byId.getId().toString());
|
payOrderInfoDto.setCode(byId.getCode());
|
payOrderInfoDto.setTradeNo(byId.getRechargeSerialNumber());
|
payOrderInfoDto.setPayType(byId.getRechargePaymentType());
|
payOrderInfoDto.setPayAmount(byId.getPaymentAmount());
|
payOrderInfoDto.setPayTime(byId.getCreateTime());
|
payOrderInfoDto.setRefundAmount(byId.getRefundAmount());
|
payOrderInfoDto.setRechargeAmount(byId.getRechargeAmount());
|
payOrderInfoDto.setFinalAmount(byId.getRechargeAmount().subtract(byId.getRefundAmount()));
|
payOrderInfoDto.setPayMethod(byId.getPayMethod());
|
payOrderInfoDto.setBalancePayAmount(byId.getBalancePayAmount());
|
payOrderInfoDto.setThirdPayAmount(byId.getThirdPayAmount());
|
payOrderInfoDto.setBalanceRefundAmount(byId.getBalanceRefundAmount());
|
payOrderInfoDto.setThirdRefundAmount(byId.getThirdRefundAmount());
|
payOrderInfoDto.setRefundableAmount(chargingOrderService.getManualRefundableAmount(byId.getId()));
|
return R.ok(payOrderInfoDto);
|
case 2:
|
TShoppingOrder byId1 = shoppingOrderService.getById(orderId);
|
PayOrderInfoDto payOrderInfoDto1 = new PayOrderInfoDto();
|
payOrderInfoDto1.setOrderId(byId1.getId().toString());
|
payOrderInfoDto1.setCode(byId1.getCode());
|
payOrderInfoDto1.setTradeNo(byId1.getSerialNumber());
|
payOrderInfoDto1.setPayType(byId1.getPaymentType());
|
payOrderInfoDto1.setPayAmount(byId1.getPaymentAmount());
|
payOrderInfoDto1.setPayTime(byId1.getCreateTime());
|
payOrderInfoDto1.setRefundAmount(byId1.getRefundAmount());
|
payOrderInfoDto1.setRechargeAmount(byId1.getPaymentAmount());
|
payOrderInfoDto1.setFinalAmount(byId1.getPaymentAmount().subtract(byId1.getRefundAmount()));
|
return R.ok(payOrderInfoDto1);
|
case 3:
|
TVipOrder byId2 = vipOrderService.getById(orderId);
|
PayOrderInfoDto payOrderInfoDto2 = new PayOrderInfoDto();
|
payOrderInfoDto2.setOrderId(byId2.getId().toString());
|
payOrderInfoDto2.setCode(byId2.getCode());
|
payOrderInfoDto2.setTradeNo(byId2.getSerialNumber());
|
payOrderInfoDto2.setPayType(byId2.getPaymentType());
|
payOrderInfoDto2.setPayAmount(byId2.getPaymentAmount());
|
payOrderInfoDto2.setPayTime(byId2.getCreateTime());
|
payOrderInfoDto2.setRefundAmount(byId2.getRefundAmount());
|
payOrderInfoDto2.setRechargeAmount(byId2.getPaymentAmount());
|
payOrderInfoDto2.setFinalAmount(byId2.getPaymentAmount().subtract(byId2.getRefundAmount()));
|
return R.ok(payOrderInfoDto2);
|
//todo luo 停车场订单
|
case 4:
|
R<TParkingRecord> recordById = parkingLotClient.getRecordById(orderId);
|
TParkingRecord byId3 =recordById.getData();
|
PayOrderInfoDto payOrderInfoDto3 = new PayOrderInfoDto();
|
payOrderInfoDto3.setOrderId(byId3.getId().toString());
|
payOrderInfoDto3.setCode(byId3.getCode());
|
payOrderInfoDto3.setPayTime(byId3.getCreateTime());
|
payOrderInfoDto3.setRechargeAmount(byId3.getPayment());
|
return R.ok(payOrderInfoDto3);
|
|
|
|
}
|
return R.ok();
|
|
}
|
|
|
|
|
@ResponseBody
|
@RequiresPermissions(value = {"/paymentOrder/refund", "/paymentOrder/refund/select"}, logical = Logical.OR)
|
@GetMapping(value = "/pay/order/refund/detail")
|
@ApiOperation(value = "退款信息", tags = {"管理后台-支付订单-订单信息"})
|
public R refundDetail(Long orderId, Integer type) {
|
switch (type) {
|
case 1:
|
List<TChargingOrderRefund> byId = chargingOrderRefundService.lambdaQuery().eq(TChargingOrderRefund::getChargingOrderId, orderId).orderByDesc(TChargingOrderRefund::getRefundTime).list();
|
return R.ok(byId);
|
case 2:
|
List<TShoppingOrderRefund> list = shoppingOrderRefundService.lambdaQuery().eq(TShoppingOrderRefund::getShoppingOrderId, orderId).orderByDesc(TShoppingOrderRefund::getRefundTime).list();
|
return R.ok(list);
|
case 3:
|
List<TVipOrderRefund> list1 = vipOrderRefundService.lambdaQuery().eq(TVipOrderRefund::getVipOrderId, orderId).orderByDesc(TVipOrderRefund::getRefundTime).list();
|
return R.ok(list1);
|
|
}
|
return R.ok();
|
|
}
|
|
@ResponseBody
|
@RequiresPermissions(value = {"/paymentOrder/order"}, logical = Logical.OR)
|
@GetMapping(value = "/pay/order/charging")
|
@ApiOperation(value = "充电信息", tags = {"管理后台-支付订单-订单信息"})
|
public R<PayOrderChargingInfo> refundDetail(Long orderId) {
|
PayOrderChargingInfo payOrderChargingInfo = new PayOrderChargingInfo();
|
TChargingOrder byId = chargingOrderService.getById(orderId);
|
List<Site> data = siteClient.getSiteByIds(Collections.singletonList(byId.getSiteId())).getData();
|
payOrderChargingInfo.setSiteName(data.get(0).getName());
|
TChargingPile data1 = chargingPileClient.getChargingPileById(byId.getChargingPileId()).getData();
|
payOrderChargingInfo.setChargingName(data1.getName());
|
TChargingGun data2 = chargingGunClient.getChargingGunById(byId.getChargingGunId()).getData();
|
payOrderChargingInfo.setGunName(data2.getName());
|
payOrderChargingInfo.setCarNum(byId.getPlateNum());
|
payOrderChargingInfo.setTChargingOrder(byId);
|
|
Long count = chargingOrderAccountingStrategyService.lambdaQuery().eq(TChargingOrderAccountingStrategy::getChargingOrderId, orderId).count();
|
payOrderChargingInfo.setPeriodCount(count);
|
if (byId.getAppUserCarId()!=null && 0 != byId.getAppUserCarId()) {
|
List<Long> carid = new ArrayList<>();
|
carid.add(byId.getAppUserCarId());
|
R<List<TAppUserCar>> carByIds = appUserCarClient.getCarByIds(carid);
|
payOrderChargingInfo.setCarNum(carByIds.getData().get(0).getLicensePlate());
|
}else{
|
payOrderChargingInfo.setCarNum(byId.getPlateNum());
|
}
|
payOrderChargingInfo.setStartTime(byId.getStartTime());
|
payOrderChargingInfo.setEndTime(byId.getEndTime());
|
payOrderChargingInfo.setTimeCount(payOrderChargingInfo.calculateDuration());
|
return R.ok(payOrderChargingInfo);
|
}
|
|
@ResponseBody
|
@RequiresPermissions(value = {"/paymentOrder/order"}, logical = Logical.OR)
|
@GetMapping(value = "/pay/order/charging/details")
|
@ApiOperation(value = "充电明细", tags = {"管理后台-支付订单-订单信息"})
|
public R<List<TChargingOrderAccountingStrategy>> chargingDetail(Long orderId) {
|
TChargingOrder chargingOrder = chargingOrderService.getById(orderId);
|
List<TChargingOrderAccountingStrategy> list = chargingOrderAccountingStrategyService.lambdaQuery().eq(TChargingOrderAccountingStrategy::getChargingOrderId, orderId)
|
.orderByDesc(TChargingOrderAccountingStrategy::getStartTime).list();
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
|
for (TChargingOrderAccountingStrategy tChargingOrderAccountingStrategy : list) {
|
LocalDateTime createTime = chargingOrder.getStartTime();
|
String format = createTime.format(formatter);
|
String startTime = tChargingOrderAccountingStrategy.getStartTime();
|
if("00:00".equals(startTime)){
|
createTime = createTime.plusDays(1);
|
format = createTime.format(formatter);
|
}
|
tChargingOrderAccountingStrategy.setStartTime(format+" "+tChargingOrderAccountingStrategy.getStartTime());
|
tChargingOrderAccountingStrategy.setEndTime(format+" "+tChargingOrderAccountingStrategy.getEndTime());
|
}
|
//从新排序
|
list.sort(new Comparator<TChargingOrderAccountingStrategy>() {
|
@Override
|
public int compare(TChargingOrderAccountingStrategy o1, TChargingOrderAccountingStrategy o2) {
|
String startTime = o1.getStartTime();
|
String startTime1 = o2.getStartTime();
|
LocalDateTime localDateTime = LocalDateTime.parse(startTime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
|
LocalDateTime localDateTime1 = LocalDateTime.parse(startTime1, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
|
if(localDateTime.isBefore(localDateTime1)){
|
return -1;
|
}
|
if(localDateTime.isAfter(localDateTime1)){
|
return 1;
|
}
|
return 0;
|
}
|
});
|
return R.ok(list);
|
}
|
|
|
|
@RequiresPermissions(value = {"/paymentOrder/refund", "/paymentOrder/order", "/paymentOrder/specialRefund"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/pay/order/refund/list")
|
@ApiOperation(value = "列表", tags = {"管理后台-支付订单-退款订单"})
|
public R<PageInfo<TChargingOrderRefund>> refundList(@RequestBody ChargingRefundDto chargingRefundDto) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
SysUser sysUser = sysUserClient.getSysUser(userId).getData();
|
if (sysUser != null && Integer.valueOf(2).equals(sysUser.getRoleType())) {
|
List<Integer> siteIds = new ArrayList<>();
|
List<GetSiteListDTO> sites = siteClient.getSiteListByUserId(userId).getData();
|
if (sites != null) {
|
for (GetSiteListDTO site : sites) {
|
siteIds.add(site.getId());
|
}
|
}
|
chargingRefundDto.setSiteIds(siteIds.isEmpty() ? Collections.singletonList(-1) : siteIds);
|
}
|
return chargingOrderService.getRefundList(chargingRefundDto);
|
}
|
|
|
|
|
public static List<TChargingOrderRefund> testing4(long total, long current, long size, List<TChargingOrderRefund> str){
|
List<TChargingOrderRefund> result = new ArrayList<>();
|
//获取初始化分页结构
|
com.ruoyi.order.util.Page<TChargingOrderRefund> page = new com.ruoyi.order.util.Page().getPage(total, size, current - 1);
|
//获取集合下标初始值
|
long startIndex = page.getStartIndex();
|
//获取集合下标结束值
|
long endInddex = 0;
|
if(startIndex + page.getCurrent() >= total || size > total){
|
endInddex = total;
|
}else {
|
endInddex = Math.min(startIndex + page.getSize(), total);
|
}
|
//如果输入的开始查询下标大于集合大小，则查询为空值
|
if(startIndex > total){
|
result = Collections.emptyList();
|
}else{
|
result = str.subList((int)startIndex,(int)endInddex);
|
}
|
return result;
|
}
|
|
|
|
|
@ResponseBody
|
@PostMapping(value = "/pay/order/refund/list1")
|
@ApiOperation(value = "列表1", tags = {"管理后台-支付订单-退款订单"})
|
public R<PageInfo<TChargingOrderRefund>> refundList1(@RequestBody ChargingRefundDto chargingRefundDto) {
|
return chargingOrderService.getRefundList(chargingRefundDto);
|
|
}
|
|
|
|
|
|
|
@RequiresPermissions(value = {"/chargingPileOrder"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/chargingOrder")
|
@ApiOperation(value = "充电桩订单列表", tags = {"管理后台-订单管理"})
|
public AjaxResult<TCharingOrderVO> chargingOrder(@RequestBody ChargingOrderQuery dto) {
|
TCharingOrderVO res = chargingOrderService.chargingOrder(dto);
|
return AjaxResult.success(res);
|
}
|
|
@RequiresPermissions(value = {"/chargingPileOrder"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/chargingOrder/list")
|
@ApiOperation(value = "充电桩订单分页列表", tags = {"管理后台-订单管理"})
|
public AjaxResult<PageInfo<ChargingOrderVO>> chargingOrderList(@RequestBody ChargingOrderQuery dto) {
|
PageInfo<ChargingOrderVO> res = chargingOrderService.chargingOrderList(dto);
|
return AjaxResult.success(res);
|
}
|
|
@RequiresPermissions(value = {"/chargingPileOrder"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/chargingOrder/summary")
|
@ApiOperation(value = "充电桩订单汇总", tags = {"管理后台-订单管理"})
|
public AjaxResult<TCharingOrderVO> chargingOrderSummary(@RequestBody ChargingOrderQuery dto) {
|
TCharingOrderVO res = chargingOrderService.chargingOrderSummary(dto);
|
return AjaxResult.success(res);
|
}
|
|
|
@RequiresPermissions(value = {"/chargingPileOrder"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/balanceIncomeDetail")
|
@ApiOperation(value = "充电桩订单余额收入明细", tags = {"管理后台-订单管理"})
|
public AjaxResult<List<ChargingOrderBalanceIncomeDetailVO>> balanceIncomeDetail(@RequestBody ChargingOrderQuery dto) {
|
List<ChargingOrderBalanceIncomeDetailVO> res = chargingOrderService.balanceIncomeDetail(dto);
|
return AjaxResult.success(res);
|
}
|
|
|
@RequiresPermissions(value = {"/chargingPileOrder/monitoring_record"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/chargingOrderInfo")
|
@ApiOperation(value = "充电桩订单列表查看详情", tags = {"管理后台-订单管理"})
|
public AjaxResult<ChargingOrderInfoVO> chargingOrderInfo(String strategyId) {
|
TChargingOrder byId = chargingOrderService.getById(strategyId);
|
ChargingOrderInfoVO chargingOrderInfoVO = new ChargingOrderInfoVO();
|
chargingOrderInfoVO.setCdElectronic(byId.getCurrent()!=null?byId.getCurrent().setScale(2, BigDecimal.ROUND_HALF_DOWN)+"":"");
|
chargingOrderInfoVO.setCdVoltage(byId.getVoltage()!=null?byId.getVoltage().setScale(2, BigDecimal.ROUND_HALF_DOWN)+"":"");
|
chargingOrderInfoVO.setSurplus(byId.getTotalElectricity()!=null?byId.getTotalElectricity().setScale(2, BigDecimal.ROUND_HALF_DOWN)+"":"");
|
chargingOrderInfoVO.setTotalPower(byId.getPower()!=null?byId.getPower().setScale(2, BigDecimal.ROUND_HALF_DOWN)+"":"");
|
chargingOrderInfoVO.setVin(byId.getActualVin());
|
chargingOrderInfoVO.setActualVin(byId.getActualVin());
|
if (byId.getAppUserCarId()!=null){
|
TAppUserCar data = appUserCarClient.getCarById(byId.getAppUserCarId()+"").getData();
|
if (data!=null){
|
chargingOrderInfoVO.setLicensePlate(data.getLicensePlate());
|
chargingOrderInfoVO.setVehicleBrand(data.getVehicleBrand());
|
chargingOrderInfoVO.setVehicleModel(data.getVehicleModel());
|
chargingOrderInfoVO.setVehicleUse(data.getVehicleUse());
|
}
|
}else{
|
chargingOrderInfoVO.setLicensePlate(byId.getPlateNum());
|
}
|
// 时段总服务费
|
List<TChargingOrderAccountingStrategy> list = chargingOrderAccountingStrategyService.lambdaQuery().eq(TChargingOrderAccountingStrategy::getChargingOrderId, strategyId).orderByDesc(TChargingOrderAccountingStrategy::getStartTime).list();
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
|
for (TChargingOrderAccountingStrategy tChargingOrderAccountingStrategy : list) {
|
LocalDateTime createTime = byId.getStartTime();
|
String format = createTime.format(formatter);
|
String startTime = tChargingOrderAccountingStrategy.getStartTime();
|
if("00:00".equals(startTime)){
|
createTime = createTime.plusDays(1);
|
format = createTime.format(formatter);
|
}
|
tChargingOrderAccountingStrategy.setStartTime(format+" "+tChargingOrderAccountingStrategy.getStartTime());
|
tChargingOrderAccountingStrategy.setEndTime(format+" "+tChargingOrderAccountingStrategy.getEndTime());
|
// if (byId.getVipDiscountAmount()!=null && byId.getServiceCharge().compareTo(BigDecimal.ZERO) != 0){
|
// BigDecimal multiply = byId.getVipDiscountAmount().divide(byId.getServiceCharge(), 2)
|
// .multiply(tChargingOrderAccountingStrategy.getPeriodOriginalServicePrice());
|
// tChargingOrderAccountingStrategy.setVipDiscount(multiply);
|
// }
|
// if (byId.getCouponDiscountAmount()!=null && byId.getServiceCharge().compareTo(BigDecimal.ZERO) != 0){
|
// BigDecimal multiply = byId.getCouponDiscountAmount().divide(byId.getServiceCharge(), 2)
|
// .multiply(tChargingOrderAccountingStrategy.getPeriodOriginalServicePrice());
|
// tChargingOrderAccountingStrategy.setCouponDiscount(multiply);
|
// }
|
if(null == tChargingOrderAccountingStrategy.getCouponDiscount()){
|
tChargingOrderAccountingStrategy.setCouponDiscount(BigDecimal.ZERO);
|
}
|
}
|
//从新排序
|
list.sort(new Comparator<TChargingOrderAccountingStrategy>() {
|
@Override
|
public int compare(TChargingOrderAccountingStrategy o1, TChargingOrderAccountingStrategy o2) {
|
String startTime = o1.getStartTime();
|
String startTime1 = o2.getStartTime();
|
LocalDateTime localDateTime = LocalDateTime.parse(startTime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
|
LocalDateTime localDateTime1 = LocalDateTime.parse(startTime1, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm"));
|
if(localDateTime.isBefore(localDateTime1)){
|
return -1;
|
}
|
if(localDateTime.isAfter(localDateTime1)){
|
return 1;
|
}
|
return 0;
|
}
|
});
|
chargingOrderInfoVO.setList(list);
|
return AjaxResult.success(chargingOrderInfoVO);
|
}
|
|
|
|
|
@Log(title = "【扫一扫】添加评价", businessType = BusinessType.INSERT,operatorType = OperatorType.MOBILE)
|
@ResponseBody
|
@PostMapping(value = "/addEvaluate")
|
@ApiOperation(value = "添加评价", tags = {"小程序-扫一扫"})
|
public AjaxResult getMyChargingOrderList(@RequestBody OrderEvaluateVo dto) {
|
dto.setAppUserId(tokenService.getLoginUserApplet().getUserId());
|
orderEvaluateService.addOrderEvaluate(dto);
|
return AjaxResult.success();
|
}
|
|
|
|
/**
|
* 查询用户最近一次充电记录使用的车辆
|
*
|
* @param
|
* @return
|
*/
|
@GetMapping(value = "/getCar/{id}")
|
public R<Long> getCar(@PathVariable("id")String id) {
|
List<TChargingOrder> list = chargingOrderService.list(new LambdaQueryWrapper<TChargingOrder>()
|
.eq(TChargingOrder::getAppUserId, id)
|
.isNotNull(TChargingOrder::getAppUserCarId));
|
if (!list.isEmpty()){
|
// 最近使用的车辆id
|
Long size = list.get(0).getAppUserCarId();
|
return R.ok(size);
|
}else{
|
return R.ok(-1L);
|
}
|
}
|
|
|
|
|
/**
|
* 查询会员在本月有多少次享受了充电折扣
|
* @param req
|
* @return
|
*/
|
@PostMapping(value = "/getChargingCount")
|
public R<Integer> getChargingCount(@RequestBody TChargingCountQuery req) {
|
int size = chargingOrderService.list(new LambdaQueryWrapper<TChargingOrder>()
|
.eq(TChargingOrder::getAppUserId, req.getUserId())
|
.eq(TChargingOrder::getRechargePaymentStatus, 2)
|
.between(TChargingOrder::getStartTime, req.getStartTime(), req.getEndTime())).size();
|
return R.ok(size);
|
}
|
|
|
//用户订单数量
|
@PostMapping(value = "/useOrderCount")
|
public R<Long> useOrderCount(@RequestParam("userId") Long userId) {
|
Long count = chargingOrderService.lambdaQuery().eq(TChargingOrder::getAppUserId, userId).count();
|
|
return R.ok(count);
|
}
|
|
/**
|
* 查询指定站点中实际发生过充电的用户ID
|
*/
|
@PostMapping(value = "/getAppUserIdsBySiteIds")
|
public R<List<Long>> getAppUserIdsBySiteIds(@RequestBody List<Integer> siteIds) {
|
return R.ok(chargingOrderService.getAppUserIdsBySiteIds(siteIds));
|
}
|
|
|
|
//订单详情
|
@PostMapping(value = "/detail")
|
public R<TChargingOrder> detail(@RequestParam("orderId") Long orderId) {
|
return R.ok(chargingOrderService.getById(orderId));
|
}
|
|
|
|
@PostMapping(value = "/getList")
|
public R<List<TChargingOrder>> getList(@RequestParam("siteId") Integer siteId) {
|
|
List<TChargingOrder> list = chargingOrderService.lambdaQuery().eq(TChargingOrder::getSiteId, siteId).list();
|
return R.ok(list);
|
}
|
|
|
|
@PostMapping(value = "/getBySiteIdAndTime")
|
public R<List<ChargingOrderGroup>> getBySiteIdAndTime(@RequestBody ChargingPercentProvinceDto chargingPercentProvinceDto) {
|
|
List<ChargingOrderGroup> groups = chargingOrderService.chargingOrderGroup(chargingPercentProvinceDto);
|
return R.ok(groups);
|
}
|
|
|
/**
|
* 根据站点id和时间区间查询订单数据
|
* @param chargingPercentProvinceDto
|
* @return
|
*/
|
@PostMapping(value = "/getOrderBySiteIdAndTime")
|
public R<List<TChargingOrder>> getOrderBySiteIdAndTime(@RequestBody ChargingPercentProvinceDto chargingPercentProvinceDto){
|
LocalDate date1 = chargingPercentProvinceDto.getDate1();
|
LocalDate date2 = chargingPercentProvinceDto.getDate2();
|
String tripartitePlatformName = chargingPercentProvinceDto.getTripartitePlatformName();
|
List<TChargingOrder> list = chargingOrderService.list(new LambdaQueryWrapper<TChargingOrder>().in(TChargingOrder::getSiteId, chargingPercentProvinceDto.getSiteIds())
|
.between(null != date1 && null != date2, TChargingOrder::getPayTime, date1.atTime(0, 0, 0), date2.atTime(23, 59, 59))
|
.eq(TChargingOrder::getDelFlag, 0).eq(TChargingOrder::getStatus, 5)
|
.eq(StringUtils.isNotEmpty(tripartitePlatformName), TChargingOrder::getOrderSource, 2)
|
.eq(StringUtils.isNotEmpty(tripartitePlatformName), TChargingOrder::getTripartitePlatformName, tripartitePlatformName));
|
return R.ok(list);
|
}
|
|
|
|
/**
|
* 根据充电枪id获取正在进行中的订单
|
* @param chargingGunId 充电枪id
|
* @return
|
*/
|
@PostMapping(value = "/getOrderDetailByGunId")
|
public R<TChargingOrder> getOrderDetailByGunId(@RequestParam("chargingGunId") Integer chargingGunId) {
|
TChargingOrder one = chargingOrderService.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getChargingGunId, chargingGunId)
|
.eq(TChargingOrder::getDelFlag, 0).eq(TChargingOrder::getStatus, 3));
|
return R.ok(one);
|
}
|
|
|
|
|
@ResponseBody
|
@GetMapping(value = "/getMyChargingOrderList")
|
@ApiOperation(value = "获取充电记录列表", tags = {"小程序-充电记录"})
|
public AjaxResult<Map<String, Object>> getMyChargingOrderList(GetMyChargingOrderList query) {
|
Map<String, Object> orderList = chargingOrderService.getMyChargingOrderList(query);
|
return AjaxResult.success(orderList);
|
}
|
|
|
@ResponseBody
|
@GetMapping(value = "/getMyChargingOrderInfo")
|
@ApiOperation(value = "获取充电记订单明细", tags = {"小程序-充电记录"})
|
public AjaxResult<MyChargingOrderInfo> getMyChargingOrderInfo(String id) {
|
TChargingOrder tChargingOrder = chargingOrderService.getById(id);
|
Long userId = tokenService.getLoginUserApplet().getUserId();
|
if(!tChargingOrder.getAppUserId().equals(userId)){
|
return AjaxResult.error("权限不足");
|
}
|
MyChargingOrderInfo myChargingOrderInfo = chargingOrderService.getMyChargingOrderInfo(id);
|
return AjaxResult.success(myChargingOrderInfo);
|
}
|
|
|
|
@ResponseBody
|
@GetMapping(value = "/getNoInvoicedOrder")
|
@ApiOperation(value = "获取未开票的订单数据", tags = {"小程序-充电发票"})
|
public AjaxResult<List<MyChargingOrderList>> getNoInvoicedOrder(GetNoInvoicedOrder query) {
|
List<MyChargingOrderList> list = chargingOrderService.getNoInvoicedOrder(query);
|
return AjaxResult.success(list);
|
}
|
|
|
@Log(title = "【扫一扫】支付充电充值费用", businessType = BusinessType.UPDATE,operatorType = OperatorType.MOBILE)
|
@ResponseBody
|
@PostMapping(value = "/paymentChargingOrder")
|
@ApiOperation(value = "支付充电充值费用", tags = {"小程序-扫一扫"})
|
public AjaxResult paymentChargingOrder(@RequestBody AddChargingOrder addChargingOrder) {
|
return chargingOrderService.paymentChargingOrder(addChargingOrder);
|
}
|
|
@ResponseBody
|
@GetMapping(value = "/confirmIcbcPayment")
|
@ApiOperation(value = "主动确认工行充电支付结果", tags = {"小程序-扫一扫"})
|
public AjaxResult confirmIcbcPayment(@RequestParam("orderCode") String orderCode) {
|
return chargingOrderService.confirmIcbcPayment(orderCode);
|
}
|
|
@RequiresPermissions(value = {"/chargingPileOrder", "/paymentOrder/refund"}, logical = Logical.AND)
|
@PostMapping("/icbc/fund/payment-query")
|
@ApiOperation(value = "管理后台查询工行支付订单", tags = {"后台-充电桩订单"})
|
public AjaxResult<IcbcPaymentResp> queryIcbcAdminPayment(@RequestBody IcbcAdminFundOperationReq request) {
|
return AjaxResult.success(chargingOrderService.queryIcbcAdminPayment(request == null ? null : request.getOrderCode()));
|
}
|
|
@RequiresPermissions(value = {"/chargingPileOrder", "/paymentOrder/refund"}, logical = Logical.AND)
|
@PostMapping("/icbc/fund/refund")
|
@ApiOperation(value = "管理后台工行主订单退款", tags = {"后台-充电桩订单"})
|
public AjaxResult<IcbcRefundResp> refundIcbcAdminPayment(@RequestBody IcbcAdminFundOperationReq request) {
|
return AjaxResult.success(chargingOrderService.refundIcbcAdminPayment(request));
|
}
|
|
@RequiresPermissions(value = {"/chargingPileOrder", "/paymentOrder/refund"}, logical = Logical.AND)
|
@PostMapping("/icbc/fund/sub-orders")
|
@ApiOperation(value = "管理后台查询工行分账子订单", tags = {"后台-充电桩订单"})
|
public AjaxResult<List<IcbcAdminSubOrderVO>> queryIcbcAdminSubOrders(@RequestBody IcbcAdminFundOperationReq request) {
|
return AjaxResult.success(chargingOrderService.queryIcbcAdminSubOrders(request == null ? null : request.getOrderCode()));
|
}
|
|
@RequiresPermissions(value = {"/chargingPileOrder", "/paymentOrder/refund"}, logical = Logical.AND)
|
@PostMapping("/icbc/fund/sub-order-refund")
|
@ApiOperation(value = "管理后台工行分账子订单退款", tags = {"后台-充电桩订单"})
|
public AjaxResult<IcbcSubOrderRefundResp> refundIcbcAdminSubOrder(@RequestBody IcbcAdminFundOperationReq request) {
|
return AjaxResult.success(chargingOrderService.refundIcbcAdminSubOrder(request));
|
}
|
|
@ResponseBody
|
@GetMapping("/simulation/current")
|
@ApiOperation(value = "查询当前枪可模拟结算的已支付订单", tags = {"小程序-模拟充电"})
|
public AjaxResult<ChargingSimulationVO> getCurrentSimulationOrder(@RequestParam("gunId") Integer gunId) {
|
return AjaxResult.success(chargingOrderService.getCurrentSimulationOrder(gunId));
|
}
|
|
@ResponseBody
|
@PostMapping("/simulation/complete")
|
@ApiOperation(value = "模拟完成充电并执行真实结算", tags = {"小程序-模拟充电"})
|
public AjaxResult<ChargingSimulationVO> completeSimulation(@RequestBody ChargingSimulationReq request) {
|
return AjaxResult.success(chargingOrderService.completeSimulation(request));
|
}
|
|
/**
|
* 充电充值支付回调
|
*/
|
@ResponseBody
|
@PostMapping(value = "/chargingOrderWXCallback")
|
public void chargingOrderWXCallback(@RequestParam("out_trade_no") String out_trade_no, @RequestParam("transaction_id") String transaction_id,
|
@RequestParam("attach") String attach) {
|
chargingOrderService.chargingOrderCallback(1, out_trade_no, transaction_id, attach);
|
}
|
|
|
/**
|
* 修改安全检测数据
|
* @param securityDetection
|
*/
|
@ResponseBody
|
@PostMapping(value = "/securityDetection")
|
public void securityDetection(@RequestBody SecurityDetectionVO securityDetection){
|
log.info("-------------------安全检测数据-------------------：" + securityDetection);
|
chargingOrderService.securityDetection(securityDetection);
|
}
|
|
/**
|
* 远程启动充电应答（按订单号前缀路由：SD=刷卡订单，VD=VIN订单，其余=普通订单）
|
* @param message
|
*/
|
@ResponseBody
|
@PostMapping(value = "/startChargeSuccessfully")
|
public void startChargeSuccessfully(@RequestBody PlatformStartChargingReplyMessageVO message){
|
log.info("-------------------远程启动充电请求应答-------------------：" + message);
|
String orderCode = message == null ? null : message.getTransaction_serial_number();
|
if (isCardOrder(orderCode)) {
|
cardChargingOrderService.cardStartChargeSuccessfully(message);
|
} else if (isVinOrder(orderCode)) {
|
vinChargingOrderService.vinStartChargeSuccessfully(message);
|
} else {
|
chargingOrderService.startChargeSuccessfully(message);
|
}
|
}
|
|
|
|
/**
|
* 支付宝支付成功后的回调
|
*/
|
@ResponseBody
|
@PostMapping(value = "/chargingOrderALICallback")
|
public void chargingOrderALICallback(@RequestParam("out_trade_no") String out_trade_no,
|
@RequestParam("transaction_id") String transaction_id,
|
@RequestParam("attach") String attach) {
|
chargingOrderService.chargingOrderCallback(2, out_trade_no, transaction_id, attach);
|
}
|
/**
|
* 支付宝H5支付成功后的回调
|
*/
|
@ResponseBody
|
@PostMapping(value = "/chargingOrderALIH5Callback")
|
public void chargingOrderALIH5Callback(@RequestParam("out_trade_no") String out_trade_no,
|
@RequestParam("transaction_id") String transaction_id,
|
@RequestParam("attach") String attach) {
|
chargingOrderService.chargingOrderCallback(3, out_trade_no, transaction_id, attach);
|
}
|
|
|
/**
|
*
|
* @param code
|
*/
|
@ResponseBody
|
@PostMapping(value = "/refund")
|
public R refund(@RequestParam(value = "code") String code){
|
chargingOrderService.refund(code);
|
return R.ok();
|
}
|
|
|
/**
|
*
|
* @param code
|
*/
|
@ResponseBody
|
@PostMapping(value = "/refund1")
|
public R refund1(@RequestParam(value = "code") String code, @RequestParam(value = "money") BigDecimal money){
|
chargingOrderService.refund1(code, money);
|
return R.ok();
|
}
|
|
|
|
/**
|
* 远程启动失败后退款回调
|
*/
|
@ResponseBody
|
@PostMapping(value = "/chargingOrderStartupFailureWxRefund")
|
public void chargingOrderStartupFailureWxRefund(@RequestParam("out_refund_no") String out_refund_no,
|
@RequestParam("refund_id") String refund_id,
|
@RequestParam("tradeState") String tradeState,
|
@RequestParam("success_time") String success_time){
|
chargingOrderService.chargingOrderStartupFailureWxRefund(out_refund_no, refund_id, tradeState, success_time);
|
}
|
|
|
|
|
@ResponseBody
|
@GetMapping(value = "/preChargeCheck/{id}")
|
@ApiOperation(value = "获取安全检测数据", tags = {"小程序-扫一扫"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "id", value = "充电枪id", required = true)
|
})
|
public AjaxResult<PreChargeCheck> preChargeCheck(@PathVariable Integer id) {
|
String key = "AQJC_" + id;
|
PreChargeCheck cacheObject = redisService.getCacheObject(key);
|
if(null != cacheObject){
|
if(LocalDateTime.now().minusMinutes(1).isAfter(cacheObject.getAddTime())){
|
redisService.deleteObject(key);
|
cacheObject = null;
|
}
|
}
|
return AjaxResult.success(cacheObject);
|
}
|
|
|
@ResponseBody
|
@GetMapping(value = "/getChargingDetails/{id}")
|
@ApiOperation(value = "获取充电中页面数据", tags = {"小程序-扫一扫"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "id", value = "充电枪id", required = true)
|
})
|
public AjaxResult<ChargingDetails> getChargingDetails(@PathVariable Integer id) {
|
ChargingDetails chargingDetails = chargingOrderService.getChargingDetails(id);
|
return AjaxResult.success(chargingDetails);
|
}
|
|
|
|
@Log(title = "【扫一扫】手动停止充电", businessType = BusinessType.STOP,operatorType = OperatorType.MOBILE)
|
@ResponseBody
|
@PutMapping(value = "/stopCharging/{id}")
|
@ApiOperation(value = "手动停止充电", tags = {"小程序-扫一扫"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "id", value = "订单id", required = true)
|
})
|
public AjaxResult stopCharging(@PathVariable String id) {
|
log.info("小程序主动发起停止充电，订单ID：{}", id);
|
return chargingOrderService.stopCharging(id);
|
}
|
|
|
/**
|
* 停止充电应答处理逻辑（普通订单原逻辑 + VIN订单按枪兜底确认）
|
* @param platformStopChargingReply
|
*/
|
@PostMapping("/terminateSuccessfulResponse")
|
public void terminateSuccessfulResponse(@RequestBody PlatformStopChargingReplyVO platformStopChargingReply){
|
log.info("-------------------远程停止充电请求应答-------------------：" + platformStopChargingReply);
|
// VIN订单平台停止应答兜底（按枪定位停止中订单，内部自带空判断，不影响普通订单处理）
|
try {
|
vinChargingOrderService.vinTerminateStopByReply(platformStopChargingReply);
|
} catch (Exception ex) {
|
log.error("VIN订单停止应答处理异常：", ex);
|
}
|
chargingOrderService.terminateSuccessfulResponse(platformStopChargingReply);
|
}
|
|
|
/**
|
* 停止充电返回账单后计算费用（按订单号前缀路由：SD=刷卡订单，VD=VIN订单，其余=普通订单）
|
* @param vo
|
*/
|
@PostMapping("/endChargeBillingCharge")
|
public R endChargeBillingCharge(@RequestBody TransactionRecordMessageVO vo){
|
log.info("-------------------停止充电返回账单后计算费用及修改业务状态-------------------：" + vo);
|
String orderCode = vo == null ? null : vo.getTransaction_serial_number();
|
if (isCardOrder(orderCode)) {
|
return cardChargingOrderService.cardEndChargeBillingCharge(vo);
|
}
|
if (isVinOrder(orderCode)) {
|
return vinChargingOrderService.vinEndChargeBillingCharge(vo);
|
}
|
return chargingOrderService.endChargeBillingCharge(vo);
|
}
|
|
|
|
|
|
@RequiresPermissions(value = {"/platformRevenueAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/six/charge")
|
@ApiOperation(value = "电站收入分析", tags = {"后台-数据分析-平台收入分析"})
|
public R<List<SixChargingDto>> charge(Integer siteId, Integer partnerId) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
SysUser sysUser = sysUserClient.getSysUser(userId).getData();
|
List<Integer> siteIds = resolvePlatformRevenueSiteIds(userId, sysUser, siteId, partnerId);
|
//通过siteIds进行sql查询统计
|
return R.ok(buildLastSixMonths(siteIds, false));
|
}
|
|
/**
|
* 近6月+当月电站收入：历史月读结算账单、当月补原始订单。
|
* 与「电站收入分析」图表、底部数据分类及加盟商收支同口径。
|
*/
|
private List<SixChargingDto> buildLastSixMonths(List<Integer> siteIds, boolean partnerView) {
|
LocalDate sixBefore = PreviousSixMonths.get();
|
List<SixChargingDto> chargingDtos = chargingOrderService.charge(sixBefore, siteIds, partnerView);
|
LocalDate statisticsEndMonth = resolveStatisticsEndMonth(LocalDate.now(), chargingDtos);
|
List<SixChargingDto> sixChargingDtos = generateLastSixMonths(statisticsEndMonth);
|
for (SixChargingDto sixChargingDto : sixChargingDtos) {
|
for (SixChargingDto chargingDto : chargingDtos) {
|
if (sixChargingDto.getMonth().equals(chargingDto.getMonth())){
|
BeanUtils.copyProperties(chargingDto,sixChargingDto);
|
}
|
}
|
|
}
|
return sixChargingDtos;
|
}
|
|
|
public static List<SixChargingDto> generateLastSixMonths() {
|
return generateLastSixMonths(LocalDate.now());
|
}
|
|
static List<SixChargingDto> generateLastSixMonths(LocalDate endMonth) {
|
List<SixChargingDto> months = new ArrayList<>();
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM");
|
|
for (int i = 5; i >= 0; i--) {
|
LocalDate date = endMonth.minusMonths(i);
|
String month = date.format(formatter);
|
SixChargingDto sixChargingDto = new SixChargingDto();
|
sixChargingDto.setMonth(month);
|
months.add(sixChargingDto);
|
}
|
|
return months;
|
}
|
|
static LocalDate resolveStatisticsEndMonth(LocalDate currentDate, List<SixChargingDto> statistics) {
|
if (statistics == null || statistics.isEmpty()) {
|
return currentDate;
|
}
|
int nextMonth = currentDate.plusMonths(1).getMonthValue();
|
boolean hasNextMonthData = statistics.stream()
|
.map(SixChargingDto::getMonth)
|
.filter(Objects::nonNull)
|
.anyMatch(month -> {
|
try {
|
return Integer.parseInt(month) == nextMonth;
|
} catch (NumberFormatException ignored) {
|
return false;
|
}
|
});
|
return hasNextMonthData ? currentDate.plusMonths(1) : currentDate;
|
}
|
|
@RequiresPermissions(value = {"/platformRevenueAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/six/circle")
|
@ApiOperation(value = "电站收入占比", tags = {"后台-数据分析-平台收入分析"})
|
public R<List<SixCircleDto>> circle(Integer siteId, Integer partnerId) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
SysUser sysUser = sysUserClient.getSysUser(userId).getData();
|
boolean partnerView = isPartnerView(sysUser);
|
List<Integer> siteIds = resolvePlatformRevenueSiteIds(userId, sysUser, siteId, partnerId);
|
LocalDate sixBefore = PreviousSixMonths.get();
|
List<SixCircleDto> sixCircleDtos = chargingOrderService.circle(siteIds,sixBefore, false);
|
for (SixCircleDto sixCircleDto : sixCircleDtos) {
|
Site site = siteClient.getSiteByIds(Arrays.asList(sixCircleDto.getSiteId())).getData().get(0);
|
sixCircleDto.setSiteName(site.getName());
|
}
|
return R.ok(sixCircleDtos);
|
|
}
|
|
|
@RequiresPermissions(value = {"/platformRevenueAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/six/shop")
|
@ApiOperation(value = "购物收入", tags = {"后台-数据分析-平台收入分析"})
|
public R<List<SixShopDto>> shop(Integer status) {
|
//count近6个月的数据
|
LocalDate sixBefore = PreviousSixMonths.get();
|
List<SixShopDto> sixShopDtos = shoppingOrderService.sixBefore(sixBefore,status);
|
List<SixShopDto> sixChargingDtos = generateLastSixMonths1();
|
for (SixShopDto sixChargingDto : sixChargingDtos) {
|
for (SixShopDto chargingDto : sixShopDtos) {
|
if (sixChargingDto.getMonth().equals(chargingDto.getMonth())){
|
BeanUtils.copyProperties(chargingDto,sixChargingDto);
|
}
|
}
|
|
}
|
|
return R.ok(sixChargingDtos);
|
}
|
|
public static List<SixShopDto> generateLastSixMonths1() {
|
LocalDate today = LocalDate.now();
|
List<SixShopDto> months = new ArrayList<>();
|
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MM");
|
|
for (int i = 5; i >= 0; i--) {
|
LocalDate date = today.minusMonths(i);
|
String month = date.format(formatter);
|
SixShopDto sixChargingDto = new SixShopDto();
|
sixChargingDto.setMonth(month);
|
months.add(sixChargingDto);
|
}
|
|
return months;
|
}
|
|
|
@RequiresPermissions(value = {"/workbench"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/work/shop")
|
@ApiOperation(value = "购物收入", tags = {"后台-工作台"})
|
public R workShop(@RequestBody ChargingStatisticsQueryDto statisticsQueryDto) {
|
//count近6个月的数据
|
LocalDate sixBefore = PreviousSixMonths.get();
|
List<Map<String,Object >> shopData = shoppingOrderService.getData(statisticsQueryDto);
|
return R.ok(shopData);
|
}
|
|
@RequiresPermissions(value = {"/platformRevenueAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/six/vip")
|
@ApiOperation(value = "vip收入", tags = {"后台-数据分析-平台收入分析"})
|
public R<List<SixVipDto>> vip() {
|
//count近6个月的数据
|
LocalDate sixBefore = PreviousSixMonths.get();
|
List<SixVipDto> vipDtos = vipOrderService.sixBefore(sixBefore);
|
return R.ok(vipDtos);
|
}
|
|
|
|
|
|
/**
|
* 查询平台收入分析底部数据分类，充电订单金额由数据库聚合，避免全量订单和计费明细加载超时。
|
*/
|
@RequiresPermissions(value = {"/platformRevenueAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/six/total")
|
@ApiOperation(value = "底部数据分类", tags = {"后台-数据分析-平台收入分析"})
|
public R<Map<String,Object>> total(Integer siteId, Integer partnerId) {
|
//count近6个月的数据
|
Long userId = tokenService.getLoginUser().getUserid();
|
SysUser sysUser = sysUserClient.getSysUser(userId).getData();
|
boolean partnerView = isPartnerView(sysUser);
|
List<Integer> siteIds = resolvePlatformRevenueSiteIds(userId, sysUser, siteId, partnerId);
|
LocalDate sixBefore = PreviousSixMonths.get();
|
Map<String,Object> map = new HashMap<String,Object>();
|
// 电费/服务费与上方「电站收入分析」图表同口径：近6月结算账单 + 当月原始订单，保证底部合计=图表6个月相加
|
List<SixChargingDto> sixChargingDtos = buildLastSixMonths(siteIds, false);
|
map.put("electrovalence", sixChargingDtos.stream()
|
.filter(Objects::nonNull)
|
.map(SixChargingDto::getElectrovalence)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add));
|
map.put("service_charge", sixChargingDtos.stream()
|
.filter(Objects::nonNull)
|
.map(SixChargingDto::getServiceCharge)
|
.filter(Objects::nonNull)
|
.reduce(BigDecimal.ZERO, BigDecimal::add));
|
// 合作商分成/三方平台分佣按近6月结算口径统计（与图表月份窗口一致）
|
Map<String,Object> sub = chargingOrderService.countAll(siteIds, false, sixBefore);
|
map.put("commission_amount", sub == null ? BigDecimal.ZERO : sub.get("commission_amount"));
|
map.put("sharing_amount", sub == null ? BigDecimal.ZERO : sub.get("sharing_amount"));
|
boolean platformVisible = !partnerView;
|
if(platformVisible){
|
R<BigDecimal> parkingAmountResult = parkingLotClient.getRecordAmount(siteIds, sixBefore.toString());
|
BigDecimal data = parkingAmountResult == null || parkingAmountResult.getData() == null
|
? BigDecimal.ZERO : parkingAmountResult.getData();
|
map.put("parkingAmount",data);
|
BigDecimal data1 = shoppingOrderService.getSumAmount(sixBefore);
|
map.put("shopAmount",data1);
|
BigDecimal data2 = vipOrderService.getSumAmout(sixBefore);
|
map.put("vipAmount",data2);
|
}else{
|
map.put("parkingAmount",0);
|
map.put("shopAmount",0);
|
map.put("vipAmount",0);
|
}
|
map.put("platformIncomeVisible", platformVisible);
|
return R.ok(map);
|
}
|
|
@RequiresPermissions(value = {"/platformRevenueAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/six/pay-type-circle")
|
@ApiOperation(value = "收入类型占比", tags = {"后台-数据分析-平台收入分析"})
|
public R<List<SixIncomeCircleDto>> payTypeCircle(Integer siteId, Integer partnerId) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
SysUser sysUser = sysUserClient.getSysUser(userId).getData();
|
boolean partnerView = isPartnerView(sysUser);
|
List<Integer> siteIds = resolvePlatformRevenueSiteIds(userId, sysUser, siteId, partnerId);
|
LocalDate sixBefore = PreviousSixMonths.get();
|
return R.ok(chargingOrderService.payTypeCircle(sixBefore, siteIds, partnerView));
|
}
|
|
private boolean isPartnerView(SysUser sysUser) {
|
return sysUser != null && Integer.valueOf(2).equals(sysUser.getRoleType());
|
}
|
|
/**
|
* 解析平台收入分析页面允许查看的站点范围。
|
* 合作商使用授权站点，其他后台账号沿用用户站点列表；传入站点时需做授权校验。
|
*/
|
private List<Integer> resolvePlatformRevenueSiteIds(Long userId, SysUser sysUser,
|
Integer siteId, Integer partnerId) {
|
List<Integer> siteIds = new ArrayList<>();
|
if (sysUser != null && Integer.valueOf(2).equals(sysUser.getRoleType())) {
|
Set<Integer> authSiteIds = partnerClient.authSite(sysUser.getObjectId(), SiteMenu.SITE_LIST.getValue()).getData();
|
if (authSiteIds != null) {
|
siteIds.addAll(authSiteIds);
|
}
|
} else {
|
List<GetSiteListDTO> data = siteClient.getSiteListByUserId(userId).getData();
|
if (data != null) {
|
for (GetSiteListDTO datum : data) {
|
siteIds.add(datum.getId());
|
}
|
}
|
}
|
if (siteId != null) {
|
return siteIds.contains(siteId) ? Collections.singletonList(siteId) : Collections.singletonList(-1);
|
}
|
if (partnerId != null && !siteIds.isEmpty()) {
|
R<List<Site>> siteResult = siteClient.getSiteByIds(siteIds);
|
return filterPlatformRevenueSiteIdsByPartner(siteIds,
|
siteResult == null ? null : siteResult.getData(), partnerId);
|
}
|
if (siteIds.isEmpty()) {
|
siteIds.add(-1);
|
}
|
return siteIds;
|
}
|
|
static List<Integer> filterPlatformRevenueSiteIdsByPartner(List<Integer> allowedSiteIds,
|
List<Site> sites,
|
Integer partnerId) {
|
if (partnerId == null) {
|
return allowedSiteIds == null || allowedSiteIds.isEmpty()
|
? Collections.singletonList(-1) : new ArrayList<>(allowedSiteIds);
|
}
|
if (allowedSiteIds == null || allowedSiteIds.isEmpty() || sites == null || sites.isEmpty()) {
|
return Collections.singletonList(-1);
|
}
|
Set<Integer> allowed = new HashSet<>(allowedSiteIds);
|
List<Integer> result = sites.stream()
|
.filter(Objects::nonNull)
|
.filter(site -> allowed.contains(site.getId()))
|
// 合作商类型不参与筛选：主合作商或场地方匹配均属于该合作商名下电站。
|
.filter(site -> Objects.equals(site.getPartnerId(), partnerId)
|
|| Objects.equals(site.getVenuePartnerId(), partnerId))
|
.map(Site::getId)
|
.distinct()
|
.collect(Collectors.toList());
|
return result.isEmpty() ? Collections.singletonList(-1) : result;
|
}
|
|
|
@RequiresPermissions(value = {"/chargeOrderMonitoring"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/watch/chargingOrder")
|
@ApiOperation(value = "监控订单", tags = {"管理后台-订单管理"})
|
public R watchChargingOrder(@RequestBody MongoChargingOrderQuery query) {
|
Set<Integer> ids = null;
|
//校验合作商权限
|
SysUser sysUser = sysUserClient.getSysUser(tokenService.getLoginUser().getUserid()).getData();
|
Integer roleType = sysUser.getRoleType();
|
Integer objectId = sysUser.getObjectId();
|
R<Integer> admin = sysUserClient.isAdmin(tokenService.getLoginUser().getUserid());
|
//合作商
|
if(roleType == 2){
|
ids = partnerClient.authSite(objectId, SiteMenu.SITE_LIST.getValue()).getData();
|
}else{
|
//非管理员需要根据角色和用户配置查询允许的站点数据
|
//改用roleId=1来判断
|
if(admin.getData()!=1){
|
List<Integer> data = userSiteClient.getSiteIds(sysUser.getUserId()).getData();
|
List<SysUserRoleVo> data2 = sysUserRoleClient.getRoleByUserId(sysUser.getUserId()).getData();
|
if(data2.size() > 0){
|
List<Integer> data1 = roleSiteClient.getSiteIds(data2.get(0).getRoleId()).getData();
|
data.addAll(data1);
|
}
|
ids = new HashSet<>(data);
|
}
|
}
|
|
LambdaQueryWrapper<TChargingOrder> queryWrapper = new LambdaQueryWrapper<TChargingOrder>().like(StringUtils.isNotEmpty(query.getCode()), TChargingOrder::getCode, query.getCode())
|
.eq(null != query.getOrderType(), TChargingOrder::getOrderType, query.getOrderType())
|
.eq(null != query.getSiteId(), TChargingOrder::getSiteId, query.getSiteId())
|
.eq(null != query.getPileId(), TChargingOrder::getChargingPileId, query.getPileId())
|
.eq(null != query.getGunId(), TChargingOrder::getChargingGunId, query.getGunId())
|
.eq(null != query.getStatus(), TChargingOrder::getStatus, query.getStatus())
|
.eq(TChargingOrder::getDelFlag, 0).eq(TChargingOrder::getRechargePaymentStatus, 2)
|
.in(null != ids && ids.size() > 0, TChargingOrder::getSiteId, ids);
|
if(StringUtils.isNotEmpty(query.getCreateTime())){
|
String[] split = query.getCreateTime().split(" - ");
|
queryWrapper.between(TChargingOrder::getStartTime, split[0], split[1]);
|
}
|
if(StringUtils.isNotEmpty(query.getLastTime())){
|
String[] split = query.getLastTime().split(" - ");
|
queryWrapper.between(TChargingOrder::getEndTime, split[0], split[1]);
|
}
|
PageInfo<TChargingOrder> pageInfo = new PageInfo<>(query.getPageCurr(), query.getPageSize());
|
PageInfo<TChargingOrder> orderPageInfo = chargingOrderService.page(pageInfo, queryWrapper.orderByDesc(TChargingOrder::getCreateTime));
|
List<Site> siteList = siteClient.getSiteAll().getData();
|
|
List<WatchChargingOrderVo> list = new ArrayList<>();
|
for (TChargingOrder record : orderPageInfo.getRecords()) {
|
WatchChargingOrderVo vo = new WatchChargingOrderVo();
|
BeanUtils.copyProperties(record, vo);
|
vo.setIdStr(record.getId().toString());
|
Site site = siteList.stream().filter(s->s.getId().equals(record.getSiteId())).findFirst().get();
|
vo.setSiteName(site.getName());
|
TChargingPile chargingPile = chargingPileClient.getChargingPileById(record.getChargingPileId()).getData();
|
vo.setTerminalName(chargingPile.getName());
|
TChargingGun chargingGun = chargingGunClient.getChargingGunById(record.getChargingGunId()).getData();
|
vo.setTerminalCode(chargingGun.getName());
|
|
if(null != record.getStartTime() && null != record.getEndTime()){
|
long time = record.getEndTime().toEpochSecond(ZoneOffset.UTC) - record.getStartTime().toEpochSecond(ZoneOffset.UTC);
|
vo.setChargingTime(time + "");
|
}
|
long count = chargingOrderAccountingStrategyService.count(new LambdaQueryWrapper<TChargingOrderAccountingStrategy>().eq(TChargingOrderAccountingStrategy::getChargingOrderId, record.getId()));
|
vo.setTimeFrame(count);
|
|
vo.setAuthInfo(roleType == 1 ? true : partnerClient.authMenu(objectId, record.getSiteId(), SiteMenu.CHARGING_PILE_ORDER_MONITORING_RECORD_INFO.getValue()));
|
vo.setAuthDelete(roleType == 1 ? true : partnerClient.authMenu(objectId, record.getSiteId(), SiteMenu.CHARGING_PILE_ORDER_MONITORING_RECORD_DEL.getValue()));
|
list.add(vo);
|
}
|
PageInfo<WatchChargingOrderVo> pageInfos = new PageInfo<>(query.getPageCurr(), query.getPageSize());
|
pageInfos.setRecords(list);
|
pageInfos.setCurrent(pageInfo.getCurrent());
|
pageInfos.setPages(pageInfo.getPages());
|
pageInfos.setSize(pageInfo.getSize());
|
pageInfos.setStartIndex(pageInfo.getStartIndex());
|
pageInfos.setTotal(pageInfo.getTotal());
|
return R.ok(pageInfos);
|
}
|
|
|
@RequiresPermissions(value = {"/chargeOrderMonitoring/del"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/watch/deletes")
|
@ApiOperation(value = "监控订单-删除", tags = {"管理后台-订单管理"})
|
public R watchChargingOrder(@RequestParam String id) {
|
uploadRealTimeMonitoringDataService.delete(id);
|
return R.ok();
|
}
|
|
/**
|
* 处理充电订单实时监控数据相关的业务逻辑（按订单号前缀路由）
|
* @param query
|
*/
|
@PostMapping("/chargeMonitoring")
|
public void chargeMonitoring(@RequestBody UploadRealTimeMonitoringDataQuery query){
|
String orderCode = query == null ? null : query.getTransaction_serial_number();
|
if (isCardOrder(orderCode)) {
|
cardChargingOrderService.cardChargeMonitoring(query);
|
} else if (isVinOrder(orderCode)) {
|
vinChargingOrderService.vinChargeMonitoring(query);
|
} else {
|
chargingOrderService.chargeMonitoring(query);
|
}
|
}
|
/**
|
* 通过流水号查询订单（统一前缀路由：SD=刷卡订单，VD=VIN订单，其余=普通订单）
|
* <p>设备链路（实时监控/BMS需求/交易记录确认等）统一经此按订单号前缀取三类订单，
|
* SD/VD 订单实体继承自 TChargingOrder，字段兼容直接返回。</p>
|
* @param code
|
* @return
|
*/
|
@PostMapping(value = "/getOrderByCode/{code}")
|
public R<TChargingOrder> getOrderByCode(@PathVariable("code") String code){
|
TChargingOrder one;
|
if (isCardOrder(code)) {
|
one = cardChargingOrderService.getCardOrderByCode(code);
|
} else if (isVinOrder(code)) {
|
one = vinChargingOrderService.getVinOrderByCode(code);
|
} else {
|
one = chargingOrderService.getOne(Wrappers.lambdaQuery(TChargingOrder.class)
|
.eq(TChargingOrder::getCode, code));
|
}
|
if (one == null) {
|
return R.ok(null);
|
}
|
one.setIdStr(one.getId().toString());
|
return R.ok(one);
|
}
|
|
@PostMapping("/updateHandshakeVin")
|
public R<Boolean> updateHandshakeVin(@RequestParam("orderCode") String orderCode,
|
@RequestParam("vin") String vin) {
|
if (StringUtils.isEmpty(orderCode)) {
|
return R.ok(false);
|
}
|
boolean updated;
|
if (orderCode.startsWith("CD")) {
|
updated = StringUtils.isNotEmpty(vin) && chargingOrderService.update(Wrappers.<TChargingOrder>lambdaUpdate()
|
.eq(TChargingOrder::getCode, orderCode)
|
.set(TChargingOrder::getActualVin, vin));
|
} else if (orderCode.startsWith("SD")) {
|
// SD/VD：VIN 为空也进入握手处理（状态推进必达）；服务内部仅非空回写 VIN，且仅状态=启动中(2)才推进
|
updated = cardChargingOrderService.handleHandshakeVin(orderCode, vin);
|
} else if (orderCode.startsWith("VD")) {
|
updated = vinChargingOrderService.handleHandshakeVin(orderCode, vin);
|
} else {
|
log.warn("握手VIN回写失败，未知订单类型：{}", orderCode);
|
return R.ok(false);
|
}
|
return R.ok(updated);
|
}
|
|
/**
|
* 设备链路订单号前缀判断：SD=刷卡充电订单
|
*/
|
private boolean isCardOrder(String orderCode) {
|
return orderCode != null && orderCode.startsWith("SD");
|
}
|
|
/**
|
* 设备链路订单号前缀判断：VD=VIN码充电订单
|
*/
|
private boolean isVinOrder(String orderCode) {
|
return orderCode != null && orderCode.startsWith("VD");
|
}
|
|
/**
|
* 设备主动发起充电（刷卡/VIN码）鉴权建单统一入口。
|
* <p>协议 start_method：1=刷卡（创建SD订单），2=账号启动（暂不支持），3=VIN码（创建VD订单）。</p>
|
*/
|
@PostMapping("/inner/device-start-charging")
|
public R<DeviceStartChargingVO> deviceStartCharging(@RequestBody DeviceStartChargingDTO dto) {
|
if (dto == null || dto.getStartMethod() == null) {
|
log.warn("[设备启动] 缺少启动方式，拒绝建单 dto={}", dto);
|
return R.ok(DeviceStartChargingVO.fail(null));
|
}
|
DeviceStartChargingVO result;
|
switch (dto.getStartMethod()) {
|
case 1:
|
result = cardChargingOrderService.startCardCharging(dto);
|
break;
|
case 3:
|
result = vinChargingOrderService.startVinCharging(dto);
|
break;
|
case 2:
|
// 账号启动暂不支持（协议无对应失败码，按最接近的“账户不存在”返回）
|
log.warn("[设备启动] 账号启动方式暂不支持 pile={} account={}", dto.getChargingPileCode(), dto.getAccount());
|
result = DeviceStartChargingVO.fail(1);
|
break;
|
default:
|
log.warn("[设备启动] 未知启动方式 startMethod={} pile={} gun={}",
|
dto.getStartMethod(), dto.getChargingPileCode(), dto.getChargingGunCode());
|
result = DeviceStartChargingVO.fail(null);
|
break;
|
}
|
return R.ok(result);
|
}
|
|
/**
|
* 内部接口：统计公司名下进行中充电订单数（三表合计，状态 2=启动中/3=充电中/4=停止中，
|
* 账户模式切换：分配→共享 前校验使用）
|
*/
|
@PostMapping("/inner/count-active-by-company")
|
public R<Integer> countActiveByCompany(@RequestParam("companyId") Integer companyId) {
|
if (companyId == null) {
|
return R.ok(0);
|
}
|
try {
|
List<Integer> activeStatuses = Arrays.asList(2, 3, 4);
|
long count = 0L;
|
count += chargingOrderService.lambdaQuery()
|
.eq(TChargingOrder::getCompanyId, companyId)
|
.in(TChargingOrder::getStatus, activeStatuses)
|
.count();
|
count += cardChargingOrderService.lambdaQuery()
|
.eq(TCardChargingOrder::getCompanyId, companyId)
|
.in(TCardChargingOrder::getStatus, activeStatuses)
|
.count();
|
count += vinChargingOrderService.lambdaQuery()
|
.eq(TVinChargingOrder::getCompanyId, companyId)
|
.in(TVinChargingOrder::getStatus, activeStatuses)
|
.count();
|
return R.ok((int) count);
|
} catch (RuntimeException ex) {
|
log.error("统计公司进行中充电订单失败：companyId={}", companyId, ex);
|
return R.fail("统计公司进行中充电订单失败:" + ex.getMessage());
|
}
|
}
|
|
@RequiresPermissions(value = {"/chargingOperationAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/charging/statistics")
|
@ApiOperation(value = "统计,充电订单分析", tags = {"管理后台-数据分析-充电运营分析"})
|
public R<TCharingOrderMapVO> watchChargingOrder(@RequestBody ChargingStatisticsQueryDto statisticsQueryDto){
|
List<Integer> siteIds =new ArrayList<>();
|
if (statisticsQueryDto.getSiteId()==null) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
//获取当前登录的siteIds
|
List<GetSiteListDTO> data = siteClient.getSiteListByUserId(userId).getData();
|
for (GetSiteListDTO datum : data) {
|
siteIds.add(datum.getId());
|
}
|
}else {
|
siteIds.add(statisticsQueryDto.getSiteId());
|
}
|
if (siteIds.isEmpty())siteIds.add(-1);
|
TCharingOrderMapVO tCharingOrderMapVO = new TCharingOrderMapVO();
|
|
LocalDate start = null;
|
LocalDate end = null;
|
if (statisticsQueryDto.getDayType()==1){
|
start = LocalDate.now();
|
end = LocalDate.now().plusDays(1);
|
}else if (statisticsQueryDto.getDayType()==2){
|
LocalDate today = LocalDate.now();
|
// 获取本周一的日期
|
start = statisticsQueryDto.getStartTime();
|
end = statisticsQueryDto.getEndTime();
|
} else if (statisticsQueryDto.getDayType()==3){
|
// 获取当前日期
|
start = statisticsQueryDto.getStartTime();
|
end = statisticsQueryDto.getEndTime();
|
}else if (statisticsQueryDto.getDayType()==4){
|
// 获取今年1月1日的日期
|
start = statisticsQueryDto.getStartTime();
|
end = statisticsQueryDto.getEndTime();
|
}else if (statisticsQueryDto.getDayType()==5){
|
start = statisticsQueryDto.getStartTime();
|
end = statisticsQueryDto.getEndTime();
|
if (start.equals(end)){
|
end = end.plusDays(1);
|
}
|
}
|
//上方饼图
|
List<Map<String,Object>> maps = chargingOrderService.getSumByType(start,end, siteIds);
|
|
if (statisticsQueryDto.getDayType()==1){
|
List<Map<String,Object>> maps1 = chargingOrderService.getDateData(start,end, siteIds);
|
|
List<Map<String, Object>> charMap = new ArrayList<>();
|
// 生成从 "00:00" 到 "23:00" 的时间数据
|
for (int hour = 0; hour < 24; hour++) {
|
String time = String.format("%02d:00", hour);
|
Map<String, Object> mapWithTimeValue = findMapWithTimeValue(maps1, time);
|
if (mapWithTimeValue!=null){
|
charMap.add(mapWithTimeValue);
|
}else {
|
Map<String, Object> timeMap = new HashMap<>();
|
timeMap.put("time", time); // 初始化值为 null
|
timeMap.put("electrovalence", 0);
|
timeMap.put("orderCount", 0);
|
timeMap.put("paymentAmount", 0);
|
timeMap.put("paymoney", 0);
|
timeMap.put("servicecharge", 0);
|
|
charMap.add(timeMap);
|
}
|
}
|
|
tCharingOrderMapVO.setMaps1(charMap);
|
}else if (statisticsQueryDto.getDayType()==2){
|
List<Map<String,Object>> maps1 = chargingOrderService.getWeekData(start,end, siteIds);
|
|
LocalDate startDate = statisticsQueryDto.getStartTime();
|
LocalDate endDate = statisticsQueryDto.getEndTime();
|
|
List<Map<String, Object>> dateRangeStatistics = new ArrayList<>();
|
|
// 遍历日期范围
|
while (!startDate.isAfter(endDate)) {
|
String formattedDate = startDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
Map<String, Object> dailyStats = findMapWithDateValue(maps1, formattedDate);
|
|
if (dailyStats != null) {
|
dateRangeStatistics.add(dailyStats);
|
} else {
|
Map<String, Object> dateMap = new HashMap<>();
|
dateMap.put("time", formattedDate);
|
dateMap.put("electrovalence", 0);
|
dateMap.put("orderCount", 0);
|
dateMap.put("paymentAmount", 0);
|
dateMap.put("paymoney", 0);
|
dateMap.put("servicecharge", 0);
|
dateRangeStatistics.add(dateMap);
|
}
|
|
// 移动到下一天
|
startDate = startDate.plusDays(1);
|
}
|
tCharingOrderMapVO.setMaps1(dateRangeStatistics);
|
}else if (statisticsQueryDto.getDayType()==3){
|
List<Map<String,Object>> maps1 = chargingOrderService.getMonthData(start,end, siteIds);
|
|
LocalDate startDate = statisticsQueryDto.getStartTime();
|
LocalDate endDate = statisticsQueryDto.getEndTime();
|
|
List<Map<String, Object>> dateRangeStatistics = new ArrayList<>();
|
|
// 遍历日期范围
|
while (!startDate.isAfter(endDate)) {
|
String formattedDate = startDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
Map<String, Object> dailyStats = findMapWithDateValue(maps1, formattedDate);
|
|
if (dailyStats != null) {
|
dateRangeStatistics.add(dailyStats);
|
} else {
|
Map<String, Object> dateMap = new HashMap<>();
|
dateMap.put("time", formattedDate);
|
dateMap.put("electrovalence", 0);
|
dateMap.put("orderCount", 0);
|
dateMap.put("paymentAmount", 0);
|
dateMap.put("paymoney", 0);
|
dateMap.put("servicecharge", 0);
|
dateRangeStatistics.add(dateMap);
|
}
|
|
// 移动到下一天
|
startDate = startDate.plusDays(1);
|
}
|
tCharingOrderMapVO.setMaps1(dateRangeStatistics);
|
}else if (statisticsQueryDto.getDayType()==4){
|
List<Map<String,Object>> maps1 = chargingOrderService.getYearData(start,end, siteIds);
|
|
LocalDate startDate = statisticsQueryDto.getStartTime();
|
LocalDate endDate = statisticsQueryDto.getEndTime();
|
|
|
List<Map<String, Object>> dateRangeStatistics = new ArrayList<>();
|
|
// 遍历日期范围
|
while (!startDate.isAfter(endDate)) {
|
String formattedDate = startDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
Map<String, Object> dailyStats = findMapWithDateValue(maps1, formattedDate);
|
|
if (dailyStats != null) {
|
dateRangeStatistics.add(dailyStats);
|
} else {
|
Map<String, Object> dateMap = new HashMap<>();
|
dateMap.put("time", formattedDate);
|
dateMap.put("electrovalence", 0);
|
dateMap.put("orderCount", 0);
|
dateMap.put("paymentAmount", 0);
|
dateMap.put("paymoney", 0);
|
dateMap.put("servicecharge", 0);
|
dateRangeStatistics.add(dateMap);
|
}
|
|
// 移动到下一天
|
startDate = startDate.plusDays(1);
|
}
|
tCharingOrderMapVO.setMaps1(dateRangeStatistics);
|
}else if (statisticsQueryDto.getDayType()==5){
|
List<Map<String,Object>> maps1 = chargingOrderService.getByDate(start,end, siteIds);
|
|
LocalDate startDate = statisticsQueryDto.getStartTime();
|
LocalDate endDate = statisticsQueryDto.getEndTime();
|
|
|
|
List<Map<String, Object>> dateRangeStatistics = new ArrayList<>();
|
|
// 遍历日期范围
|
while (!startDate.isAfter(endDate)) {
|
String formattedDate = startDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
Map<String, Object> dailyStats = findMapWithDateValue(maps1, formattedDate);
|
|
if (dailyStats != null) {
|
dateRangeStatistics.add(dailyStats);
|
} else {
|
Map<String, Object> dateMap = new HashMap<>();
|
dateMap.put("time", formattedDate);
|
dateMap.put("electrovalence", 0);
|
dateMap.put("orderCount", 0);
|
dateMap.put("paymentAmount", 0);
|
dateMap.put("paymoney", 0);
|
dateMap.put("servicecharge", 0);
|
dateRangeStatistics.add(dateMap);
|
}
|
|
// 移动到下一天
|
startDate = startDate.plusDays(1);
|
}
|
tCharingOrderMapVO.setMaps1(dateRangeStatistics);
|
}
|
|
|
tCharingOrderMapVO.setMaps(maps);
|
BigDecimal allMoney = new BigDecimal(0);
|
BigDecimal commissionAmount = BigDecimal.ZERO;
|
for (Map<String, Object> map : maps) {
|
BigDecimal periodElectricPrice = (BigDecimal) map.get("period_electric_price");
|
Long order_source = (Long)map.get("order_source");
|
if(2 != order_source){
|
allMoney = allMoney.add(periodElectricPrice);
|
}
|
BigDecimal total_amount = (BigDecimal) map.get("total_amount");
|
allMoney = allMoney.add(total_amount);
|
commissionAmount = commissionAmount.add((BigDecimal) map.get("commissionAmount"));
|
}
|
allMoney = allMoney.multiply(new BigDecimal("0.006"));
|
tCharingOrderMapVO.setAllMoney(allMoney);
|
tCharingOrderMapVO.setCommissionAmount(commissionAmount);
|
return R.ok(tCharingOrderMapVO);
|
|
}
|
|
|
@ResponseBody
|
@PostMapping(value = "/charging/power")
|
@ApiOperation(value = "功率", tags = {"管理后台-数据分析-充电运营分析"})
|
public R<TCharingOrderPowerMapVO> power(@RequestBody ChargingStatisticsQueryDto statisticsQueryDto) {
|
List<Integer> siteIds = new ArrayList<>();
|
if (statisticsQueryDto.getSiteId() == null) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
//获取当前登录的siteIds
|
List<GetSiteListDTO> data = siteClient.getSiteListByUserId(userId).getData();
|
for (GetSiteListDTO datum : data) {
|
siteIds.add(datum.getId());
|
}
|
} else {
|
siteIds.add(statisticsQueryDto.getSiteId());
|
}
|
|
|
List<Map<String,Object>> maps1 = chargingOrderService.queryPower(siteIds);
|
|
|
Map<String,Object> map = chargingOrderService.qureryPowerLevel(siteIds,statisticsQueryDto);
|
|
TCharingOrderPowerMapVO tCharingOrderPowerMapVO = new TCharingOrderPowerMapVO();
|
tCharingOrderPowerMapVO.setMaps1(map);
|
tCharingOrderPowerMapVO.setMaps(maps1);
|
return R.ok(tCharingOrderPowerMapVO);
|
|
}
|
|
|
@RequiresPermissions(value = {"/chargingUserAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/charging/users")
|
@ApiOperation(value = "除电站流量外", tags = {"管理后台-数据分析-充电用户分析"})
|
public R<TCharingUserMapVO> users(@RequestBody ChargingStatisticsQueryDto statisticsQueryDto){
|
Long userId = tokenService.getLoginUser().getUserid();
|
|
List<Integer> siteIds = new ArrayList<>();
|
if (statisticsQueryDto.getSiteId()==null){
|
List<GetSiteListDTO> data = siteClient.getSiteListByUserId(userId).getData();
|
for (GetSiteListDTO datum : data) {
|
siteIds.add(datum.getId());
|
}
|
}else {
|
siteIds.add(statisticsQueryDto.getSiteId());
|
}
|
if (siteIds.isEmpty())siteIds.add(-1);
|
statisticsQueryDto.setSiteIds(siteIds);
|
|
|
TCharingUserMapVO tCharingUserMapVO = new TCharingUserMapVO();
|
//上方折现
|
if (statisticsQueryDto.getDayType()==1){
|
List<Map<String,Object>> map = chargingOrderService.usersDay(statisticsQueryDto);
|
|
List<Map<String, Object>> charMap = new ArrayList<>();
|
// 生成从 "00:00" 到 "23:00" 的时间数据
|
for (int hour = 0; hour < 24; hour++) {
|
String time = String.format("%02d:00", hour);
|
Map<String, Object> mapWithTimeValue = findMapWithTimeValue(map, time);
|
if (mapWithTimeValue!=null){
|
charMap.add(mapWithTimeValue);
|
}else {
|
Map<String, Object> timeMap = new HashMap<>();
|
timeMap.put("time", time); // 初始化值为 null
|
timeMap.put("counts", 0);
|
|
charMap.add(timeMap);
|
}
|
}
|
|
List<Map<String,Object>> map1 = chargingOrderService.usersDay1();
|
|
List<Map<String, Object>> charMap1 = new ArrayList<>();
|
// 生成从 "00:00" 到 "23:00" 的时间数据
|
for (int hour = 0; hour < 24; hour++) {
|
String time = String.format("%02d:00", hour);
|
Map<String, Object> mapWithTimeValue = findMapWithTimeValue(map1, time);
|
if (mapWithTimeValue!=null){
|
charMap1.add(mapWithTimeValue);
|
}else {
|
Map<String, Object> timeMap = new HashMap<>();
|
timeMap.put("time", time); // 初始化值为 null
|
timeMap.put("counts", 0);
|
|
charMap1.add(timeMap);
|
}
|
}
|
|
|
tCharingUserMapVO.setMap(charMap);
|
tCharingUserMapVO.setMap1(charMap1);
|
}else {
|
|
|
List<Map<String,Object>> map = chargingOrderService.usersByQuery(statisticsQueryDto);
|
|
|
//按日
|
// 解析 startTime 和 endTime 为 LocalDate
|
LocalDate startDate = statisticsQueryDto.getStartTime();
|
LocalDate endDate = statisticsQueryDto.getEndTime();
|
|
List<Map<String, Object>> dateRangeStatistics = new ArrayList<>();
|
|
// 遍历日期范围
|
while (!startDate.isAfter(endDate)) {
|
String formattedDate = startDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
Map<String, Object> dailyStats = findMapWithDateValue(map, formattedDate);
|
|
if (dailyStats != null) {
|
dateRangeStatistics.add(dailyStats);
|
} else {
|
Map<String, Object> dateMap = new HashMap<>();
|
dateMap.put("time", formattedDate);
|
dateMap.put("counts", 0);
|
dateRangeStatistics.add(dateMap);
|
}
|
|
// 移动到下一天
|
startDate = startDate.plusDays(1);
|
}
|
|
tCharingUserMapVO.setMap(dateRangeStatistics);
|
|
|
List<Map<String,Object>> map1 = chargingOrderService.usersByQuery1(statisticsQueryDto);
|
|
|
|
LocalDate startDate1 = statisticsQueryDto.getStartTime();
|
LocalDate endDate1 = statisticsQueryDto.getEndTime();
|
|
List<Map<String, Object>> dateRangeStatistics1 = new ArrayList<>();
|
|
// 遍历日期范围
|
while (!startDate1.isAfter(endDate1)) {
|
String formattedDate = startDate1.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
Map<String, Object> dailyStats = findMapWithDateValue(map1, formattedDate);
|
|
if (dailyStats != null) {
|
dateRangeStatistics1.add(dailyStats);
|
} else {
|
Map<String, Object> dateMap = new HashMap<>();
|
dateMap.put("time", formattedDate);
|
dateMap.put("counts", 0);
|
dateRangeStatistics1.add(dateMap);
|
}
|
|
// 移动到下一天
|
startDate1 = startDate1.plusDays(1);
|
}
|
|
tCharingUserMapVO.setMap1(dateRangeStatistics1);
|
|
|
|
|
}
|
|
//用户标签
|
List<Map<String,Object>> maps = chargingOrderService.getUserTagCount();
|
Map<String,Object> stringObjectMap = new HashMap<>();
|
Long noTagCount = chargingOrderService.countNoTag();
|
stringObjectMap.put("count",noTagCount);
|
maps.add(stringObjectMap);
|
|
//会员标签
|
List<Map<String,Object>> maps1 = chargingOrderService.getVipCount();
|
|
//单位消费
|
List<Map<String, Object>> untiMap = chargingOrderService.unitConsumption(statisticsQueryDto);
|
|
//车辆用途
|
List<Map<String, Object>> carMap = chargingOrderService.carUserMethod();
|
|
//车辆品牌
|
List<Map<String, Object>> carBrandMap = chargingOrderService.carUserBrand();
|
List<String> brands = new ArrayList<>();
|
for (Map<String, Object> objectMap : carBrandMap) {
|
brands.add(objectMap.get("vehicle_brand").toString());
|
}
|
|
if (carBrandMap.size()>=5) {
|
Long count = chargingOrderService.countCar(brands);
|
Map<String, Object> others = new HashMap<>();
|
others.put("vehicle_brand", "其他");
|
others.put("counts", count);
|
carBrandMap.add(others);
|
}
|
//本地车数量
|
Map<String,Object> localCarMap = chargingOrderService.countLocalCar();
|
|
|
tCharingUserMapVO.setUserMaps(maps);
|
tCharingUserMapVO.setVipMaps(maps1);
|
tCharingUserMapVO.setUntiMap(untiMap);
|
tCharingUserMapVO.setCarMap(carMap);
|
tCharingUserMapVO.setCarBrandMap(carBrandMap);
|
tCharingUserMapVO.setLocalCarMap(localCarMap);
|
return R.ok(tCharingUserMapVO);
|
|
}
|
|
|
@RequiresPermissions(value = {"/chargingUserAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/charging/sites")
|
@ApiOperation(value = "电站评价", tags = {"管理后台-数据分析-充电用户分析"})
|
public R<TCharingUserEvaluateVO> sites(@RequestBody ChargingStatisticsQueryDto statisticsQueryDto){
|
List<Integer> siteIds =new ArrayList<>();
|
if (statisticsQueryDto.getSiteId()==null) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
//获取当前登录的siteIds
|
List<GetSiteListDTO> data = siteClient.getSiteListByUserId(userId).getData();
|
for (GetSiteListDTO datum : data) {
|
siteIds.add(datum.getId());
|
}
|
}else {
|
siteIds.add(statisticsQueryDto.getSiteId());
|
}
|
//查询评价分
|
Double aver = chargingOrderService.getAver(siteIds);
|
//查询各个分数
|
List<Map<String,Object>> evaluate = chargingOrderService.getLevelEvaluate(siteIds);
|
//查询差评回复数
|
List<Integer> mark = new ArrayList<>();
|
mark.add(1);
|
mark.add(2);
|
Long count = orderEvaluateService.lambdaQuery().in(TOrderEvaluate::getMark, mark).isNotNull(TOrderEvaluate::getResponseTime).count();
|
TCharingUserEvaluateVO tCharingUserEvaluateVO = new TCharingUserEvaluateVO();
|
tCharingUserEvaluateVO.setAver(aver);
|
tCharingUserEvaluateVO.setEvaluate(evaluate);
|
tCharingUserEvaluateVO.setBlackCount(count);
|
|
|
//好评标签
|
List<Map<String,Object>> goodTop = orderEvaluateService.goodTop(siteIds);
|
//差评标签
|
List<Map<String,Object>> badTop = orderEvaluateService.badTop(siteIds);
|
|
//流量分析
|
List<Map<String,Object>> sourceMap = chargingOrderService.countBySource(siteIds,statisticsQueryDto);
|
tCharingUserEvaluateVO.setGoodTop(goodTop);
|
tCharingUserEvaluateVO.setBadTop(badTop);
|
tCharingUserEvaluateVO.setFlow(sourceMap);
|
//流量
|
return R.ok(tCharingUserEvaluateVO);
|
}
|
|
|
@RequiresPermissions(value = {"/operationMaintenanceAnalysis"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/charging/equipment")
|
@ApiOperation(value = "电站评价", tags = {"管理后台-数据分析-设备运维分析"})
|
public R<TCharingUserEquimentVO> equipment(@RequestBody ChargingStatisticsQueryDto statisticsQueryDto){
|
List<Integer> siteIds =new ArrayList<>();
|
if (statisticsQueryDto.getSiteId()==null||statisticsQueryDto.getSiteId()==0) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
//获取当前登录的siteIds
|
List<GetSiteListDTO> data = siteClient.getSiteListByUserId(userId).getData();
|
for (GetSiteListDTO datum : data) {
|
siteIds.add(datum.getId());
|
}
|
}else {
|
siteIds.add(statisticsQueryDto.getSiteId());
|
}
|
//直流可用率
|
List<Map<String,Object>> equipmentMap1 = chargingOrderService.equipmentUserType1(siteIds,statisticsQueryDto);
|
for (Map<String, Object> result : equipmentMap1) {
|
Object percentObj = result.get("percent");
|
if (percentObj instanceof String) {
|
try {
|
BigDecimal percent = new BigDecimal((String) percentObj);
|
if (percent.compareTo(BigDecimal.ZERO) < 0) {
|
result.put("percent", percent.negate().toString());
|
}
|
} catch (NumberFormatException e) {
|
// 处理转换异常
|
result.put("percent", BigDecimal.ZERO); // 或者其他默认值
|
}
|
} else if (percentObj instanceof BigDecimal) {
|
BigDecimal percent = (BigDecimal) percentObj;
|
if (percent.compareTo(BigDecimal.ZERO) < 0) {
|
result.put("percent", percent.negate().toString());
|
}
|
}
|
}
|
|
//交流可用率
|
List<Map<String,Object>> equipmentMap2= chargingOrderService.equipmentUserType2(siteIds,statisticsQueryDto);
|
|
for (Map<String, Object> result : equipmentMap2) {
|
Object percentObj = result.get("percent");
|
if (percentObj instanceof String) {
|
try {
|
BigDecimal percent = new BigDecimal((String) percentObj);
|
if (percent.compareTo(BigDecimal.ZERO) < 0) {
|
result.put("percent", percent.negate().toString());
|
}
|
} catch (NumberFormatException e) {
|
// 处理转换异常
|
result.put("percent", BigDecimal.ZERO); // 或者其他默认值
|
}
|
} else if (percentObj instanceof BigDecimal) {
|
BigDecimal percent = (BigDecimal) percentObj;
|
if (percent.compareTo(BigDecimal.ZERO) < 0) {
|
result.put("percent", percent.negate().toString());
|
}
|
}
|
}
|
|
//取出直流可用率和交流可用率的percent的平均值保留两位小数
|
|
double average1 = calculateAveragePercent(equipmentMap1, equipmentMap2);
|
System.out.printf("The average percent is: %.2f\n", average1);
|
|
|
//直流故障率
|
List<Map<String,Object>> equipmentMapbroke1 = chargingOrderService.equipmentMapbroke1(siteIds,statisticsQueryDto);
|
//交流故障率
|
List<Map<String,Object>> equipmentMapbroke2 = chargingOrderService.equipmentMapbroke2(siteIds,statisticsQueryDto);
|
|
|
double average2 = calculateAveragePercent(equipmentMapbroke1, equipmentMapbroke2);
|
System.out.printf("The average percent is: %.2f\n", average2);
|
//直流离网率
|
List<Map<String,Object>> equipmentMapOut1 = chargingOrderService.equipmentMapOut1(siteIds,statisticsQueryDto);
|
//交流离网率
|
List<Map<String,Object>> equipmentMapOut2 = chargingOrderService.equipmentMapOut2(siteIds,statisticsQueryDto);
|
|
double average3 = calculateAveragePercent(equipmentMapOut1, equipmentMapOut2);
|
System.out.printf("The average percent is: %.2f\n", average3);
|
|
//需求电流满足率
|
List<Map<String,Object>> needElec1 = chargingOrderService.needElec(siteIds,statisticsQueryDto);
|
List<Map<String,Object>> needElec2 = chargingOrderService.needElec1(siteIds,statisticsQueryDto);
|
|
double average4 = calculateAveragePercent(needElec1, needElec2);
|
System.out.printf("The average percent is: %.2f\n", average4);
|
|
|
|
TCharingUserEquimentVO tCharingUserEquimentVO = new TCharingUserEquimentVO();
|
tCharingUserEquimentVO.setEquipmentMap1(equipmentMap1);
|
tCharingUserEquimentVO.setEquipmentMap2(equipmentMap2);
|
tCharingUserEquimentVO.setEquipmentMapbroke1(equipmentMapbroke1);
|
tCharingUserEquimentVO.setEquipmentMapbroke2(equipmentMapbroke2);
|
tCharingUserEquimentVO.setEquipmentMapOut1(equipmentMapOut1);
|
tCharingUserEquimentVO.setEquipmentMapOut2(equipmentMapOut2);
|
tCharingUserEquimentVO.setNeedElec1(needElec1);
|
tCharingUserEquimentVO.setNeedElec2(needElec2);
|
tCharingUserEquimentVO.setAverage1(average1);
|
tCharingUserEquimentVO.setAverage2(average2);
|
tCharingUserEquimentVO.setAverage3(average3);
|
tCharingUserEquimentVO.setAverage4(average4);
|
return R.ok(tCharingUserEquimentVO);
|
}
|
|
private static final DecimalFormat DF = new DecimalFormat("#.00");
|
public static double calculateAveragePercent(List<Map<String, Object>> mapList1, List<Map<String, Object>> mapList2) {
|
int totalElements = mapList1.size() + mapList2.size();
|
double sum = 0.0;
|
|
// 累加两个列表中所有元素的 "percent" 值
|
for (Map<String, Object> map : mapList1) {
|
if (map.containsKey("percent")) {
|
sum += Double.parseDouble((String) map.get("percent"));
|
}
|
}
|
for (Map<String, Object> map : mapList2) {
|
if (map.containsKey("percent")) {
|
sum += Double.parseDouble((String) map.get("percent"));
|
}
|
}
|
|
// 防止除以零错误
|
if (totalElements == 0) {
|
return 0.0;
|
}
|
|
// 计算平均值
|
double average = sum / totalElements;
|
|
// 格式化为两位小数
|
return Double.parseDouble(DF.format(average));
|
}
|
|
|
@RequiresPermissions(value = {"/workbench"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/work/charge")
|
@ApiOperation(value = "上方充电数据统计", tags = {"管理后台-工作台"})
|
public R<TCharingWorkVO> workCharge(@RequestBody ChargingStatisticsQueryDto statisticsQueryDto) {
|
List<Integer> siteIds = new ArrayList<>();
|
if (statisticsQueryDto.getSiteId() == null) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
//获取当前登录的siteIds
|
List<GetSiteListDTO> data = siteClient.getSiteListByUserId(userId).getData();
|
if (data != null) {
|
for (GetSiteListDTO datum : data) {
|
siteIds.add(datum.getId());
|
}
|
}
|
} else {
|
siteIds.add(statisticsQueryDto.getSiteId());
|
}
|
if (siteIds.isEmpty()) {
|
siteIds.add(-1);
|
}
|
LocalDateTime selectDate = statisticsQueryDto.getSelectDate() == null ? LocalDateTime.now() : statisticsQueryDto.getSelectDate();
|
String format = selectDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
Map<String, Object> stringObjectMap = chargingOrderService.getChargingOrderCount(siteIds, format);
|
//当日的订单总数
|
int size = 0;
|
//计算list中paymentAmount的总和
|
BigDecimal totalPaymentAmount = BigDecimal.ZERO;
|
//计算list中electrovalence的总和
|
BigDecimal totalElectrovalence = BigDecimal.ZERO;
|
//计算list中serviceCharge的总和
|
BigDecimal totalServiceCharge = BigDecimal.ZERO;
|
//计算list中charging_capacity的总和
|
BigDecimal totalChargingCapacity = BigDecimal.ZERO;
|
if(null != stringObjectMap){
|
size = getWorkChargeInt(stringObjectMap, "num");
|
totalElectrovalence = getWorkChargeDecimal(stringObjectMap, "electrovalence");
|
totalServiceCharge = getWorkChargeDecimal(stringObjectMap, "servicecharge");
|
totalChargingCapacity = getWorkChargeDecimal(stringObjectMap, "electricity");
|
totalPaymentAmount = totalElectrovalence.add(totalServiceCharge);
|
}
|
|
TCharingWorkVO tCharingWorkVO = new TCharingWorkVO();
|
tCharingWorkVO.setCount(size);
|
tCharingWorkVO.setTotalPaymentAmount(totalPaymentAmount);
|
tCharingWorkVO.setTotalElectrovalence(totalElectrovalence);
|
tCharingWorkVO.setTotalServiceCharge(totalServiceCharge);
|
tCharingWorkVO.setTotalChargingCapacity(totalChargingCapacity);
|
return R.ok(tCharingWorkVO);
|
}
|
|
private int getWorkChargeInt(Map<String, Object> map, String key) {
|
Object value = map.get(key);
|
if (value == null) {
|
return 0;
|
}
|
if (value instanceof Number) {
|
return ((Number) value).intValue();
|
}
|
return Integer.parseInt(value.toString());
|
}
|
|
private BigDecimal getWorkChargeDecimal(Map<String, Object> map, String key) {
|
Object value = map.get(key);
|
if (value == null) {
|
return BigDecimal.ZERO;
|
}
|
if (value instanceof BigDecimal) {
|
return (BigDecimal) value;
|
}
|
if (value instanceof Number) {
|
return BigDecimal.valueOf(((Number) value).doubleValue());
|
}
|
return new BigDecimal(value.toString());
|
}
|
|
|
|
@RequiresPermissions(value = {"/workbench"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/work/chargeDetail")
|
@ApiOperation(value = "运营情况", tags = {"管理后台-工作台"})
|
public R workCharge(@RequestBody ChargingDetailQueryDto statisticsQueryDto) {
|
try {
|
List<Integer> siteIds = new ArrayList<>();
|
if (statisticsQueryDto.getSiteId() == null) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
//获取当前登录的siteIds
|
List<GetSiteListDTO> data = siteClient.getSiteListByUserId(userId).getData();
|
for (GetSiteListDTO datum : data) {
|
siteIds.add(datum.getId());
|
}
|
} else {
|
siteIds.add(statisticsQueryDto.getSiteId());
|
}
|
if (statisticsQueryDto.getDayType()==1) {
|
List<Map<String,Object>> charMap1 = chargingOrderService.getHourType(siteIds,statisticsQueryDto);
|
List<Map<String, Object>> charMap = new ArrayList<>();
|
// 生成从 "00:00" 到 "23:00" 的时间数据
|
for (int hour = 0; hour < 24; hour++) {
|
String time = String.format("%02d:00", hour);
|
Map<String, Object> mapWithTimeValue = findMapWithTimeValue(charMap1, time);
|
if (mapWithTimeValue!=null){
|
charMap.add(mapWithTimeValue);
|
}else {
|
Map<String, Object> timeMap = new HashMap<>();
|
timeMap.put("time", time); // 初始化值为 null
|
timeMap.put("electrovalence", 0);
|
timeMap.put("orderCount", 0);
|
timeMap.put("servicecharge", 0);
|
timeMap.put("electricity", 0);
|
charMap.add(timeMap);
|
}
|
}
|
return R.ok(charMap);
|
}else if (statisticsQueryDto.getDayType()==2){
|
// 假设 chargingOrderService.getDateType() 返回的是按天的数据
|
List<Map<String, Object>> charMap1 = chargingOrderService.getDateType(siteIds, statisticsQueryDto);
|
|
// 解析 startTime 和 endTime 为 LocalDate
|
LocalDate startDate = statisticsQueryDto.getStartTime();
|
LocalDate endDate = statisticsQueryDto.getEndTime();
|
|
List<Map<String, Object>> dateRangeStatistics = new ArrayList<>();
|
|
// 遍历日期范围
|
while (!startDate.isAfter(endDate)) {
|
String formattedDate = startDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
Map<String, Object> dailyStats = findMapWithDateValue(charMap1, formattedDate);
|
|
if (dailyStats != null) {
|
dateRangeStatistics.add(dailyStats);
|
} else {
|
Map<String, Object> dateMap = new HashMap<>();
|
dateMap.put("time", formattedDate);
|
dateMap.put("electrovalence", 0);
|
dateMap.put("orderCount", 0);
|
dateMap.put("servicecharge", 0);
|
dateMap.put("electricity", 0);
|
dateRangeStatistics.add(dateMap);
|
}
|
|
// 移动到下一天
|
startDate = startDate.plusDays(1);
|
}
|
|
// return dateRangeStatistics;
|
return R.ok(dateRangeStatistics);
|
}else if (statisticsQueryDto.getDayType()==3){
|
List<Map<String,Object>> charMap1 = chargingOrderService.getMonthType(siteIds,statisticsQueryDto);
|
// 解析 startTime 和 endTime 为 LocalDate
|
LocalDate startDate = statisticsQueryDto.getStartTime();
|
LocalDate endDate = statisticsQueryDto.getEndTime();
|
|
List<Map<String, Object>> dateRangeStatistics = new ArrayList<>();
|
|
// 遍历日期范围
|
while (!startDate.isAfter(endDate)) {
|
String formattedDate = startDate.format(DateTimeFormatter.ofPattern("yyyy-MM"));
|
Map<String, Object> dailyStats = findMapWithDateValue(charMap1, formattedDate);
|
|
if (dailyStats != null) {
|
dateRangeStatistics.add(dailyStats);
|
} else {
|
Map<String, Object> dateMap = new HashMap<>();
|
dateMap.put("time", formattedDate);
|
dateMap.put("electrovalence", 0);
|
dateMap.put("orderCount", 0);
|
dateMap.put("servicecharge", 0);
|
dateMap.put("electricity", 0);
|
dateRangeStatistics.add(dateMap);
|
}
|
|
// 移动到下一天
|
startDate = startDate.plusMonths(1);
|
}
|
return R.ok(dateRangeStatistics);
|
|
}
|
}catch (Exception e){
|
e.printStackTrace();
|
}
|
return R.ok();
|
|
|
}
|
|
private static Map<String, Object> findMapWithTimeValue(List<Map<String, Object>> charMap1,String timeValue) {
|
for (Map<String, Object> map : charMap1) {
|
if (map.containsKey("time") && map.get("time").equals(timeValue)) {
|
return map;
|
}
|
}
|
return null; // 如果没有找到，返回 null
|
}
|
|
private Map<String, Object> findMapWithDateValue(List<Map<String, Object>> list, String date) {
|
for (Map<String, Object> map : list) {
|
if (date.equals(map.get("time"))) {
|
return map;
|
}
|
}
|
return null;
|
}
|
|
|
|
|
@RequiresPermissions(value = {"/workbench"}, logical = Logical.OR)
|
@ResponseBody
|
@PostMapping(value = "/work/use")
|
@ApiOperation(value = "利用率", tags = {"管理后台-工作台"})
|
public R workUse(@RequestBody ChargingDetailQueryDto statisticsQueryDto) {
|
List<Integer> siteIds = new ArrayList<>();
|
if (statisticsQueryDto.getSiteId() == null) {
|
Long userId = tokenService.getLoginUser().getUserid();
|
//获取当前登录的siteIds
|
List<GetSiteListDTO> data = siteClient.getSiteListByUserId(userId).getData();
|
for (GetSiteListDTO datum : data) {
|
siteIds.add(datum.getId());
|
}
|
} else {
|
siteIds.add(statisticsQueryDto.getSiteId());
|
}
|
List<Map<String,Object>> capMap = chargingOrderService.getchargingCapacity(siteIds,statisticsQueryDto);
|
List<TChargingPile> chargingPiles = chargingPileClient.getChargingPileBySiteIds(siteIds).getData();
|
BigDecimal totalRatedPower = chargingPiles.stream().map(TChargingPile::getRatedPower).reduce(BigDecimal.ZERO, BigDecimal::add);
|
|
//每日利用率=当日充电度数/（桩总功率*24小时）
|
BigDecimal multiply1 = totalRatedPower.multiply(new BigDecimal(24));
|
System.err.println(JSON.toJSONString(capMap) + "---" + chargingPiles.size() + "---" + totalRatedPower + "---" + multiply1);
|
capMap.forEach(map -> {
|
BigDecimal chargingCapacity = (BigDecimal) map.get("chargingCapacity");
|
BigDecimal result = chargingCapacity.divide(multiply1, 4, RoundingMode.HALF_UP);
|
BigDecimal multiply = result.multiply(new BigDecimal(100));
|
map.put("chargingCapacity", multiply);
|
});
|
|
// 解析 startTime 和 endTime 为 LocalDate
|
LocalDate startDate = statisticsQueryDto.getStartTime();
|
LocalDate endDate = statisticsQueryDto.getEndTime();
|
|
List<Map<String, Object>> dateRangeStatistics = new ArrayList<>();
|
|
// 遍历日期范围
|
while (!startDate.isAfter(endDate)) {
|
String formattedDate = startDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
|
Map<String, Object> dailyStats = findMapWithDateValue(capMap, formattedDate);
|
|
if (dailyStats != null) {
|
dateRangeStatistics.add(dailyStats);
|
} else {
|
Map<String, Object> dateMap = new HashMap<>();
|
dateMap.put("time", formattedDate);
|
dateMap.put("chargingCapacity", 0);
|
dateRangeStatistics.add(dateMap);
|
}
|
|
// 移动到下一天
|
startDate = startDate.plusDays(1);
|
}
|
return R.ok(dateRangeStatistics);
|
}
|
|
|
@RequiresPermissions(value = {"/workbench"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/work/shopOrder")
|
@ApiOperation(value = "购物订单统计", tags = {"管理后台-工作台"})
|
public R shopOrder() {
|
Long count = shoppingOrderService.lambdaQuery().eq(TShoppingOrder::getStatus, 1).count();
|
Long count1 = shoppingOrderService.lambdaQuery().eq(TShoppingOrder::getStatus, 2).count();
|
List<Long> counts = new ArrayList<>();
|
counts.add(count);
|
counts.add(count1);
|
return R.ok(counts);
|
}
|
|
|
@RequiresPermissions(value = {"/workbench"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/work/invoice")
|
@ApiOperation(value = "开票统计", tags = {"管理后台-工作台"})
|
public R invoice() {
|
Long count = invoiceService.lambdaQuery().eq(TOrderInvoice::getStatus, 1).count();
|
Long count1 = invoiceService.lambdaQuery().eq(TOrderInvoice::getStatus, 3).count();
|
List<Long> counts = new ArrayList<>();
|
counts.add(count);
|
counts.add(count1);
|
return R.ok(counts);
|
}
|
|
@RequiresPermissions(value = {"/workbench"}, logical = Logical.OR)
|
@ResponseBody
|
@GetMapping(value = "/work/users/count")
|
@ApiOperation(value = "用户数量", tags = {"管理后台-工作台"})
|
public R usersCount() {
|
List<Map<String,Object>> userMap = chargingOrderService.countAllUserData();
|
return R.ok(userMap);
|
|
}
|
|
@GetMapping(value = "/getGunIdsByUserId")
|
@ApiOperation(value = "查询当前用户正在充电中的枪id集合", tags = {"小程序-首页-用户充电订单信息"})
|
public R<List<Integer>> getGunIdsByUserId() {
|
Long userId = tokenService.getLoginUserApplet().getUserId();
|
List<TChargingOrder> list = chargingOrderService.list(Wrappers.lambdaQuery(TChargingOrder.class)
|
.eq(TChargingOrder::getAppUserId, userId)
|
.in(TChargingOrder::getStatus, Arrays.asList(1,2,3,4)));
|
List<Integer> gunIds = list.stream().map(TChargingOrder::getChargingGunId).collect(Collectors.toList());
|
return R.ok(gunIds);
|
}
|
|
|
|
|
/**
|
* 硬件充电结束后的处理逻辑（按订单号前缀路由，结束方式2=设备自动结束）
|
* @param code
|
*/
|
@PostMapping("/endCharge")
|
public void endCharge(@RequestParam("code") String code){
|
log.info(code + "：-------------------充电桩自动结束充电-------------------");
|
if (isCardOrder(code)) {
|
cardChargingOrderService.cardEndCharge(code, 2);
|
} else if (isVinOrder(code)) {
|
vinChargingOrderService.vinEndCharge(code, 2);
|
} else {
|
chargingOrderService.endCharge(code, 2);
|
}
|
}
|
|
|
|
/**
|
* 硬件异常结束充电后的处理逻辑（按订单号前缀路由，结束方式0=异常终止）
|
* @param code
|
*/
|
@PostMapping("/excelEndCharge")
|
public void excelEndCharge(@RequestParam("code") String code){
|
log.info(code + "：-------------------充电异常，停止充电-------------------");
|
if (isCardOrder(code)) {
|
cardChargingOrderService.cardEndCharge(code, 0);
|
} else if (isVinOrder(code)) {
|
vinChargingOrderService.vinEndCharge(code, 0);
|
} else {
|
chargingOrderService.excelEndCharge(code);
|
}
|
}
|
|
|
/**
|
* 根据车牌号和时间查询有效的充电数据
|
* @param query
|
* @return
|
*/
|
@PostMapping("/getChargingOrderByLicensePlate")
|
public R<TChargingOrder> getChargingOrderByLicensePlate(@RequestBody GetChargingOrderByLicensePlate query){
|
TChargingOrder chargingOrder = chargingOrderService.getChargingOrderByLicensePlate(query);
|
return R.ok(chargingOrder);
|
}
|
|
|
/**
|
* 修改充电订单
|
* @param chargingOrder
|
* @return
|
*/
|
@PostMapping("/updateChargingOrder")
|
public R<String> updateChargingOrder(@RequestBody TChargingOrder chargingOrder){
|
chargingOrderService.updateById(chargingOrder);
|
return R.ok();
|
}
|
|
|
@ResponseBody
|
@GetMapping(value = "/getEndOfChargePageInfo/{id}")
|
@ApiOperation(value = "获取充电结束页面数据", tags = {"小程序-扫一扫"})
|
@ApiImplicitParams({
|
@ApiImplicitParam(name = "id", value = "订单id", required = true)
|
})
|
public AjaxResult<EndOfChargePageInfo> getEndOfChargePageInfo(@PathVariable("id") String id){
|
EndOfChargePageInfo endOfChargePageInfo = chargingOrderService.getEndOfChargePageInfo(id);
|
return AjaxResult.success(endOfChargePageInfo);
|
}
|
|
|
/**
|
* 获取订单数据
|
* @param order
|
* @return
|
*/
|
@PostMapping("/getChargingOrder")
|
public R<List<TChargingOrder>> getChargingOrder(@RequestBody TChargingOrderVo order){
|
List<TChargingOrder> chargingOrder = chargingOrderService.getChargingOrder(order);
|
return R.ok(chargingOrder);
|
}
|
|
|
/**
|
* 根据车辆id获取指定时间范围内的数据
|
* @param carId
|
* @param startTime
|
* @param endTime
|
* @return
|
*/
|
@PostMapping("/getCarChargingOrder")
|
public R<List<TChargingOrder>> getCarChargingOrder(@RequestParam("carId") Long carId, @RequestParam("startTime") String startTime, @RequestParam("endTime") String endTime){
|
List<TChargingOrder> list = chargingOrderService.list(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getAppUserCarId, carId).eq(TChargingOrder::getDelFlag, 0)
|
.in(TChargingOrder::getStatus, Arrays.asList(4, 5)).between(TChargingOrder::getStartTime, startTime, endTime));
|
return R.ok(list);
|
}
|
|
|
/**
|
* 根据车牌号查询指定时间范围内的数据
|
* @param plateNum
|
* @param startTime
|
* @param endTime
|
* @return
|
*/
|
@PostMapping("/getCarChargingOrderByPlateNum")
|
public R<List<TChargingOrder>> getCarChargingOrderByPlateNum(@RequestParam("plateNum") String plateNum, @RequestParam("startTime") String startTime,
|
@RequestParam("endTime") String endTime){
|
List<TChargingOrder> list = chargingOrderService.list(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getPlateNum, plateNum).eq(TChargingOrder::getDelFlag, 0)
|
.in(TChargingOrder::getStatus, Arrays.asList(4, 5)).between(TChargingOrder::getStartTime, startTime, endTime));
|
return R.ok(list);
|
}
|
|
|
/**
|
* 添加三方平台充电订单数据
|
* @return
|
*/
|
@PostMapping("/addTripartitePlatformOrder")
|
public R addTripartitePlatformOrder(@RequestBody AddTripartitePlatformOrder query){
|
return chargingOrderService.addTripartitePlatformOrder(query);
|
}
|
|
|
|
|
|
/**
|
* 根据三方平台订单id获取充电数据
|
* @param startChargeSeq
|
* @return
|
*/
|
@PostMapping("/getChargingOrderByStartChargeSeq")
|
public R<TChargingOrder> getChargingOrderByStartChargeSeq(@RequestParam("startChargeSeq") String startChargeSeq){
|
TChargingOrder chargingOrder = chargingOrderService.getOne(new LambdaQueryWrapper<TChargingOrder>().eq(TChargingOrder::getStartChargeSeq, startChargeSeq));
|
return R.ok(chargingOrder);
|
}
|
|
|
|
|
/**
|
* 根据三方平台订单ids获取充电数据
|
* @param startChargeSeqs
|
* @return
|
*/
|
@PostMapping("/getChargingOrderByStartChargeSeqs")
|
public R<List<TChargingOrder>> getChargingOrderByStartChargeSeqs(@RequestParam("startChargeSeqs") List<String> startChargeSeqs){
|
List<TChargingOrder> list = chargingOrderService.list(new LambdaQueryWrapper<TChargingOrder>().in(TChargingOrder::getStartChargeSeq, startChargeSeqs));
|
return R.ok(list);
|
}
|
|
|
/**
|
* 三方平台请求停止充电
|
* @param startChargeSeq
|
* @return
|
*/
|
@PostMapping("/tripartitePlatformStopCharge")
|
public R tripartitePlatformStopCharge(@RequestParam("startChargeSeq") String startChargeSeq){
|
return chargingOrderService.tripartitePlatformStopCharge(startChargeSeq);
|
}
|
|
|
/**
|
* 临时接口
|
* 获取充电后没有扣除费用的数据
|
* @return
|
*/
|
@GetMapping("/getNotPaymentChargingOrder")
|
public R getNotPaymentChargingOrder(){
|
return chargingOrderService.getNotPaymentChargingOrder();
|
}
|
|
|
/**
|
* 手动推送订单给三方平台
|
* @param code
|
* @return
|
*/
|
@PostMapping("/pushOrderInfo")
|
public R pushOrderInfo(@RequestParam String code){
|
return chargingOrderService.pushOrderInfo(code);
|
}
|
|
|
/**
|
* 添加汇总数据（临时）
|
* @return
|
*/
|
@ResponseBody
|
@GetMapping(value = "/addChargingOrderSummaryData")
|
public R addChargingOrderSummaryData(){
|
return chargingOrderService.addChargingOrderSummaryData();
|
}
|
|
/**
|
* 充电桩数据大屏 新能源汽车电池安全检测次数统计
|
*/
|
@ResponseBody
|
@GetMapping(value = "/getStatisticsOfBattery")
|
@ApiOperation(value = "新能源汽车电池安全检测次数统计", tags = {"充电桩数据大屏"})
|
public R<StatisticsOfBatteryVO> getStatisticsOfBattery(
|
@RequestParam(value = "siteIds", required = false) List<Integer> siteIds){
|
|
return chargingOrderService.getStatisticsOfBattery(siteIds);
|
}
|
|
/**
|
* 充电桩数据大屏 获取站点集合中总的充电量
|
*/
|
@ResponseBody
|
@GetMapping("/getSumDegreeBySiteIds")
|
public R<BigDecimal> getSumDegreeBySiteIds(@RequestParam("siteIds") List<Integer> SiteIds){
|
Double sumDegreeBySiteIds = chargingOrderService.getSumDegreeBySiteIds(SiteIds);
|
|
return R.ok(new BigDecimal(sumDegreeBySiteIds));
|
}
|
|
/**
|
* 充电桩数据大屏 获取站点集合中累计充电量(与 /large-screen/summary 同口径: 已结束+已支付订单)
|
*/
|
@ResponseBody
|
@GetMapping("/getLargeScreenTotalCapacity")
|
public R<BigDecimal> getLargeScreenTotalCapacity(@RequestParam("siteIds") List<Integer> siteIds){
|
return R.ok(chargingOrderService.getLargeScreenTotalCapacity(siteIds));
|
}
|
@ResponseBody
|
@PostMapping("/addChargingOrder")
|
public R<Long> addChargingOrder(@RequestBody TChargingOrder chargingOrder){
|
chargingOrderService.save(chargingOrder);
|
return R.ok(chargingOrder.getId());
|
}
|
|
|
@GetMapping(value = "/getOrderIdByUserId")
|
@ApiOperation(value = "H5查询当前用户正在充电中的订单id集合", tags = {"H5-首页-用户充电订单信息"})
|
public R<String> getOrderIdByUserId() {
|
Long userId = tokenService.getLoginUserApplet().getUserId();
|
TChargingOrder chargingOrder = chargingOrderService.getOne(Wrappers.lambdaQuery(TChargingOrder.class)
|
.eq(TChargingOrder::getAppUserId, userId)
|
.in(TChargingOrder::getStatus, Arrays.asList(1,2,3,4))
|
.orderByDesc(TChargingOrder::getCreateTime)
|
.last("LIMIT 1"));
|
if(Objects.isNull(chargingOrder)){
|
return R.ok();
|
}
|
return R.ok(String.valueOf(chargingOrder.getId()));
|
}
|
|
|
/**
|
* 手动查询订单和退款数据，完善退款记录
|
* @param orderId
|
* @param refund_out_trade_no
|
* @return
|
*/
|
@PostMapping("/orderQueryRefund")
|
public R<?> orderQueryRefund(@RequestParam("orderId") Long orderId, @RequestParam("refund_out_trade_no") String refund_out_trade_no){
|
chargingOrderService.orderQueryRefund(orderId, refund_out_trade_no);
|
return R.ok();
|
}
|
|
/**
|
* 手动查询订单和退款数据，批量完善退款记录
|
* @return
|
*/
|
@PostMapping("/orderQueryRefundList")
|
public R<?> orderQueryRefundList(@RequestBody List<String> dto){
|
for (String s : dto) {
|
String[] split = s.split(",");
|
chargingOrderService.orderQueryRefund(Long.valueOf(split[0]), split[1]);
|
}
|
return R.ok();
|
}
|
|
|
/**
|
* 手动添加完善订单费用明细
|
* @param orderId
|
* @return
|
*/
|
@PostMapping("/addOrderExpenseBreakdown")
|
public R<?> addOrderExpenseBreakdown(@RequestParam("orderId") Long orderId){
|
chargingOrderService.addOrderExpenseBreakdown(orderId);
|
return R.ok();
|
}
|
|
|
/**
|
* 手动批量修改订单支付金额
|
* @param dtos
|
* @return
|
*/
|
@PostMapping("/updateOrderPaymentAmount")
|
public R<?> updateOrderPaymentAmount(@RequestBody List<UpdateOrderPaymentAmountDto> dtos){
|
for (UpdateOrderPaymentAmountDto dto : dtos) {
|
chargingOrderService.update(new UpdateWrapper<TChargingOrder>().eq("id", dto.getOrderId())
|
.set("payment_amount", dto.getPaymentAmount()));
|
}
|
return R.ok();
|
}
|
}
|
