diff --git a/business-service-api/src/main/java/com/ho/business/vo/resp/ShipStationRespVO.java b/business-service-api/src/main/java/com/ho/business/vo/resp/ShipStationRespVO.java new file mode 100644 index 0000000..0e4bb4d --- /dev/null +++ b/business-service-api/src/main/java/com/ho/business/vo/resp/ShipStationRespVO.java @@ -0,0 +1,47 @@ +package com.ho.business.vo.resp; + +import com.alibaba.fastjson.JSONArray; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * 主监控汇总信息 + */ +@Data +public class ShipStationRespVO { + + @ApiModelProperty(value = "储能系统累计收益，单位（元）") + private Float incomeSum; + @ApiModelProperty(value = "储能系统昨⽇收益") + private Float incomeYesterday; + @ApiModelProperty(value = "储能系统累计充电量，单位（kWh）") + private Float positivePowerSum; + @ApiModelProperty(value = "储能系统累计放电量，单位（kWh）") + private Float reversePowerSum; + @ApiModelProperty(value = "储能系统今⽇充电量，单位（kWh）") + private Float positivePowerToday; + @ApiModelProperty(value = "储能系统今⽇放电量，单位（kWh）") + private Float reversePowerToday; + @ApiModelProperty(value = "储能系统实时功率，单位（kw）") + private Float realTimePower; + @ApiModelProperty(value = "关⼝表电压，单位（v）") + private Float voltage; + @ApiModelProperty(value = "储能系统剩余电量，单位（kwh）") + private Float surplus; + @ApiModelProperty(value = "储能系统剩余SOC") + private Float soc; + @ApiModelProperty(value = "储能系统装机容量，单位（kWh）") + private Integer capacity; + @ApiModelProperty(value = "储能系统投运时⻓，单位（天）") + private Integer operationTime; + @ApiModelProperty(value = "储能系统能量链数量，单位（条）") + private Integer eLinkNumber; + @ApiModelProperty(value = "储能系统在线能量链数量，单位（条）") + private Integer eLinkOnline; + @ApiModelProperty(value = "储能系统能量块数量，单位（个）") + private Integer eBLockNumber; + @ApiModelProperty(value = "储能系统在线能量块数量，单位（个）") + private Integer eBlockOnline; + @ApiModelProperty(value = "储能系统今⽇功率和soc曲线") + private JSONArray historyDataList; +} diff --git a/business-service-dao/src/main/java/com/ho/business/mapper/EarningsCalculateMapper.java b/business-service-dao/src/main/java/com/ho/business/mapper/EarningsCalculateMapper.java index 5deee72..a8eb122 100644 --- a/business-service-dao/src/main/java/com/ho/business/mapper/EarningsCalculateMapper.java +++ b/business-service-dao/src/main/java/com/ho/business/mapper/EarningsCalculateMapper.java @@ -29,6 +29,8 @@ public interface EarningsCalculateMapper { int deleteByDay(@Param("day") String day, @Param("typeList") List typeList); + int deleteByStationAndDay(@Param("day") String day, @Param("typeList") List typeList, @Param("stationId") Integer stationId); + int insertBatch(List list); // 类型是传入多个 //List selectList(@Param("stationId") Integer stationId, @Param("typeList") List typeList, @Param("beginTime") String beginTime, @Param("endTime") String endTime); diff --git a/business-service-dao/src/main/java/com/ho/business/service/BoulderEnergyService.java b/business-service-dao/src/main/java/com/ho/business/service/BoulderEnergyService.java new file mode 100644 index 0000000..1a01b09 --- /dev/null +++ b/business-service-dao/src/main/java/com/ho/business/service/BoulderEnergyService.java @@ -0,0 +1,354 @@ +package com.ho.business.service; + +import cn.hutool.core.date.DateTime; +import cn.hutool.core.date.DateUtil; +import com.alibaba.fastjson.JSON; +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import com.google.common.collect.Maps; +import com.ho.business.constant.DeviceTypeConstant; +import com.ho.business.entity.EarningsCalculate; +import com.ho.business.entity.ElecMeterValue; +import com.ho.business.mapper.EarningsCalculateMapper; +import com.ho.business.vo.req.carbin.EarningsCalculateReq; +import com.ho.business.vo.resp.ShipStationRespVO; +import com.ho.common.tools.constant.CommonConstant; +import com.ho.common.tools.service.RedisService; +import com.ho.common.tools.util.HttpUtils; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.io.IOException; +import java.math.BigDecimal; +import java.text.SimpleDateFormat; +import java.time.Instant; +import java.time.LocalDate; +import java.time.ZoneId; +import java.time.format.DateTimeFormatter; +import java.util.*; +import java.util.concurrent.TimeUnit; + +/** + * 成都巨石 能源 储能 + * 成都巨石能源 API 接口 服务 + * + * @author kerwin + */ +@Service +@Slf4j +public class BoulderEnergyService { + + /** + * 获取token 参数 appAccount + */ + private static final String APP_ACCOUNT = "cdjs_app"; + /** + * 获取token 参数 appSecretKey + */ + private static final String APP_SECRET_KEY = "cdjs@0108"; + /** + * 中车- 获取电站id + */ + private static final Integer BOULDER_STATION_ID = 11006; + + + /** + * 中车- 获取token Url + */ + private static final String TOKEN_URL = "http://111.15.176.77:18082/gate-newpc/zhny-openapi/openapi/v1/authentication/getAccessToken"; + + /** + * 中车- 统计数据 Url + */ + private static final String BOULDER_DATA_URL = "http://111.15.176.77:18082/gate-newpc/zhny-openapi/openapi/v1/statistics/station/qryIncDayBill"; + + @Autowired + private RedisService redisService; + + @Autowired + ElecMeterValueService elecMeterValueService; + + @Autowired + EarningsCalculateMapper earningsCalculateMapper; + + /** + * 中车能源 - 获取token + * @return token + */ + public String getToken(){ + String token = null; + if(redisService.hasKey(CommonConstant.BOULDER_ENERGY_TOKEN_KEY)){ + token = (String)redisService.get(CommonConstant.BOULDER_ENERGY_TOKEN_KEY); + return token; + } + Map params = Maps.newHashMap(); + params.put("appAccount",APP_ACCOUNT); + params.put("appSecretKey",APP_SECRET_KEY); + try { + String json = HttpUtils.postWithJson(TOKEN_URL,params); + log.info("json:" + TOKEN_URL); + log.info("json:" + json); + JSONObject jsonObject = JSONObject.parseObject(json); + Integer code = jsonObject.getInteger("code"); + if(CommonConstant.HttpCode.SUCCESS_CODE.equals(code)){ + JSONObject data = jsonObject.getJSONObject("data"); + token = data.getString("accessToken"); + //redis 缓存 + redisService.set(CommonConstant.BOULDER_ENERGY_TOKEN_KEY,token,50, TimeUnit.SECONDS); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + return token; + } + + /** + * 中车能源 - 统计数据 + * @param beginTime 开始时间 + * @return + */ + public String getBoulderData(String beginTime){ + Map headers = new HashMap<>(); + headers.put("Authorization", getToken()); + Map params = new HashMap<>(); + params.put("stationCode","SC020075040001"); + params.put("time",beginTime); + String contentType = "application/json; charset=utf-8"; + try { + String json = HttpUtils.postWithHeaders(BOULDER_DATA_URL,HttpUtils.mapToJson(params),contentType,headers); + log.info("MAIN_URL:" + BOULDER_DATA_URL); + log.info("json:" + json); + JSONObject jsonObject = JSONObject.parseObject(json); + Integer code = jsonObject.getInteger("code"); + if(CommonConstant.HttpCode.SUCCESS_CODE.equals(code)){ + String data = jsonObject.getString("data"); + JSONObject dataJson = JSONObject.parseObject(data); + return dataJson.getString("records"); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + return null; + } + /*****************************************业务处理******************************************************/ + + /** + * 中车 - 获取电站历史收益、充放电数据并存储 + */ + public void getBoulderEleIncome(String beginTime){ + DateTime yesterday = DateUtil.yesterday(); + String yesterdayStr = DateUtil.formatDate(yesterday); + if(beginTime==null){ + beginTime = yesterdayStr; + } + long timestamp = dateStringToTimestamp(beginTime); + String records = getBoulderData(String.valueOf(timestamp)); + JSONArray data = JSON.parseArray(records); + String finalBeginTime = beginTime; + data.forEach(i->{ + List list = new ArrayList<>(); + List elecList = new ArrayList<>(); + JSONObject obj = (JSONObject) i; + String date = timestampToDateString(obj.getLong("balanceDate")); + if(finalBeginTime.equals(date)){ + //收益-充-尖 + EarningsCalculate sharpCharge = new EarningsCalculate(); + BigDecimal sharpChargeEle = obj.getBigDecimal("sharpChargeElectricity"); + sharpCharge.setElec(sharpChargeEle); + sharpCharge.setType(0); + sharpCharge.setRateType(CommonConstant.RateType.TIP); + sharpCharge.setPrice(BigDecimal.ZERO); + sharpCharge.setDigital(BigDecimal.ZERO); + sharpCharge.setTotal(BigDecimal.ZERO); + list.add(sharpCharge); + //收益-充-峰 + EarningsCalculate peakCharge = new EarningsCalculate(); + BigDecimal peakChargeEle = obj.getBigDecimal("peakChargeElectricity"); + peakCharge.setElec(peakChargeEle); + peakCharge.setType(0); + peakCharge.setRateType(CommonConstant.RateType.PEAK); + peakCharge.setPrice(BigDecimal.ZERO); + peakCharge.setDigital(BigDecimal.ZERO); + peakCharge.setTotal(BigDecimal.ZERO); + list.add(peakCharge); + //收益-充-平 + EarningsCalculate flatCharge = new EarningsCalculate(); + BigDecimal flatChargeEle = obj.getBigDecimal("flatChargeElectricity"); + flatCharge.setElec(flatChargeEle); + flatCharge.setType(0); + flatCharge.setRateType(CommonConstant.RateType.FLAT); + flatCharge.setPrice(BigDecimal.ZERO); + flatCharge.setDigital(BigDecimal.ZERO); + flatCharge.setTotal(BigDecimal.ZERO); + list.add(flatCharge); + //收益-充-谷 + EarningsCalculate valleyCharge = new EarningsCalculate(); + BigDecimal valleyChargeEle = obj.getBigDecimal("valleyChargeElectricity"); + valleyCharge.setElec(valleyChargeEle); + valleyCharge.setType(0); + valleyCharge.setRateType(CommonConstant.RateType.VALLEY); + valleyCharge.setPrice(BigDecimal.ZERO); + valleyCharge.setDigital(BigDecimal.ZERO); + valleyCharge.setTotal(BigDecimal.ZERO); + list.add(valleyCharge); + //收益-充-深谷 + EarningsCalculate deepValleyCharge = new EarningsCalculate(); + BigDecimal deepValleyChargeEle = obj.getBigDecimal("deepValleyChargeElectricity"); + deepValleyCharge.setElec(deepValleyChargeEle); + deepValleyCharge.setType(0); + deepValleyCharge.setRateType(CommonConstant.RateType.DEEP_VALLEY); + deepValleyCharge.setPrice(BigDecimal.ZERO); + deepValleyCharge.setDigital(BigDecimal.ZERO); + deepValleyCharge.setTotal(BigDecimal.ZERO); + list.add(deepValleyCharge); + //收益-放-尖 + EarningsCalculate sharpDischarge = new EarningsCalculate(); + BigDecimal reverseSharp = obj.getBigDecimal("sharpDischargeElectricity"); + sharpDischarge.setElec(reverseSharp); + sharpDischarge.setType(1); + sharpDischarge.setRateType(CommonConstant.RateType.TIP); + sharpDischarge.setPrice(BigDecimal.ZERO); + sharpDischarge.setDigital(BigDecimal.ZERO); + sharpDischarge.setTotal(BigDecimal.ZERO); + list.add(sharpDischarge); + //收益-放-峰 + EarningsCalculate peakDischarge = new EarningsCalculate(); + BigDecimal peakDischargeEle = obj.getBigDecimal("peakDischargeElectricity"); + peakDischarge.setElec(peakDischargeEle); + peakDischarge.setType(1); + peakDischarge.setRateType(CommonConstant.RateType.PEAK); + peakDischarge.setPrice(BigDecimal.ZERO); + peakDischarge.setDigital(BigDecimal.ZERO); + peakDischarge.setTotal(BigDecimal.ZERO); + list.add(peakDischarge); + //收益-放-平 + EarningsCalculate flatDischarge = new EarningsCalculate(); + BigDecimal flatDischargeEle = obj.getBigDecimal("flatDischargeElectricity"); + flatDischarge.setElec(flatDischargeEle); + flatDischarge.setType(1); + flatDischarge.setRateType(CommonConstant.RateType.FLAT); + flatDischarge.setPrice(BigDecimal.ZERO); + flatDischarge.setDigital(BigDecimal.ZERO); + flatDischarge.setTotal(BigDecimal.ZERO); + list.add(flatDischarge); + //收益-放-谷 + EarningsCalculate valleyDischarge = new EarningsCalculate(); + BigDecimal valleyDischargeEle = obj.getBigDecimal("valleyDischargeElectricity"); + valleyDischarge.setElec(valleyDischargeEle); + valleyDischarge.setType(1); + valleyDischarge.setRateType(CommonConstant.RateType.VALLEY); + valleyDischarge.setPrice(BigDecimal.ZERO); + valleyDischarge.setDigital(BigDecimal.ZERO); + valleyDischarge.setTotal(BigDecimal.ZERO); + list.add(valleyDischarge); + //收益-放-深谷 + EarningsCalculate deepValleyDischarge = new EarningsCalculate(); + BigDecimal deepValleyDischargeEle = obj.getBigDecimal("deepValleyDischargeElectricity"); + BigDecimal income = obj.getBigDecimal("income"); + deepValleyDischarge.setElec(deepValleyDischargeEle); + deepValleyDischarge.setType(1); + deepValleyDischarge.setRateType(CommonConstant.RateType.DEEP_VALLEY); + deepValleyDischarge.setPrice(BigDecimal.ZERO); + deepValleyDischarge.setDigital(income); + deepValleyDischarge.setTotal(income); + list.add(deepValleyDischarge); + // 充电 + ElecMeterValue charge = new ElecMeterValue(); + BigDecimal chargeEle = obj.getBigDecimal("chargeElectricity"); + charge.setDigital(chargeEle); + charge.setType(DeviceTypeConstant.ELEC_METER_VALUE_TYPE.CHARGE); + charge.setStatus(CommonConstant.STATUS_FLAG); + elecList.add(charge); + // 放电 + ElecMeterValue disCharge = new ElecMeterValue(); + BigDecimal dischargeEle = obj.getBigDecimal("dischargeElectricity"); + disCharge.setDigital(dischargeEle); + disCharge.setType(DeviceTypeConstant.ELEC_METER_VALUE_TYPE.DISCHARGE); + disCharge.setStatus(CommonConstant.STATUS_FLAG); + elecList.add(disCharge); + + if(elecList.size()>0){ + //删除 + elecMeterValueService.deleteByStationAndDay(BOULDER_STATION_ID,date,null); + elecList.forEach(eleMeter -> { + eleMeter.setGroupId(155); + eleMeter.setStationId(BOULDER_STATION_ID); + eleMeter.setCreateTime(new Date()); + eleMeter.setDay(date); + //新增 + elecMeterValueService.insert(eleMeter); + }); + } + if(list.size()>0){ + //删除 + earningsCalculateMapper.deleteByStationAndDay(date,null,BOULDER_STATION_ID); + list.forEach(a->{ + a.setGroupId(155); + a.setStationId(BOULDER_STATION_ID); + a.setCreateTime(new Date()); + a.setDay(date); + a.setDiscount(BigDecimal.ONE); + //新增 + earningsCalculateMapper.insertSelective(a); + }); + } + } + }); + } + public void getCacheBoulderData(){ + ShipStationRespVO vo = new ShipStationRespVO(); + //查询电站收益数据 + EarningsCalculateReq ec = new EarningsCalculateReq(); + //昨日 + DateTime yesterday = DateUtil.yesterday(); + String yesterdayStr = DateUtil.formatDate(yesterday); + //今日 + DateTime nowDay = DateUtil.date(); + String nowDayStr = DateUtil.formatDate(nowDay); + //查询电站所有收益数据-组装参数 + ec.setStationId(BOULDER_STATION_ID); + ec.setBeginTime(earningsCalculateMapper.getFirstTime()); + ec.setEndTime(nowDayStr); + List earnList = earningsCalculateMapper.selectList(ec); + // 累计充电、放电、收益 + BigDecimal incomeSum = earnList.stream().map(EarningsCalculate::getDigital).reduce(BigDecimal.ZERO, BigDecimal::add); + BigDecimal positivePowerSum = earnList.stream().filter(i->i.getType().equals(CommonConstant.ZERO)).map(EarningsCalculate::getElec).reduce(BigDecimal.ZERO, BigDecimal::add); + BigDecimal reversePowerSum = earnList.stream().filter(i->i.getType().equals(CommonConstant.ONE)).map(EarningsCalculate::getElec).reduce(BigDecimal.ZERO, BigDecimal::add); + vo.setIncomeSum(incomeSum.floatValue()); + vo.setPositivePowerSum(positivePowerSum.floatValue()); + vo.setReversePowerSum(reversePowerSum.floatValue()); + // 昨日收益 + BigDecimal incomeYesterday = earnList.stream().filter(i->i.getDay().equals(yesterdayStr)).map(EarningsCalculate::getDigital).reduce(BigDecimal.ZERO, BigDecimal::add); + vo.setIncomeYesterday(incomeYesterday.floatValue()); + // 今日充、放电 + BigDecimal positivePowerToday = earnList.stream().filter(i->i.getDay().equals(nowDayStr)&&i.getType().equals(CommonConstant.ZERO)).map(EarningsCalculate::getElec).reduce(BigDecimal.ZERO, BigDecimal::add); + vo.setPositivePowerToday(positivePowerToday.floatValue()); + BigDecimal reversePowerToday = earnList.stream().filter(i->i.getDay().equals(nowDayStr)&&i.getType().equals(CommonConstant.ONE)).map(EarningsCalculate::getElec).reduce(BigDecimal.ZERO, BigDecimal::add); + vo.setReversePowerToday(reversePowerToday.floatValue()); + String mainKey = CommonConstant.SHIP_ENERGY_MAIN + BOULDER_STATION_ID; + redisService.set(mainKey,JSONObject.toJSONString(vo)); + } + + /** + * 时间日期 转换为时间戳 + * @param dateStr yyyy-MM-dd + * @return long 时间戳 + */ + public static long dateStringToTimestamp(String dateStr) { + LocalDate localDate = LocalDate.parse(dateStr, DateTimeFormatter.ISO_LOCAL_DATE); + return localDate.atStartOfDay(ZoneId.systemDefault()).toInstant().toEpochMilli(); + } + + /** + * 毫秒级时间戳 转换为日期 yyyy-MM-dd + * @param timestamp long 时间戳 + * @return yyyy-MM-dd + */ + public static String timestampToDateString(long timestamp) { + DateTimeFormatter formatter = DateTimeFormatter.ofPattern(CommonConstant.DATE_YMD); + return Instant.ofEpochMilli(timestamp) + .atZone(ZoneId.systemDefault()) + .format(formatter); + } +} diff --git a/business-service-dao/src/main/java/com/ho/business/service/ShipEnergyService.java b/business-service-dao/src/main/java/com/ho/business/service/ShipEnergyService.java new file mode 100644 index 0000000..77feb56 --- /dev/null +++ b/business-service-dao/src/main/java/com/ho/business/service/ShipEnergyService.java @@ -0,0 +1,446 @@ +package com.ho.business.service; + +import cn.hutool.core.date.DateTime; +import cn.hutool.core.date.DateUtil; +import com.alibaba.fastjson.JSON; +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; +import com.google.common.collect.Maps; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.ho.business.constant.DeviceTypeConstant; +import com.ho.business.entity.EarningsCalculate; +import com.ho.business.entity.ElecMeterValue; +import com.ho.business.entity.Station; +import com.ho.business.mapper.EarningsCalculateMapper; +import com.ho.business.vo.req.StationReqVO; +import com.ho.business.vo.resp.ShipStationRespVO; +import com.ho.common.tools.constant.CommonConstant; +import com.ho.common.tools.exception.BaseResponseCode; +import com.ho.common.tools.exception.BusinessException; +import com.ho.common.tools.service.RedisService; +import com.ho.common.tools.util.HttpUtils; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.web.jsf.FacesContextUtils; + +import java.io.IOException; +import java.math.BigDecimal; +import java.text.SimpleDateFormat; +import java.util.*; +import java.util.concurrent.TimeUnit; + +/** + * 西安寄点能源股份有限公司 + * 西安寄点能源 API 接口 服务 + * + * @author kerwin + */ +@Service +@Slf4j +public class ShipEnergyService { + + + /** + * 获取token 参数 platform + */ + private static final String PLATFORM = "f9599b6c79a5efbfc6ddce5fed1bbed5"; + + /** + * 获取token 参数 platformsecret + */ + private static final String PLATFORM_SECRET = "2928b16f9cb8e85199a4caa6ba3b6620"; + + /** + * 寄点能源- 获取token Url + */ + private static final String TOKEN_URL = "https://www.emind2000.cloud/rest-api/gettoken"; + + /** + * 寄点能源- 获取项目列表 Url + */ + private static final String STATION_URL = "https://www.emind2000.cloud/rest-api/getStations"; + + /** + * 寄点能源- 主监控汇总 Url + */ + private static final String MAIN_URL = "https://www.emind2000.cloud/rest-api/getMainTotal"; + /** + * 寄点能源- 历史收益 Url + */ + private static final String INCOME_HIS_URL = "https://www.emind2000.cloud/rest-api/getIncomeHis"; + + @Autowired + private RedisService redisService; + + @Autowired + private StationService stationService; + + @Autowired + ElecMeterValueService elecMeterValueService; + + @Autowired + EarningsCalculateMapper earningsCalculateMapper; + + /** + * 寄点能源 - 获取token + * @return token + */ + public String getToken(){ + String token = null; + if(redisService.hasKey(CommonConstant.SHIP_ENERGY_TOKEN_KEY)){ + token = (String)redisService.get(CommonConstant.SHIP_ENERGY_TOKEN_KEY); + return token; + } + Map params = Maps.newHashMap(); + params.put("platform",PLATFORM); + params.put("platformsecret",PLATFORM_SECRET); + try { + String json = HttpUtils.getWithForm(TOKEN_URL,params); + log.info("json:" + TOKEN_URL); + log.info("json:" + json); + JSONObject jsonObject = JSONObject.parseObject(json); + Integer code = jsonObject.getInteger("code"); + if(CommonConstant.HttpCode.SUCCESS_CODE.equals(code)){ + JSONObject data = jsonObject.getJSONObject("data"); + token = data.getString("access_token"); + //redis 缓存 + redisService.set(CommonConstant.SHIP_ENERGY_TOKEN_KEY,token,10, TimeUnit.HOURS); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + return token; + } + + /** + * 寄点能源 - 获取 项目列表 + * @return 项目列表 json 字符串 + */ + public String getStations(){ + Map headers = new HashMap<>(); + headers.put("Authorization", getToken()); + try { + String json = HttpUtils.getWithHeaders(STATION_URL,null,headers); + log.info("json:" + STATION_URL); + log.info("json:" + json); + JSONObject jsonObject = JSONObject.parseObject(json); + Integer code = jsonObject.getInteger("code"); + if(CommonConstant.HttpCode.SUCCESS_CODE.equals(code)){ + JSONObject data = jsonObject.getJSONObject("data"); + return data.getString("rows"); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + return null; + } + + /** + * + * 寄点能源 - 获取 主监控汇总信息 + * @param stationId 电站id + * @return 返回对应电站汇总信息 + */ + public String getMainTotal(Integer stationId){ + Map headers = new HashMap<>(); + headers.put("Authorization", getToken()); + Map params = new HashMap<>(); + params.put("stationId",stationId.toString()); + try { + Thread.sleep(2000); + String json = HttpUtils.getWithHeaders(MAIN_URL,params,headers); + log.info("MAIN_URL:" + MAIN_URL); + log.info("json:" + json); + JSONObject jsonObject = JSONObject.parseObject(json); + Integer code = jsonObject.getInteger("code"); + if(CommonConstant.HttpCode.SUCCESS_CODE.equals(code)){ + return jsonObject.getString("data"); + } + } catch (IOException e) { + throw new RuntimeException(e); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + return null; + } + /** + * 寄点能源 - 获取 历史收益查询 + */ + public String getIncomeHis(Integer stationId,String beginTime){ + Map headers = new HashMap<>(); + headers.put("Authorization", getToken()); + Map params = new HashMap<>(); + params.put("stationId",stationId.toString()); + params.put("startTime",beginTime+CommonConstant.START_SUFFIX_TIMESTAMP); + params.put("endTime",beginTime+CommonConstant.END_SUFFIX_TIMESTAMP); + try { + String json = HttpUtils.getWithHeaders(INCOME_HIS_URL,params,headers); + log.info("INCOME_HIS_URL:" + INCOME_HIS_URL); + log.info("json:" + json); + JSONObject jsonObject = JSONObject.parseObject(json); + Integer code = jsonObject.getInteger("code"); + if(CommonConstant.HttpCode.SUCCESS_CODE.equals(code)){ + return jsonObject.getString("data"); + } + } catch (IOException e) { + throw new RuntimeException(e); + } + return null; + } + /*****************************************业务处理******************************************************/ + + /** + * 寄点能源 - 电站信息融合储能平台处理 + */ + public void addShipEnergyStation(){ + String json = getStations(); + JSONArray jsonStation = JSON.parseArray(json); + jsonStation.forEach(i->{ + JSONObject jsonObj = (JSONObject) i; + Integer stationId = jsonObj.getInteger("stationId"); + String name = jsonObj.getString("name"); + String address = jsonObj.getString("address"); + String province = jsonObj.getString("province"); + String city = jsonObj.getString("city"); + BigDecimal longitude = jsonObj.getBigDecimal("longitude"); + BigDecimal latitude = jsonObj.getBigDecimal("latitude"); + BigDecimal maxPower = jsonObj.getBigDecimal("maxPower"); + BigDecimal capacity = jsonObj.getBigDecimal("capacity"); + Date commossioningTime = jsonObj.getDate("commossioningTime"); + StationReqVO vo = new StationReqVO(); + vo.setId(stationId+10000); + vo.setName(name); + vo.setAddress(address); + vo.setLongitude(longitude); + vo.setLatitude(latitude); + vo.setCapacity(capacity); + vo.setRatePower(maxPower); + vo.setGridTime(commossioningTime); + vo.setGroupId(155); + vo.setDeptId(592); + vo.setStatus(1); + vo.setType(7); + vo.setPId(0); + vo.setIsDailyCount(0); + vo.setTopologyType(1); + vo.setCupboardType(2); + Station station = stationService.selectByName(vo.getName()); + if (station != null) { + throw new BusinessException(BaseResponseCode.STATION_ALREADY_EXISTS); + } + stationService.insertStation(vo); + }); + } + /** + * 寄点能源 - 缓存电站监控信息 + */ + public void getShipEnergyTotal(){ + String stations = getStations(); + JSONArray jsonStation = JSON.parseArray(stations); + jsonStation.forEach(i->{ + JSONObject jsonObj = (JSONObject) i; + Integer stationId = jsonObj.getInteger("stationId"); + String json = getMainTotal(stationId); + Integer finalStationId = stationId +10000; + String mainKey = CommonConstant.SHIP_ENERGY_MAIN + finalStationId; + redisService.set(mainKey,json); + }); + } + + /** + * 寄点能源 - 获取寄点电站历史收益 并存储 + */ + public void getStationIncomeHis(String beginTime){ + DateTime yesterday = DateUtil.yesterday(); + String yesterdayStr = DateUtil.formatDate(yesterday); + if(beginTime==null){ + beginTime = yesterdayStr; + } + String stations = getStations(); + JSONArray jsonStation = JSON.parseArray(stations); + String finalBeginTime = beginTime; + log.info("传入参数-统计时间：{}",beginTime); + jsonStation.forEach(i->{ + JSONObject jsonObj = (JSONObject) i; + Integer stationId = jsonObj.getInteger("stationId"); + String incomeHis = getIncomeHis(stationId, finalBeginTime); + JSONArray incomes = JSON.parseArray(incomeHis); + log.info("远程查询-历史收益数据：{}",incomes); + incomes.forEach(j->{ + JSONObject income = (JSONObject) j; + String date = income.getString("date"); + String price = income.getString("price"); + JsonObject jsonPrice = JsonParser.parseString(price).getAsJsonObject(); + List list = new ArrayList<>(); + List elecList = new ArrayList<>(); + BigDecimal inTotalIncome = BigDecimal.ZERO; + BigDecimal outTotalIncome = BigDecimal.ZERO; + log.info("远程查询-统计日期：{}",date); + if(finalBeginTime.equals(date)){ + //收益-充-尖 + EarningsCalculate inSharp = new EarningsCalculate(); + BigDecimal positiveSharp = income.getBigDecimal("sum_e_positive_sharp"); + inSharp.setElec(positiveSharp); + inSharp.setType(0); + inSharp.setRateType(CommonConstant.RateType.TIP); + BigDecimal inSharpPrice = jsonPrice.get("in_sharp_price").getAsBigDecimal(); + inSharp.setPrice(inSharpPrice); + inSharp.setDigital(positiveSharp.multiply(inSharpPrice)); + inTotalIncome = inTotalIncome.add(inSharp.getDigital()); + inSharp.setTotal(BigDecimal.ZERO); + list.add(inSharp); + //收益-充-峰 + EarningsCalculate inPeak = new EarningsCalculate(); + BigDecimal positivePeak = income.getBigDecimal("sum_e_positive_peak"); + inPeak.setElec(positivePeak); + inPeak.setType(0); + inPeak.setRateType(CommonConstant.RateType.PEAK); + BigDecimal inPeakPrice = jsonPrice.get("in_peak_price").getAsBigDecimal(); + inPeak.setPrice(inPeakPrice); + inPeak.setDigital(positivePeak.multiply(inPeakPrice)); + inTotalIncome = inTotalIncome.add(inPeak.getDigital()); + inPeak.setTotal(BigDecimal.ZERO); + list.add(inPeak); + //收益-充-平 + EarningsCalculate inFlat = new EarningsCalculate(); + BigDecimal positiveFlat = income.getBigDecimal("sum_e_positive_flat"); + inFlat.setElec(positiveFlat); + inFlat.setType(0); + inFlat.setRateType(CommonConstant.RateType.FLAT); + BigDecimal inFlatPrice = jsonPrice.get("in_flat_price").getAsBigDecimal(); + inFlat.setPrice(inFlatPrice); + inFlat.setDigital(positiveFlat.multiply(inFlatPrice)); + inTotalIncome = inTotalIncome.add(inFlat.getDigital()); + inFlat.setTotal(BigDecimal.ZERO); + list.add(inFlat); + //收益-充-谷 + EarningsCalculate inValley = new EarningsCalculate(); + BigDecimal positiveValley = income.getBigDecimal("sum_e_positive_valley"); + inValley.setElec(positiveValley); + inValley.setType(0); + inValley.setRateType(CommonConstant.RateType.VALLEY); + BigDecimal inValleyPrice = jsonPrice.get("in_valley_price").getAsBigDecimal(); + inValley.setPrice(inValleyPrice); + inValley.setDigital(positiveValley.multiply(inValleyPrice)); + inTotalIncome = inTotalIncome.add(inValley.getDigital()); + inValley.setTotal(BigDecimal.ZERO); + list.add(inValley); + //收益-充-深谷 + EarningsCalculate inDeepValley = new EarningsCalculate(); + BigDecimal positiveDeepValley = income.getBigDecimal("sum_e_positive_deep_valley"); + inDeepValley.setElec(positiveDeepValley); + inDeepValley.setType(0); + inDeepValley.setRateType(CommonConstant.RateType.DEEP_VALLEY); + BigDecimal inDeepValleyPrice = jsonPrice.get("in_deep_valley_price").getAsBigDecimal(); + inDeepValley.setPrice(inDeepValleyPrice); + inDeepValley.setDigital(positiveDeepValley.multiply(inDeepValleyPrice)); + inTotalIncome = inTotalIncome.add(inValley.getDigital()); + inDeepValley.setTotal(inTotalIncome); + list.add(inDeepValley); + //收益-放-尖 + EarningsCalculate outSharp = new EarningsCalculate(); + BigDecimal reverseSharp = income.getBigDecimal("sum_e_reverse_sharp"); + outSharp.setElec(reverseSharp); + outSharp.setType(1); + outSharp.setRateType(CommonConstant.RateType.TIP); + BigDecimal outSharpPrice = jsonPrice.get("out_sharp_price").getAsBigDecimal(); + outSharp.setPrice(outSharpPrice); + outSharp.setDigital(reverseSharp.multiply(outSharpPrice)); + outTotalIncome = outTotalIncome.add(outSharp.getDigital()); + outSharp.setTotal(BigDecimal.ZERO); + list.add(outSharp); + //收益-放-峰 + EarningsCalculate outPeak = new EarningsCalculate(); + BigDecimal reversePeak = income.getBigDecimal("sum_e_reverse_peak"); + outPeak.setElec(reversePeak); + outPeak.setType(1); + outPeak.setRateType(CommonConstant.RateType.PEAK); + BigDecimal outPeakPrice = jsonPrice.get("out_peak_price").getAsBigDecimal(); + outPeak.setPrice(outPeakPrice); + outPeak.setDigital(reversePeak.multiply(outPeakPrice)); + outTotalIncome = outTotalIncome.add(outPeak.getDigital()); + outPeak.setTotal(BigDecimal.ZERO); + list.add(outPeak); + //收益-放-平 + EarningsCalculate outFlat = new EarningsCalculate(); + BigDecimal reverseFlat = income.getBigDecimal("sum_e_reverse_flat"); + outFlat.setElec(reverseFlat); + outFlat.setType(1); + outFlat.setRateType(CommonConstant.RateType.FLAT); + BigDecimal outFlatPrice = jsonPrice.get("out_flat_price").getAsBigDecimal(); + outFlat.setPrice(outFlatPrice); + outFlat.setDigital(reverseFlat.multiply(outFlatPrice)); + outTotalIncome = outTotalIncome.add(outFlat.getDigital()); + outFlat.setTotal(BigDecimal.ZERO); + list.add(outFlat); + //收益-放-谷 + EarningsCalculate outValley = new EarningsCalculate(); + BigDecimal reverseValley = income.getBigDecimal("sum_e_reverse_valley"); + outValley.setElec(reverseValley); + outValley.setType(1); + outValley.setRateType(CommonConstant.RateType.VALLEY); + BigDecimal outValleyPrice = jsonPrice.get("out_valley_price").getAsBigDecimal(); + outValley.setPrice(outValleyPrice); + outValley.setDigital(reverseValley.multiply(outValleyPrice)); + outTotalIncome = outTotalIncome.add(outValley.getDigital()); + outValley.setTotal(BigDecimal.ZERO); + list.add(outValley); + //收益-放-深谷 + EarningsCalculate outDeepValley = new EarningsCalculate(); + BigDecimal reverseDeepValley = income.getBigDecimal("sum_e_reverse_deep_valley"); + outDeepValley.setElec(reverseDeepValley); + outDeepValley.setType(1); + outDeepValley.setRateType(CommonConstant.RateType.DEEP_VALLEY); + BigDecimal outDeepValleyPrice = jsonPrice.get("out_deep_valley_price").getAsBigDecimal(); + outDeepValley.setPrice(outDeepValleyPrice); + outDeepValley.setDigital(reverseDeepValley.multiply(outDeepValleyPrice)); + outTotalIncome = outTotalIncome.add(outDeepValley.getDigital()); + outDeepValley.setTotal(outTotalIncome); + list.add(outDeepValley); + // 充电 + ElecMeterValue charge = new ElecMeterValue(); + BigDecimal sumEPositive = income.getBigDecimal("sum_e_positive"); + charge.setDigital(sumEPositive); + charge.setType(DeviceTypeConstant.ELEC_METER_VALUE_TYPE.CHARGE); + charge.setStatus(CommonConstant.STATUS_FLAG); + elecList.add(charge); + // 放电 + ElecMeterValue disCharge = new ElecMeterValue(); + BigDecimal sumEReverse = income.getBigDecimal("sum_e_reverse"); + disCharge.setDigital(sumEReverse); + disCharge.setType(DeviceTypeConstant.ELEC_METER_VALUE_TYPE.DISCHARGE); + disCharge.setStatus(CommonConstant.STATUS_FLAG); + elecList.add(disCharge); + } + if(elecList.size()>0){ + //删除 + elecMeterValueService.deleteByStationAndDay(stationId+10000,date,null); + elecList.forEach(eleMeter -> { + eleMeter.setGroupId(155); + eleMeter.setStationId(stationId+10000); + eleMeter.setCreateTime(new Date()); + eleMeter.setDay(date); + //新增 + elecMeterValueService.insert(eleMeter); + }); + } + if(list.size()>0){ + //删除 + earningsCalculateMapper.deleteByStationAndDay(date,null,stationId+10000); + list.forEach(a->{ + a.setGroupId(155); + a.setStationId(stationId+10000); + a.setCreateTime(new Date()); + a.setDay(date); + a.setDiscount(BigDecimal.ONE); + //新增 + earningsCalculateMapper.insertSelective(a); + }); + } + }); + }); + } +} + diff --git a/business-service-dao/src/main/java/com/ho/business/service/impl/EarningsCalculateServiceImpl.java b/business-service-dao/src/main/java/com/ho/business/service/impl/EarningsCalculateServiceImpl.java index 5568cf2..3fe1139 100644 --- a/business-service-dao/src/main/java/com/ho/business/service/impl/EarningsCalculateServiceImpl.java +++ b/business-service-dao/src/main/java/com/ho/business/service/impl/EarningsCalculateServiceImpl.java @@ -6,6 +6,7 @@ import cn.hutool.core.date.DateUnit; import cn.hutool.core.date.DateUtil; import com.alibaba.excel.util.DateUtils; import com.alibaba.excel.util.StringUtils; +import com.alibaba.fastjson.JSON; import com.ho.business.constant.DeviceTypeConstant; import com.ho.business.entity.*; import com.ho.business.feignclient.UserFeignClient; @@ -24,6 +25,7 @@ import com.ho.business.vo.req.pcsStation.PcsStationReq; import com.ho.business.vo.req.report.ReportReqVO; import com.ho.business.vo.resp.CountEleData; import com.ho.business.vo.resp.DeviceRespVO; +import com.ho.business.vo.resp.ShipStationRespVO; import com.ho.business.vo.resp.cabin.EarningsCalculateCountResp; import com.ho.business.vo.resp.cabin.EarningsCalculateResp; import com.ho.business.vo.resp.colCount.ColCountResp; @@ -1403,6 +1405,16 @@ public class EarningsCalculateServiceImpl implements EarningsCalculateService { revenueOverview.setStationName(station.getName()); revenueOverview.setCapacity(station.getCapacity()); revenueOverview.setOperationDays((int) operationDays); + if(station.getId()==11003 || station.getId()==10942 ||station.getId()==11006){ + // 寄点电站数据 + String mainKey = CommonConstant.SHIP_ENERGY_MAIN + station.getId(); + String json = (String)redisService.get(mainKey); + ShipStationRespVO respVO = JSON.parseObject(json,ShipStationRespVO.class); + revenueOverview.setCharging(respVO.getPositivePowerSum()==null?BigDecimal.ZERO:BigDecimal.valueOf(respVO.getPositivePowerSum())); + revenueOverview.setDischarging(respVO.getReversePowerSum()==null?BigDecimal.ZERO:BigDecimal.valueOf(respVO.getReversePowerSum())); + revenueOverview.setTotalRevenue(respVO.getIncomeSum()==null?BigDecimal.ZERO:BigDecimal.valueOf(respVO.getIncomeSum())); + return revenueOverview; + } List list = getRevenueOverviewData(vo); diff --git a/business-service-dao/src/main/java/com/ho/business/service/impl/IargeScreenShowServiceImpl.java b/business-service-dao/src/main/java/com/ho/business/service/impl/IargeScreenShowServiceImpl.java index 409d3cc..563b960 100644 --- a/business-service-dao/src/main/java/com/ho/business/service/impl/IargeScreenShowServiceImpl.java +++ b/business-service-dao/src/main/java/com/ho/business/service/impl/IargeScreenShowServiceImpl.java @@ -3,6 +3,7 @@ package com.ho.business.service.impl; import cn.hutool.core.date.DateField; import cn.hutool.core.date.DateTime; import cn.hutool.core.date.DateUtil; +import com.alibaba.fastjson.JSON; import com.ho.business.constant.DeviceTypeConstant; import com.ho.business.entity.Device; import com.ho.business.entity.ElecMeterValue; @@ -17,6 +18,7 @@ import com.ho.business.vo.req.colCount.ColCountReq; import com.ho.business.vo.resp.CountEleData; import com.ho.business.vo.resp.DeviceRespVO; import com.ho.business.vo.resp.ProvinceStation; +import com.ho.business.vo.resp.ShipStationRespVO; import com.ho.business.vo.resp.colCount.ColCountResp; import com.ho.business.vo.resp.iargeScreen.*; import com.ho.business.vo.resp.profit.DayProfitType; @@ -294,6 +296,19 @@ public class IargeScreenShowServiceImpl implements IargeScreenShowService { annualOverviewResp.setTotalCharge(incomeShow1.getYearCharge()); annualOverviewResp.setTotalDischarge(incomeShow1.getYearDischarge()); } + // 寄点站点数据融合 + stations.forEach(s->{ + if(s.getId()==11003 || s.getId()==10942 || s.getId()==11006) { + // 寄点电站数据 + String mainKey = CommonConstant.SHIP_ENERGY_MAIN + s.getId(); + String json = (String) redisService.get(mainKey); + ShipStationRespVO respVO = JSON.parseObject(json, ShipStationRespVO.class); + // 日充 + annualOverviewResp.setDayCharge(annualOverviewResp.getDayCharge().add(respVO.getPositivePowerToday()==null?BigDecimal.ZERO:BigDecimal.valueOf(respVO.getPositivePowerToday()))); + // 日放 + annualOverviewResp.setDayDischarge(annualOverviewResp.getDayDischarge().add(respVO.getReversePowerToday()==null?BigDecimal.ZERO:BigDecimal.valueOf(respVO.getReversePowerToday()))); + } + }); return annualOverviewResp; } diff --git a/business-service-dao/src/main/java/com/ho/business/service/impl/OutApiServiceImpl.java b/business-service-dao/src/main/java/com/ho/business/service/impl/OutApiServiceImpl.java index 37270f9..115ae31 100644 --- a/business-service-dao/src/main/java/com/ho/business/service/impl/OutApiServiceImpl.java +++ b/business-service-dao/src/main/java/com/ho/business/service/impl/OutApiServiceImpl.java @@ -197,6 +197,7 @@ public class OutApiServiceImpl implements OutApiService { SysSubDictVO sysSubDictVO = new SysSubDictVO(); sysSubDictVO.setType(CommonConstant.CF_FROZEN); Map cfMap = userFeignClient.getSysSubDict(sysSubDictVO); + stations = stations.stream().filter(i->i.getId()!=11003 && i.getId()!=10942 && i.getId()!=11006).collect(Collectors.toList()); for (Station station : stations) { try { //先删除站的当日数据 diff --git a/business-service-dao/src/main/java/com/ho/business/service/impl/StationHomeServiceImpl.java b/business-service-dao/src/main/java/com/ho/business/service/impl/StationHomeServiceImpl.java index abd5073..e547ede 100644 --- a/business-service-dao/src/main/java/com/ho/business/service/impl/StationHomeServiceImpl.java +++ b/business-service-dao/src/main/java/com/ho/business/service/impl/StationHomeServiceImpl.java @@ -4,6 +4,7 @@ import cn.hutool.core.date.DateField; import cn.hutool.core.date.DateTime; import cn.hutool.core.date.DateUnit; import cn.hutool.core.date.DateUtil; +import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.JSONObject; import com.ho.business.constant.DeviceTypeConstant; import com.ho.business.entity.*; @@ -1042,6 +1043,14 @@ public class StationHomeServiceImpl implements StationHomeService { dailyDischargeElec = new BigDecimal(dailyDischargeElecStr); pcsElecData.setChargeElec(dailyChargeElec); pcsElecData.setDischargeElec(dailyDischargeElec); + if(req.getStationId()==11003 || req.getStationId()==10942 || req.getStationId()==11006){ + // 寄点电站数据 + String mainKey = CommonConstant.SHIP_ENERGY_MAIN + req.getStationId(); + String json = (String)redisService.get(mainKey); + ShipStationRespVO vo = JSON.parseObject(json,ShipStationRespVO.class); + pcsElecData.setChargeElec(vo.getPositivePowerToday()==null?BigDecimal.ZERO:BigDecimal.valueOf(vo.getPositivePowerToday())); + pcsElecData.setDischargeElec(vo.getReversePowerToday()==null?BigDecimal.ZERO:BigDecimal.valueOf(vo.getReversePowerToday())); + } } } } diff --git a/business-service/src/main/java/com/ho/business/controller/BoulderEnergyController.java b/business-service/src/main/java/com/ho/business/controller/BoulderEnergyController.java new file mode 100644 index 0000000..0370030 --- /dev/null +++ b/business-service/src/main/java/com/ho/business/controller/BoulderEnergyController.java @@ -0,0 +1,47 @@ +package com.ho.business.controller; + +import com.ho.business.service.BoulderEnergyService; +import com.ho.common.tools.annotation.TokenIgnore; +import com.ho.common.tools.constant.ContextConstant; +import com.ho.common.tools.exception.DataResult; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.factory.annotation.Autowired; +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; + +@RequestMapping(ContextConstant.BUSINESS + "boulderEnergyStation") +@RestController +@Api(tags = "业务模块-中车能源电站管理") +@Slf4j +public class BoulderEnergyController { + + @Autowired + BoulderEnergyService boulderEnergyService; + + @PostMapping("getToken") + @ApiOperation(value = "获取token") + @TokenIgnore + public DataResult getToken() { + return DataResult.success(boulderEnergyService.getToken()); + } + + @PostMapping("getBoulderEleIncome") + @ApiOperation(value = "中车-统计缓存充放电、及收益数据") + @TokenIgnore + public DataResult getBoulderEleIncome(@RequestBody(required = false) String beginTime) { + log.info("参数: {} ", beginTime); + // beginTime ==null 时统计昨日充放电、及收益数据 + // beginTime ！=null 时统计beginTime充放电、及收益数据 + boulderEnergyService.getBoulderEleIncome(beginTime); + if(beginTime!=null){ + //beginTime ！=null 缓存中车电站累计数据 + boulderEnergyService.getCacheBoulderData(); + } + return DataResult.success(); + } + +} diff --git a/business-service/src/main/java/com/ho/business/controller/OpenStationController.java b/business-service/src/main/java/com/ho/business/controller/OpenStationController.java index d8e600c..e7b7081 100644 --- a/business-service/src/main/java/com/ho/business/controller/OpenStationController.java +++ b/business-service/src/main/java/com/ho/business/controller/OpenStationController.java @@ -1,6 +1,8 @@ package com.ho.business.controller; import com.alibaba.fastjson.JSON; +import com.alibaba.fastjson.JSONArray; +import com.alibaba.fastjson.JSONObject; import com.ho.business.constant.DeviceTypeConstant; import com.ho.business.entity.Station; import com.ho.business.service.*; @@ -10,6 +12,7 @@ import com.ho.business.vo.req.StationReq; import com.ho.business.vo.req.dynamicConfig.DynamicConfigQuery; import com.ho.business.vo.req.pcsStation.PcsStationReq; import com.ho.business.vo.resp.DeviceRespVO; +import com.ho.business.vo.resp.ShipStationRespVO; import com.ho.business.vo.resp.cabin.CircleCtrlResp; import com.ho.business.vo.resp.cabin.EarningsCalculateCountResp; import com.ho.business.vo.resp.openStationHome.OpenStationMiddle; @@ -44,6 +47,8 @@ import javax.servlet.http.HttpServletResponse; import javax.validation.Valid; import java.math.BigDecimal; import java.text.ParseException; +import java.time.ZonedDateTime; +import java.time.format.DateTimeFormatter; import java.util.*; import java.util.stream.Collectors; @@ -106,6 +111,38 @@ public class OpenStationController { public DataResult> realtimeCurve(@RequestBody StationReq stationReq) { log.info("realtimeCurve.stationRealtimeCurve:" + stationReq); List resList = stationHomeService.getRealtimeCurve(stationReq); + // 寄点电站功率、soc曲线 + if(stationReq.getStationId()==11003 || stationReq.getStationId()==10942 || stationReq.getStationId()==11006){ + // 寄点电站数据 + String mainKey = CommonConstant.SHIP_ENERGY_MAIN + stationReq.getStationId(); + String json = (String)redisService.get(mainKey); + ShipStationRespVO vo = JSON.parseObject(json,ShipStationRespVO.class); + JSONArray historyDataList = vo.getHistoryDataList(); + if(historyDataList!=null){ + NewRealTimeCurveVo soc = new NewRealTimeCurveVo(); + soc.setName("SOC"); + List soclist =new ArrayList<>(); + NewRealTimeCurveVo p = new NewRealTimeCurveVo(); + p.setName("实时功率"); + List plist =new ArrayList<>(); + DateTimeFormatter formatter = DateTimeFormatter.ofPattern(CommonConstant.DATE); + historyDataList.forEach(i->{ + JSONObject obj = (JSONObject) i; + StationHomeRespVo socCurve = new StationHomeRespVo(); + socCurve.setDate(ZonedDateTime.parse(obj.getString("record_time")).format(formatter)); + socCurve.setDigital(obj.getBigDecimal("soc")); + soclist.add(socCurve); + StationHomeRespVo pCurve = new StationHomeRespVo(); + pCurve.setDate(ZonedDateTime.parse(obj.getString("record_time")).format(formatter)); + pCurve.setDigital(obj.getBigDecimal("p_total")); + plist.add(pCurve); + }); + soc.setList(soclist); + p.setList(plist); + resList.add(soc); + resList.add(p); + } + } //返回值的BigDecimal类型保留两位小数 for (NewRealTimeCurveVo newRealTimeCurveVo : resList) { List list = newRealTimeCurveVo.getList(); @@ -221,6 +258,21 @@ public class OpenStationController { req.setDeviceType(deviceType); } PcsTotalData data = stationHomeService.getPcsTotalData(req); + if(req.getStationId()==11003 || req.getStationId()==10942 || req.getStationId()==11006){ + // 寄点电站数据 + String mainKey = CommonConstant.SHIP_ENERGY_MAIN + req.getStationId(); + String json = (String)redisService.get(mainKey); + ShipStationRespVO vo = JSON.parseObject(json,ShipStationRespVO.class); + // 数据转换 + data.setTotalChargeElec(vo.getPositivePowerSum()==null?BigDecimal.ZERO:BigDecimal.valueOf(vo.getPositivePowerSum())); + data.setTotalDischargeElec(vo.getReversePowerSum()==null?BigDecimal.ZERO:BigDecimal.valueOf(vo.getReversePowerSum())); + data.setDailyChargeElec(vo.getPositivePowerToday()==null?BigDecimal.ZERO:BigDecimal.valueOf(vo.getPositivePowerToday())); + data.setDailyDischargeElec(vo.getReversePowerToday()==null?BigDecimal.ZERO:BigDecimal.valueOf(vo.getReversePowerToday())); + data.setCurrentPower(vo.getRealTimePower()==null?BigDecimal.ZERO:BigDecimal.valueOf(vo.getRealTimePower())); + if(data.getTotalChargeElec().compareTo(BigDecimal.ZERO)>0){ + data.setSystemEfficiency(data.getTotalDischargeElec().divide(data.getTotalChargeElec(), 4, BigDecimal.ROUND_HALF_UP)); + } + } BigDecimal systemEfficiency = data.getSystemEfficiency(); bigDecimalUtil.keepTwoDecimalPlaces(data); bigDecimalUtil.ifIsNUll(data); diff --git a/business-service/src/main/java/com/ho/business/controller/ShipEnergyController.java b/business-service/src/main/java/com/ho/business/controller/ShipEnergyController.java new file mode 100644 index 0000000..d245d44 --- /dev/null +++ b/business-service/src/main/java/com/ho/business/controller/ShipEnergyController.java @@ -0,0 +1,51 @@ +package com.ho.business.controller; + +import com.ho.business.service.ShipEnergyService; +import com.ho.common.tools.annotation.TokenIgnore; +import com.ho.common.tools.constant.ContextConstant; +import com.ho.common.tools.exception.DataResult; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springframework.beans.factory.annotation.Autowired; +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 java.util.List; + +@RequestMapping(ContextConstant.BUSINESS + "shipEnergyStation") +@RestController +@Api(tags = "业务模块-寄点能源电站管理") +public class ShipEnergyController { + + + @Autowired + ShipEnergyService shipEnergyService; + + + @PostMapping("add") + @ApiOperation(value = "新增电站接口") + @TokenIgnore + public DataResult add() { + shipEnergyService.addShipEnergyStation(); + return DataResult.success(); + } + + @PostMapping("getMainTotal") + @ApiOperation(value = "获取主监控汇总信息") + @TokenIgnore + public DataResult getMainTotal() { + shipEnergyService.getShipEnergyTotal(); + return DataResult.success(); + } + + @PostMapping("getStationIncomeHis") + @ApiOperation(value = "获取寄点电站历史收益") + @TokenIgnore + public DataResult getStationIncomeHis(@RequestBody(required = false) String beginTime) { + shipEnergyService.getStationIncomeHis(beginTime); + return DataResult.success(); + } + +} diff --git a/common-tools/src/main/java/com/ho/common/tools/constant/CommonConstant.java b/common-tools/src/main/java/com/ho/common/tools/constant/CommonConstant.java index eeb8fed..5347fd3 100644 --- a/common-tools/src/main/java/com/ho/common/tools/constant/CommonConstant.java +++ b/common-tools/src/main/java/com/ho/common/tools/constant/CommonConstant.java @@ -996,4 +996,22 @@ public interface CommonConstant { String JOIN_STATION_ID = "\\_"; String EN_US="en_US"; + + interface HttpCode { + // 调用成功code + Integer SUCCESS_CODE = 200; + } + + /** + * 寄点 token 缓存 key + */ + String SHIP_ENERGY_TOKEN_KEY = "ShipEnergyToken"; + /** + * 中车 token 缓存 key + */ + String BOULDER_ENERGY_TOKEN_KEY = "BoulderEnergyToken"; + /** + * 监控数据 + */ + String SHIP_ENERGY_MAIN = "ShipEnergyMain:"; } diff --git a/common-tools/src/main/java/com/ho/common/tools/util/HttpUtils.java b/common-tools/src/main/java/com/ho/common/tools/util/HttpUtils.java new file mode 100644 index 0000000..e4cc47d --- /dev/null +++ b/common-tools/src/main/java/com/ho/common/tools/util/HttpUtils.java @@ -0,0 +1,342 @@ +package com.ho.common.tools.util; + +import java.io.*; +import java.net.HttpURLConnection; +import java.net.URL; +import java.net.URLEncoder; +import java.nio.charset.StandardCharsets; +import java.util.HashMap; +import java.util.Map; +import java.util.StringJoiner; + +/** + * HTTP工具类 - 支持GET/POST请求，支持表单和JSON传参 + */ +public class HttpUtils { + /** + * 连接超时时间（毫秒） + */ + private static final int CONNECT_TIMEOUT = 10000; + + /** + * 读取超时时间（毫秒） + */ + private static final int READ_TIMEOUT = 30000; + + /** + * 发送GET请求（表单参数模式） + * + * @param url 请求URL + * @param params 表单参数 + * @return 响应字符串 + * @throws IOException 网络异常 + */ + public static String getWithForm(String url, Map params) throws IOException { + return get(url, buildFormParams(params), "application/x-www-form-urlencoded"); + } + + /** + * 发送GET请求（JSON参数模式） + * + * @param url 请求URL + * @param jsonParams JSON参数字符串 + * @return 响应字符串 + * @throws IOException 网络异常 + */ + public static String getWithJson(String url, String jsonParams) throws IOException { + // 注意：GET请求通常不支持请求体中的JSON参数 + // 但某些API可能支持，这里将其作为查询参数传递 + Map params = new HashMap<>(); + params.put("json", jsonParams); + return get(url, buildFormParams(params), "application/x-www-form-urlencoded"); + } + + /** + * 发送POST请求（表单参数模式） + * + * @param url 请求URL + * @param params 表单参数 + * @return 响应字符串 + * @throws IOException 网络异常 + */ + public static String postWithForm(String url, Map params) throws IOException { + return post(url, buildFormParams(params), "application/x-www-form-urlencoded"); + } + + /** + * 发送POST请求（JSON参数模式） + * + * @param url 请求URL + * @param jsonParams JSON参数字符串 + * @return 响应字符串 + * @throws IOException 网络异常 + */ + public static String postWithJson(String url, String jsonParams) throws IOException { + return post(url, jsonParams, "application/json; charset=utf-8"); + } + + /** + * 发送POST请求（JSON参数模式，使用Map自动转换为JSON） + * + * @param url 请求URL + * @param params 参数Map + * @return 响应字符串 + * @throws IOException 网络异常 + */ + public static String postWithJson(String url, Map params) throws IOException { + String jsonParams = mapToJson(params); + return postWithJson(url, jsonParams); + } + + /** + * 发送GET请求（基础方法） + */ + private static String get(String url, String queryParams, String contentType) throws IOException { + String fullUrl = url; + if (queryParams != null && !queryParams.isEmpty()) { + fullUrl = url + "?" + queryParams; + } + + HttpURLConnection connection = null; + BufferedReader reader = null; + + try { + URL requestUrl = new URL(fullUrl); + connection = (HttpURLConnection) requestUrl.openConnection(); + connection.setRequestMethod("GET"); + connection.setConnectTimeout(CONNECT_TIMEOUT); + connection.setReadTimeout(READ_TIMEOUT); + connection.setRequestProperty("Content-Type", contentType); + connection.setRequestProperty("User-Agent", "HttpUtils/1.0"); + + int responseCode = connection.getResponseCode(); + if (responseCode == HttpURLConnection.HTTP_OK) { + reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8)); + return readResponse(reader); + } else { + reader = new BufferedReader(new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8)); + String errorResponse = readResponse(reader); + throw new IOException("HTTP GET Request Failed with Error Code: " + responseCode + ", Response: " + errorResponse); + } + } finally { + reader.close(); + connection.disconnect(); + } + } + + /** + * 发送POST请求（基础方法） + */ + private static String post(String url, String requestBody, String contentType) throws IOException { + HttpURLConnection connection = null; + OutputStream outputStream = null; + BufferedReader reader = null; + + try { + URL requestUrl = new URL(url); + connection = (HttpURLConnection) requestUrl.openConnection(); + connection.setRequestMethod("POST"); + connection.setConnectTimeout(CONNECT_TIMEOUT); + connection.setReadTimeout(READ_TIMEOUT); + connection.setDoOutput(true); + connection.setRequestProperty("Content-Type", contentType); + connection.setRequestProperty("User-Agent", "HttpUtils/1.0"); + connection.setRequestProperty("Accept", "application/json, text/plain, */*"); + + // 写入请求体 + if (requestBody != null && !requestBody.isEmpty()) { + outputStream = connection.getOutputStream(); + outputStream.write(requestBody.getBytes(StandardCharsets.UTF_8)); + outputStream.flush(); + } + + int responseCode = connection.getResponseCode(); + if (responseCode == HttpURLConnection.HTTP_OK || + responseCode == HttpURLConnection.HTTP_CREATED || + responseCode == HttpURLConnection.HTTP_ACCEPTED) { + reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8)); + return readResponse(reader); + } else { + reader = new BufferedReader(new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8)); + String errorResponse = readResponse(reader); + throw new IOException("HTTP POST Request Failed with Error Code: " + responseCode + ", Response: " + errorResponse); + } + } finally { + outputStream.close(); + reader.close(); + connection.connect(); + } + } + + /** + * 构建表单参数字符串 + */ + private static String buildFormParams(Map params) throws UnsupportedEncodingException { + if (params == null || params.isEmpty()) { + return ""; + } + + StringJoiner joiner = new StringJoiner("&"); + for (Map.Entry entry : params.entrySet()) { + String encodedKey = URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8.toString()); + String encodedValue = URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8.toString()); + joiner.add(encodedKey + "=" + encodedValue); + } + return joiner.toString(); + } + /** + * 将Map转换为JSON字符串（简单实现，实际项目中建议使用Jackson/Gson等库） + */ + public static String mapToJson(Map params) { + if (params == null || params.isEmpty()) { + return "{}"; + } + + StringBuilder jsonBuilder = new StringBuilder("{"); + boolean first = true; + + for (Map.Entry entry : params.entrySet()) { + if (!first) { + jsonBuilder.append(","); + } + first = false; + + jsonBuilder.append("\"").append(escapeJson(entry.getKey())).append("\":"); + + Object value = entry.getValue(); + if (value == null) { + jsonBuilder.append("null"); + } else if (value instanceof String) { + jsonBuilder.append("\"").append(escapeJson((String) value)).append("\""); + } else if (value instanceof Number || value instanceof Boolean) { + jsonBuilder.append(value); + } else { + // 复杂对象需要序列化，这里简单处理 + jsonBuilder.append("\"").append(escapeJson(value.toString())).append("\""); + } + } + + jsonBuilder.append("}"); + return jsonBuilder.toString(); + } + /** + * 转义JSON特殊字符 + */ + private static String escapeJson(String input) { + if (input == null) { + return ""; + } + + return input.replace("\\", "\\\\") + .replace("\"", "\\\"") + .replace("\b", "\\b") + .replace("\f", "\\f") + .replace("\n", "\\n") + .replace("\r", "\\r") + .replace("\t", "\\t"); + } + /** + * 读取响应内容 + */ + private static String readResponse(BufferedReader reader) throws IOException { + StringBuilder response = new StringBuilder(); + String line; + while ((line = reader.readLine()) != null) { + response.append(line); + } + return response.toString(); + } + + + /** + * 发送带请求头的GET请求（扩展方法） + */ + public static String getWithHeaders(String url, Map params, Map headers) throws IOException { + String fullUrl = url; + if (params != null && !params.isEmpty()) { + fullUrl = url + "?" + buildFormParams(params); + } + + HttpURLConnection connection = null; + BufferedReader reader = null; + + try { + URL requestUrl = new URL(fullUrl); + connection = (HttpURLConnection) requestUrl.openConnection(); + connection.setRequestMethod("GET"); + connection.setConnectTimeout(CONNECT_TIMEOUT); + connection.setReadTimeout(READ_TIMEOUT); + connection.setRequestProperty("User-Agent", "HttpUtils/1.0"); + + // 添加自定义请求头 + if (headers != null) { + for (Map.Entry header : headers.entrySet()) { + connection.setRequestProperty(header.getKey(), header.getValue()); + } + } + + int responseCode = connection.getResponseCode(); + if (responseCode == HttpURLConnection.HTTP_OK) { + reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8)); + return readResponse(reader); + } else { + reader = new BufferedReader(new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8)); + String errorResponse = readResponse(reader); + throw new IOException("HTTP GET Request Failed with Error Code: " + responseCode + ", Response: " + errorResponse); + } + } finally { + reader.close(); + connection.disconnect(); + } + } + + /** + * 发送带请求头的POST请求（扩展方法） + */ + public static String postWithHeaders(String url, String requestBody, String contentType, Map headers) throws IOException { + HttpURLConnection connection = null; + OutputStream outputStream = null; + BufferedReader reader = null; + + try { + URL requestUrl = new URL(url); + connection = (HttpURLConnection) requestUrl.openConnection(); + connection.setRequestMethod("POST"); + connection.setConnectTimeout(CONNECT_TIMEOUT); + connection.setReadTimeout(READ_TIMEOUT); + connection.setDoOutput(true); + connection.setRequestProperty("Content-Type", contentType); + connection.setRequestProperty("User-Agent", "HttpUtils/1.0"); + + // 添加自定义请求头 + if (headers != null) { + for (Map.Entry header : headers.entrySet()) { + connection.setRequestProperty(header.getKey(), header.getValue()); + } + } + + // 写入请求体 + if (requestBody != null && !requestBody.isEmpty()) { + outputStream = connection.getOutputStream(); + outputStream.write(requestBody.getBytes(StandardCharsets.UTF_8)); + outputStream.flush(); + } + + int responseCode = connection.getResponseCode(); + if (responseCode == HttpURLConnection.HTTP_OK || + responseCode == HttpURLConnection.HTTP_CREATED || + responseCode == HttpURLConnection.HTTP_ACCEPTED) { + reader = new BufferedReader(new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8)); + return readResponse(reader); + } else { + reader = new BufferedReader(new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8)); + String errorResponse = readResponse(reader); + throw new IOException("HTTP POST Request Failed with Error Code: " + responseCode + ", Response: " + errorResponse); + } + } finally { + outputStream.close(); + reader.close(); + connection.disconnect(); + } + } +} diff --git a/user-service-api/src/main/java/com/ho/user/api/vo/req/UserUnifiedLoginVo.java b/user-service-api/src/main/java/com/ho/user/api/vo/req/UserUnifiedLoginVo.java new file mode 100644 index 0000000..4ac679e --- /dev/null +++ b/user-service-api/src/main/java/com/ho/user/api/vo/req/UserUnifiedLoginVo.java @@ -0,0 +1,19 @@ +package com.ho.user.api.vo.req; + +import com.ho.common.tools.entity.UserDetailRespVO; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; + +/** + * 用户统一登陆 + */ +@Data +public class UserUnifiedLoginVo { + + @ApiModelProperty(value = "储能登陆") + private UserDetailRespVO energy; + + @ApiModelProperty(value = "光伏登陆") + private UserDetailRespVO pv; + +} diff --git a/user-service/src/main/java/com/ho/user/config/shiro/ShiroConfig.java b/user-service/src/main/java/com/ho/user/config/shiro/ShiroConfig.java index 5de56be..b3a8374 100644 --- a/user-service/src/main/java/com/ho/user/config/shiro/ShiroConfig.java +++ b/user-service/src/main/java/com/ho/user/config/shiro/ShiroConfig.java @@ -73,6 +73,7 @@ public class ShiroConfig { // 配置不会被拦截的链接 顺序判断 filterChainDefinitionMap.put("/sys/user/login", "anon"); filterChainDefinitionMap.put("/sys/user/getToken", "anon"); + filterChainDefinitionMap.put("/sys/user/getUnifiedLogin", "anon"); filterChainDefinitionMap.put("/sys/user/register", "anon"); filterChainDefinitionMap.put("/sys/key/decrypt", "anon"); filterChainDefinitionMap.put("/mongoId", "anon"); diff --git a/user-service/src/main/java/com/ho/user/controller/UserController.java b/user-service/src/main/java/com/ho/user/controller/UserController.java index 0b2f0e1..29f2698 100644 --- a/user-service/src/main/java/com/ho/user/controller/UserController.java +++ b/user-service/src/main/java/com/ho/user/controller/UserController.java @@ -2,6 +2,9 @@ package com.ho.user.controller; import cn.hutool.core.date.DateUtil; import cn.hutool.crypto.digest.BCrypt; +import com.alibaba.fastjson.JSON; +import com.alibaba.fastjson.JSONObject; +import com.fasterxml.jackson.databind.ObjectMapper; import com.ho.common.tools.annotation.HzPermission; import com.ho.common.tools.annotation.LogAnnotation; import com.ho.common.tools.annotation.TokenIgnore; @@ -18,9 +21,11 @@ import com.ho.common.tools.exception.DataResult; import com.ho.common.tools.service.RedisService; import com.ho.common.tools.util.AESEncryptUtil; import com.ho.common.tools.util.FastUtils; +import com.ho.common.tools.util.HttpUtils; import com.ho.user.api.entity.SysDept; import com.ho.user.api.entity.SysUser; import com.ho.user.api.entity.WorkOrderUser; +import com.ho.user.api.vo.req.UserUnifiedLoginVo; import com.ho.user.entity.SysTheme; import com.ho.user.service.*; import com.ho.user.vo.req.*; @@ -543,4 +548,60 @@ public class UserController { return DataResult.success(); } + @PostMapping(value = "getUnifiedLogin") + @ApiOperation(value = "用户统一登录接口") + @TokenIgnore + public DataResult getUnifiedLogin(@RequestBody @Valid LoginReqVO loginReqVO) { + UserUnifiedLoginVo unifiedLoginVo = new UserUnifiedLoginVo(); + ObjectMapper mapper = new ObjectMapper(); + try { + //储能登陆 + String enUrl = "http://localhost:8012/api/sys/user/login"; + String enJson = HttpUtils.postWithJson(enUrl,mapper.writeValueAsString(loginReqVO)); + JSONObject en = JSONObject.parseObject(enJson); + Integer codeEn = en.getInteger("code"); + if(CommonConstant.HttpCode.SUCCESS_CODE.equals(codeEn)){ + String enString = en.getString("data"); + UserDetailRespVO enVo = JSON.parseObject(enString,UserDetailRespVO.class); + unifiedLoginVo.setEnergy(enVo); + } + //光伏登陆 + String pvUrl = "http://localhost:18012/api/sys/user/login"; + String pvJson = HttpUtils.postWithJson(pvUrl,mapper.writeValueAsString(loginReqVO)); + JSONObject pv = JSONObject.parseObject(pvJson); + Integer codePv = pv.getInteger("code"); + if(CommonConstant.HttpCode.SUCCESS_CODE.equals(codePv)){ + String pvString = pv.getString("data"); + UserDetailRespVO pvVo = JSON.parseObject(pvString,UserDetailRespVO.class); + unifiedLoginVo.setPv(pvVo); + } + if(unifiedLoginVo.getEnergy()==null && unifiedLoginVo.getPv()==null){ + if(BaseResponseCode.NOT_ACCOUNT.getCode()==codeEn + &&BaseResponseCode.NOT_ACCOUNT.getCode()==codePv){ + throw new BusinessException(BaseResponseCode.NOT_ACCOUNT); + } + if (BaseResponseCode.PASSWORD_ERROR.getCode()==codeEn + ||BaseResponseCode.PASSWORD_ERROR.getCode()==codePv ){ + throw new BusinessException(BaseResponseCode.PASSWORD_ERROR); + } + if (BaseResponseCode.USER_LOCK.getCode()==codeEn + ||BaseResponseCode.USER_LOCK.getCode()==codePv ){ + throw new BusinessException(BaseResponseCode.USER_LOCK); + } + if (BaseResponseCode.LOSE_EFFICACY.getCode()==codeEn + ||BaseResponseCode.LOSE_EFFICACY.getCode()==codePv ){ + throw new BusinessException(BaseResponseCode.LOSE_EFFICACY); + } + if (BaseResponseCode.TO_BELONGING_DEPT_DISABLE.getCode()==codeEn + ||BaseResponseCode.TO_BELONGING_DEPT_DISABLE.getCode()==codePv ){ + throw new BusinessException(BaseResponseCode.TO_BELONGING_DEPT_DISABLE); + } + } + } catch (IOException e) { + throw new RuntimeException(e); + } + return DataResult.success(unifiedLoginVo); + } + + } diff --git a/xxl-job/src/main/java/com/ho/xxljob/JobHandler.java b/xxl-job/src/main/java/com/ho/xxljob/JobHandler.java index 97e8cde..0c19e1c 100644 --- a/xxl-job/src/main/java/com/ho/xxljob/JobHandler.java +++ b/xxl-job/src/main/java/com/ho/xxljob/JobHandler.java @@ -231,4 +231,55 @@ public class JobHandler { log.info("jobUpdateMessageInfo end !"); return ReturnT.SUCCESS; } + + /** + * 寄点-站点监控数据 + * @param param + * @return + */ + @XxlJob("jobCacheShipEnergyMainInfo") + public ReturnT jobCacheShipEnergyMainInfo(String param){ + log.info("jobCacheShipEnergyMainInfo start !"); + businessFeignClient.jobCacheShipEnergyMainInfo(); + log.info("jobCacheShipEnergyMainInfo end !"); + return ReturnT.SUCCESS; + } + + /** + * 寄点-站点充放电数据 + * @param param + * @return + */ + @XxlJob("jobCacheShipEleIncome") + public ReturnT jobCacheShipEleIncome(String param){ + log.info("jobCacheShipEnergyEle start !"); + businessFeignClient.jobCacheShipEleIncome(param); + log.info("jobCacheShipEnergyEle end !"); + return ReturnT.SUCCESS; + } + /** + * 中车-站点收益、充放电数据 - 昨日 + * @param param + * @return + */ + @XxlJob("jobBoulderEleIncome") + public ReturnT jobBoulderEleIncome(String param){ + log.info("jobCacheShipEnergyEle start !"); + businessFeignClient.jobBoulderEleIncome(param); + log.info("jobCacheShipEnergyEle end !"); + return ReturnT.SUCCESS; + } + + /** + * 中车-站点收益、充放电数据 - 今日 + * @param param + * @return + */ + @XxlJob("jobBoulderEleIncomeToday") + public ReturnT jobBoulderEleIncomeToday(String param){ + log.info("jobCacheShipEnergyEle start !"); + businessFeignClient.jobBoulderEleIncome(DateUtil.formatDate(new Date())); + log.info("jobCacheShipEnergyEle end !"); + return ReturnT.SUCCESS; + } } diff --git a/xxl-job/src/main/java/com/ho/xxljob/feignclient/BusinessFeignClient.java b/xxl-job/src/main/java/com/ho/xxljob/feignclient/BusinessFeignClient.java index aa28c5e..7003ec7 100644 --- a/xxl-job/src/main/java/com/ho/xxljob/feignclient/BusinessFeignClient.java +++ b/xxl-job/src/main/java/com/ho/xxljob/feignclient/BusinessFeignClient.java @@ -67,4 +67,13 @@ public interface BusinessFeignClient { @PostMapping(value = ContextConstant.ROOT_CONTEXT + ContextConstant.BUSINESS + "messageInfo/jobUpdateMessageInfo") void jobUpdateMessageInfo(); + @PostMapping(value = ContextConstant.ROOT_CONTEXT + ContextConstant.BUSINESS + "shipEnergyStation/getMainTotal") + void jobCacheShipEnergyMainInfo(); + + @PostMapping(value = ContextConstant.ROOT_CONTEXT + ContextConstant.BUSINESS + "shipEnergyStation/getStationIncomeHis") + void jobCacheShipEleIncome(@RequestBody String dateTime); + + @PostMapping(value = ContextConstant.ROOT_CONTEXT + ContextConstant.BUSINESS + "boulderEnergyStation/getBoulderEleIncome") + void jobBoulderEleIncome(@RequestBody String dateTime); + } diff --git a/xxl-job/src/main/java/com/ho/xxljob/feignclient/BusinessFeignClientFallback.java b/xxl-job/src/main/java/com/ho/xxljob/feignclient/BusinessFeignClientFallback.java index e567da1..38b7a49 100644 --- a/xxl-job/src/main/java/com/ho/xxljob/feignclient/BusinessFeignClientFallback.java +++ b/xxl-job/src/main/java/com/ho/xxljob/feignclient/BusinessFeignClientFallback.java @@ -99,4 +99,22 @@ public class BusinessFeignClientFallback implements BusinessFeignClient { throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL); } + @Override + public void jobCacheShipEnergyMainInfo() { + log.error("BusinessFeignClient.jobCacheShipEnergyMainInfo error!"); + throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL); + } + + @Override + public void jobCacheShipEleIncome(String dateTime) { + log.error("BusinessFeignClient.jobCacheShipEleIncome error!"); + throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL); + } + + @Override + public void jobBoulderEleIncome(String dateTime) { + log.error("BusinessFeignClient.jobBoulderEleIncome error!"); + throw new BusinessException(BaseResponseCode.FEIGN_CALL_FAIL); + } + }