diff --git a/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/ChargeAlgorithmController.java b/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/ChargeAlgorithmController.java new file mode 100644 index 000000000..3cbdffed8 --- /dev/null +++ b/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/ChargeAlgorithmController.java @@ -0,0 +1,39 @@ +package com.jsowell.api.thirdparty; + +import com.jsowell.common.annotation.Anonymous; +import com.jsowell.common.core.controller.BaseController; +import com.jsowell.common.response.RestApiResponse; +import com.jsowell.thirdparty.platform.service.impl.ChargeAlgorithmService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.PathVariable; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +/** + * 算法应用Controller + * + * @author Lemon + * @Date 2024/12/17 15:20:36 + */ +@Anonymous +@RestController +@RequestMapping("/chargealgorithm") +public class ChargeAlgorithmController extends BaseController { + + @Autowired + private ChargeAlgorithmService chargeAlgorithmService; + + @GetMapping("/pushOrderInfo/{orderCode}") + public RestApiResponse pushOrderInfo(@PathVariable("orderCode") String orderCode) { + RestApiResponse response = null; + try { + String result = chargeAlgorithmService.pushOrderInfo(orderCode); + response = new RestApiResponse<>(result); + }catch (Exception e) { + logger.error("算法应用推送订单信息 error, ", e); + response = new RestApiResponse<>(e); + } + return response; + } +} diff --git a/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/GuiZhouPlatformController.java b/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/GuiZhouPlatformController.java index 649f3805d..a084d3f2c 100644 --- a/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/GuiZhouPlatformController.java +++ b/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/GuiZhouPlatformController.java @@ -1,10 +1,11 @@ package com.jsowell.api.thirdparty; - import com.alibaba.fastjson2.JSON; import com.jsowell.common.annotation.Anonymous; +import com.jsowell.common.core.domain.AjaxResult; import com.jsowell.common.enums.thirdparty.ThirdPartyReturnCodeEnum; import com.jsowell.common.exception.BusinessException; +import com.jsowell.common.response.RestApiResponse; import com.jsowell.pile.dto.QueryOperatorInfoDTO; import com.jsowell.pile.dto.QueryStationInfoDTO; import com.jsowell.pile.thirdparty.CommonParamsDTO; @@ -12,12 +13,10 @@ import com.jsowell.thirdparty.lianlian.common.CommonResult; import com.jsowell.thirdparty.platform.service.ThirdPartyPlatformService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.beans.factory.annotation.Qualifier; -import org.springframework.web.bind.annotation.PostMapping; -import org.springframework.web.bind.annotation.RequestBody; -import org.springframework.web.bind.annotation.RequestMapping; -import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.bind.annotation.*; import javax.servlet.http.HttpServletRequest; +import java.util.List; import java.util.Map; /** @@ -33,6 +32,7 @@ public class GuiZhouPlatformController extends ThirdPartyBaseController { @Qualifier("guiZhouPlatformServiceImpl") private ThirdPartyPlatformService platformLogic; + /** * getToken */ @@ -150,4 +150,63 @@ public class GuiZhouPlatformController extends ThirdPartyBaseController { } return CommonResult.failed("查询充电站状态信息发生异常"); } -} + + /** + * 历史充电订单信息推送 + */ + @GetMapping("/v1/notificationChargeOrderInfoHistory/{orderCode}") + public RestApiResponse notificationChargeOrderInfoHistory(@PathVariable("orderCode") String orderCode) { + RestApiResponse response = null; + String result = null; + try { + result = platformLogic.notificationChargeOrderInfoHistory(orderCode); + response = new RestApiResponse<>(result); + } catch (Exception e) { + logger.error("贵州平台推送充电站历史充电订单信息 error", e); + return new RestApiResponse<>(e); + } + logger.info("贵州平台推送充电站历史充电订单信息 result:{}", result); + return response; + } + + /** + * 推送充换电站用能统计信息 + * @param stationId + * @return + */ + @GetMapping("/v1/notificationOperationStatsInfo/{stationId}") + public RestApiResponse notificationOperationStatsInfo(@PathVariable("stationId") String stationId) { + RestApiResponse response = null; + String result = null; + try { + result = platformLogic.notificationOperationStatsInfo(stationId); + response = new RestApiResponse<>(result); + } catch (Exception e) { + logger.error("贵州平台推送充换电站用能统计信息 error", e); + return new RestApiResponse<>(e); + } + logger.info("贵州平台推送充换电站用能统计信息 result:{}", result); + return response; + } + + /** + * 推送充换电站实时功率 + * @param stationIds + * @return + */ + @GetMapping("/v1/notificationPowerInfo/{stationIds}") + public RestApiResponse notificationPowerInfo(@PathVariable("stationIds") List stationIds) { + RestApiResponse response = null; + String result = null; + try { + result = platformLogic.notificationPowerInfo(stationIds); + response = new RestApiResponse<>(result); + } catch (Exception e) { + logger.error("贵州平台推送充换电站用能统计信息 error", e); + return new RestApiResponse<>(e); + } + logger.info("贵州平台推送充换电站用能统计信息 result:{}", result); + return response; + } + +} \ No newline at end of file diff --git a/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/ZDLController.java b/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/ZDLController.java index 28a40af2b..098c2d9cb 100644 --- a/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/ZDLController.java +++ b/jsowell-admin/src/main/java/com/jsowell/api/thirdparty/ZDLController.java @@ -11,14 +11,12 @@ import com.jsowell.common.exception.BusinessException; import com.jsowell.common.response.RestApiResponse; import com.jsowell.common.util.JWTUtils; import com.jsowell.common.util.StringUtils; -import com.jsowell.pile.dto.PushInfoParamDTO; -import com.jsowell.pile.dto.PushRealTimeInfoDTO; -import com.jsowell.pile.dto.PushStationInfoDTO; -import com.jsowell.pile.dto.QueryStationInfoDTO; +import com.jsowell.pile.dto.*; import com.jsowell.thirdparty.lianlian.common.CommonResult; import com.jsowell.pile.thirdparty.CommonParamsDTO; import com.jsowell.thirdparty.lianlian.service.LianLianService; import com.jsowell.thirdparty.platform.service.ThirdPartyPlatformService; +import com.jsowell.thirdparty.platform.service.impl.ZhongDianLianPlatformServiceImpl; import com.jsowell.thirdparty.platform.util.Cryptos; import com.jsowell.thirdparty.platform.util.Encodes; import com.jsowell.thirdparty.zhongdianlian.service.ZDLService; @@ -383,4 +381,12 @@ public class ZDLController extends ThirdPartyBaseController { logger.info("宁波平台推送订单信息 result:{}", response); return response; } + + @PostMapping("/tempPushHistoryOrderInfo") + public RestApiResponse tempPushHistoryOrderInfo(@RequestBody QueryOrderDTO dto) { + RestApiResponse response = null; + String result = platformLogic.pushOrderInfo(dto); + response = new RestApiResponse<>(result); + return response; + } } diff --git a/jsowell-admin/src/main/java/com/jsowell/service/OrderService.java b/jsowell-admin/src/main/java/com/jsowell/service/OrderService.java index 4db3f7cbc..92c07eda9 100644 --- a/jsowell-admin/src/main/java/com/jsowell/service/OrderService.java +++ b/jsowell-admin/src/main/java/com/jsowell/service/OrderService.java @@ -422,6 +422,7 @@ public class OrderService { order.setStartTime(DateUtils.formatDateTime(orderBasicInfo.getChargeStartTime())); order.setEndTime(DateUtils.formatDateTime(orderBasicInfo.getChargeEndTime())); order.setCreateTime(DateUtils.formatDateTime(orderBasicInfo.getCreateTime())); + order.setStopReasonCode(orderBasicInfo.getStopReasonCode()); order.setStopReasonMsg(orderBasicInfo.getReason()); order.setStartSOC(orderBasicInfo.getStartSoc()); order.setEndSOC(orderBasicInfo.getEndSoc()); @@ -580,6 +581,7 @@ public class OrderService { } PileStationVO stationInfo = pileStationInfoService.getStationInfo(orderBasicInfo.getStationId()); vo.setStationName(stationInfo.getStationName()); + vo.setStopReasonCode(orderBasicInfo.getStopReasonCode()); vo.setReason(orderBasicInfo.getReason()); vo.setOrderAmount(String.valueOf(orderBasicInfo.getOrderAmount())); vo.setPayAmount(String.valueOf(orderBasicInfo.getPayAmount())); diff --git a/jsowell-admin/src/main/java/com/jsowell/service/PileService.java b/jsowell-admin/src/main/java/com/jsowell/service/PileService.java index 9a19fb2c1..d7da64f0f 100644 --- a/jsowell-admin/src/main/java/com/jsowell/service/PileService.java +++ b/jsowell-admin/src/main/java/com/jsowell/service/PileService.java @@ -112,15 +112,17 @@ public class PileService { public int batchCreatePile(BatchCreatePileDTO dto) { String softwareProtocol = dto.getSoftwareProtocol(); - if (StringUtils.isBlank(softwareProtocol)) { - throw new BusinessException(ReturnCodeEnum.valueOf("软件协议不能为空")); - } + // if (StringUtils.isBlank(softwareProtocol)) { + // throw new BusinessException(ReturnCodeEnum.valueOf("软件协议不能为空")); + // } // 批量生成sn号 List snList = null; if (StringUtils.equals(SoftwareProtocolEnum.YOU_DIAN.getValue(), softwareProtocol)) { snList = snUtils.generateEBikeSN(dto.getNum()); - } else { + } else if (StringUtils.equals(SoftwareProtocolEnum.YUN_KUAI_CHONG.getValue(), softwareProtocol)){ snList = snUtils.generateEVPileSN(dto.getNum()); + } else { + throw new BusinessException(ReturnCodeEnum.valueOf("软件协议不正确")); } // @@ -488,42 +490,54 @@ public class PileService { // 为空说明此用户未注册平台账号 throw new BusinessException(ReturnCodeEnum.CODE_USER_IS_NOT_REGISTER); } + // 被分享的用户memberId + String memberId = memberBasicInfo.getMemberId(); List relationList = pileMemberRelationService.selectPileMemberRelationByPileSn(dto.getPileSn()); if (CollectionUtils.isEmpty(relationList)) { // 充电桩没有绑定任何人 + throw new BusinessException(ReturnCodeEnum.CODE_NO_ADMIN_FOR_PILE); } + // 使用stream把relationList转为map, key为type, value为List + Map> map = relationList.stream().collect(Collectors.groupingBy(PileMemberRelation::getType)); + List adminMemberRelationList = map.get(Constants.ONE); // 管理员列表 - List adminList = relationList.stream() - .filter(x -> x.getType().equals(Constants.ONE)) // 1-管理员用户 + if (CollectionUtils.isEmpty(adminMemberRelationList)) { + // 充电桩没有管理员 + throw new BusinessException(ReturnCodeEnum.CODE_NO_ADMIN_FOR_PILE); + } + List adminList = adminMemberRelationList.stream() .map(PileMemberRelation::getMemberId) .collect(Collectors.toList()); - if (CollectionUtils.isEmpty(adminList)) { - // 没有管理员 - } - - // 校验身份 - if (adminList.contains(dto.getMemberId())) { + // 校验身份 入参是否是管理员 + if (adminList.contains(memberId)) { // 如果不为空，说明被分享的用户是管理员，抛出异常 - throw new BusinessException(ReturnCodeEnum.CODE_AUTHENTICATION_ERROR); + throw new BusinessException(ReturnCodeEnum.CODE_ALREADY_AN_ADMIN); } - List userList = relationList.stream() - .filter(x -> !x.getType().equals(Constants.TWO)) // 2-普通用户 - .map(PileMemberRelation::getMemberId) - .collect(Collectors.toList()); - - if (userList.contains(memberBasicInfo.getMemberId())) { + List userList = Lists.newArrayList(); + List userMemberRelations = map.get(Constants.TWO); // 普通用户列表 + if (CollectionUtils.isNotEmpty(userMemberRelations)) { + userList = userMemberRelations.stream() + .map(PileMemberRelation::getMemberId) + .collect(Collectors.toList()); + } + // 校验身份 入参是否是普通用户 + if (userList.contains(memberId)) { // 不为空说明已绑定 - throw new BusinessException(ReturnCodeEnum.CODE_USER_HAS_BEEN_THIS_PILE); - } else { - // 进行绑定，此用户为普通用户 - PileMemberRelation info = new PileMemberRelation(); - info.setPileSn(dto.getPileSn()); - info.setMemberId(memberBasicInfo.getMemberId()); - info.setType(Constants.TWO); - pileMemberRelationService.insertPileMemberRelation(info); + throw new BusinessException(ReturnCodeEnum.CODE_ALREADY_AN_USER); } + PileMemberRelation pileMemberRelation = adminMemberRelationList.get(0); // 获取管理员列表的第一个元素 + // 进行绑定，此用户为普通用户 + PileMemberRelation info = new PileMemberRelation(); + info.setPileSn(dto.getPileSn()); + info.setMemberId(memberId); + info.setType(Constants.TWO); + if (pileMemberRelation != null && StringUtils.isNotBlank(pileMemberRelation.getDeviceId())) { + info.setDeviceId(pileMemberRelation.getDeviceId()); + info.setDeviceName(pileMemberRelation.getDeviceName()); + } + pileMemberRelationService.insertPileMemberRelation(info); } /** @@ -650,6 +664,7 @@ public class PileService { } vo.setMemberId(personalChargingRecord.getMemberId()); vo.setSumChargingDegree(personalChargingRecord.getTotalUsedElectricity().toString()); + vo.setStopReasonCode(personalChargingRecord.getStopReasonCode()); vo.setStopReasonMsg(personalChargingRecord.getReason()); list.add(vo); } diff --git a/jsowell-admin/src/test/java/PaymentTestController.java b/jsowell-admin/src/test/java/PaymentTestController.java index d5678d94c..73eba5cae 100644 --- a/jsowell-admin/src/test/java/PaymentTestController.java +++ b/jsowell-admin/src/test/java/PaymentTestController.java @@ -3,6 +3,7 @@ import com.alibaba.fastjson2.JSONArray; import com.alibaba.fastjson2.JSONObject; import com.google.common.collect.Lists; import com.google.common.collect.Maps; +import com.google.common.collect.Sets; import com.huifu.adapay.core.exception.BaseAdaPayException; import com.huifu.adapay.model.PaymentReverse; import com.huifu.adapay.model.Refund; @@ -84,6 +85,200 @@ public class PaymentTestController { return list; } + // 需要重新分账的订单信息（针对未分账的订单） + public JSONArray getPaymentList() { + String jsonArrayString = "[" + + "{\"orderCode\":\"C25133803815\", \"settleAmount\":\"42.94\", \"paymentId\":\"002212024071413111510658428550211133440\"}" + + "]"; + return JSONArray.parseArray(jsonArrayString); + } + + /** + * 批量执行分账 + */ + @Test + public void batchCreatePaymentConfirm() { + JSONArray paymentList = getPaymentList(); + // TODO 获取默认结算账户，如需分给对应商户就填写正确的汇付会员id + // AdapayMemberAccount adapayMemberAccount = adapayMemberAccountService.getDefault(); + AdapayMemberAccount adapayMemberAccount = new AdapayMemberAccount(); + adapayMemberAccount.setAdapayMemberId("ACM25158725"); + for (int i = 0; i < paymentList.size(); i++) { + JSONObject jsonObject = (JSONObject) paymentList.get(i); + BigDecimal confirmAmt = jsonObject.getBigDecimal("settleAmount"); // 确认金额就是结算金额 + String paymentId = jsonObject.getString("paymentId"); // 支付id + String orderCode = jsonObject.getString("orderCode"); // 订单编号 + + // 延时分账，使用确认交易API + PaymentConfirmResponse paymentConfirmResponse = adapayService.createPaymentConfirmRequest(paymentId, + adapayMemberAccount, confirmAmt, orderCode, wechatAppId1); + System.out.println(JSON.toJSONString(paymentConfirmResponse)); + } + } + + public static void main(String[] args) { + List list1 = Lists.newArrayList( + "C84866578627", + "C69407733440", + "C46698893183", + "C23481086913", + "C46631353044", + "C82315862441", + "C48515444163", + "C88894523461", + "C63539142496", + "C88227376749", + "C69808468000", + "C29756635462", + "C48171513017", + "C82929694510", + "C42286214889", + "C40531240168", + "C42818195903", + "C44772182853", + "C63995701102", + "C84653836282", + "C82929004110", + "C42248888826", + "C42871512014", + "C61630741271", + "C44120948533", + "C86510728306", + "C23698728789", + "C40725164803", + "C46426468297", + "C80876734677", + "C65208404269", + "C48131292456", + "C27264263390", + "C42620874381", + "C27264478506", + "C82758563554", + "C44588350706", + "C86153980315", + "C86782182478", + "C42077527679", + "C80606430852", + "C21377880382", + "C63590496985", + "C25745398205", + "C63136978056", + "C21983806615", + "C42016184953", + "C27458903931", + "C40590975531", + "C44987731257", + "C63554143992", + "C46468609277", + "C23483139052", + "C67759764676", + "C65286550984", + "C44772583755", + "C65037735356", + "C23065540340", + "C82330428460", + "C40136408323", + "C65896968515", + "C80093965053", + "C23029064125", + "C46291260090", + "C40915419435", + "C69234709266", + "C61064626771", + "C84216893653", + "C69869670458", + "C44755242724", + "C63706872923", + "C61047783388", + "C80663278468", + "C46232390797", + "C44561702210", + "C61404525849", + "C80813608253" + ); + List list2 = Lists.newArrayList( + "C69407733440", + "C84866578627", + "C46698893183", + "C46631353044", + "C23481086913", + "C88894523461", + "C48515444163", + "C82315862441", + "C48171513017", + "C29756635462", + "C69808468000", + "C88227376749", + "C63539142496", + "C42818195903", + "C40531240168", + "C42286214889", + "C82929694510", + "C63995701102", + "C44772182853", + "C84653836282", + "C42871512014", + "C42248888826", + "C82929004110", + "C44120948533", + "C61630741271", + "C23698728789", + "C86510728306", + "C80876734677", + "C46426468297", + "C40725164803", + "C48131292456", + "C65208404269", + "C82758563554", + "C27264263390", + "C27264478506", + "C42620874381", + "C25745398205", + "C86153980315", + "C63590496985", + "C21377880382", + "C80606430852", + "C44588350706", + "C42077527679", + "C86782182478", + "C40590975531", + "C27458903931", + "C42016184953", + "C21983806615", + "C63136978056", + "C44772583755", + "C46468609277", + "C65286550984", + "C63554143992", + "C67759764676", + "C44987731257", + "C23483139052", + "C23065540340", + "C65037735356", + "C80093965053", + "C65896968515", + "C82330428460", + "C40136408323", + "C23029064125", + "C63706872923", + "C40915419435", + "C44755242724", + "C69869670458", + "C84216893653", + "C61064626771", + "C69234709266", + "C46291260090", + "C80813608253", + "C61404525849", + "C61047783388", + "C44561702210", + "C46232390797", + "C80663278468"); + Sets.SetView difference = Sets.intersection(Sets.newHashSet(list1), Sets.newHashSet(list2)); + System.out.println(difference); + + } + /** * 查询分账信息 * @throws BaseAdaPayException @@ -232,10 +427,10 @@ public class PaymentTestController { */ @Test public void createPaymentReverseRequestTest() { - String paymentId = "002212024120516445110710666157707481088"; - BigDecimal refundAmount = new BigDecimal("32.31"); - String memberId = "46690495"; - String orderCode = "C86577082495"; + String paymentId = "002212024102215301510694702317666226176"; + BigDecimal refundAmount = new BigDecimal("15.42"); + String memberId = "42833137"; + String orderCode = "C21960272918"; // 延迟分账未确认调撤销调撤销接口退款 PaymentReverseOperation operation = new PaymentReverseOperation(); @@ -273,35 +468,4 @@ public class PaymentTestController { String wechatAppId = wechatAppId1; // 万车充id adapayService.createBalancePaymentRequest(outMemberId, inMemberId, transAmt, title, desc, wechatAppId); } - - // 需要重新分账的订单信息（针对未分账的订单） - public JSONArray getPaymentList() { - String jsonArrayString = "[" + - "{\"orderCode\":\"C25133803815\", \"settleAmount\":\"42.94\", \"paymentId\":\"002212024071413111510658428550211133440\"}" + - "]"; - return JSONArray.parseArray(jsonArrayString); - } - - /** - * 批量执行分账 - */ - @Test - public void batchCreatePaymentConfirm() { - JSONArray paymentList = getPaymentList(); - // TODO 获取默认结算账户，如需分给对应商户就填写正确的汇付会员id - // AdapayMemberAccount adapayMemberAccount = adapayMemberAccountService.getDefault(); - AdapayMemberAccount adapayMemberAccount = new AdapayMemberAccount(); - adapayMemberAccount.setAdapayMemberId("ACM25158725"); - for (int i = 0; i < paymentList.size(); i++) { - JSONObject jsonObject = (JSONObject) paymentList.get(i); - BigDecimal confirmAmt = jsonObject.getBigDecimal("settleAmount"); // 确认金额就是结算金额 - String paymentId = jsonObject.getString("paymentId"); // 支付id - String orderCode = jsonObject.getString("orderCode"); // 订单编号 - - // 延时分账，使用确认交易API - PaymentConfirmResponse paymentConfirmResponse = adapayService.createPaymentConfirmRequest(paymentId, - adapayMemberAccount, confirmAmt, orderCode, wechatAppId1); - System.out.println(JSON.toJSONString(paymentConfirmResponse)); - } - } } diff --git a/jsowell-common/src/main/java/com/jsowell/common/constant/CacheConstants.java b/jsowell-common/src/main/java/com/jsowell/common/constant/CacheConstants.java index d1df8d255..8194e96fb 100644 --- a/jsowell-common/src/main/java/com/jsowell/common/constant/CacheConstants.java +++ b/jsowell-common/src/main/java/com/jsowell/common/constant/CacheConstants.java @@ -175,6 +175,21 @@ public class CacheConstants { */ public static final String TRANSACTION_RECORD_BY_TRANSACTION_CODE = "transaction_record_by_transaction_code:"; + /** + * 0x23缓存key + */ + public static final String BMS_DEMAND_AND_CHARGER_OUTPUT_BY_TRANSACTION_CODE = "bms_demand_and_charger_output_by_transaction_code:"; + + /** + * 0x25缓存key + */ + public static final String BMS_CHARGE_INFO_BY_TRANSACTION_CODE = "bms_charge_info_by_transaction_code:"; + + /** + * 0x15缓存key + */ + public static final String CHARGING_HANDSHAKE_DATA_BY_TRANSACTION_CODE = "charging_handshake_data_by_transaction_code:"; + /** * 充电桩状态前缀 */ diff --git a/jsowell-common/src/main/java/com/jsowell/common/constant/Constants.java b/jsowell-common/src/main/java/com/jsowell/common/constant/Constants.java index 60936558a..3981a9934 100644 --- a/jsowell-common/src/main/java/com/jsowell/common/constant/Constants.java +++ b/jsowell-common/src/main/java/com/jsowell/common/constant/Constants.java @@ -95,6 +95,7 @@ public class Constants { public static final String OPERATORID_LIANLIAN = "MA1JLFUU8"; public static final String OPERATORID_JIANG_SU = "MA1X78KH5"; + public static final String OPERATORID_GUI_ZHOU = "MAC9K4RRX"; public static final String MANUFACTURER_NAME = "举视(江苏)新能源设备制造有限公司"; diff --git a/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/BMSChargeInfoData.java b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/BMSChargeInfoData.java new file mode 100644 index 000000000..d1680cc97 --- /dev/null +++ b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/BMSChargeInfoData.java @@ -0,0 +1,120 @@ +package com.jsowell.common.core.domain.ykc; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * 0x25数据信息 + * + * @author Lemon + * @Date 2024/12/10 15:45:14 + */ +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +public class BMSChargeInfoData { + + /** + * 交易流水号 + */ + private String transactionCode; + + /** + * 桩编码 + */ + private String pileSn; + + /** + * 枪号 + */ + private String connectorCode; + + /** + * BMS 最高单体动力蓄电池电压所在编号 + * 1/位， 1 偏移量； + * 数据范围： 1~256 + */ + private String bmsMaxVoltageNum; + + /** + * BMS 最高动力蓄电池温度 + * 1ºC/位， -50 ºC 偏移量； + * 数据范围： -50 ºC ~+200 ºC + */ + private String bmsMaxBatteryTemperature; + + /** + * 最高温度检测点编号 + * 1/位， 1 偏移量； + * 数据范围： 1~128 + */ + private String maxTemperatureDetectionNum; + + /** + * 最低动力蓄电池温度 + * 1ºC/位， -50 ºC 偏移量； + * 数据范围： -50 ºC ~+200 ºC + */ + private String minBatteryTemperature; + + /** + * 最低动力蓄电池温度检测点编号 + * 1/位， 1 偏移量； + * 数据范围： 1~128 + */ + private String minTemperatureDetectionNum; + + /** + * BMS 单体动力蓄电池电压过高 /过低 + * (<00> ：=正常 ; <01> ：=过高 ; <10>： =过低) + */ + private String singleBMSVoltageStatus; + + /** + * BMS 整车动力蓄电池荷电状态 SOC 过高/过低 + * (<00> ：=正常 ; <01> ：=过高 ; <10>： =过低) + */ + private String carBMSSocStatus; + + /** + * BMS 动力蓄电池充电过电流 + * (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + private String bmsBatteryChargeCurrentStatus; + + /** + * BMS 动力蓄电池温度过高 + * (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + private String bmsBatteryTemperature; + + /** + * BMS 动力蓄电池绝缘状态 + * (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + private String bmsBatteryInsulationStatus; + + /** + * BMS 动力蓄电池组输出连接器连接状态 + * (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + private String bmsBatteryOutputStatus; + + /** + * 充电禁止 + * (<00>： =禁止; <01>： =允许) + */ + private String chargeProhibit; + + /** + * 预留位 + */ + private String noMeanPositionByteArr; + + + private String dateTime; + +} diff --git a/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/BMSDemandAndChargerOutputData.java b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/BMSDemandAndChargerOutputData.java new file mode 100644 index 000000000..e4219a70d --- /dev/null +++ b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/BMSDemandAndChargerOutputData.java @@ -0,0 +1,37 @@ +package com.jsowell.common.core.domain.ykc; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * 0x23信息数据 + * + * @author Lemon + * @Date 2024/12/9 14:33:35 + */ +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +public class BMSDemandAndChargerOutputData { + + private String transactionCode; // 交易流水号 + private String pileSn; // 桩编号 + private String connectorCode; // 枪口号 + private String bmsVoltageDemand; // BMS 电压需求 0.1 V/位， 0 V 偏移量 + private String bmsCurrentDemand; // BMS 电流需求 0.1 A/位， -400 A 偏移量 + private String bmsChargingModel; // BMS 充电模式 0x01：恒压充电； 0x02：恒流充电 + private String bmsChargingVoltage; // BMS 充电电压测量值 0.1 V/位， 0 V 偏移量 + private String bmsChargingCurrent; // BMS 充电电流测量值 0.1 A/位， -400 A 偏移量 + private String bmsMaxVoltageAndGroup; // BMS 最高单体动力蓄电池电压及组号 1-12 位：最高单体动力蓄电池电压， 数据分辨率： 0.01 V/位， 0 V 偏移量；数据范围： 0~24 V； 13-16 位： 最高单体动力蓄电池电 压所在组号，数据分辨率： 1/位， 0 偏移量；数据范围： 0~15 + private String soc; // BMS 当前荷电状态 SOC（ %） 1%/位， 0%偏移量； 数据范围： 0~100% + private String bmsTheRestChargingTime; // BMS 估算剩余充电时间 1 min/位， 0 min 偏移量； 数据范围： 0~600 min + private String pileVoltageOutput; // 电桩电压输出值 0.1 V/位， 0 V 偏移量 + private String pileCurrentOutput; // 电桩电流输出值 0.1 A/位， -400 A 偏移量 + private String chargingTime; // 累计充电时间 1 min/位， 0 min 偏移量； 数据范围： 0~600 min + + private String dateTime; + private String outputPower; +} diff --git a/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/ChargingHandshakeData.java b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/ChargingHandshakeData.java new file mode 100644 index 000000000..15f9b9571 --- /dev/null +++ b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/ChargingHandshakeData.java @@ -0,0 +1,123 @@ +package com.jsowell.common.core.domain.ykc; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; + +/** + * 0x15充电握手Data + * + * @author Lemon + * @Date 2024/12/11 10:34:53 + */ +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +public class ChargingHandshakeData { + /** + * 交易流水号 + */ + private String transactionCode; + + /** + * 桩编码 + */ + private String pileSn; + + /** + * 枪号 + */ + private String connectorCode; + + /** + * BMS 通信协议版本号 当前版本为 V1.1， 表示为： byte3， byte2—0001H；byte1—01H + */ + private String bmsCommunicationVersion; + + /** + * BMS 电池类型 + * + * 01H:铅酸电池; + * 02H:氢电池; + * 03H:磷酸铁锂电池; + * 04H:锰酸锂电池; + * 05H:钴酸锂电池; + * 06H:三元材料电池; + * 07H:聚合物锂离子电池; + * 08H:钛酸锂电池; + * FFH:其他 + */ + private String bmsBatteryType; + + /** + * BMS 整车动力蓄电池系统额定容量 + * 0.1 Ah /位， 0 Ah 偏移量 + */ + private String bmsBatteryCapacity; + + /** + * BMS 整车动力蓄电池系统额定总电压 + * 0.1V/位， 0V 偏移量 + */ + private String bmsBatteryVoltage; + + /** + * BMS 电池生产厂商名称 + */ + private String bmsBatteryFactory; + + /** + * BMS 电池组序号 + */ + private String bmsBatteryNum; + + /** + * BMS 电池组生产日期年 + * 1985 年偏移量， + * 数据范围： 1985～ 2235 年 + */ + private String bmsProductionDateYear; + + /** + * BMS 电池组生产日期月 + * 0 月偏移量， + * 数据范围： 1～12 月 + */ + private String bmsProductionDateMonth; + + /** + * BMS 电池组生产日期日 + * 0 日偏移量， + * 数据范围： 1～31 日 + */ + private String bmsProductionDateDay; + + /** + * BMS 电池组充电次数 + * 1 次/位， 0 次偏移量， + * 以 BMS 统 计为准 + */ + private String bmsChargingTimes; + + /** + * BMS 电池组产权标识 （<0>： =租赁； <1>： =车自有） + */ + private String BMSPropertyIdentificationByteArr; + + /** + * BMS 预留位 + */ + private String BMSReservePosition; + + /** + * BMS 车辆识别码 + */ + private String vinCode; + + /** + * BMS 软件版本号 + */ + private String BMSSoftwareVersionByteArr; +} diff --git a/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/TransactionRecordsData.java b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/TransactionRecordsData.java index a69fc6aa7..e4b6a8d78 100644 --- a/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/TransactionRecordsData.java +++ b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/TransactionRecordsData.java @@ -115,6 +115,9 @@ public class TransactionRecordsData { // 交易时间 CP56Time2a 格式 private String transactionTime; + // 停止原因码（16进制） + private String stopReasonCode; + // 停止原因 private String stopReasonMsg; diff --git a/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/device2platform/Data0x15.java b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/device2platform/Data0x15.java index 6ad9acb79..84fce7174 100644 --- a/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/device2platform/Data0x15.java +++ b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/device2platform/Data0x15.java @@ -1,14 +1,221 @@ package com.jsowell.common.core.domain.ykc.device2platform; import com.jsowell.common.core.domain.ykc.YKCBaseMessage; +import com.jsowell.common.util.BytesUtil; +import com.jsowell.common.util.YKCUtils; import lombok.Data; /** - * 计费模板验证请求数据 + * 充电握手 */ @Data public class Data0x15 extends YKCBaseMessage { + + /** + * 交易流水号 + */ + private String transactionCode; + + /** + * 桩编码 + */ + private String pileSn; + + /** + * 枪号 + */ + private String connectorCode; + + /** + * BMS 通信协议版本号 当前版本为 V1.1， 表示为： byte3， byte2—0001H；byte1—01H + */ + private String bmsCommunicationVersion; + + /** + * BMS 电池类型 + * + * 01H:铅酸电池; + * 02H:氢电池; + * 03H:磷酸铁锂电池; + * 04H:锰酸锂电池; + * 05H:钴酸锂电池; + * 06H:三元材料电池; + * 07H:聚合物锂离子电池; + * 08H:钛酸锂电池; + * FFH:其他 + */ + private String bmsBatteryType; + + /** + * BMS 整车动力蓄电池系统额定容量 + * 0.1 Ah /位， 0 Ah 偏移量 + */ + private String bmsBatteryCapacity; + + /** + * BMS 整车动力蓄电池系统额定总电压 + * 0.1V/位， 0V 偏移量 + */ + private String bmsBatteryVoltage; + + /** + * BMS 电池生产厂商名称 + */ + private String bmsBatteryFactory; + + /** + * BMS 电池组序号 + */ + private String bmsBatteryNum; + + /** + * BMS 电池组生产日期年 + * 1985 年偏移量， + * 数据范围： 1985～ 2235 年 + */ + private String bmsProductionDateYear; + + /** + * BMS 电池组生产日期月 + * 0 月偏移量， + * 数据范围： 1～12 月 + */ + private String bmsProductionDateMonth; + + /** + * BMS 电池组生产日期日 + * 0 日偏移量， + * 数据范围： 1～31 日 + */ + private String bmsProductionDateDay; + + /** + * BMS 电池组充电次数 + * 1 次/位， 0 次偏移量， + * 以 BMS 统 计为准 + */ + private String bmsChargingTimes; + + /** + * BMS 电池组产权标识 （<0>： =租赁； <1>： =车自有） + */ + private String bmsPropertyIdentification; + + /** + * BMS 预留位 + */ + private String bmsReservePosition; + + /** + * BMS 车辆识别码 + */ + private String vinCode; + + /** + * BMS 软件版本号 + */ + private String bmsSoftwareVersion; + public Data0x15(byte[] messageBytes) { super(messageBytes); + + // 初始startIndex为6, 跳过消息头等6个字节 + int startIndex = 6; + + // 交易流水号 + int length = 16; + byte[] serialNumByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.transactionCode = BytesUtil.bcd2Str(serialNumByteArr); + + // 桩编码 + startIndex += length; + length = 7; + byte[] pileSnByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.pileSn = BytesUtil.bcd2Str(pileSnByteArr); + + // 枪号 + startIndex += length; + length = 1; + byte[] pileConnectorNumByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.connectorCode = BytesUtil.bcd2Str(pileConnectorNumByteArr); + + // BMS 通信协议版本号 当前版本为 V1.1， 表示为： byte3， byte2—0001H；byte1—01H + startIndex += length; + length = 3; + byte[] BMSCommunicationProtocolVersionByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsCommunicationVersion = "V1.1"; + + // BMS 电池类型 01H:铅酸电池;02H:氢 电池;03H:磷酸铁锂电池;04H:锰 酸锂电池;05H:钴酸锂电池 ;06H: 三元材料电池;07H:聚合物锂离子 电池;08H:钛酸锂电池;FFH:其他 + startIndex += length; + length = 1; + byte[] BMSBatteryTypeByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsBatteryType = BytesUtil.bcd2Str(BMSBatteryTypeByteArr); // 03 + + // BMS 整车动力蓄电池系统额定容量 0.1 Ah /位， 0 Ah 偏移量 + startIndex += length; + length = 2; + byte[] BMSBatteryCapacityByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsBatteryCapacity = String.valueOf(BytesUtil.bytesToIntLittle(BMSBatteryCapacityByteArr) * 0.1); // 171.0 + + // BMS 整车动力蓄电池系统额定总电压 0.1V/位， 0V 偏移量 + startIndex += length; + byte[] BMSBatteryVoltageByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsBatteryVoltage = String.valueOf(BytesUtil.bytesToIntLittle(BMSBatteryVoltageByteArr) * 0.1); // 347.8 + + // BMS 电池生产厂商名称 + startIndex += length; + length = 4; + byte[] BMSBatteryFactoryByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsBatteryFactory = BytesUtil.ascii2Str(BMSBatteryFactoryByteArr); // CATL + + // BMS 电池组序号 + startIndex += length; + byte[] BMSBatteryNumByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsBatteryNum = BytesUtil.bin2HexStr(BMSBatteryNumByteArr); + + // BMS 电池组生产日期年 1985 年偏移量， 数据范围： 1985～ 2235 年 + startIndex += length; + length = 1; + byte[] BMSProductionDateYearByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsProductionDateYear = BytesUtil.bin2HexStr(BMSProductionDateYearByteArr); + + // BMS 电池组生产日期月 0 月偏移量， 数据范围： 1～12 月 + startIndex += length; + byte[] BMSProductionDateMonthByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsProductionDateMonth = BytesUtil.bin2HexStr(BMSProductionDateMonthByteArr); + + // BMS 电池组生产日期日 0 日偏移量， 数据范围： 1～31 日 + startIndex += length; + byte[] BMSProductionDateDayByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsProductionDateDay = BytesUtil.bin2HexStr(BMSProductionDateDayByteArr); + + // BMS 电池组充电次数 1 次/位， 0 次偏移量， 以 BMS 统 计为准 + startIndex += length; + length = 3; + byte[] BMSChargingTimesByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsChargingTimes = BytesUtil.bin2HexStr(BMSChargingTimesByteArr); + + // BMS 电池组产权标识 （<0>： =租赁； <1>： =车自有） + startIndex += length; + length = 1; + byte[] bmsPropertyIdentificationByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsPropertyIdentification = BytesUtil.bin2HexStr(bmsPropertyIdentificationByteArr); + + // BMS 预留位 + startIndex += length; + byte[] BMSReservePosition = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsReservePosition = BytesUtil.bin2HexStr(BMSReservePosition); + + // BMS 车辆识别码 + startIndex += length; + length = 17; + byte[] vinByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.vinCode = YKCUtils.parseVin(vinByteArr); + + // BMS 软件版本号 + startIndex += length; + length = 8; + byte[] BMSSoftwareVersionByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsSoftwareVersion = BytesUtil.bcd2Str(BMSSoftwareVersionByteArr); } } diff --git a/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/device2platform/Data0x25.java b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/device2platform/Data0x25.java index abf53a9ad..3264f8746 100644 --- a/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/device2platform/Data0x25.java +++ b/jsowell-common/src/main/java/com/jsowell/common/core/domain/ykc/device2platform/Data0x25.java @@ -1,14 +1,198 @@ package com.jsowell.common.core.domain.ykc.device2platform; import com.jsowell.common.core.domain.ykc.YKCBaseMessage; +import com.jsowell.common.util.BytesUtil; import lombok.Data; /** - * 计费模板验证请求数据 + * 充电过程 BMS 信息 */ @Data public class Data0x25 extends YKCBaseMessage { + + /** + * 交易流水号 BCD 码 16 见名词解释 + */ + private String transactionCode; + + /** + * 桩编号 BCD 码 7 不足 7 位补 0 + */ + private String pileSn; + + /** + * 枪号 BCD 码 1 + */ + private String connectorCode; + + /** + * BMS 最高单体动力蓄电池电压所在编号 1/位， 1 偏移量； 数据范围： 1~256 + */ + private String bmsMaxVoltageNum; + + /** + * BMS 最高动力蓄电池温度 1ºC/位， -50 ºC 偏移量；数据范 围： -50 ºC ~+200 ºC + */ + private String bmsMaxBatteryTemperature; + + /** + * 最高温度检测点编号 1/位， 1 偏移量； 数据范围： 1~128 + */ + private String maxTemperatureDetectionNum; + + /** + * 最低动力蓄电池温度 + */ + private String minBatteryTemperature; + + /** + * 最低动力蓄电池温度检测点编号 + */ + private String minTemperatureDetectionNum; + + /** + * BMS 单体动力蓄电池电压过高 /过低 + * @param messageBytes + */ + private String singleBMSVoltageStatus; + + /** + * BMS 整车动力蓄电池荷电状态 SOC 过高/过低 (<00> ：=正常 ; <01> ：=过高 ; <10>： =过低) + */ + private String carBMSSocStatus; + + /** + * BMS 动力蓄电池充电过电流 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + private String bmsBatteryChargeCurrentStatus; + + /** + * BMS 动力蓄电池温度过高 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + private String bmsBatteryTemperature; + + /** + * BMS 动力蓄电池绝缘状态 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + private String bmsBatteryInsulationStatus; + + /** + * BMS 动力蓄电池组输出连接器连接状态 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + private String bmsBatteryOutputStatus; + + /** + * 充电禁止 (<00>： =禁止; <01>： =允许) + */ + private String chargeProhibit; + + /** + * 预留位 + */ + private String reservedBit; + public Data0x25(byte[] messageBytes) { super(messageBytes); + + // 初始startIndex为6, 跳过消息头等6个字节 + int startIndex = 6; + + // 交易流水号 + int length = 16; + byte[] orderCodeByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.transactionCode = BytesUtil.bcd2Str(orderCodeByteArr); + + // 桩编码 + startIndex += length; + length = 7; + byte[] pileSnByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.pileSn = BytesUtil.bcd2Str(pileSnByteArr); + + // 枪号 + startIndex += length; + length = 1; + byte[] connectorCodeByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.connectorCode = BytesUtil.bcd2Str(connectorCodeByteArr); + + // BMS 最高单体动力蓄电池电压 所在编号 + startIndex += length; + length = 1; + byte[] bmsMaxVoltageNumByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsMaxVoltageNum = String.valueOf(BytesUtil.bytesToIntLittle(bmsMaxVoltageNumByteArr)); + + // BMS 最高动力蓄电池温度 + startIndex += length; + length = 1; + byte[] BMSMaxBatteryTemperatureByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsMaxBatteryTemperature = String.valueOf(BytesUtil.bytesToIntLittle(BMSMaxBatteryTemperatureByteArr) - 50); + + // 最高温度检测点编号 + startIndex += length; + length = 1; + byte[] maxTemperatureDetectionNumByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.maxTemperatureDetectionNum = String.valueOf(BytesUtil.bytesToIntLittle(maxTemperatureDetectionNumByteArr) + 1); + + + // 最低动力蓄电池温度 + startIndex += length; + length = 1; + byte[] minBatteryTemperatureByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.minBatteryTemperature = String.valueOf(BytesUtil.bytesToIntLittle(minBatteryTemperatureByteArr) - 50); + + + // 最低动力蓄电池温度检测点 编号 + startIndex += length; + length = 1; + byte[] minTemperatureDetectionNumByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.minTemperatureDetectionNum = String.valueOf(BytesUtil.bytesToIntLittle(minTemperatureDetectionNumByteArr) + 1); + + + // BMS 单体动力蓄电池电压过高 /过低 + startIndex += length; + length = 2; + byte[] singleBMSVoltageStatusByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.singleBMSVoltageStatus = BytesUtil.bcd2Str(singleBMSVoltageStatusByteArr); + + // BMS 整车动力蓄电池荷电状态 SOC 过高/过低 + startIndex += length; + length = 2; + byte[] carBMSSocStatusByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.carBMSSocStatus = BytesUtil.bcd2Str(carBMSSocStatusByteArr); + + // BMS 动力蓄电池充电过电流 + startIndex += length; + length = 2; + byte[] BMSBatteryChargeCurrentStatusByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsBatteryChargeCurrentStatus = BytesUtil.bcd2Str(BMSBatteryChargeCurrentStatusByteArr); + + // BMS 动力蓄电池温度过高 + startIndex += length; + length = 2; + byte[] BMSBatteryTemperatureByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsBatteryTemperature = BytesUtil.bcd2Str(BMSBatteryTemperatureByteArr); + + // BMS 动力蓄电池绝缘状态 + startIndex += length; + length = 2; + byte[] BMSBatteryInsulationStatusByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsBatteryInsulationStatus = BytesUtil.bcd2Str(BMSBatteryInsulationStatusByteArr); + + // BMS 动力蓄电池组输出连接器 连接状态 + startIndex += length; + length = 2; + byte[] BMSBatteryOutputStatusByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.bmsBatteryOutputStatus = BytesUtil.bcd2Str(BMSBatteryOutputStatusByteArr); + + // 充电禁止 + startIndex += length; + length = 2; + byte[] chargeProhibitByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.chargeProhibit = BytesUtil.bcd2Str(chargeProhibitByteArr); + + // 预留位 + startIndex += length; + length = 2; + byte[] reservedBitByteArr = BytesUtil.copyBytes(messageBytes, startIndex, length); + this.reservedBit = BytesUtil.bcd2Str(reservedBitByteArr); } } diff --git a/jsowell-common/src/main/java/com/jsowell/common/enums/ykc/ReturnCodeEnum.java b/jsowell-common/src/main/java/com/jsowell/common/enums/ykc/ReturnCodeEnum.java index b87c20e78..e09c83d96 100644 --- a/jsowell-common/src/main/java/com/jsowell/common/enums/ykc/ReturnCodeEnum.java +++ b/jsowell-common/src/main/java/com/jsowell/common/enums/ykc/ReturnCodeEnum.java @@ -187,6 +187,14 @@ public enum ReturnCodeEnum { CODE_START_PERSONAL_PILE_CHARGING_ERROR("00400020", "个人桩启动充电异常"), + CODE_PILE_MEMBER_RELATION_IS_EMPTY("00400021", "个人桩绑定列表为空"), + + CODE_NO_ADMIN_FOR_PILE("00400022", "充电桩未设置管理员"), + + CODE_ALREADY_AN_ADMIN("00400023", "您已经是此充电桩管理员, 无需再次绑定"), + + CODE_ALREADY_AN_USER("00400024", "您已经是此充电桩用户, 无需再次绑定"), + /* 个人桩 end */ CODE_THIS_CARNO_HAS_BEEN_BINDING("00500001", "当前车牌号已经绑定，请检查！"), diff --git a/jsowell-common/src/main/java/com/jsowell/common/util/YKCUtils.java b/jsowell-common/src/main/java/com/jsowell/common/util/YKCUtils.java index 7436462c9..aa31e4694 100644 --- a/jsowell-common/src/main/java/com/jsowell/common/util/YKCUtils.java +++ b/jsowell-common/src/main/java/com/jsowell/common/util/YKCUtils.java @@ -394,6 +394,7 @@ public class YKCUtils { /** * 保存soc + * 默认保存7天 * @param transactionCode * @param soc */ @@ -429,16 +430,27 @@ public class YKCUtils { } } + /** + * 根据交易流水号获取redis保存的soc信息 + */ + public static Map getSOCMap(String transactionCode) { + String hashKey = CacheConstants.GET_THE_SOC + transactionCode; + RedisCache staticRedisCache = StaticRedisCache.staticRedisCache; + return staticRedisCache.getCacheMap(hashKey); + } + /** * 根据的交易码获取当前soc * @param transactionCode */ public static String getCurrentSOC(String transactionCode) { - String hashKey = CacheConstants.GET_THE_SOC + transactionCode; - RedisCache staticRedisCache = StaticRedisCache.staticRedisCache; - Map cacheMap = staticRedisCache.getCacheMap(hashKey); + // String hashKey = CacheConstants.GET_THE_SOC + transactionCode; + // RedisCache staticRedisCache = StaticRedisCache.staticRedisCache; + // Map cacheMap = staticRedisCache.getCacheMap(hashKey); + + Map socMap = getSOCMap(transactionCode); // 获取最小值和最大值, 两个值中最大的为当前soc - return (String) cacheMap.get("max"); + return (String) socMap.get("max"); } } diff --git a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/BMSDemandAndChargerOutputHandler.java b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/BMSDemandAndChargerOutputHandler.java index d9dd0265d..280786e01 100644 --- a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/BMSDemandAndChargerOutputHandler.java +++ b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/BMSDemandAndChargerOutputHandler.java @@ -2,11 +2,15 @@ package com.jsowell.netty.handler.yunkuaichong; import com.jsowell.common.core.domain.ykc.YKCDataProtocol; import com.jsowell.common.core.domain.ykc.YKCFrameTypeCode; +import com.jsowell.common.core.redis.RedisCache; import com.jsowell.common.util.BytesUtil; import com.jsowell.common.util.YKCUtils; import com.jsowell.netty.factory.YKCOperateFactory; +import com.jsowell.common.core.domain.ykc.BMSDemandAndChargerOutputData; +import com.jsowell.pile.service.PileBasicInfoService; import io.netty.channel.ChannelHandlerContext; import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; /** @@ -19,6 +23,13 @@ import org.springframework.stereotype.Component; @Slf4j @Component public class BMSDemandAndChargerOutputHandler extends AbstractYkcHandler { + + @Autowired + private RedisCache redisCache; + + @Autowired + private PileBasicInfoService pileBasicInfoService; + private final String type = YKCUtils.frameType2Str(YKCFrameTypeCode.CHARGING_PROCESS_BMS_DEMAND_AND_CHARGER_OUTPUT_CODE.getBytes()); @Override @@ -26,6 +37,94 @@ public class BMSDemandAndChargerOutputHandler extends AbstractYkcHandler { YKCOperateFactory.register(type, this); } + public static void main(String[] args) { + + String msg = "8823000000259602241208235501743088230000002596023c10ed1202d70d40037201175500e10de3120000"; + // 获取消息体 + byte[] msgBody = BytesUtil.str2Bcd(msg); + + int startIndex = 0; + int length = 16; + + // 交易流水号 + byte[] serialNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String transactionCode = BytesUtil.bcd2Str(serialNumByteArr); + + // 桩编码 + startIndex += length; + length = 7; + byte[] pileSnByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String pileSn = BytesUtil.bcd2Str(pileSnByteArr); + + // 枪号 + startIndex += length; + length = 1; + byte[] pileConnectorNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String connectorCode = BytesUtil.bcd2Str(pileConnectorNumByteArr); + + // BMS 电压需求 0.1 V/位， 0 V 偏移量 + startIndex += length; + length = 2; + byte[] bmsVoltageDemandByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsVoltageDemand = String.valueOf(BytesUtil.bytesToIntLittle(bmsVoltageDemandByteArr) * 0.1); + + // BMS 电流需求 0.1 A/位， -400 A 偏移量 + startIndex += length; + byte[] bmsCurrentDemandByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsCurrentDemand = String.valueOf(BytesUtil.bytesToIntLittle(bmsCurrentDemandByteArr) * 0.1 - 400); + + // BMS 充电模式 0x01：恒压充电； 0x02：恒流充电 + startIndex += length; + length = 1; + byte[] bmsChargingModelByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsChargingModel = BytesUtil.bcd2Str(bmsChargingModelByteArr); + + // BMS 充电电压测量值 0.1 V/位， 0 V 偏移量 + startIndex += length; + length = 2; + byte[] bmsChargingVoltageByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsChargingVoltage = String.valueOf(BytesUtil.bytesToIntLittle(bmsChargingVoltageByteArr) * 0.1); + + // BMS 充电电流测量值 0.1 A/位， -400 A 偏移量 + startIndex += length; + byte[] bmsChargingCurrentByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsChargingCurrent = String.valueOf(BytesUtil.bytesToIntLittle(bmsChargingCurrentByteArr) * 0.1 - 400); + + // BMS 最高单体动力蓄电池电压及组号 1-12 位：最高单体动力蓄电池电压， 数据分辨率： 0.01 V/位， 0 V 偏移量；数据范围： 0~24 V； 13-16 位： 最高单体动力蓄电池电 压所在组号，数据分辨率： 1/位， 0 偏移量；数据范围： 0~15 + startIndex += length; + byte[] bmsMaxVoltageAndGroupNum = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsMaxVoltageAndGroup = String.valueOf(BytesUtil.bytesToIntLittle(bmsMaxVoltageAndGroupNum) * 0.01); + + // BMS 当前荷电状态 SOC（ %） 1%/位， 0%偏移量； 数据范围： 0~100% + startIndex += length; + length = 1; + byte[] socByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String soc = BytesUtil.bcd2Str(socByteArr); + + // BMS 估算剩余充电时间 1 min/位， 0 min 偏移量； 数据范围： 0~600 min + startIndex += length; + length = 2; + byte[] bmsTheRestChargingTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsTheRestChargingTime = String.valueOf(BytesUtil.bytesToIntLittle(bmsTheRestChargingTimeByteArr)); + + // 电桩电压输出值 0.1 V/位， 0 V 偏移量 + startIndex += length; + byte[] pileVoltageOutputByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String pileVoltageOutput = String.valueOf(BytesUtil.bytesToIntLittle(pileVoltageOutputByteArr) * 0.1); + + // 电桩电流输出值 0.1 A/位， -400 A 偏移量 + startIndex += length; + byte[] pileCurrentOutputByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String pileCurrentOutput = String.valueOf(BytesUtil.bytesToIntLittle(pileCurrentOutputByteArr) * 0.1 - 400); + + // 累计充电时间 1 min/位， 0 min 偏移量； 数据范围： 0~600 min + startIndex += length; + byte[] chargingTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String chargingTime = String.valueOf(BytesUtil.bytesToIntLittle(chargingTimeByteArr)); + + + } + @Override public byte[] supplyProcess(YKCDataProtocol ykcDataProtocol, ChannelHandlerContext channel) { // log.info("[===充电过程 BMS 需求与充电机输出===] param:{}, channel:{}", JSON.toJSONString(ykcDataProtocol), channel.toString()); @@ -37,6 +136,7 @@ public class BMSDemandAndChargerOutputHandler extends AbstractYkcHandler { // 交易流水号 byte[] serialNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String transactionCode = BytesUtil.bcd2Str(serialNumByteArr); // 桩编码 startIndex += length; @@ -51,56 +151,91 @@ public class BMSDemandAndChargerOutputHandler extends AbstractYkcHandler { startIndex += length; length = 1; byte[] pileConnectorNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String connectorCode = BytesUtil.bcd2Str(pileConnectorNumByteArr); // BMS 电压需求 0.1 V/位， 0 V 偏移量 startIndex += length; length = 2; byte[] bmsVoltageDemandByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsVoltageDemand = String.valueOf(BytesUtil.bytesToIntLittle(bmsVoltageDemandByteArr) * 0.1); // BMS 电流需求 0.1 A/位， -400 A 偏移量 startIndex += length; byte[] bmsCurrentDemandByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsCurrentDemand = String.valueOf(BytesUtil.bytesToIntLittle(bmsCurrentDemandByteArr) * 0.1 - 400); // BMS 充电模式 0x01：恒压充电； 0x02：恒流充电 startIndex += length; length = 1; byte[] bmsChargingModelByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsChargingModel = BytesUtil.bcd2Str(bmsChargingModelByteArr); // BMS 充电电压测量值 0.1 V/位， 0 V 偏移量 startIndex += length; length = 2; byte[] bmsChargingVoltageByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsChargingVoltage = String.valueOf(BytesUtil.bytesToIntLittle(bmsChargingVoltageByteArr) * 0.1); // BMS 充电电流测量值 0.1 A/位， -400 A 偏移量 startIndex += length; byte[] bmsChargingCurrentByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsChargingCurrent = String.valueOf(BytesUtil.bytesToIntLittle(bmsChargingCurrentByteArr) * 0.1 - 400); // BMS 最高单体动力蓄电池电压及组号 1-12 位：最高单体动力蓄电池电压， 数据分辨率： 0.01 V/位， 0 V 偏移量；数据范围： 0~24 V； 13-16 位： 最高单体动力蓄电池电 压所在组号，数据分辨率： 1/位， 0 偏移量；数据范围： 0~15 startIndex += length; byte[] bmsMaxVoltageAndGroupNum = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsMaxVoltageAndGroup = String.valueOf(BytesUtil.bytesToIntLittle(bmsMaxVoltageAndGroupNum) * 0.01); // BMS 当前荷电状态 SOC（ %） 1%/位， 0%偏移量； 数据范围： 0~100% startIndex += length; length = 1; byte[] socByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String soc = BytesUtil.bcd2Str(socByteArr); // BMS 估算剩余充电时间 1 min/位， 0 min 偏移量； 数据范围： 0~600 min startIndex += length; length = 2; byte[] bmsTheRestChargingTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsTheRestChargingTime = String.valueOf(BytesUtil.bytesToIntLittle(bmsTheRestChargingTimeByteArr)); // 电桩电压输出值 0.1 V/位， 0 V 偏移量 startIndex += length; byte[] pileVoltageOutputByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String pileVoltageOutput = String.valueOf(BytesUtil.bytesToIntLittle(pileVoltageOutputByteArr) * 0.1); // 电桩电流输出值 0.1 A/位， -400 A 偏移量 startIndex += length; byte[] pileCurrentOutputByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String pileCurrentOutput = String.valueOf(BytesUtil.bytesToIntLittle(pileCurrentOutputByteArr) * 0.1 - 400); // 累计充电时间 1 min/位， 0 min 偏移量； 数据范围： 0~600 min startIndex += length; byte[] chargingTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String chargingTime = String.valueOf(BytesUtil.bytesToIntLittle(chargingTimeByteArr)); + // 存入缓存(过期时间 3 天) + BMSDemandAndChargerOutputData bmsDemandAndChargerOutputData = BMSDemandAndChargerOutputData.builder() + .transactionCode(transactionCode) + .pileSn(pileSn) + .connectorCode(connectorCode) + .bmsVoltageDemand(bmsVoltageDemand) + .bmsCurrentDemand(bmsCurrentDemand) + .bmsChargingModel(bmsChargingModel) + .bmsChargingVoltage(bmsChargingVoltage) + .bmsChargingCurrent(bmsChargingCurrent) + .bmsMaxVoltageAndGroup(bmsMaxVoltageAndGroup) + .soc(soc) + .bmsTheRestChargingTime(bmsTheRestChargingTime) + .pileVoltageOutput(pileVoltageOutput) + .pileCurrentOutput(pileCurrentOutput) + .chargingTime(chargingTime) + .build(); + + // 保存此订单的soc + YKCUtils.saveSOC(transactionCode, soc); + + // 调用方法存入缓存 + pileBasicInfoService.saveBMSDemandAndChargerOutputInfo2Redis(bmsDemandAndChargerOutputData); return null; } diff --git a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/BMSInformationHandler.java b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/BMSInformationHandler.java index 44e0bb607..56e78d47f 100644 --- a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/BMSInformationHandler.java +++ b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/BMSInformationHandler.java @@ -1,12 +1,15 @@ package com.jsowell.netty.handler.yunkuaichong; +import com.jsowell.common.core.domain.ykc.BMSChargeInfoData; import com.jsowell.common.core.domain.ykc.YKCDataProtocol; import com.jsowell.common.core.domain.ykc.YKCFrameTypeCode; import com.jsowell.common.util.BytesUtil; import com.jsowell.common.util.YKCUtils; import com.jsowell.netty.factory.YKCOperateFactory; +import com.jsowell.pile.service.PileBasicInfoService; import io.netty.channel.ChannelHandlerContext; import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; /** @@ -19,6 +22,10 @@ import org.springframework.stereotype.Component; @Slf4j @Component public class BMSInformationHandler extends AbstractYkcHandler { + + @Autowired + private PileBasicInfoService pileBasicInfoService; + private final String type = YKCUtils.frameType2Str(YKCFrameTypeCode.CHARGING_PROCESS_BMS_INFORMATION_CODE.getBytes()); @Override @@ -37,6 +44,7 @@ public class BMSInformationHandler extends AbstractYkcHandler { // 交易流水号 byte[] serialNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String transactionCode = BytesUtil.bcd2Str(serialNumByteArr); // 桩编码 startIndex += length; @@ -51,47 +59,110 @@ public class BMSInformationHandler extends AbstractYkcHandler { startIndex += length; length = 1; byte[] pileConnectorNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String connectorCode = BytesUtil.bcd2Str(pileConnectorNumByteArr); // BMS 最高单体动力蓄电池电压所在编号 1/位， 1 偏移量； 数据范围： 1~256 startIndex += length; byte[] BMSMaxVoltageNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsMaxVoltageNum = String.valueOf(BytesUtil.bytesToIntLittle(BMSMaxVoltageNumByteArr)); // BMS 最高动力蓄电池温度 1ºC/位， -50 ºC 偏移量；数据范 围： -50 ºC ~+200 ºC startIndex += length; byte[] BMSMaxBatteryTemperatureByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsMaxBatteryTemperature = String.valueOf(BytesUtil.bytesToIntLittle(BMSMaxBatteryTemperatureByteArr) - 50); // 最高温度检测点编号 1/位， 1 偏移量； 数据范围： 1~128 startIndex += length; byte[] maxTemperatureDetectionNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String maxTemperatureDetectionNum = String.valueOf(BytesUtil.bytesToIntLittle(maxTemperatureDetectionNumByteArr) + 1); // 最低动力蓄电池温度 1ºC/位， -50 ºC 偏移量；数据范 围： -50 ºC ~+200 ºC startIndex += length; - byte[] minBatteryTemperature = BytesUtil.copyBytes(msgBody, startIndex, length); + byte[] minBatteryTemperatureByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String minBatteryTemperature = String.valueOf(BytesUtil.bytesToIntLittle(minBatteryTemperatureByteArr) - 50); // 最低动力蓄电池温度检测点编号 1/位， 1 偏移量； 数据范围： 1~128 startIndex += length; byte[] minTemperatureDetectionNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String minTemperatureDetectionNum = String.valueOf(BytesUtil.bytesToIntLittle(minTemperatureDetectionNumByteArr) + 1); /** - * 9-12 - * 9: BMS 单体动力蓄电池电压过高 /过低 (<00> ：=正常 ; <01> ：=过高 ; <10>： =过低) - * 10: BMS 整车动力蓄电池荷电状态 SOC 过高/过低 (<00> ：=正常 ; <01> ：=过高 ; <10>： =过低) - * 11: BMS 动力蓄电池充电过电流 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) - * 12: BMS 动力蓄电池温度过高 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + * BMS 单体动力蓄电池电压过高 /过低 (<00> ：=正常 ; <01> ：=过高 ; <10>： =过低) */ startIndex += length; - byte[] numNineToTwelve = BytesUtil.copyBytes(msgBody, startIndex, length); + length = 2; + byte[] singleBMSVoltageStatusByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String singleBMSVoltageStatus = BytesUtil.bcd2Str(singleBMSVoltageStatusByteArr); /** - * 13-16 - * 13: BMS 动力蓄电池绝缘状态 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) - * 14: BMS 动力蓄电池组输出连接器连接状态 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) - * 15: 充电禁止 (<00>： =禁止; <01>： =允许) - * 16: 预留位 00 + * BMS 整车动力蓄电池荷电状态 SOC 过高/过低 (<00> ：=正常 ; <01> ：=过高 ; <10>： =过低) */ startIndex += length; - byte[] numThirteenToSixteen = BytesUtil.copyBytes(msgBody, startIndex, length); + byte[] carBMSSocStatusByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String carBMSSocStatus = BytesUtil.bcd2Str(carBMSSocStatusByteArr); + /** + * BMS 动力蓄电池充电过电流 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + startIndex += length; + byte[] BMSBatteryChargeCurrentStatusByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsBatteryChargeCurrentStatus = BytesUtil.bcd2Str(BMSBatteryChargeCurrentStatusByteArr); + + /** + * BMS 动力蓄电池温度过高 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + startIndex += length; + byte[] BMSBatteryTemperatureByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsBatteryTemperature = BytesUtil.bcd2Str(BMSBatteryTemperatureByteArr); + + /** + * BMS 动力蓄电池绝缘状态 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + startIndex += length; + byte[] BMSBatteryInsulationStatusByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsBatteryInsulationStatus = BytesUtil.bcd2Str(BMSBatteryInsulationStatusByteArr); + + /** + * BMS 动力蓄电池组输出连接器连接状态 (<00> ：=正常 ; <01> ：=过流 ; <10>： =不可信状态) + */ + startIndex += length; + byte[] BMSBatteryOutputStatusByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsBatteryOutputStatus = BytesUtil.bcd2Str(BMSBatteryOutputStatusByteArr); + + /** + * 充电禁止 (<00>： =禁止; <01>： =允许) + */ + startIndex += length; + byte[] chargeProhibitByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String chargeProhibit = BytesUtil.bcd2Str(chargeProhibitByteArr); + + /** + * 预留位 + */ + startIndex += length; + byte[] noMeanPositionByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + + // 存入缓存（缓存时间3天） + BMSChargeInfoData data = BMSChargeInfoData.builder() + .transactionCode(transactionCode) + .pileSn(pileSn) + .connectorCode(connectorCode) + .bmsMaxVoltageNum(bmsMaxVoltageNum) + .bmsMaxBatteryTemperature(bmsMaxBatteryTemperature) + .maxTemperatureDetectionNum(maxTemperatureDetectionNum) + .minBatteryTemperature(minBatteryTemperature) + .minTemperatureDetectionNum(minTemperatureDetectionNum) + .singleBMSVoltageStatus(singleBMSVoltageStatus) + .carBMSSocStatus(carBMSSocStatus) + .bmsBatteryChargeCurrentStatus(bmsBatteryChargeCurrentStatus) + .bmsBatteryTemperature(bmsBatteryTemperature) + .bmsBatteryInsulationStatus(bmsBatteryInsulationStatus) + .bmsBatteryOutputStatus(bmsBatteryOutputStatus) + .chargeProhibit(chargeProhibit) + + .build(); + + pileBasicInfoService.saveBMSChargeInfo2Redis(data); return null; } diff --git a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ChargeEndHandler.java b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ChargeEndHandler.java index 3e61c2e69..8191df287 100644 --- a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ChargeEndHandler.java +++ b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ChargeEndHandler.java @@ -115,6 +115,9 @@ public class ChargeEndHandler extends AbstractYkcHandler { } updateOrder.setUpdateTime(nowDate); orderBasicInfoService.updateOrderBasicInfo(updateOrder); + + // 保存此订单的soc + YKCUtils.saveSOC(transactionCode, stopSoc); } return null; diff --git a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ChargingHandshakeHandler.java b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ChargingHandshakeHandler.java index 8f7ea544c..5cde86da0 100644 --- a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ChargingHandshakeHandler.java +++ b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ChargingHandshakeHandler.java @@ -1,14 +1,20 @@ package com.jsowell.netty.handler.yunkuaichong; +import com.jsowell.common.constant.CacheConstants; +import com.jsowell.common.core.domain.ykc.ChargingHandshakeData; import com.jsowell.common.core.domain.ykc.YKCDataProtocol; import com.jsowell.common.core.domain.ykc.YKCFrameTypeCode; +import com.jsowell.common.core.redis.RedisCache; import com.jsowell.common.util.BytesUtil; import com.jsowell.common.util.YKCUtils; import com.jsowell.netty.factory.YKCOperateFactory; import io.netty.channel.ChannelHandlerContext; import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; +import java.util.concurrent.TimeUnit; + /** * 充电握手 * @@ -19,6 +25,9 @@ import org.springframework.stereotype.Component; @Slf4j @Component public class ChargingHandshakeHandler extends AbstractYkcHandler { + @Autowired + private RedisCache redisCache; + private final String type = YKCUtils.frameType2Str(YKCFrameTypeCode.CHARGING_HANDSHAKE_CODE.getBytes()); @Override @@ -37,6 +46,7 @@ public class ChargingHandshakeHandler extends AbstractYkcHandler { // 交易流水号 byte[] serialNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String transactionCode = BytesUtil.bcd2Str(serialNumByteArr); // 桩编码 startIndex += length; @@ -57,48 +67,57 @@ public class ChargingHandshakeHandler extends AbstractYkcHandler { startIndex += length; length = 3; byte[] BMSCommunicationProtocolVersionByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - + String bmsCommunicationVersion = "V1.1"; // BMS 电池类型 01H:铅酸电池;02H:氢 电池;03H:磷酸铁锂电池;04H:锰 酸锂电池;05H:钴酸锂电池 ;06H: 三元材料电池;07H:聚合物锂离子 电池;08H:钛酸锂电池;FFH:其他 startIndex += length; length = 1; byte[] BMSBatteryTypeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsBatteryType = BytesUtil.bcd2Str(BMSBatteryTypeByteArr); // 03 // BMS 整车动力蓄电池系统额定容量 0.1 Ah /位， 0 Ah 偏移量 startIndex += length; length = 2; byte[] BMSBatteryCapacityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsBatteryCapacity = String.valueOf(BytesUtil.bytesToIntLittle(BMSBatteryCapacityByteArr) * 0.1); // 171.0 // BMS 整车动力蓄电池系统额定总电压 0.1V/位， 0V 偏移量 startIndex += length; byte[] BMSBatteryVoltageByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsBatteryVoltage = String.valueOf(BytesUtil.bytesToIntLittle(BMSBatteryVoltageByteArr) * 0.1); // 347.8 // BMS 电池生产厂商名称 startIndex += length; length = 4; byte[] BMSBatteryFactoryByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsBatteryFactory = BytesUtil.ascii2Str(BMSBatteryFactoryByteArr); // CATL // BMS 电池组序号 startIndex += length; byte[] BMSBatteryNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsBatteryNum = BytesUtil.bin2HexStr(BMSBatteryNumByteArr); // BMS 电池组生产日期年 1985 年偏移量， 数据范围： 1985～ 2235 年 startIndex += length; length = 1; byte[] BMSProductionDateYearByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsProductionDateYear = BytesUtil.bin2HexStr(BMSProductionDateYearByteArr); // BMS 电池组生产日期月 0 月偏移量， 数据范围： 1～12 月 startIndex += length; byte[] BMSProductionDateMonthByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsProductionDateMonth = BytesUtil.bin2HexStr(BMSProductionDateMonthByteArr); // BMS 电池组生产日期日 0 日偏移量， 数据范围： 1～31 日 startIndex += length; byte[] BMSProductionDateDayByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsProductionDateDay = BytesUtil.bin2HexStr(BMSProductionDateDayByteArr); // BMS 电池组充电次数 1 次/位， 0 次偏移量， 以 BMS 统 计为准 startIndex += length; length = 3; byte[] BMSChargingTimesByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String bmsChargingTimes = BytesUtil.bin2HexStr(BMSChargingTimesByteArr); // BMS 电池组产权标识 （<0>： =租赁； <1>： =车自有） startIndex += length; @@ -112,14 +131,38 @@ public class ChargingHandshakeHandler extends AbstractYkcHandler { // BMS 车辆识别码 startIndex += length; length = 17; - byte[] BMSCarIdentifyCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + byte[] vinByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + String vinCode = YKCUtils.parseVin(vinByteArr); // BMS 软件版本号 startIndex += length; length = 8; byte[] BMSSoftwareVersionByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // 保存数据到redis(缓存3天) + ChargingHandshakeData data = ChargingHandshakeData.builder() + .transactionCode(transactionCode) + .pileSn(pileSn) + .connectorCode(connectorCode) + .bmsCommunicationVersion(bmsCommunicationVersion) + .bmsBatteryType(bmsBatteryType) + .bmsBatteryCapacity(bmsBatteryCapacity) + .bmsBatteryVoltage(bmsBatteryVoltage) + .bmsBatteryFactory(bmsBatteryFactory) + .bmsBatteryNum(bmsBatteryNum) + .bmsProductionDateYear(bmsProductionDateYear) + .bmsProductionDateMonth(bmsProductionDateMonth) + .bmsProductionDateDay(bmsProductionDateDay) + .bmsChargingTimes(bmsChargingTimes) + // .BMSPropertyIdentificationByteArr(BMSPropertyIdentificationByteArr) + // .BMSReservePosition(BMSReservePosition) + .vinCode(vinCode) + // .BMSSoftwareVersionByteArr(BMSSoftwareVersionByteArr) + .build(); + + String redisKey = CacheConstants.CHARGING_HANDSHAKE_DATA_BY_TRANSACTION_CODE + transactionCode; + redisCache.setCacheObject(redisKey, data, 3, TimeUnit.DAYS); return null; } diff --git a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/HeartbeatRequestHandler.java b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/HeartbeatRequestHandler.java index 0a810843c..9dcb75941 100644 --- a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/HeartbeatRequestHandler.java +++ b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/HeartbeatRequestHandler.java @@ -6,13 +6,17 @@ import com.jsowell.common.core.domain.ykc.YKCDataProtocol; import com.jsowell.common.core.domain.ykc.YKCFrameTypeCode; import com.jsowell.common.util.BytesUtil; import com.jsowell.common.util.YKCUtils; +import com.jsowell.common.util.spring.SpringUtils; import com.jsowell.netty.factory.YKCOperateFactory; import com.jsowell.pile.service.PileBasicInfoService; import io.netty.channel.ChannelHandlerContext; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor; import org.springframework.stereotype.Component; +import java.util.concurrent.CompletableFuture; + /** * 充电桩心跳包 */ @@ -25,6 +29,9 @@ public class HeartbeatRequestHandler extends AbstractYkcHandler { @Autowired private PileBasicInfoService pileBasicInfoService; + // 引入线程池 + private ThreadPoolTaskExecutor executor = SpringUtils.getBean("threadPoolTaskExecutor"); + @Override public void afterPropertiesSet() throws Exception { YKCOperateFactory.register(type, this); @@ -65,11 +72,20 @@ public class HeartbeatRequestHandler extends AbstractYkcHandler { // updateStatus(pileSn, pileConnectorNum, connectorStatus); // 公共方法修改状态 - try { - pileBasicInfoService.updateStatus(BytesUtil.bcd2Str(ykcDataProtocol.getFrameType()), pileSn, pileConnectorNum, connectorStatus, null); - } catch (Exception e) { - log.error("公共方法修改状态error", e); - } + // try { + // pileBasicInfoService.updateStatus(BytesUtil.bcd2Str(ykcDataProtocol.getFrameType()), pileSn, pileConnectorNum, connectorStatus, null); + // } catch (Exception e) { + // log.error("公共方法修改状态error", e); + // } + + // 异步修改状态 + CompletableFuture.runAsync(() -> { + try { + pileBasicInfoService.updateStatus(BytesUtil.bcd2Str(ykcDataProtocol.getFrameType()), pileSn, pileConnectorNum, connectorStatus, null); + } catch (Exception e) { + log.error("公共方法修改状态error", e); + } + }, executor); // 心跳应答（置0） byte[] flag = Constants.zeroByteArray; diff --git a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ParameterConfigurationHandler.java b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ParameterConfigurationHandler.java index 674e2dba9..7c11796f2 100644 --- a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ParameterConfigurationHandler.java +++ b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/ParameterConfigurationHandler.java @@ -157,6 +157,9 @@ public class ParameterConfigurationHandler extends AbstractYkcHandler { .build(); orderBasicInfoService.updateOrderBasicInfo(orderBasicInfo); log.info("更新订单起始SOC, orderCode:{}, transactionCode:{}, startSoc:{}", orderInfo.getOrderCode(), transactionCode, soc); + + // 保存此订单的soc + YKCUtils.saveSOC(transactionCode, data.getSoc()); } return null; diff --git a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/TransactionRecordsRequestHandler.java b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/TransactionRecordsRequestHandler.java index d02dc002a..88cf9c33b 100644 --- a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/TransactionRecordsRequestHandler.java +++ b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/TransactionRecordsRequestHandler.java @@ -81,251 +81,253 @@ public class TransactionRecordsRequestHandler extends AbstractYkcHandler { private PersonalChargingRecordService personalChargingRecordService; - /*public static void main(String[] args) { - BigDecimal totalElectricity = new BigDecimal("23.73"); - if (totalElectricity.compareTo(BigDecimal.TEN) > 0) { - // 充电度数大于10度 - System.out.println("123"); - } - - - // 获取消息体 - String msg = "000000000000000000000000000000008823000000030601a08c2e0d0404170000380d0404170000000000000000000000000000000000000000000000000000000000000000400d0300ee250000ee250000c84b000000000000000000000000000000000000e0bb040000cee1040000ee250000ee250000c84b00000000000000000000000000000000000000010000380d04041745a511101970000000"; - byte[] msgBody = BytesUtil.str2Bcd(msg); - - int startIndex = 0; - int length = 16; - - // 交易流水号 - byte[] orderCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String transactionCode = BytesUtil.bcd2Str(orderCodeByteArr); - - // 桩编码 - startIndex += length; - length = 7; - byte[] pileSnByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String pileSn = BytesUtil.bcd2Str(pileSnByteArr); - - // 枪号 - startIndex += length; - length = 1; - byte[] connectorCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String connectorCode = BytesUtil.bcd2Str(connectorCodeByteArr); - - - // 开始时间 CP56Time2a 格式 - startIndex += length; - length = 7; - byte[] startTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - // String binary = BytesUtil.binary(startTimeByteArr, 16); - Date startDate = Cp56Time2aUtil.byte2Hdate(startTimeByteArr); - String startTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, startDate); - - - // 结束时间 CP56Time2a 格式 - startIndex += length; - byte[] endTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - Date endDate = Cp56Time2aUtil.byte2Hdate(endTimeByteArr); - String endTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, endDate); - - // 尖单价 精确到小数点后五位（尖电费+尖服务费，见费率帧） - startIndex += length; - length = 4; - byte[] sharpPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String sharpPrice = YKCUtils.convertDecimalPoint(sharpPriceByteArr, 5); - - // 尖电量 精确到小数点后四位 - startIndex += length; - length = 4; - byte[] sharpUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String sharpUsedElectricity = YKCUtils.convertDecimalPoint(sharpUsedElectricityByteArr, 4); - - // 计损尖电量 - startIndex += length; - byte[] sharpPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String sharpPlanLossElectricity = YKCUtils.convertDecimalPoint(sharpPlanLossElectricityByteArr, 4); - - // 尖金额 - startIndex += length; - byte[] sharpAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String sharpAmount = YKCUtils.convertDecimalPoint(sharpAmountByteArr, 4); - - // 峰单价 精确到小数点后五位（峰电费+峰服务费） - startIndex += length; - byte[] peakPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String peakPrice = YKCUtils.convertDecimalPoint(peakPriceByteArr, 5); - - // 峰电量 - startIndex += length; - byte[] peakUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String peakUsedElectricity = YKCUtils.convertDecimalPoint(peakUsedElectricityByteArr, 4); - - // 计损峰电量 - startIndex += length; - byte[] peakPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String peakPlanLossElectricity = YKCUtils.convertDecimalPoint(peakPlanLossElectricityByteArr, 4); - - // 峰金额 - startIndex += length; - byte[] peakAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String peakAmount = YKCUtils.convertDecimalPoint(peakAmountByteArr, 4); - - // 平单价 精确到小数点后五位（平电费+平服务费） - startIndex += length; - byte[] flatPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String flatPrice = YKCUtils.convertDecimalPoint(flatPriceByteArr, 5); - - // 平电量 - startIndex += length; - byte[] flatUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String flatUsedElectricity = YKCUtils.convertDecimalPoint(flatUsedElectricityByteArr, 4); - - // 计损平电量 - startIndex += length; - byte[] flatPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String flatPlanLossElectricity = YKCUtils.convertDecimalPoint(flatPlanLossElectricityByteArr, 4); - - // 平金额 - startIndex += length; - byte[] flatAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String flatAmount = YKCUtils.convertDecimalPoint(flatAmountByteArr, 4); - - // 谷单价 精确到小数点后五位（谷电费+谷 服务费） - startIndex += length; - byte[] valleyPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String valleyPrice = YKCUtils.convertDecimalPoint(valleyPriceByteArr, 5); - - // 谷电量 - startIndex += length; - byte[] valleyUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String valleyUsedElectricity = YKCUtils.convertDecimalPoint(valleyUsedElectricityByteArr, 4); - - // 计损谷电量 - startIndex += length; - byte[] valleyPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String valleyPlanLossElectricity = YKCUtils.convertDecimalPoint(valleyPlanLossElectricityByteArr, 4); - - // 谷金额 - startIndex += length; - byte[] valleyAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String valleyAmount = YKCUtils.convertDecimalPoint(valleyAmountByteArr, 4); - - // 电表总起值 - startIndex += length; - length = 5; - byte[] ammeterTotalStartByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String ammeterTotalStart = YKCUtils.convertDecimalPoint(ammeterTotalStartByteArr, 4); - - // 电表总止值 - startIndex += length; - byte[] ammeterTotalEndByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String ammeterTotalEnd = YKCUtils.convertDecimalPoint(ammeterTotalEndByteArr, 4); - - // 总电量 - startIndex += length; - length = 4; - byte[] totalElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - // String totalElectricity = YKCUtils.convertDecimalPoint(totalElectricityByteArr, 4); - - // 计损总电量 - startIndex += length; - byte[] planLossTotalElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String planLossTotalElectricity = YKCUtils.convertDecimalPoint(planLossTotalElectricityByteArr, 4); - - // 消费金额 精确到小数点后四位，包含电费、 服务费 - startIndex += length; - byte[] consumptionAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String consumptionAmount = YKCUtils.convertDecimalPoint(consumptionAmountByteArr, 4); - - // VIN 码 VIN 码，此处 VIN 码和充电时 VIN 码不同， 正序直接上传， 无需补 0 和反序 - startIndex += length; - length = 17; - byte[] vinCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String vinCode = BytesUtil.ascii2Str(vinCodeByteArr); - - *//** - * 交易标识 - * 0x01： app 启动 - * 0x02：卡启动 - * 0x04：离线卡启动 - * 0x05: vin 码启动充电 - *//* - startIndex += length; - length = 1; - byte[] transactionIdentifierByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String transactionIdentifier = BytesUtil.bcd2Str(transactionIdentifierByteArr); - - // 交易时间 CP56Time2a 格式 - startIndex += length; - length = 7; - byte[] transactionTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - Date transactionDate = Cp56Time2aUtil.byte2Hdate(transactionTimeByteArr); - String transactionTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, transactionDate); - - // 停止原因 - startIndex += length; - length = 1; - byte[] stopReasonByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - String stopReason = BytesUtil.bin2HexStr(stopReasonByteArr); - String stopReasonMsg = YKCChargingStopReasonEnum.getMsgByCode(Integer.parseInt(stopReason, 16)); - - // 物理卡号 不足 8 位补 0 - startIndex += length; - length = 8; - byte[] cardNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); - // byte[] logicCardNum = BytesUtil.checkLengthAndBehindAppendZero(cardNumByteArr, 16); - String logicCard = BytesUtil.binary(cardNumByteArr, 16); - log.info("桩号:{}, 发送交易记录物理卡号:{}", pileSn, logicCard); - - log.info("[===交易记录===]交易流水号:{}, 桩编号:{}, 枪号:{}, 开始时间:{}, 结束时间:{}, 尖单价:{}, 尖电量:{}, 计损尖电量:{}, 尖金额:{}, " + - "峰单价:{}, 峰电量:{}, 计损峰电量:{}, 峰金额:{}, 平单价:{}, 平电量:{}, 计损平电量:{}, 平金额:{}, " + - "谷单价:{}, 谷电量:{}, 计损谷电量:{}, 谷金额:{}, 电表总起值:{}, 电表总止值:{}, 总电量:{}, 计损总电量:{}, 消费金额:{}, " + - "电动汽车唯一标识:{}, 交易标识:{}, 交易日期、时间:{}, 停止原因码:{}, 停止原因描述:{}, 物理卡号:{}", - transactionCode, pileSn, connectorCode, startTime, endTime, sharpPrice, sharpUsedElectricity, sharpPlanLossElectricity, sharpAmount, - peakPrice, peakUsedElectricity, peakPlanLossElectricity, peakAmount, flatPrice, flatUsedElectricity, flatPlanLossElectricity, flatAmount, - valleyPrice, valleyUsedElectricity, valleyPlanLossElectricity, valleyAmount, ammeterTotalStart, ammeterTotalEnd, totalElectricity, planLossTotalElectricity, - consumptionAmount, vinCode, transactionIdentifier, transactionTime, stopReason, stopReasonMsg, logicCard); - - // 交易记录封装到对象里 - TransactionRecordsData data = TransactionRecordsData.builder() - // .orderCode(transactionCode) - .transactionCode(transactionCode) - .pileSn(pileSn) - .connectorCode(connectorCode) - .startTime(startTime) - .endTime(endTime) - .sharpPrice(sharpPrice) - .sharpUsedElectricity(sharpUsedElectricity) - .sharpPlanLossElectricity(sharpPlanLossElectricity) - .sharpAmount(sharpAmount) - .peakPrice(peakPrice) - .peakUsedElectricity(peakUsedElectricity) - .peakPlanLossElectricity(peakPlanLossElectricity) - .peakAmount(peakAmount) - .flatPrice(flatPrice) - .flatUsedElectricity(flatUsedElectricity) - .flatPlanLossElectricity(flatPlanLossElectricity) - .flatAmount(flatAmount) - .valleyPrice(valleyPrice) - .valleyUsedElectricity(valleyUsedElectricity) - .valleyPlanLossElectricity(valleyPlanLossElectricity) - .valleyAmount(valleyAmount) - .ammeterTotalStart(ammeterTotalStart) - .ammeterTotalEnd(ammeterTotalEnd) - // .totalElectricity(totalElectricity) - .planLossTotalElectricity(planLossTotalElectricity) - .consumptionAmount(consumptionAmount) - .vinCode(vinCode) - .transactionIdentifier(transactionIdentifier) - .transactionTime(transactionTime) - .stopReasonMsg(stopReasonMsg) - .logicCard(logicCard) - .build(); - - boolean flag = !StringUtils.equals("0000000000000000", "a511101970000000"); - System.out.println(flag); - - }*/ + // public static void main(String[] args) { + // // BigDecimal totalElectricity = new BigDecimal("23.73"); + // // if (totalElectricity.compareTo(BigDecimal.TEN) > 0) { + // // // 充电度数大于10度 + // // System.out.println("123"); + // // } + // + // + // // 获取消息体 + // // String msg = "000000000000000000000000000000008823000000030601a08c2e0d0404170000380d0404170000000000000000000000000000000000000000000000000000000000000000400d0300ee250000ee250000c84b000000000000000000000000000000000000e0bb040000cee1040000ee250000ee250000c84b00000000000000000000000000000000000000010000380d04041745a511101970000000"; + // // byte[] msgBody = BytesUtil.str2Bcd(msg); + // // + // // int startIndex = 0; + // // int length = 16; + // // + // // // 交易流水号 + // // byte[] orderCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String transactionCode = BytesUtil.bcd2Str(orderCodeByteArr); + // // + // // // 桩编码 + // // startIndex += length; + // // length = 7; + // // byte[] pileSnByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String pileSn = BytesUtil.bcd2Str(pileSnByteArr); + // // + // // // 枪号 + // // startIndex += length; + // // length = 1; + // // byte[] connectorCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String connectorCode = BytesUtil.bcd2Str(connectorCodeByteArr); + // // + // // + // // // 开始时间 CP56Time2a 格式 + // // startIndex += length; + // // length = 7; + // // byte[] startTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // // String binary = BytesUtil.binary(startTimeByteArr, 16); + // // Date startDate = Cp56Time2aUtil.byte2Hdate(startTimeByteArr); + // // String startTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, startDate); + // // + // // + // // // 结束时间 CP56Time2a 格式 + // // startIndex += length; + // // byte[] endTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // Date endDate = Cp56Time2aUtil.byte2Hdate(endTimeByteArr); + // // String endTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, endDate); + // // + // // // 尖单价 精确到小数点后五位（尖电费+尖服务费，见费率帧） + // // startIndex += length; + // // length = 4; + // // byte[] sharpPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String sharpPrice = YKCUtils.convertDecimalPoint(sharpPriceByteArr, 5); + // // + // // // 尖电量 精确到小数点后四位 + // // startIndex += length; + // // length = 4; + // // byte[] sharpUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String sharpUsedElectricity = YKCUtils.convertDecimalPoint(sharpUsedElectricityByteArr, 4); + // // + // // // 计损尖电量 + // // startIndex += length; + // // byte[] sharpPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String sharpPlanLossElectricity = YKCUtils.convertDecimalPoint(sharpPlanLossElectricityByteArr, 4); + // // + // // // 尖金额 + // // startIndex += length; + // // byte[] sharpAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String sharpAmount = YKCUtils.convertDecimalPoint(sharpAmountByteArr, 4); + // // + // // // 峰单价 精确到小数点后五位（峰电费+峰服务费） + // // startIndex += length; + // // byte[] peakPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String peakPrice = YKCUtils.convertDecimalPoint(peakPriceByteArr, 5); + // // + // // // 峰电量 + // // startIndex += length; + // // byte[] peakUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String peakUsedElectricity = YKCUtils.convertDecimalPoint(peakUsedElectricityByteArr, 4); + // // + // // // 计损峰电量 + // // startIndex += length; + // // byte[] peakPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String peakPlanLossElectricity = YKCUtils.convertDecimalPoint(peakPlanLossElectricityByteArr, 4); + // // + // // // 峰金额 + // // startIndex += length; + // // byte[] peakAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String peakAmount = YKCUtils.convertDecimalPoint(peakAmountByteArr, 4); + // // + // // // 平单价 精确到小数点后五位（平电费+平服务费） + // // startIndex += length; + // // byte[] flatPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String flatPrice = YKCUtils.convertDecimalPoint(flatPriceByteArr, 5); + // // + // // // 平电量 + // // startIndex += length; + // // byte[] flatUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String flatUsedElectricity = YKCUtils.convertDecimalPoint(flatUsedElectricityByteArr, 4); + // // + // // // 计损平电量 + // // startIndex += length; + // // byte[] flatPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String flatPlanLossElectricity = YKCUtils.convertDecimalPoint(flatPlanLossElectricityByteArr, 4); + // // + // // // 平金额 + // // startIndex += length; + // // byte[] flatAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String flatAmount = YKCUtils.convertDecimalPoint(flatAmountByteArr, 4); + // // + // // // 谷单价 精确到小数点后五位（谷电费+谷 服务费） + // // startIndex += length; + // // byte[] valleyPriceByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String valleyPrice = YKCUtils.convertDecimalPoint(valleyPriceByteArr, 5); + // // + // // // 谷电量 + // // startIndex += length; + // // byte[] valleyUsedElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String valleyUsedElectricity = YKCUtils.convertDecimalPoint(valleyUsedElectricityByteArr, 4); + // // + // // // 计损谷电量 + // // startIndex += length; + // // byte[] valleyPlanLossElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String valleyPlanLossElectricity = YKCUtils.convertDecimalPoint(valleyPlanLossElectricityByteArr, 4); + // // + // // // 谷金额 + // // startIndex += length; + // // byte[] valleyAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String valleyAmount = YKCUtils.convertDecimalPoint(valleyAmountByteArr, 4); + // // + // // // 电表总起值 + // // startIndex += length; + // // length = 5; + // // byte[] ammeterTotalStartByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String ammeterTotalStart = YKCUtils.convertDecimalPoint(ammeterTotalStartByteArr, 4); + // // + // // // 电表总止值 + // // startIndex += length; + // // byte[] ammeterTotalEndByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String ammeterTotalEnd = YKCUtils.convertDecimalPoint(ammeterTotalEndByteArr, 4); + // // + // // // 总电量 + // // startIndex += length; + // // length = 4; + // // byte[] totalElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // // String totalElectricity = YKCUtils.convertDecimalPoint(totalElectricityByteArr, 4); + // // + // // // 计损总电量 + // // startIndex += length; + // // byte[] planLossTotalElectricityByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String planLossTotalElectricity = YKCUtils.convertDecimalPoint(planLossTotalElectricityByteArr, 4); + // // + // // // 消费金额 精确到小数点后四位，包含电费、 服务费 + // // startIndex += length; + // // byte[] consumptionAmountByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String consumptionAmount = YKCUtils.convertDecimalPoint(consumptionAmountByteArr, 4); + // // + // // // VIN 码 VIN 码，此处 VIN 码和充电时 VIN 码不同， 正序直接上传， 无需补 0 和反序 + // // startIndex += length; + // // length = 17; + // // byte[] vinCodeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String vinCode = BytesUtil.ascii2Str(vinCodeByteArr); + // // + // // /** + // // * 交易标识 + // // * 0x01： app 启动 + // // * 0x02：卡启动 + // // * 0x04：离线卡启动 + // // * 0x05: vin 码启动充电 + // // */ + // // startIndex += length; + // // length = 1; + // // byte[] transactionIdentifierByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String transactionIdentifier = BytesUtil.bcd2Str(transactionIdentifierByteArr); + // // + // // // 交易时间 CP56Time2a 格式 + // // startIndex += length; + // // length = 7; + // // byte[] transactionTimeByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // Date transactionDate = Cp56Time2aUtil.byte2Hdate(transactionTimeByteArr); + // // String transactionTime = DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, transactionDate); + // // + // // // 停止原因 + // // startIndex += length; + // // length = 1; + // // byte[] stopReasonByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // String stopReason = BytesUtil.bin2HexStr(stopReasonByteArr); + // // int i = Integer.parseInt(stopReason, 16); + // // String stopReasonMsg = YKCChargingStopReasonEnum.getMsgByCode(i); + // + // + // // 物理卡号 不足 8 位补 0 + // // startIndex += length; + // // length = 8; + // // byte[] cardNumByteArr = BytesUtil.copyBytes(msgBody, startIndex, length); + // // // byte[] logicCardNum = BytesUtil.checkLengthAndBehindAppendZero(cardNumByteArr, 16); + // // String logicCard = BytesUtil.binary(cardNumByteArr, 16); + // // log.info("桩号:{}, 发送交易记录物理卡号:{}", pileSn, logicCard); + // // + // // log.info("[===交易记录===]交易流水号:{}, 桩编号:{}, 枪号:{}, 开始时间:{}, 结束时间:{}, 尖单价:{}, 尖电量:{}, 计损尖电量:{}, 尖金额:{}, " + + // // "峰单价:{}, 峰电量:{}, 计损峰电量:{}, 峰金额:{}, 平单价:{}, 平电量:{}, 计损平电量:{}, 平金额:{}, " + + // // "谷单价:{}, 谷电量:{}, 计损谷电量:{}, 谷金额:{}, 电表总起值:{}, 电表总止值:{}, 总电量:{}, 计损总电量:{}, 消费金额:{}, " + + // // "电动汽车唯一标识:{}, 交易标识:{}, 交易日期、时间:{}, 停止原因码:{}, 停止原因描述:{}, 物理卡号:{}", + // // transactionCode, pileSn, connectorCode, startTime, endTime, sharpPrice, sharpUsedElectricity, sharpPlanLossElectricity, sharpAmount, + // // peakPrice, peakUsedElectricity, peakPlanLossElectricity, peakAmount, flatPrice, flatUsedElectricity, flatPlanLossElectricity, flatAmount, + // // valleyPrice, valleyUsedElectricity, valleyPlanLossElectricity, valleyAmount, ammeterTotalStart, ammeterTotalEnd, totalElectricity, planLossTotalElectricity, + // // consumptionAmount, vinCode, transactionIdentifier, transactionTime, stopReason, stopReasonMsg, logicCard); + // // + // // // 交易记录封装到对象里 + // // TransactionRecordsData data = TransactionRecordsData.builder() + // // // .orderCode(transactionCode) + // // .transactionCode(transactionCode) + // // .pileSn(pileSn) + // // .connectorCode(connectorCode) + // // .startTime(startTime) + // // .endTime(endTime) + // // .sharpPrice(sharpPrice) + // // .sharpUsedElectricity(sharpUsedElectricity) + // // .sharpPlanLossElectricity(sharpPlanLossElectricity) + // // .sharpAmount(sharpAmount) + // // .peakPrice(peakPrice) + // // .peakUsedElectricity(peakUsedElectricity) + // // .peakPlanLossElectricity(peakPlanLossElectricity) + // // .peakAmount(peakAmount) + // // .flatPrice(flatPrice) + // // .flatUsedElectricity(flatUsedElectricity) + // // .flatPlanLossElectricity(flatPlanLossElectricity) + // // .flatAmount(flatAmount) + // // .valleyPrice(valleyPrice) + // // .valleyUsedElectricity(valleyUsedElectricity) + // // .valleyPlanLossElectricity(valleyPlanLossElectricity) + // // .valleyAmount(valleyAmount) + // // .ammeterTotalStart(ammeterTotalStart) + // // .ammeterTotalEnd(ammeterTotalEnd) + // // // .totalElectricity(totalElectricity) + // // .planLossTotalElectricity(planLossTotalElectricity) + // // .consumptionAmount(consumptionAmount) + // // .vinCode(vinCode) + // // .transactionIdentifier(transactionIdentifier) + // // .transactionTime(transactionTime) + // // .stopReasonMsg(stopReasonMsg) + // // .logicCard(logicCard) + // // .build(); + // // + // // boolean flag = !StringUtils.equals("0000000000000000", "a511101970000000"); + // // System.out.println(flag); + // + // } @Override public byte[] supplyProcess(YKCDataProtocol ykcDataProtocol, ChannelHandlerContext channel) { @@ -559,6 +561,7 @@ public class TransactionRecordsRequestHandler extends AbstractYkcHandler { .vinCode(vinCode) .transactionIdentifier(transactionIdentifier) .transactionTime(transactionTime) + .stopReasonCode(stopReason) .stopReasonMsg(stopReasonMsg) .logicCard(logicCard) .build(); @@ -635,6 +638,9 @@ public class TransactionRecordsRequestHandler extends AbstractYkcHandler { orderBasicInfo.setChargeEndTime(new Date()); } + // 将停止原因码存库 + orderBasicInfo.setStopReasonCode("0x" + data.getStopReasonCode()); + orderBasicInfoService.updateOrderBasicInfo(orderBasicInfo); // 重新查询订单信息 diff --git a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/UploadRealTimeMonitorHandler.java b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/UploadRealTimeMonitorHandler.java index 4d1368ba9..b2d535597 100644 --- a/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/UploadRealTimeMonitorHandler.java +++ b/jsowell-netty/src/main/java/com/jsowell/netty/handler/yunkuaichong/UploadRealTimeMonitorHandler.java @@ -288,6 +288,9 @@ public class UploadRealTimeMonitorHandler extends AbstractYkcHandler { // 查询数据库中该订单当前信息 OrderBasicInfo orderInfo = orderBasicInfoService.getOrderInfoByTransactionCode(transactionCode); if (Objects.nonNull(orderInfo)) { + // 保存此订单的soc + YKCUtils.saveSOC(transactionCode, realTimeMonitorData.getSOC()); + if (StringUtils.equals(orderInfo.getOrderStatus(), OrderStatusEnum.ORDER_COMPLETE.getValue()) || StringUtils.equals(orderInfo.getOrderStatus(), OrderStatusEnum.STAY_SETTLEMENT.getValue())) { // 在订单状态为 订单完成或待结算，不保存 diff --git a/jsowell-netty/src/main/java/com/jsowell/netty/server/NettyServerManager.java b/jsowell-netty/src/main/java/com/jsowell/netty/server/NettyServerManager.java index 61b2f3247..4c318795a 100644 --- a/jsowell-netty/src/main/java/com/jsowell/netty/server/NettyServerManager.java +++ b/jsowell-netty/src/main/java/com/jsowell/netty/server/NettyServerManager.java @@ -32,6 +32,9 @@ public class NettyServerManager implements CommandLineRunner { @Resource private ElectricBicyclesServerChannelInitializer electricBicyclesServerChannelInitializer; + private int bossGroupSize = Runtime.getRuntime().availableProcessors(); + private int workerGroupSize = bossGroupSize * 2; + @Override public void run(String... args) throws Exception { startNettyServer(Constants.SOCKET_IP, 9011); @@ -41,8 +44,8 @@ public class NettyServerManager implements CommandLineRunner { public void startNettyServer(String host, int port) { new Thread(() -> { - EventLoopGroup bossGroup = new NioEventLoopGroup(1); - EventLoopGroup workerGroup = new NioEventLoopGroup(); + EventLoopGroup bossGroup = new NioEventLoopGroup(bossGroupSize); + EventLoopGroup workerGroup = new NioEventLoopGroup(workerGroupSize); try { ServerBootstrap bootstrap = new ServerBootstrap() @@ -51,14 +54,17 @@ public class NettyServerManager implements CommandLineRunner { .handler(new LoggingHandler(LogLevel.DEBUG)) // .option(ChannelOption.SO_BACKLOG, 128) // 默认128 .option(ChannelOption.SO_BACKLOG, 1024) + .option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT) // 启用池化内存分配器 // .option(ChannelOption.SO_REUSEADDR, true) .childOption(ChannelOption.SO_KEEPALIVE, true) // 保持连接 + // .childOption(ChannelOption.SO_RCVBUF, 64 * 1024) // 接收缓冲区 + .childOption(ChannelOption.SO_RCVBUF, 1024 * 1024) // 接收缓冲区 + // .childOption(ChannelOption.SO_SNDBUF, 64 * 1024) // 发送缓冲区 + .childOption(ChannelOption.SO_SNDBUF, 1024 * 1024) // 发送缓冲区 .childOption(ChannelOption.TCP_NODELAY, true) // 禁用 Nagle 算法 - .childOption(ChannelOption.SO_RCVBUF, 64 * 1024) // 接收缓冲区 - .childOption(ChannelOption.SO_SNDBUF, 64 * 1024) // 发送缓冲区 .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(32 * 1024, 64 * 1024)) // 写缓冲水位 .childOption(ChannelOption.SO_REUSEADDR, true) - .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT) // 启用池化内存分配器 + // .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT) // 启用池化内存分配器 .childHandler(nettyServerChannelInitializer) .localAddress(new InetSocketAddress(host, port)); @@ -130,6 +136,7 @@ public class NettyServerManager implements CommandLineRunner { .localAddress(new InetSocketAddress(host, port)); mqttBootstrap.childHandler(new ChannelInitializer() { + @Override protected void initChannel(SocketChannel ch) { ChannelPipeline channelPipeline = ch.pipeline(); // 设置读写空闲超时时间 diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/domain/OrderBasicInfo.java b/jsowell-pile/src/main/java/com/jsowell/pile/domain/OrderBasicInfo.java index 6e50736b0..d1a05061b 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/domain/OrderBasicInfo.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/domain/OrderBasicInfo.java @@ -175,6 +175,11 @@ public class OrderBasicInfo { */ private String endSoc; + /** + * 停止原因码 + */ + private String stopReasonCode; + /** * 异常原因 */ diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/domain/PersonalChargingRecord.java b/jsowell-pile/src/main/java/com/jsowell/pile/domain/PersonalChargingRecord.java index 2958eb285..9a79d939c 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/domain/PersonalChargingRecord.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/domain/PersonalChargingRecord.java @@ -155,6 +155,11 @@ public class PersonalChargingRecord { */ private BigDecimal valleyUsedElectricity; + /** + * 停止原因码 + */ + private String stopReasonCode; + /** * 异常原因 */ diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/domain/PileStationInfo.java b/jsowell-pile/src/main/java/com/jsowell/pile/domain/PileStationInfo.java index dcaabe829..d1b877c88 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/domain/PileStationInfo.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/domain/PileStationInfo.java @@ -1,5 +1,6 @@ package com.jsowell.pile.domain; +import com.alibaba.fastjson2.annotation.JSONField; import com.jsowell.common.annotation.Excel; import com.jsowell.common.core.domain.BaseEntity; import lombok.Data; @@ -8,6 +9,7 @@ import org.apache.commons.lang3.builder.ToStringBuilder; import org.apache.commons.lang3.builder.ToStringStyle; import java.math.BigDecimal; +import java.util.List; /** * 充电站信息对象 pile_station_info @@ -336,6 +338,57 @@ public class PileStationInfo extends BaseEntity { @Excel(name = "是否有地锁(0-无；1-有)") private String parkingLockFlag; + /** + *服务车型描述 + */ + @Excel(name = "服务车型描述") + private List swapMatchCars; + + /** + *是否为通用类型 + */ + @Excel(name = "是否为通用类型(1-通用 ; 2-非通用)") + private Integer generalApplicationType; + + /** + *充换电站方位 + * 1：地面-停车场 + * 2：地面-路侧 + * 3：地下停车场 + * 4：立体式停车楼 + */ + @Excel(name = "充换电站方位") + private Integer stationOrientation; + + /** + * 充换电站建筑面积 + */ + @Excel(name = "充换电站建筑面积") + private String stationArea; + + /** + * 充换电站人工值守 + */ + @Excel(name = "是否有充换电站人工值守(0-无 ; 1-有)") + private String havePerson; + + /** + * 周边配套设施 + * 1：卫生间 + * 2：便利店 + * 3：餐厅 + * 4：休息室 + * 5：雨棚 + */ + @Excel(name = "周边配套设施") + private String supportingFacilities; + + /** + * 站点额定总功率 + */ + @Excel(name = "站点额定总功率") + private BigDecimal ratedPower; + /** * 删除标识（0-正常；1-删除） */ @@ -386,6 +439,9 @@ public class PileStationInfo extends BaseEntity { .append("barrierFlag", barrierFlag) .append("parkingLockFlag", parkingLockFlag) .append("delFlag", delFlag) + .append("swapMatchCars", swapMatchCars) + .append("generalApplicationType",generalApplicationType) + .append("ratedPower",ratedPower) .toString(); } } diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/dto/QueryConnectorListDTO.java b/jsowell-pile/src/main/java/com/jsowell/pile/dto/QueryConnectorListDTO.java index 363483209..ebbc8b505 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/dto/QueryConnectorListDTO.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/dto/QueryConnectorListDTO.java @@ -49,4 +49,6 @@ public class QueryConnectorListDTO { * 接口编号 */ private List connectorCodeList; + + private String requestSource; } diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/mapper/OrderBasicInfoMapper.java b/jsowell-pile/src/main/java/com/jsowell/pile/mapper/OrderBasicInfoMapper.java index f14c18d07..f093b9ac8 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/mapper/OrderBasicInfoMapper.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/mapper/OrderBasicInfoMapper.java @@ -391,4 +391,7 @@ public interface OrderBasicInfoMapper { List getOrderDetailByStationIds(@Param("stationIds") List stationIds, @Param("startTime") String startTime, @Param("endTime") String endTime); List queryOrdersByPileConnectorCodeAndStatus(@Param("pileConnectorCode") String pileConnectorCode, @Param("orderStatus") String orderStatus, @Param("payStatus") String payStatus); + + + List tempGetOrderCodes(QueryOrderDTO dto); } \ No newline at end of file diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/service/OrderBasicInfoService.java b/jsowell-pile/src/main/java/com/jsowell/pile/service/OrderBasicInfoService.java index 90655c1f4..0366a3de2 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/service/OrderBasicInfoService.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/service/OrderBasicInfoService.java @@ -504,4 +504,11 @@ public interface OrderBasicInfoService{ * @param orderCode */ List getOrderBillingDetail(String orderCode); + + /** + * 临时接口，根据站点id、订单创建时间区间查询订单编号 + * @param dto + * @return + */ + List tempGetOrderCodes(QueryOrderDTO dto); } diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/service/PileBasicInfoService.java b/jsowell-pile/src/main/java/com/jsowell/pile/service/PileBasicInfoService.java index 2720a625c..c88eaf772 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/service/PileBasicInfoService.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/service/PileBasicInfoService.java @@ -1,5 +1,7 @@ package com.jsowell.pile.service; +import com.jsowell.common.core.domain.ykc.BMSChargeInfoData; +import com.jsowell.common.core.domain.ykc.BMSDemandAndChargerOutputData; import com.jsowell.common.core.domain.ykc.RealTimeMonitorData; import com.jsowell.pile.domain.PileBasicInfo; import com.jsowell.pile.domain.ebike.deviceupload.EBikeMessageCmd20; @@ -110,7 +112,6 @@ public interface PileBasicInfoService { /** * 通过桩sn查询basic信息 * - * @param id 桩id * @return 结果集合 */ PileDetailVO selectPileDetailByPileSn(String pileSn); @@ -151,6 +152,31 @@ public interface PileBasicInfoService { */ void saveRealTimeMonitorData2Redis(RealTimeMonitorData realTimeMonitorData); + /** + * 0x23数据保存到redis + * @param bmsDemandAndChargerOutputData + */ + void saveBMSDemandAndChargerOutputInfo2Redis(BMSDemandAndChargerOutputData bmsDemandAndChargerOutputData); + + /** + * 0x25数据保存到redis + * @param bmsChargeInfoData + */ + void saveBMSChargeInfo2Redis(BMSChargeInfoData bmsChargeInfoData); + + /** + * 根据交易流水号获取0x25数据（时间倒序） + * @return + */ + List getBMSChargeInfoList(String transactionCode); + + /** + * 根据交易流水号查询0x23数据（时间倒序） + * @param transactionCode + * @return + */ + List getBMSDemandAndChargerOutputInfoList(String transactionCode); + PileConnectorDetailVO queryPileConnectorDetail(String pileConnectorCode); String getPileQrCodeUrl(String pileSn); @@ -206,7 +232,6 @@ public interface PileBasicInfoService { /** * 获取充电桩列表 * 提供给联联平台 - * @param pileStationInfo * @return */ // List getPileList(PileStationInfo pileStationInfo); diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/service/PileSnGenerateService.java b/jsowell-pile/src/main/java/com/jsowell/pile/service/PileSnGenerateService.java index 37cdea594..82b4a41cb 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/service/PileSnGenerateService.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/service/PileSnGenerateService.java @@ -72,7 +72,7 @@ public class PileSnGenerateService { increResult = prefix + year + String.format("%1$010d", increNum); // 保存到字典中 - savePileSn2Dict(pileNum); + // savePileSn2Dict(pileNum); } catch (Exception e) { logger.error("获取序列号失败", e); } @@ -91,7 +91,7 @@ public class PileSnGenerateService { } else { SysDictData dictData = new SysDictData(); dictData.setDictType(pile_sn_generate_type); - dictData.setDictLabel(EBIKE_PILE_SN_LABEL); + dictData.setDictLabel(EV_PILE_SN_LABEL); dictData.setDictValue(pileSnNum + ""); dictData.setListClass(Constants.DEFAULT); dictData.setCreateBy(Constants.SYSTEM); diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/OrderBasicInfoServiceImpl.java b/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/OrderBasicInfoServiceImpl.java index df482ebf8..181485cd8 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/OrderBasicInfoServiceImpl.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/OrderBasicInfoServiceImpl.java @@ -1208,6 +1208,7 @@ public class OrderBasicInfoServiceImpl implements OrderBasicInfoService { } List orderCodeList = Lists.newArrayList(StringUtils.split(orderCodes, ",")); List orderBasicInfos = queryOrderList(orderCodeList); + logger.info("运营商id:{}, 日期:{}, 订单号数量:{}, 查询结果数量:{}, orderCodeList:{}", merchantId, orderReport.getTradeDate(), orderCodeList.size(), orderBasicInfos.size(), JSON.toJSONString(orderCodeList)); if (CollectionUtils.isEmpty(orderBasicInfos)) { continue; } @@ -1247,12 +1248,11 @@ public class OrderBasicInfoServiceImpl implements OrderBasicInfoService { .subtract(feeAmt); clearingBillDetail.setFeeAmt(feeAmt); clearingBillDetail.setConfirmAmt(confirmAmt); - billDetailList.add(clearingBillDetail); } else { clearingBillDetail.setFeeAmt(BigDecimal.ZERO); clearingBillDetail.setConfirmAmt(BigDecimal.ZERO); - billDetailList.add(clearingBillDetail); } + billDetailList.add(clearingBillDetail); } catch (Exception e) { logger.error("订单交易确认失败:{}", orderBasicInfo.getOrderCode(), e); } @@ -4458,5 +4458,10 @@ public class OrderBasicInfoServiceImpl implements OrderBasicInfoService { } return resultList; } + + @Override + public List tempGetOrderCodes(QueryOrderDTO dto) { + return orderBasicInfoMapper.tempGetOrderCodes(dto); + } } diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileBasicInfoServiceImpl.java b/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileBasicInfoServiceImpl.java index fb50aea81..09f4abbe5 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileBasicInfoServiceImpl.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileBasicInfoServiceImpl.java @@ -1,14 +1,13 @@ package com.jsowell.pile.service.impl; import com.alibaba.fastjson2.JSON; +import com.alibaba.fastjson2.JSONObject; import com.google.common.collect.Lists; import com.jsowell.common.YouDianUtils; import com.jsowell.common.constant.CacheConstants; import com.jsowell.common.constant.Constants; import com.jsowell.common.core.domain.vo.AuthorizedDeptVO; -import com.jsowell.common.core.domain.ykc.GroundLockData; -import com.jsowell.common.core.domain.ykc.RealTimeMonitorData; -import com.jsowell.common.core.domain.ykc.YKCFrameTypeCode; +import com.jsowell.common.core.domain.ykc.*; import com.jsowell.common.core.redis.RedisCache; import com.jsowell.common.enums.DelFlagEnum; import com.jsowell.common.enums.lianlian.LianLianPileStatusEnum; @@ -634,6 +633,14 @@ public class PileBasicInfoServiceImpl implements PileBasicInfoService { if (StringUtils.equals(realTimeMonitorData.getTransactionCode(), Constants.ILLEGAL_TRANSACTION_CODE)) { return; } + + BigDecimal outputVoltage = new BigDecimal(realTimeMonitorData.getOutputVoltage()); + BigDecimal outputCurrent = new BigDecimal(realTimeMonitorData.getOutputCurrent()); + if (outputCurrent.compareTo(BigDecimal.ZERO) == 0) { + // 电流等于0，不保存到redis + return; + } + // 保存到redis String redisKey = CacheConstants.PILE_REAL_TIME_MONITOR_DATA + realTimeMonitorData.getPileConnectorCode() + "_" + realTimeMonitorData.getTransactionCode(); @@ -641,8 +648,7 @@ public class PileBasicInfoServiceImpl implements PileBasicInfoService { Date now = new Date(); realTimeMonitorData.setDateTime(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, now)); // 计算功率，后面查询要用 - String power = new BigDecimal(realTimeMonitorData.getOutputVoltage()) - .multiply(new BigDecimal(realTimeMonitorData.getOutputCurrent())).setScale(2, RoundingMode.HALF_UP).toString(); + String power = outputVoltage.multiply(outputCurrent).setScale(2, RoundingMode.HALF_UP).toString(); realTimeMonitorData.setOutputPower(power); // 保存json字符串 String jsonMsg = JSON.toJSONString(realTimeMonitorData); @@ -663,6 +669,122 @@ public class PileBasicInfoServiceImpl implements PileBasicInfoService { redisCache.setCacheObject(pileIsChargingKey, realTimeMonitorData.getTransactionCode(), 20); } + /** + * 0x23信息设置缓存 (缓存时间3天) + * @param data + */ + @Override + public void saveBMSDemandAndChargerOutputInfo2Redis(BMSDemandAndChargerOutputData data) { + if (StringUtils.equals(data.getTransactionCode(), Constants.ILLEGAL_TRANSACTION_CODE)) { + return; + } + // 保存到redis + String redisKey = CacheConstants.BMS_DEMAND_AND_CHARGER_OUTPUT_BY_TRANSACTION_CODE + data.getTransactionCode(); + // 设置接收到实时数据的时间 + Date now = new Date(); + data.setDateTime(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, now)); + // 计算功率，后面查询要用 + String power = new BigDecimal(data.getPileVoltageOutput()) + .multiply(new BigDecimal(data.getPileCurrentOutput())).setScale(2, RoundingMode.HALF_UP).toString(); + data.setOutputPower(power); + // 保存json字符串 + String jsonMsg = JSON.toJSONString(data); + // 0x23数据20秒发送一次，1分钟3次，在同一分钟内，只保留最后一条实时数据 + redisCache.hset(redisKey, DateUtils.parseDateToStr("yyyy-MM-dd HH:mm:00", now), jsonMsg); + + // 设置过期时间 + try { + redisCache.expire(redisKey, CacheConstants.cache_expire_time_3d); + // if (redisCache.getExpire(redisKey) < 0) { + // } + } catch (Exception e) { + log.info("0x23存入缓存设置过期时间error", e); + } + } + + /** + * 0x25数据保存到redis + * @param bmsChargeInfoData + */ + @Override + public void saveBMSChargeInfo2Redis(BMSChargeInfoData bmsChargeInfoData) { + if (StringUtils.equals(bmsChargeInfoData.getTransactionCode(), Constants.ILLEGAL_TRANSACTION_CODE)) { + return; + } + // 保存到redis + String redisKey = CacheConstants.BMS_CHARGE_INFO_BY_TRANSACTION_CODE + bmsChargeInfoData.getTransactionCode(); + // 设置接收到实时数据的时间 + Date now = new Date(); + bmsChargeInfoData.setDateTime(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD_HH_MM_SS, now)); + // 保存json字符串 + String jsonMsg = JSON.toJSONString(bmsChargeInfoData); + // 0x25数据20秒发送一次，1分钟3次，在同一分钟内，只保留最后一条实时数据 + redisCache.hset(redisKey, DateUtils.parseDateToStr("yyyy-MM-dd HH:mm:00", now), jsonMsg); + + // 设置过期时间 + try { + redisCache.expire(redisKey, CacheConstants.cache_expire_time_3d); + } catch (Exception e) { + log.info("0x25存入缓存设置过期时间error", e); + } + } + + /** + * 根据交易流水号获取0x25数据 + * @param transactionCode + * @return + */ + @Override + public List getBMSChargeInfoList(String transactionCode) { + List resultList = Lists.newArrayList(); + if (StringUtils.isBlank(transactionCode)) { + return resultList; + } + String redisKey = CacheConstants.BMS_CHARGE_INFO_BY_TRANSACTION_CODE + transactionCode; + // 拿到所有数据 + Map map = redisCache.hmget(redisKey); + if (map != null && !map.isEmpty()) { + List keyList = map.keySet().stream() + .map(x -> (String) x) + .sorted(Comparator.reverseOrder()) // 对keyList排序 时间倒序 + .collect(Collectors.toList()); + for (String s : keyList) { + Object o = map.get(s); + BMSChargeInfoData data = JSONObject.parseObject((String) o, BMSChargeInfoData.class); + resultList.add(data); + } + } + return resultList; + } + + /** + * 根据交易流水号查询0x23数据（时间倒序） + * @param transactionCode + * @return + */ + @Override + public List getBMSDemandAndChargerOutputInfoList(String transactionCode) { + List resultList = Lists.newArrayList(); + if (StringUtils.isBlank(transactionCode)) { + return resultList; + } + String redisKey = CacheConstants.BMS_DEMAND_AND_CHARGER_OUTPUT_BY_TRANSACTION_CODE + transactionCode; + // 拿到所有数据 + Map map = redisCache.hmget(redisKey); + if (map != null && !map.isEmpty()) { + List keyList = map.keySet().stream() + .map(x -> (String) x) + .sorted(Comparator.reverseOrder()) // 对keyList排序 时间倒序 + .collect(Collectors.toList()); + for (String s : keyList) { + Object o = map.get(s); + BMSDemandAndChargerOutputData data = JSONObject.parseObject((String) o, BMSDemandAndChargerOutputData.class); + resultList.add(data); + } + } + return resultList; + } + @Override public PileConnectorDetailVO queryPileConnectorDetail(String pileConnectorCode) { return pileBasicInfoMapper.queryPileConnectorDetail(pileConnectorCode); @@ -1111,6 +1233,7 @@ public class PileBasicInfoServiceImpl implements PileBasicInfoService { String pileSn = pileBasicInfo.getSn(); equipmentInfo.setEquipmentID(pileSn); + equipmentInfo.setEquipmentClassification(1); equipmentInfo.setManufacturerID(Constants.OPERATORID_LIANLIAN); equipmentInfo.setManufacturerName(Constants.MANUFACTURER_NAME); equipmentInfo.setConstructionTime(DateUtils.parseDateToStr(DateUtils.YYYY_MM_DD, pileBasicInfo.getCreateTime())); @@ -1146,6 +1269,7 @@ public class PileBasicInfoServiceImpl implements PileBasicInfoService { resultList.add(equipmentInfo); } + return resultList; } @@ -1208,6 +1332,7 @@ public class PileBasicInfoServiceImpl implements PileBasicInfoService { connectorInfo.setParkNo(pileConnectorInfo.getParkNo()); } connectorInfo.setVoltageUpperLimits(Integer.valueOf(modelInfo.getRatedVoltage())); + connectorInfo.setEquipmentClassification(1); connectorInfo.setVoltageLowerLimits(Integer.valueOf(modelInfo.getRatedVoltage())); connectorInfo.setCurrent(Integer.valueOf(modelInfo.getRatedCurrent())); connectorInfo.setConnectorName(pileConnectorInfo.getPileConnectorCode()); diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileConnectorInfoServiceImpl.java b/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileConnectorInfoServiceImpl.java index c148400d5..bf8dd217b 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileConnectorInfoServiceImpl.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileConnectorInfoServiceImpl.java @@ -337,7 +337,10 @@ public class PileConnectorInfoServiceImpl implements PileConnectorInfoService { if (CollectionUtils.isEmpty(pileSns) && CollectionUtils.isEmpty(connectorIds) && CollectionUtils.isEmpty(connectorCodeList)) { return Lists.newArrayList(); } - PageHelper.startPage(pageNum, pageSize); + + if (StringUtils.isBlank(dto.getRequestSource())) { + PageHelper.startPage(pageNum, pageSize); + } List pileConnectorInfoList = pileConnectorInfoMapper.getPileConnectorInfoList(pileSns, connectorIds, connectorCodeList); diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileMemberRelationServiceImpl.java b/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileMemberRelationServiceImpl.java index fd19f794e..7e30ed359 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileMemberRelationServiceImpl.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/service/impl/PileMemberRelationServiceImpl.java @@ -116,6 +116,7 @@ public class PileMemberRelationServiceImpl implements PileMemberRelationService return selectPileMemberRelationList(pileMemberRelation); } + @Override public List selectMemberList(String pileSn) { return pileMemberRelationMapper.selectMemberList(pileSn); } diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/service/programlogic/AbstractProgramLogic.java b/jsowell-pile/src/main/java/com/jsowell/pile/service/programlogic/AbstractProgramLogic.java index 1b868cfcf..883de3d19 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/service/programlogic/AbstractProgramLogic.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/service/programlogic/AbstractProgramLogic.java @@ -16,6 +16,7 @@ import com.jsowell.common.enums.ykc.OrderPayRecordEnum; import com.jsowell.common.enums.ykc.OrderStatusEnum; import com.jsowell.common.util.DateUtils; import com.jsowell.common.util.StringUtils; +import com.jsowell.common.util.YKCUtils; import com.jsowell.pile.domain.*; import com.jsowell.pile.domain.ebike.deviceupload.EBikeMessageCmd03; import com.jsowell.pile.dto.*; @@ -246,6 +247,23 @@ public abstract class AbstractProgramLogic implements InitializingBean { orderBasicInfo.setSettlementTime(DateUtils.getNowDate()); // 结算时间 } orderBasicInfo.setRefundAmount(residue); // 结算退款金额 + + if (StringUtils.isBlank(orderBasicInfo.getStartSoc()) || StringUtils.isBlank(orderBasicInfo.getEndSoc())) { + try { + Map socMap = YKCUtils.getSOCMap(orderBasicInfo.getTransactionCode()); + if (Objects.nonNull(socMap)) { + if (StringUtils.isBlank(orderBasicInfo.getStartSoc())) { + orderBasicInfo.setStartSoc(socMap.get("startSoc")); + } + if (StringUtils.isBlank(orderBasicInfo.getEndSoc())) { + orderBasicInfo.setEndSoc(socMap.get("endSoc")); + } + } + } catch (Exception e) { + logger.error("获取订单充电开始结束SOC失败:{}", e.getMessage()); + } + } + } /** diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/ConnectorInfo.java b/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/ConnectorInfo.java index 1b021e141..ffef9cd28 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/ConnectorInfo.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/ConnectorInfo.java @@ -23,6 +23,14 @@ public class ConnectorInfo { @JSONField(name = "ConnectorID") private String connectorID; + /** + * 设备接口分类 + * 1：车辆充电设备接口 + * 2：换电站内的电池箱 充电设备接口 + */ + @JSONField(name = "EquipmentClassification") + private Integer equipmentClassification; + /** * 充电设备接口名称 N */ @@ -51,12 +59,36 @@ public class ConnectorInfo { @JSONField(name = "VoltageLowerLimits") private Integer voltageLowerLimits; + /** + *恒功率电压上限 + */ + @JSONField(name = "ConstantVoltageUpperLimits") + private Integer constantVoltageUpperLimits; + + /** + *恒功率电压下限 + */ + @JSONField(name = "ConstantVoltageLowerLimits") + private Integer constantVoltageLowerLimits; + /** * 额定电流(单位：A) Y */ @JSONField(name = "Current") private Integer current; + /** + *恒功率电流上限 + */ + @JSONField(name = "ConstantCurrentUpperLimits") + private Integer ConstantCurrentUpperLimits; + + /** + *恒功率电流下限 + */ + @JSONField(name = "ConstantCurrentLowerLimits") + private Integer ConstantCurrentLowerLimits; + /** * 额定功率(单位：kW) Y */ @@ -105,4 +137,10 @@ public class ConnectorInfo { @JSONField(name = "AuxPower") private Integer auxPower; + /** + * 运营时间 + */ + @JSONField(name = "OpreateHours") + private String opreateHours; + } diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/EquipmentInfo.java b/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/EquipmentInfo.java index 35ae8fffa..bb3309a8b 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/EquipmentInfo.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/EquipmentInfo.java @@ -24,6 +24,13 @@ public class EquipmentInfo { @JSONField(name = "EquipmentID") private String equipmentID; + /** + * 设备唯一编码 + *设备生产商组织机构代 码 9 位+设备出厂唯一 编码 + */ + @JSONField(name = "EquipmentUniqueNumber") + private String equipmentUniqueNumber; + /** * 设备生产商组织机构代码 Y */ @@ -54,7 +61,7 @@ public class EquipmentInfo { * YYYY-MM-DD */ @JSONField(name = "ProductionDate") - private String productionDate; + private String productionDate; /** * 建设时间 Y @@ -69,6 +76,13 @@ public class EquipmentInfo { @JSONField(name = "EquipmentType") private Integer equipmentType; + /** + * 设备分类 + * 1：车辆充电设备 2：换电站内的电池箱 充电设备 + */ + @JSONField(name = "EquipmentClassification") + private Integer equipmentClassification; + /** * 设备状态 Y * 0：未知 @@ -104,13 +118,15 @@ public class EquipmentInfo { * 充电设备经度 N * GCJ-02坐标系 */ - // private BigDecimal EquipmentLng; + @JSONField(name = "EquipmentLng") + private BigDecimal equipmentLng; /** * 充电设备纬度 N * GCJ-02坐标系 */ - // private BigDecimal EquipmentLat; + @JSONField(name = "EquipmentLat") + private BigDecimal equipmentLat; /** * 是否支持VIN码识别(0-否；1-是) Y @@ -124,4 +140,10 @@ public class EquipmentInfo { @JSONField(name = "Power") private BigDecimal power; + + /** + * 站点额定功率 + */ + private BigDecimal stationRatedPower; + } diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/publicinfo/BaseStationInfo.java b/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/publicinfo/BaseStationInfo.java index fca136e8d..6fb6ca9cc 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/publicinfo/BaseStationInfo.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/thirdparty/publicinfo/BaseStationInfo.java @@ -186,6 +186,14 @@ public class BaseStationInfo { @JSONField(name = "MatchCars") private String matchCars; + /** + * 服务车型描述 + * 描述换电站可服务的车系车型（厂牌型号） + * 注：站点分类为 2 或 3 时，此字段必填，为 1 时非必填。 + */ + @JSONField(name = "SwapMatchCars") + private List swapMatchCars; + /** * 车位楼层及数量描述 N * 车位楼层以及数量信息 @@ -256,4 +264,11 @@ public class BaseStationInfo { @JSONField(name = "EquipmentInfos") private List equipmentInfos; + /** + * 充电设备信息列表 Y + * 该充电站所有充电设备信息对象集合 + */ + @JSONField(name = "SupEquipmentInfos") + private List supequipmentInfos; + } diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/OrderVO.java b/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/OrderVO.java index 0b2bd1f6e..c52c5779b 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/OrderVO.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/OrderVO.java @@ -95,6 +95,11 @@ public class OrderVO { */ private String orderStatus; + /** + * 停止原因码 + */ + private String stopReasonCode; + /** * 订单异常原因 */ diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/PersonPileConnectorSumInfoVO.java b/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/PersonPileConnectorSumInfoVO.java index 6527de0da..7388f9c30 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/PersonPileConnectorSumInfoVO.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/PersonPileConnectorSumInfoVO.java @@ -47,6 +47,11 @@ public class PersonPileConnectorSumInfoVO { */ private String sourceType; + /** + * 停止原因码 + */ + private String stopReasonCode; + /** * 停止原因 */ diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/UniAppOrderVO.java b/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/UniAppOrderVO.java index 4790a918d..619db8fb1 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/UniAppOrderVO.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/vo/uniapp/customer/UniAppOrderVO.java @@ -39,6 +39,11 @@ public class UniAppOrderVO { */ private String pileConnectorCode; + /** + * 停止充电原因码 + */ + private String stopReasonCode; + /** * 异常原因 */ diff --git a/jsowell-pile/src/main/java/com/jsowell/pile/vo/web/OrderDetailInfoVO.java b/jsowell-pile/src/main/java/com/jsowell/pile/vo/web/OrderDetailInfoVO.java index 2169a264c..f4da82191 100644 --- a/jsowell-pile/src/main/java/com/jsowell/pile/vo/web/OrderDetailInfoVO.java +++ b/jsowell-pile/src/main/java/com/jsowell/pile/vo/web/OrderDetailInfoVO.java @@ -62,6 +62,7 @@ public class OrderDetailInfoVO { private String vinCode; // vin号 private String startTime; // 充电开始时间 private String endTime; // 充电结束时间 + private String stopReasonCode; // 停止原因码 private String stopReasonMsg; // 停止原因 private String createTime; // 订单创建时间 private String startSOC; // 开始SOC diff --git a/jsowell-pile/src/main/resources/mapper/pile/OrderBasicInfoMapper.xml b/jsowell-pile/src/main/resources/mapper/pile/OrderBasicInfoMapper.xml index 2e7defa3d..fce21a633 100644 --- a/jsowell-pile/src/main/resources/mapper/pile/OrderBasicInfoMapper.xml +++ b/jsowell-pile/src/main/resources/mapper/pile/OrderBasicInfoMapper.xml @@ -36,6 +36,7 @@ + @@ -52,7 +53,7 @@ pile_sn, connector_code, pile_connector_code, logic_card, vin_code, start_mode, third_party_type, pay_mode, pay_status, pay_amount, pay_time, plate_number, order_amount, virtual_amount, group_code, discount_amount, settle_amount, remedial_amount, charge_start_time, charge_end_time, - start_type, reserved_start_time, reserved_end_time, start_soc, end_soc, reason, settlement_time, refund_amount, + start_type, reserved_start_time, reserved_end_time, start_soc, end_soc, stop_reason_code, reason, settlement_time, refund_amount, refund_status, create_by, create_time, update_by, update_time, del_flag + \ No newline at end of file diff --git a/jsowell-pile/src/main/resources/mapper/pile/PersonalChargingRecordMapper.xml b/jsowell-pile/src/main/resources/mapper/pile/PersonalChargingRecordMapper.xml index 7931d6c52..d22850100 100644 --- a/jsowell-pile/src/main/resources/mapper/pile/PersonalChargingRecordMapper.xml +++ b/jsowell-pile/src/main/resources/mapper/pile/PersonalChargingRecordMapper.xml @@ -31,6 +31,7 @@ + @@ -46,7 +47,7 @@ pile_connector_code, logic_card, vin_code, start_mode, plate_number, charge_start_time, charge_end_time, start_type, reservation_start_time, reservation_end_time, start_soc, end_soc, ammeter_total_start, ammeter_total_end, total_used_electricity, sharp_used_electricity, - peak_used_electricity, flat_used_electricity, valley_used_electricity, reason, trade_date, + peak_used_electricity, flat_used_electricity, valley_used_electricity, stop_reason_code, reason, trade_date, source_type, create_by, create_time, update_by, update_time, del_flag