diff --git a/hzims-service-api/pom.xml b/hzims-service-api/pom.xml index 8fcd395..6fc1e55 100644 --- a/hzims-service-api/pom.xml +++ b/hzims-service-api/pom.xml @@ -32,6 +32,7 @@ dam-safety-api video-image-api water-quality-api + water-rain-api diff --git a/hzims-service-api/water-rain-api/pom.xml b/hzims-service-api/water-rain-api/pom.xml new file mode 100644 index 0000000..a919a96 --- /dev/null +++ b/hzims-service-api/water-rain-api/pom.xml @@ -0,0 +1,20 @@ + + + 4.0.0 + + com.hnac.hzims + hzims-service-api + 4.0.0-SNAPSHOT + + + water-rain-api + + + 8 + 8 + UTF-8 + + + \ No newline at end of file diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/bo/StationResp.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/bo/StationResp.java new file mode 100644 index 0000000..2691c22 --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/bo/StationResp.java @@ -0,0 +1,26 @@ +package com.hnac.hzims.waterrain.bo; + + +import com.hnac.hzims.waterrain.entity.StStbprpB; + +public class StationResp { + private StStbprpB stStbprpB; + + private Object obj; + + public StStbprpB getStStbprpB() { + return stStbprpB; + } + + public void setStStbprpB(StStbprpB stStbprpB) { + this.stStbprpB = stStbprpB; + } + + public Object getObj() { + return obj; + } + + public void setObj(Object obj) { + this.obj = obj; + } +} diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/HzStPptnR.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/HzStPptnR.java new file mode 100644 index 0000000..dda2d53 --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/HzStPptnR.java @@ -0,0 +1,13 @@ +package com.hnac.hzims.waterrain.entity; + +import lombok.Data; + +import java.io.Serializable; +import java.util.Date; + +@Data +public class HzStPptnR implements Serializable { + private String stcd; + private Date tm; + private Double drp; +} diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/HzStRiverR.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/HzStRiverR.java new file mode 100644 index 0000000..d69750a --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/HzStRiverR.java @@ -0,0 +1,14 @@ +package com.hnac.hzims.waterrain.entity; + +import lombok.Data; + +import java.io.Serializable; +import java.util.Date; + +@Data +public class HzStRiverR implements Serializable { + private String stcd; + private Date tm; + private Double z; + private Double q; +} diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/HzStRsvrR.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/HzStRsvrR.java new file mode 100644 index 0000000..feb5928 --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/HzStRsvrR.java @@ -0,0 +1,15 @@ +package com.hnac.hzims.waterrain.entity; + +import lombok.Data; + +import java.io.Serializable; +import java.util.Date; + +@Data +public class HzStRsvrR implements Serializable { + private String stcd;//测站编码 + private Date tm;//时间 + private Double rz; //水位 + private Double inq;//流量 +} + diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/ReorganizeData.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/ReorganizeData.java new file mode 100644 index 0000000..fee68a4 --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/ReorganizeData.java @@ -0,0 +1,14 @@ +package com.hnac.hzims.waterrain.entity; + +import lombok.Data; + +import java.util.List; +import java.util.Map; + +@Data +public class ReorganizeData { + private String yearMonth; + private String stcd; + private String sttp; + private List> data; +} diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/ReorganizeLog.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/ReorganizeLog.java new file mode 100644 index 0000000..355fb4a --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/ReorganizeLog.java @@ -0,0 +1,13 @@ +package com.hnac.hzims.waterrain.entity; + +import lombok.Data; + +import java.io.Serializable; + +@Data +public class ReorganizeLog implements Serializable { + private String stcd; + private String yearMonth; + private String operateUser; + private String checkUser; +} diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/StStbprpB.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/StStbprpB.java new file mode 100644 index 0000000..5c8fb95 --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/entity/StStbprpB.java @@ -0,0 +1,74 @@ +package com.hnac.hzims.waterrain.entity; + +import com.baomidou.mybatisplus.annotation.TableName; +import io.swagger.annotations.ApiModelProperty; +import lombok.Data; +import org.springblade.core.mp.base.BaseEntity; + +/** + * 水雨情测站信息表 + */ +@Data +@TableName("st_stbprp_b") +public class StStbprpB extends BaseEntity { + @ApiModelProperty("机构id") + private String orgId; + @ApiModelProperty("河流id") + private String rvid; + @ApiModelProperty("水系id") + private String hnid; + @ApiModelProperty("流域id") + private String bsid; + @ApiModelProperty("测站编码") + private String stcd; + @ApiModelProperty("测站名称") + private String stnm; + @ApiModelProperty("河流名称") + private String rvnm; + @ApiModelProperty("水系名称") + private String hnnm; + @ApiModelProperty("流域名称") + private String bsnm; + @ApiModelProperty("经度(度分秒)") + private String lgtd; + @ApiModelProperty("纬度(度分秒)") + private String lttd; + @ApiModelProperty("站址") + private String stlc; + @ApiModelProperty("行政区划码") + private String addvcd; + @ApiModelProperty("基面修正基值") + private Double mdbz; + @ApiModelProperty("基面修正参数") + private Double mdpr; + @ApiModelProperty("基面名称") + private String dtmnm; + @ApiModelProperty("基面高程") + private Double dtmel; + @ApiModelProperty("站类") + private String sttp; + @ApiModelProperty("拍报段次") + private Double dfrtms; + @ApiModelProperty("拍报项目") + private String fritm; + @ApiModelProperty("报讯等级") + private String frgrd; + @ApiModelProperty("始报年月") + private String bgfrym; + @ApiModelProperty("截报年月") + private String edfrym; + @ApiModelProperty("管理机构") + private String admauth; + @ApiModelProperty("测站岸别") + private String stbk; + @ApiModelProperty("集水面积") + private Double drna; + @ApiModelProperty("拼音码") + private String phcd; + @ApiModelProperty("数值经度") + private Double nlgtd; + @ApiModelProperty("数值纬度") + private Double nlttd; + @ApiModelProperty("水库编码") + private String rscd; +} diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/enums/HistoryDataCalcTypeEnum.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/enums/HistoryDataCalcTypeEnum.java new file mode 100644 index 0000000..a840f68 --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/enums/HistoryDataCalcTypeEnum.java @@ -0,0 +1,35 @@ +package com.hnac.hzims.waterrain.enums; + +public enum HistoryDataCalcTypeEnum { + ZERO(0,"整点值/最早值"), + ONE(1,"最大值"), + TWO(2,"最小值"), + THREE(3,"平均值"), + FOUR(4,"累计值/和值"), + FIVE(5,"变化值/差值"), + SIX(6,"最新值"); + + Integer strategy; + String desc; + + HistoryDataCalcTypeEnum(Integer strategy, String desc){ + this.strategy = strategy; + this.desc = desc; + } + + public Integer getStrategy() { + return strategy; + } + + public void setStrategy(Integer strategy) { + this.strategy = strategy; + } + + public String getDesc() { + return desc; + } + + public void setDesc(String desc) { + this.desc = desc; + } +} diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/enums/WaterFlowRainEnum.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/enums/WaterFlowRainEnum.java new file mode 100644 index 0000000..9858933 --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/enums/WaterFlowRainEnum.java @@ -0,0 +1,35 @@ +package com.hnac.hzims.waterrain.enums; + +public enum WaterFlowRainEnum { + RR("RR","水库水文站"), + ZZ("ZZ","河道水位站"), + ZQ("ZQ","河道水文站"), + PP("PP","雨量站"), + + LEVEL("level","水位"), + FLOW("flow","流量"), + RAIN("rain","降水"); + private String code; + private String name; + + WaterFlowRainEnum(String code,String name){ + this.code=code; + this.name=name; + } + + public String getCode() { + return code; + } + + public void setCode(String code) { + this.code = code; + } + + public String getName() { + return name; + } + + public void setName(String name) { + this.name = name; + } +} diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/feign/IStStbprpBClient.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/feign/IStStbprpBClient.java new file mode 100644 index 0000000..13c92ea --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/feign/IStStbprpBClient.java @@ -0,0 +1,28 @@ +package com.hnac.hzims.waterrain.feign; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.hnac.hzims.waterrain.entity.StStbprpB; +import org.springframework.cloud.openfeign.FeignClient; +import org.springframework.web.bind.annotation.GetMapping; + +import java.util.List; + +@FeignClient( + value = "water-rain-monitor", + url = "${feign.water-rain-monitor:}" +) +public interface IStStbprpBClient { + String API_PREFIX = "/stStbprpBClient"; + String DETAIL = API_PREFIX + "/detail"; + String LIST = API_PREFIX + "/list"; + + /** + * 获取测站详情 + * @return + */ + @GetMapping(DETAIL) + StStbprpB detail(LambdaQueryWrapper wrapper); + + @GetMapping(LIST) + List list(LambdaQueryWrapper wrapper); +} diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/feign/IStStbprpBDataClient.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/feign/IStStbprpBDataClient.java new file mode 100644 index 0000000..091e381 --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/feign/IStStbprpBDataClient.java @@ -0,0 +1,19 @@ +package com.hnac.hzims.waterrain.feign; + +import org.springframework.cloud.openfeign.FeignClient; +import org.springframework.web.bind.annotation.GetMapping; + +import java.util.Date; +import java.util.Map; + +@FeignClient( + value = "water-rain-monitor", + url = "${feign.water-rain-monitor:}" +) +public interface IStStbprpBDataClient { + String API_PREFIX = "/stStbprpBDataClient"; + String QUERYMAXORMIN = API_PREFIX + "/queryMaxOrMin"; + + @GetMapping(QUERYMAXORMIN) + Map queryMaxOrMin(String deviceCode, Date startTime, Date endTime, Integer calcType,Integer saveTimeType,Integer timeInterval, String col); +} diff --git a/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/vo/StStbprpBVo.java b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/vo/StStbprpBVo.java new file mode 100644 index 0000000..8d1dfb8 --- /dev/null +++ b/hzims-service-api/water-rain-api/src/main/java/com/hnac/hzims/waterrain/vo/StStbprpBVo.java @@ -0,0 +1,9 @@ +package com.hnac.hzims.waterrain.vo; + +import com.hnac.hzims.waterrain.entity.StStbprpB; +import lombok.Data; + +@Data +public class StStbprpBVo extends StStbprpB { + private String sttpName; +} diff --git a/hzims-service/pom.xml b/hzims-service/pom.xml index 53bf722..e69bc7f 100644 --- a/hzims-service/pom.xml +++ b/hzims-service/pom.xml @@ -32,6 +32,7 @@ dam-safety video-image water-quality + water-rain diff --git a/hzims-service/water-rain/pom.xml b/hzims-service/water-rain/pom.xml new file mode 100644 index 0000000..14d3992 --- /dev/null +++ b/hzims-service/water-rain/pom.xml @@ -0,0 +1,77 @@ + + + 4.0.0 + + com.hnac.hzims + hzims-service + 4.0.0-SNAPSHOT + + + water-rain + + + 8 + 8 + UTF-8 + + + + + + + org.springblade + blade-core-boot + + + org.springblade + blade-starter-swagger + + + org.springblade + blade-starter-oss-all + + + com.baomidou + dynamic-datasource-spring-boot-starter + + + org.springblade + blade-core-test + test + + + org.springblade + blade-core-auto + compile + + + + com.hnac.hzims + water-rain-api + ${hzims.project.version} + + + com.alibaba + easyexcel + + + org.springblade + blade-core-boot + + + org.springblade + blade-common + + + com.hnac.hzinfo.data + hzinfo-data-sdk + + + com.hnac.hzims + common-api + + + + \ No newline at end of file diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/WaterRainApplication.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/WaterRainApplication.java new file mode 100644 index 0000000..b8ebc15 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/WaterRainApplication.java @@ -0,0 +1,29 @@ +package com.hnac.hzims.waterrain; + +import org.mybatis.spring.annotation.MapperScan; +import org.springblade.core.cloud.feign.EnableBladeFeign; +import org.springblade.core.launch.BladeApplication; +import org.springframework.boot.builder.SpringApplicationBuilder; +import org.springframework.boot.web.servlet.support.SpringBootServletInitializer; +import org.springframework.cloud.client.SpringCloudApplication; +import org.springframework.context.annotation.ComponentScan; +import org.springframework.scheduling.annotation.EnableScheduling; + +//水雨情模块 +@EnableBladeFeign(basePackages = {"org.springblade","com.hnac"}) +@SpringCloudApplication +@MapperScan("com.hnac.hzims.**.mapper.**") +@EnableScheduling +@ComponentScan(basePackages = {"com.hnac.hzims.*"}) +public class WaterRainApplication extends SpringBootServletInitializer { + public final static String APP_NAME = "water-rain"; + + public static void main(String[] args) { + BladeApplication.run(APP_NAME, WaterRainApplication.class, args); + } + + @Override + protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) { + return BladeApplication.createSpringApplicationBuilder(builder, APP_NAME, WaterRainApplication.class); + } +} \ No newline at end of file diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/ReorganizeLogController.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/ReorganizeLogController.java new file mode 100644 index 0000000..4d152ca --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/ReorganizeLogController.java @@ -0,0 +1,51 @@ +package com.hnac.hzims.waterrain.controller; + +import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiImplicitParam; +import io.swagger.annotations.ApiImplicitParams; +import io.swagger.annotations.ApiOperation; +import lombok.AllArgsConstructor; +import org.springblade.core.secure.utils.AuthUtil; +import org.springblade.core.tool.api.R; +import com.hnac.hzims.waterrain.entity.ReorganizeLog; +import com.hnac.hzims.waterrain.service.IReorganizeLogService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.GetMapping; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +@RestController +@RequestMapping("/waterRain/reorganizeLog") +@AllArgsConstructor +@Api(value = "整编日志", tags = "整编日志接口") +public class ReorganizeLogController { + + @Autowired + IReorganizeLogService reorganizeLogService; + + @GetMapping("/detail") + @ApiImplicitParams({ + @ApiImplicitParam(name = "stcd", value = "测站编码", paramType = "query", dataType = "string"), + @ApiImplicitParam(name = "yearMonth", value = "年月", paramType = "query", dataType = "string") + }) + @ApiOperationSupport(order = 1) + @ApiOperation(value = "详情", notes = "传入stcd+yearMonth") + public R detail(String stcd,String yearMonth) { + ReorganizeLog reorganizeLog = reorganizeLogService.queryReorganizeLog(stcd, yearMonth); + return R.data(reorganizeLog); + } + + + @GetMapping("/check") + @ApiImplicitParams({ + @ApiImplicitParam(name = "stcd", value = "测站编码", paramType = "query", dataType = "string"), + @ApiImplicitParam(name = "yearMonth", value = "年月", paramType = "query", dataType = "string") + }) + @ApiOperationSupport(order = 1) + @ApiOperation(value = "校核", notes = "传入stcd+yearMonth") + public R check(String stcd,String yearMonth) { + boolean flag = reorganizeLogService.check(stcd, yearMonth, AuthUtil.getUserName()); + return R.data(flag,"校核成功"); + } +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/StStbprpBController.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/StStbprpBController.java new file mode 100644 index 0000000..f51536c --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/StStbprpBController.java @@ -0,0 +1,151 @@ +package com.hnac.hzims.waterrain.controller; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.github.xiaoymin.knife4j.annotations.ApiOperationSupport; +import io.swagger.annotations.*; +import lombok.AllArgsConstructor; +import org.springblade.common.cache.CacheNames; +import org.springblade.core.boot.ctrl.BladeController; +import org.springblade.core.mp.support.Condition; +import org.springblade.core.mp.support.Query; +import org.springblade.core.tool.api.R; +import org.springblade.core.tool.utils.Func; +import com.hnac.hzims.waterrain.entity.StStbprpB; +import com.hnac.hzims.waterrain.service.IStStbprpBService; +import com.hnac.hzims.waterrain.util.GisUtil; +import com.hnac.hzims.waterrain.util.ParamUtil; +import com.hnac.hzims.waterrain.vo.StStbprpBVo; +import com.hnac.hzims.waterrain.wrapper.StStbprpBWrapper; +import org.springframework.web.bind.annotation.*; +import springfox.documentation.annotations.ApiIgnore; + +import java.util.List; +import java.util.Map; + +@RestController +@RequestMapping("/waterRain/stStbprpB") +@AllArgsConstructor +@Api(value = "水雨情测站信息表", tags = "水雨情测站信息表接口") +public class StStbprpBController extends BladeController implements CacheNames { + private final IStStbprpBService stStbprpBService; + + + /** + * 分页 + */ + + @GetMapping("/pageList") + @ApiImplicitParams({ + @ApiImplicitParam(name = "stcd", value = "测站编码", paramType = "query", dataType = "string"), + @ApiImplicitParam(name = "stnm", value = "测站名称", paramType = "query", dataType = "string"), + @ApiImplicitParam(name = "rscd", value = "水库编码", paramType = "query", dataType = "string"), + @ApiImplicitParam(name = "sttp", value = "站类", paramType = "query", dataType = "string") + }) + @ApiOperationSupport(order = 1) + @ApiOperation(value = "分页", notes = "传入StStbprpB") + public R> pageList(@ApiIgnore @RequestParam Map param, Query query) { + LambdaQueryWrapper wrapper= ParamUtil.conditionStStbprpB(param); + IPage pages = stStbprpBService.page(Condition.getPage(query), wrapper); + return R.data(StStbprpBWrapper.build().pageVO(pages)); + } + + /** + * 列表 + */ + + @GetMapping("/list") + @ApiImplicitParams({ + @ApiImplicitParam(name = "stcd", value = "测站编码", paramType = "query", dataType = "string"), + @ApiImplicitParam(name = "stnm", value = "测站名称", paramType = "query", dataType = "string"), + @ApiImplicitParam(name = "rscd", value = "水库编码", paramType = "query", dataType = "string"), + @ApiImplicitParam(name = "sttp", value = "站类", paramType = "query", dataType = "string") + }) + @ApiOperationSupport(order = 2) + @ApiOperation(value = "列表", notes = "传入StStbprpB") + public R> list(@ApiIgnore @RequestParam Map param) { + LambdaQueryWrapper wrapper=ParamUtil.conditionStStbprpB(param); + List list = stStbprpBService.list(wrapper); + return R.data(StStbprpBWrapper.build().listVO(list)); + } + + + /** + * 详情 + */ + + @GetMapping("/detail") + @ApiOperationSupport(order = 3) + @ApiOperation(value = "详情", notes = "传入StStbprpB") + public R detail(StStbprpB stStbprpB) { + StStbprpB detail = stStbprpBService.getOne(Condition.getQueryWrapper(stStbprpB)); + return R.data(StStbprpBWrapper.build().entityVO(detail)); + } + + /** + * 新增 + */ + + @PostMapping("/save") + @ApiOperationSupport(order = 4) + @ApiOperation(value = "新增", notes = "传入stStbprpB") + public R save(@RequestBody StStbprpB stStbprpB) { + LambdaQueryWrapper wrapper=new LambdaQueryWrapper(); + wrapper.eq(StStbprpB::getIsDeleted,stStbprpB.getIsDeleted()); + wrapper.eq(StStbprpB::getStcd,stStbprpB.getStcd()); + List list = stStbprpBService.list(wrapper); + if(list!=null && !list.isEmpty()){ + return R.fail("测站编码已存在"); + } + wrapper=new LambdaQueryWrapper(); + wrapper.eq(StStbprpB::getIsDeleted,stStbprpB.getIsDeleted()); + wrapper.eq(StStbprpB::getStnm,stStbprpB.getStnm()); + list = stStbprpBService.list(wrapper); + if(list!=null && !list.isEmpty()){ + return R.fail("测站名称已存在"); + } + //将经纬度转为度分秒 + GisUtil.dealGisData(stStbprpB); + return R.status(stStbprpBService.save(stStbprpB)); + } + + /** + * 修改 + */ + + @PostMapping("/update") + @ApiOperationSupport(order = 5) + @ApiOperation(value = "修改", notes = "传入StStbprpB") + public R update(@RequestBody StStbprpB stStbprpB) { + LambdaQueryWrapper wrapper=new LambdaQueryWrapper(); + wrapper.eq(StStbprpB::getStcd,stStbprpB.getStcd()); + wrapper.eq(StStbprpB::getIsDeleted,stStbprpB.getIsDeleted()); + wrapper.ne(StStbprpB::getId,stStbprpB.getId()); + List list = stStbprpBService.list(wrapper); + if(list!=null && !list.isEmpty()){ + return R.fail("测站编码已存在"); + } + wrapper=new LambdaQueryWrapper(); + wrapper.eq(StStbprpB::getIsDeleted,stStbprpB.getIsDeleted()); + wrapper.eq(StStbprpB::getStnm,stStbprpB.getStnm()); + wrapper.ne(StStbprpB::getId,stStbprpB.getId()); + list = stStbprpBService.list(wrapper); + if(list!=null && !list.isEmpty()){ + return R.fail("测站名称已存在"); + } + //将经纬度转为度分秒 + GisUtil.dealGisData(stStbprpB); + return R.status(stStbprpBService.updateById(stStbprpB)); + } + + /** + * 删除 + */ + @PostMapping("/remove") + @ApiOperationSupport(order = 6) + @ApiOperation(value = "逻辑删除", notes = "ids") + public R remove(@ApiParam(value = "主键集合") @RequestParam String ids) { + boolean temp = stStbprpBService.deleteLogic(Func.toLongList(ids)); + return R.status(temp); + } +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/StStbprpBDataController.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/StStbprpBDataController.java new file mode 100644 index 0000000..9e0abda --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/StStbprpBDataController.java @@ -0,0 +1,163 @@ +package com.hnac.hzims.waterrain.controller; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.hnac.hzims.cache.CaffeineCacheUtil; +import com.hnac.hzims.entity.Report; +import com.hnac.hzims.entity.YearReport; +import com.hnac.hzims.util.CommonUtil; +import com.hnac.hzinfo.datasearch.analyse.domain.FieldsData; +import com.hnac.hzinfo.datasearch.analyse.vo.AnalyzeInstanceFieldVO; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import lombok.AllArgsConstructor; +import org.apache.commons.lang3.StringUtils; +import org.springblade.common.cache.CacheNames; +import org.springblade.core.boot.ctrl.BladeController; +import org.springblade.core.mp.support.Condition; +import org.springblade.core.mp.support.Query; +import org.springblade.core.secure.utils.AuthUtil; +import org.springblade.core.tool.api.R; +import com.hnac.hzims.waterrain.bo.StationResp; +import com.hnac.hzims.waterrain.entity.StStbprpB; +import com.hnac.hzims.waterrain.service.IStStbprpBDataService; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RequestParam; +import org.springframework.web.bind.annotation.RestController; + +import java.util.Arrays; +import java.util.Date; +import java.util.List; +import java.util.Map; + +@RestController +@RequestMapping("/waterRain/stStbprpBData") +@AllArgsConstructor +@Api(value = "水雨情测站数据", tags = "水雨情测站数据接口") +public class StStbprpBDataController extends BladeController implements CacheNames { + private final IStStbprpBDataService stStbprpBDataService; + + //获取实时数据 + @ApiOperation("实时数据") + @RequestMapping(value = "getRealData", method = RequestMethod.GET) + public R getRealData(String stcd) { + List realData = stStbprpBDataService.getRealData(stcd); + return R.data(realData,"查询成功"); + } + + + @ApiOperation("根据测站查询历史数据") + @RequestMapping(value = "getDataByHour", method = RequestMethod.GET) + public R getDataByHour(String stcd,String yearMonth) { + List> yearReport = stStbprpBDataService.getDataByHour(stcd,yearMonth); + return R.data(yearReport,"查询成功"); + } + + + @ApiOperation("表头列") + @RequestMapping(value = "/getTableHead", method = RequestMethod.GET) + public R getTableHead(String stcd) { + //查询基础数据 + List report = stStbprpBDataService.getSignages(stcd); + return R.data(report,"查询成功"); + } + /** + * 获取某站点年度统计报表 + * + * @param stcd 测站点 + * @param year 统计年份 yyyy + * @return + */ + @ApiOperation("年度统计报表") + @RequestMapping(value = "getYearReport", method = RequestMethod.GET) + public R getYearReport(String stcd, Integer year,String sttp,String col) { + String key=stcd+"_"+year+"_"+col; + YearReport report =CaffeineCacheUtil.getYear(key); + if(report!=null){ + return R.data(report,"查询缓存成功"); + } + YearReport yearReport = stStbprpBDataService.getYearReport(stcd, year,sttp, col); + CaffeineCacheUtil.addYear(key,yearReport); + return R.data(yearReport,"查询成功"); + } + + + @ApiOperation("水量年度统计报表") + @RequestMapping(value = "getWaterYearReport", method = RequestMethod.GET) + public R getWaterYearReport(String stcd, Integer year,String sttp) { + YearReport yearReport = stStbprpBDataService.getWaterYearReport(stcd, year,sttp); + return R.data(yearReport,"查询成功"); + } + + + @ApiOperation("水量年度统计报表") + @RequestMapping(value = "getRainYearReport", method = RequestMethod.GET) + public R getRainYearReport(String stcd, Integer year,String sttp,String col) { + YearReport yearReport = stStbprpBDataService.getRainYearReport(stcd, year,sttp,col); + return R.data(yearReport,"查询成功"); + } + + + @ApiOperation("基础数据报表,数据查询和统计分析使用接口") + @RequestMapping(value = "/getReportData", method = RequestMethod.GET) + public R getReportData( + String[] stcds, String beginSpt, String endSpt, String type,String sttp,String col) { + Map res=CommonUtil.getStartEnd(beginSpt,endSpt); + if(res == null){ + return R.data(500,false, "日期格式错误"); + } + String key=stcds.toString()+"_"+beginSpt+"_"+endSpt+"_"+type+"_"+col; + Report report = CaffeineCacheUtil.get(key); + if(report!=null){ + return R.data(report,"查询成功"); + } + //查询基础数据 + report = stStbprpBDataService + .getReportData(Arrays.asList(stcds), res.get("begin"), res.get("end"), type, sttp,col); + CaffeineCacheUtil.add(key,report); + return R.data(report,"查询成功"); + } + + + + @ApiOperation("水量基础数据报表,数据查询和统计分析使用接口") + @RequestMapping(value = "/getWaterReportData", method = RequestMethod.GET) + public R getWaterReportData( + String[] stcds, String beginSpt, String endSpt, String type,String sttp) { + Map res= CommonUtil.getStartEnd(beginSpt,endSpt); + if(res == null){ + return R.data(500,false, "日期格式错误"); + } + //查询基础数据 + Report report = stStbprpBDataService + .getWaterReportData(Arrays.asList(stcds), res.get("begin"), res.get("end"), type, sttp); + return R.data(report,"查询成功"); + } + + + @ApiOperation("app 水雨情接口") + @RequestMapping(value = "page", method = RequestMethod.GET) + public R page(String sttp,String name, Query page) { + LambdaQueryWrapper wrapper=new LambdaQueryWrapper(); + if(StringUtils.isNotBlank(sttp)) { + wrapper.in(StStbprpB::getSttp,sttp.split(",")); + } + if(StringUtils.isNotBlank(name)) { + wrapper.like(StStbprpB::getStnm, name); + } + wrapper.like(StStbprpB::getCreateDept, AuthUtil.getDeptId()); + IPage pageList = stStbprpBDataService.pageData(wrapper, Condition.getPage(page)); + return R.data(pageList,"查询成功"); + } + + + + @ApiOperation("app 获取实时数据") + @RequestMapping(value = "getLastValue", method = RequestMethod.GET) + public R getLastValue(@RequestParam String stcd) { + Object obj = stStbprpBDataService.getLastValue(stcd); + return R.data(obj,"查询成功"); + } + +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/WaterRainReorganizeController.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/WaterRainReorganizeController.java new file mode 100644 index 0000000..1f2c182 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/controller/WaterRainReorganizeController.java @@ -0,0 +1,145 @@ +package com.hnac.hzims.waterrain.controller; + +import com.alibaba.excel.EasyExcel; +import io.swagger.annotations.Api; +import io.swagger.annotations.ApiOperation; +import org.springblade.core.secure.utils.AuthUtil; +import org.springblade.core.tool.api.R; +import com.hnac.hzims.waterrain.entity.ReorganizeData; +import com.hnac.hzims.waterrain.entity.ReorganizeLog; +import com.hnac.hzims.waterrain.listener.UploadWaterFlowRainDataListener; +import com.hnac.hzims.waterrain.service.IReorganizeLogService; +import com.hnac.hzims.waterrain.service.IWaterRainReorganizeService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RequestMethod; +import org.springframework.web.bind.annotation.RestController; +import org.springframework.web.multipart.MultipartFile; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +@RestController +@RequestMapping("/waterRain/reorganize") +@Api(tags = "水雨情数据整编接口") +public class WaterRainReorganizeController { + + @Autowired + IWaterRainReorganizeService reorganizeDataService; + + @Autowired + IReorganizeLogService reorganizeLogService; + + //批量新增 + + @ApiOperation(value = "水雨情数据保存",notes = "水雨情数据保存") + @RequestMapping(value = "/batchInsert", method = RequestMethod.POST) + public R batchInsert(@RequestBody ReorganizeData data) { + //判定是否已整编 + String stcd=data.getStcd(); + String yearMonth=data.getYearMonth(); + String sttp=data.getSttp(); + boolean flag=reorganizeLogService.getReorganizeLog(stcd,yearMonth); + if(flag){ + return R.fail(data.getYearMonth()+"数据已整编"); + } + //删除数据,防止插入主键冲突 + reorganizeDataService.delData(stcd,sttp,yearMonth); + flag=reorganizeDataService.batchInsert(data); + if(flag){ + ReorganizeLog reorganizeLog=new ReorganizeLog(); + reorganizeLog.setStcd(stcd); + reorganizeLog.setYearMonth(yearMonth); + reorganizeLog.setOperateUser(AuthUtil.getUserName()); + reorganizeLogService.insertReorganizeLog(reorganizeLog); + return R.data("数据整编成功"); + }else{ + return R.fail(500,"数据整编失败"); + } + } + + + //批量导入 + /** + * @param file excel文件 + * @param sttp + * @param stcd + * @return + */ + + @ApiOperation(value = "水雨情数据导入",notes = "水雨情数据导入") + @RequestMapping(value = "/uploadWaterFlowRain", method = RequestMethod.POST) + public R uploadReservoir(MultipartFile file, String sttp,String stcd,String yearMonth) { + //判定是否已整编 + boolean flag=reorganizeLogService.getReorganizeLog(stcd,yearMonth); + if(flag){ + return R.data(yearMonth+"数据已整编"); + } + if(file == null){ + return R.fail(500,"未上传文件"); + } + String suffix = file.getOriginalFilename().substring(file.getOriginalFilename().lastIndexOf(".") + 1); + if("xls".equals(suffix) || "xlsx".equals(suffix)){ + try { + //删除数据,防止插入主键冲突 + reorganizeDataService.delData(stcd, sttp, yearMonth); + List errMessage=getMessage(file,sttp,stcd); + if (errMessage.isEmpty()) { + ReorganizeLog reorganizeLog=new ReorganizeLog(); + reorganizeLog.setStcd(stcd); + reorganizeLog.setYearMonth(yearMonth); + reorganizeLog.setOperateUser(AuthUtil.getUserName()); + reorganizeLogService.insertReorganizeLog(reorganizeLog); + return R.data(true,"导入成功"); + } else { + return R.data(500,errMessage,"导入失败,请查看具体详情"); + } + + }catch (IOException e){ + return R.fail(500,"导入失败，文件流获取出错"); + } + }else{ + return R.fail(500,"导入文件格式不对，请按模板文件格式来"); + } + } + + + private List getMessage(MultipartFile file, String sttp,String stcd) throws IOException { + List errMessage=new ArrayList<>(); + + UploadWaterFlowRainDataListener uploadDataListener = new UploadWaterFlowRainDataListener(reorganizeDataService,sttp,stcd,0); + + EasyExcel.read(file.getInputStream(), uploadDataListener).sheet().doReadSync(); + + errMessage.addAll(uploadDataListener.getErrMessage()); + + return errMessage; + } + + + + @ApiOperation(value = "整编后数据查询",notes = "整编后数据查询") + @RequestMapping(value = "/queryData", method = RequestMethod.GET) + public R queryData(String stcd,String sttp,String yearMonth) { + //判定是否已整编 + boolean flag=reorganizeLogService.getReorganizeLog(stcd,yearMonth); + if(!flag){ + return R.data(200,null,"数据未整编，无法查询到数据"); + } + List> list=reorganizeDataService.queryData(stcd,sttp,yearMonth); + return R.data(list,"数据查询成功"); + } + + //重新整编 + @ApiOperation(value = "重新整编",notes = "重新整编") + @RequestMapping(value = "/afresh", method = RequestMethod.GET) + public R afresh(String stcd,String yearMonth) { + //删除整编日志 + reorganizeLogService.delReorganizeLog(stcd, yearMonth); + return R.data(true,"可以重新整编了"); + } + +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/feign/StStbprpBClient.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/feign/StStbprpBClient.java new file mode 100644 index 0000000..c9e67db --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/feign/StStbprpBClient.java @@ -0,0 +1,26 @@ +package com.hnac.hzims.waterrain.feign; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.hnac.hzims.waterrain.entity.StStbprpB; +import com.hnac.hzims.waterrain.service.IStStbprpBService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; + +@RestController +public class StStbprpBClient implements IStStbprpBClient{ + + @Autowired + private IStStbprpBService stStbprpBService; + + @Override + public StStbprpB detail(LambdaQueryWrapper wrapper) { + return stStbprpBService.getOne(wrapper); + } + + @Override + public List list(LambdaQueryWrapper wrapper) { + return stStbprpBService.list(wrapper); + } +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/feign/StStbprpBDataClient.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/feign/StStbprpBDataClient.java new file mode 100644 index 0000000..d205cb3 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/feign/StStbprpBDataClient.java @@ -0,0 +1,20 @@ +package com.hnac.hzims.waterrain.feign; + +import com.hnac.hzims.waterrain.service.IStStbprpBDataService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.RestController; + +import java.util.Date; +import java.util.Map; + +@RestController +public class StStbprpBDataClient implements IStStbprpBDataClient{ + + @Autowired + IStStbprpBDataService stStbprpBDataService; + + @Override + public Map queryMaxOrMin(String deviceCode, Date startTime, Date endTime, Integer calcType, Integer saveTimeType, Integer timeInterval, String col) { + return stStbprpBDataService.queryMaxOrMin(deviceCode,startTime,endTime,calcType,col); + } +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/listener/UploadWaterFlowRainDataListener.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/listener/UploadWaterFlowRainDataListener.java new file mode 100644 index 0000000..8b5d4fd --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/listener/UploadWaterFlowRainDataListener.java @@ -0,0 +1,336 @@ +package com.hnac.hzims.waterrain.listener; + +import com.alibaba.excel.context.AnalysisContext; +import com.alibaba.excel.event.AnalysisEventListener; +import com.hnac.hzims.waterrain.entity.HzStPptnR; +import com.hnac.hzims.waterrain.entity.HzStRiverR; +import com.hnac.hzims.waterrain.entity.HzStRsvrR; +import com.hnac.hzims.waterrain.enums.WaterFlowRainEnum; +import com.hnac.hzims.waterrain.service.IWaterRainReorganizeService; +import org.apache.commons.lang3.StringUtils; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.*; + +public class UploadWaterFlowRainDataListener extends AnalysisEventListener> { + //每00条在invoke中执行一次，剩余的会在doAfterAllAnalysed中执行 + private static final int BATCH_COUNT = 200; + private List errMessage; + //对应的测站类型 + private String sttp; + //对应的测站编码 + private String stcd; + //头部信息 + private List head; + + //数据的起始列数(从0开始算) + private int firstColumn; + + List> list = new ArrayList<>(); + + private IWaterRainReorganizeService waterRainReorganizeService;; + + public UploadWaterFlowRainDataListener(IWaterRainReorganizeService waterRainReorganizeService, String sttp, + String stcd, int firstColumn) { + this.waterRainReorganizeService = waterRainReorganizeService; + this.sttp = sttp; + this.stcd = stcd; + this.firstColumn = firstColumn; + errMessage = new ArrayList<>(); + head = new ArrayList<>(); + } + + + public String getSttp() { + return sttp; + } + + public void setSttp(String sttp) { + this.sttp = sttp; + } + + public List getErrMessage() { + return errMessage; + } + + public void setErrMessage(List errMessage) { + this.errMessage = errMessage; + } + + @Override + public void invokeHeadMap(Map headMap, AnalysisContext context) { + for(int i=0;i map, AnalysisContext analysisContext) { + list.add(map); + // 达到BATCH_COUNT了，需要去存储一次数据库，防止数据几万条数据在内存，容易OOM + if (list.size() >= BATCH_COUNT) { + saveData(); + // 存储完成清理 list + list.clear(); + } + } + + @Override + public void doAfterAllAnalysed(AnalysisContext analysisContext) { + if(!list.isEmpty()) { + saveData(); + } + list.clear(); + head.clear(); + } + + private void saveData() { + //逐条执行 + try { +// dealData(); + //批量执行 + batchDealDataList(); + } catch (ParseException e) { + e.printStackTrace(); + } + + } + + private void dealData() throws ParseException { + Map data=checkData(sttp); + if ("true".equals(data.get("flag"))) { + for (Map map : list) { + //组装批量数据 + saveEntity(map, sttp, stcd); + } + } else { + errMessage.add(data.get("msg")); + } + } + + //批量执行 + private void batchDealDataList() throws ParseException { + List stPptnRList=new ArrayList<>(); + List stRiverRList=new ArrayList<>(); + List stRsvrRList=new ArrayList<>(); + Map data=checkData(sttp); + if ("true".equals(data.get("flag"))) { + for (Map map : list) { + + //组装批量数据 + Map res=getOneObj(map,sttp,stcd); + if(res!=null) { + if(WaterFlowRainEnum.PP.getCode().equals(sttp)) { + Object stPptnR = res.get(WaterFlowRainEnum.PP.getCode()); + stPptnRList.addAll((List) stPptnR); + } + + if(WaterFlowRainEnum.ZZ.getCode().equals(sttp)) { + Object stRiverR = res.get(WaterFlowRainEnum.ZZ.getCode()); + stRiverRList.addAll((List) stRiverR); + stRiverR = res.get(WaterFlowRainEnum.ZQ.getCode()); + stRiverRList.addAll((List) stRiverR); + } + if(WaterFlowRainEnum.ZQ.getCode().equals(sttp)) { + Object stRiverR = res.get(WaterFlowRainEnum.ZQ.getCode()); + stRiverRList.addAll((List) stRiverR); + } + + if(WaterFlowRainEnum.RR.getCode().equals(sttp)) { + Object stRsvrR = res.get(WaterFlowRainEnum.RR.getCode()); + stRsvrRList.addAll((List) stRsvrR); + } + + } + + } + } else { + errMessage.add(data.get("msg")); + } + //批量插入 + if(stPptnRList!=null && !stPptnRList.isEmpty() ) {//雨量站 + waterRainReorganizeService.batchStPptnR(stPptnRList); + } + if(stRiverRList!=null && !stRiverRList.isEmpty()) {//河道水文、水位站 + waterRainReorganizeService.batchStRiverR(stRiverRList); + } + if(stRsvrRList!=null && !stRsvrRList.isEmpty()) {//水库水文站 + waterRainReorganizeService.batchStRsvrR(stRsvrRList); + } + } + + private Map getOneObj(Map map,String sttp,String stcd) throws ParseException { + SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH"); + Map res=new HashMap<>(); + + Date dd=sdf.parse(map.get(0)); + + if(WaterFlowRainEnum.RR.getCode().equals(sttp)){ + HzStRsvrR stRsvrR=new HzStRsvrR(); + stRsvrR.setStcd(stcd); + stRsvrR.setTm(dd); + + String data=map.get(1); + stRsvrR.setRz(Double.valueOf(data)); + + data=map.get(2); + stRsvrR.setInq(Double.valueOf(data)); + + List dataRes=(List)res.get(sttp);; + if(dataRes==null || dataRes.isEmpty()) { + dataRes=new ArrayList<>(); + } + dataRes.add(stRsvrR); + res.put(sttp,dataRes); + } + if(WaterFlowRainEnum.ZZ.getCode().equals(sttp) || WaterFlowRainEnum.ZQ.getCode().equals(sttp)){ + HzStRiverR stRiverR=new HzStRiverR(); + stRiverR.setStcd(stcd); + stRiverR.setTm(dd); + String z=map.get(1); + stRiverR.setZ(Double.valueOf(z)); + String q=map.get(2); + stRiverR.setQ(Double.valueOf(q)); + List dataRes=(List)res.get(sttp); + if(dataRes==null || dataRes.isEmpty()) { + dataRes=new ArrayList<>(); + } + dataRes.add(stRiverR); + res.put(sttp,dataRes); + } + if(WaterFlowRainEnum.PP.getCode().equals(sttp)){ + HzStPptnR stPptnR=new HzStPptnR(); + String drp=map.get(1); + stPptnR.setStcd(stcd); + stPptnR.setTm(dd); + stPptnR.setDrp(Double.valueOf(drp)); + List dataRes=null; + if(res.get(sttp)!=null) { + dataRes=(List)res.get(sttp); + dataRes.add(stPptnR); + }else{ + dataRes=new ArrayList<>(); + } + res.put(sttp,dataRes); + } + + + return res; + } + + private void saveEntity(Map map,String sttp,String stcd) throws ParseException { + SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH"); + + String dateStr=map.get(0); + Date dd=sdf.parse(dateStr); + + if(WaterFlowRainEnum.RR.getCode().equals(sttp)){ + HzStRsvrR stRsvrR=new HzStRsvrR(); + stRsvrR.setStcd(stcd); + stRsvrR.setTm(dd); + String rz=map.get(1); + stRsvrR.setRz(Double.valueOf(rz)); + + String inq=map.get(2); + stRsvrR.setInq(Double.valueOf(inq)); + + waterRainReorganizeService.insertHzStRsvrR(stRsvrR); + } + if(WaterFlowRainEnum.ZZ.getCode().equals(sttp) || WaterFlowRainEnum.ZQ.getCode().equals(sttp)){ + HzStRiverR stRiverR=new HzStRiverR(); + stRiverR.setStcd(stcd); + stRiverR.setTm(dd); + String z=map.get(1); + stRiverR.setZ(Double.valueOf(z)); + String q=map.get(2); + stRiverR.setQ(Double.valueOf(q)); + + waterRainReorganizeService.insertHzStRiverR(stRiverR); + } + if(WaterFlowRainEnum.PP.getCode().equals(sttp)){//降雨 + HzStPptnR stPptnR=new HzStPptnR(); + stPptnR.setStcd(stcd); + stPptnR.setTm(dd); + String drp=map.get(1); + stPptnR.setDrp(Double.valueOf(drp)); + + waterRainReorganizeService.insertHzStPptnR(stPptnR); + } + } + + //校核某一行的数据 + Map checkData(String sttp) { + Map data = new HashMap<>(); + String msg="请检查导入数据中"; + for (Map map : list) { + String dateStr = map.get(0); + + String columnStr = ""; + + if (WaterFlowRainEnum.RR.getCode().equals(sttp)) { + String rz = map.get(1); + String inq = map.get(2); + if (StringUtils.isBlank(rz)) { + columnStr += dateStr + "的水位数据为空"; + if (StringUtils.isBlank(inq)) { + columnStr += ",流量数据为空"; + data.put("msg", msg + "," + columnStr); + data.put("flag", "false"); + return data; + } + data.put("msg", msg + "," + columnStr); + data.put("flag", "false"); + return data; + } else { + if (StringUtils.isBlank(inq)) { + columnStr += dateStr + "的流量数据为空"; + data.put("msg", msg + "," + columnStr); + data.put("flag", "false"); + return data; + } + } + } + if (WaterFlowRainEnum.ZZ.getCode().equals(sttp) || WaterFlowRainEnum.ZQ.getCode().equals(sttp)) { + String z = map.get(1); + String q = map.get(2); + if (StringUtils.isBlank(z)) { + columnStr += dateStr + "的水位数据为空"; + if (StringUtils.isBlank(q)) { + columnStr += ",流量数据为空"; + data.put("msg", msg + "," + columnStr); + data.put("flag", "false"); + return data; + } + data.put("msg", msg + "," + columnStr); + data.put("flag", "false"); + return data; + } else { + if (StringUtils.isBlank(q)) { + columnStr += dateStr + "的流量数据为空;"; + data.put("msg", msg + "," + columnStr); + data.put("flag", "false"); + return data; + } + } + } + if (WaterFlowRainEnum.PP.getCode().equals(sttp)) {//降雨 + String drp = map.get(1); + if (StringUtils.isBlank(drp)) { + columnStr += dateStr + "的降雨量数据为空"; + data.put("msg", msg + "," + columnStr); + data.put("flag", "false"); + return data; + } + } + + if ("".equals(columnStr)) { + data.put("msg", ""); + data.put("flag", "true"); + } + } + return data; + } + + +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/ReorganizeLogMapper.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/ReorganizeLogMapper.java new file mode 100644 index 0000000..b3815f7 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/ReorganizeLogMapper.java @@ -0,0 +1,11 @@ +package com.hnac.hzims.waterrain.mapper; + +import org.apache.ibatis.annotations.Param; +import com.hnac.hzims.waterrain.entity.ReorganizeLog; + +public interface ReorganizeLogMapper { + int insert(ReorganizeLog reorganizeLog); + ReorganizeLog queryReorganizeLog(@Param("stcd") String stcd, @Param("yearMonth") String yearMonth); + int checkOk(ReorganizeLog reorganizeLog); + int delReorganizeLog(@Param("stcd") String stcd, @Param("yearMonth") String yearMonth); +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/ReorganizeLogMapper.xml b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/ReorganizeLogMapper.xml new file mode 100644 index 0000000..6ae1ac1 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/ReorganizeLogMapper.xml @@ -0,0 +1,33 @@ + + + + + + + + + + + insert into reorganize_log(stcd,`year_month`,operate_user,check_user) + values (#{stcd,jdbcType=VARCHAR},#{yearMonth,jdbcType=VARCHAR}, + #{operateUser,jdbcType=VARCHAR},#{checkUser,jdbcType=VARCHAR}) + + + + + + update reorganize_log + set check_user=#{checkUser} + where stcd=#{stcd} and `year_month`=#{yearMonth} + + + + delete + from reorganize_log + where stcd=#{stcd} and `year_month`=#{yearMonth} + + \ No newline at end of file diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/StStbprpBMapper.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/StStbprpBMapper.java new file mode 100644 index 0000000..16d59e8 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/StStbprpBMapper.java @@ -0,0 +1,8 @@ +package com.hnac.hzims.waterrain.mapper; + +import org.springblade.core.datascope.mapper.UserDataScopeBaseMapper; +import com.hnac.hzims.waterrain.entity.StStbprpB; + +public interface StStbprpBMapper extends UserDataScopeBaseMapper { + +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/StStbprpBMapper.xml b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/StStbprpBMapper.xml new file mode 100644 index 0000000..0c090e6 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/StStbprpBMapper.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/WaterRainReorganizeMapper.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/WaterRainReorganizeMapper.java new file mode 100644 index 0000000..5b4592a --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/WaterRainReorganizeMapper.java @@ -0,0 +1,28 @@ +package com.hnac.hzims.waterrain.mapper; + +import org.apache.ibatis.annotations.Param; +import com.hnac.hzims.waterrain.entity.HzStPptnR; +import com.hnac.hzims.waterrain.entity.HzStRiverR; +import com.hnac.hzims.waterrain.entity.HzStRsvrR; + +import java.util.Date; +import java.util.List; +import java.util.Map; + +public interface WaterRainReorganizeMapper { + int batchStPptnR(@Param("list") List list); + int batchStRiverR(@Param("list")List list); + int batchStRsvrR(@Param("list")List list); + + int insertHzStPptnR(HzStPptnR hzStPptnR); + int insertHzStRsvrR(HzStRsvrR hzStRsvrR); + int insertHzStRiverR(HzStRiverR hzStRiverR); + + List> queryStPptnR(@Param("stcd") String stcd, @Param("start") Date start, @Param("end") Date end); + List> queryStRsvrR(@Param("stcd")String stcd,@Param("start") Date start, @Param("end") Date end); + List> queryStRiverR(@Param("stcd")String stcd,@Param("start") Date start, @Param("end") Date end); + + int delStPptnR(@Param("stcd") String stcd, @Param("start") Date start, @Param("end") Date end); + int delStRsvrR(@Param("stcd")String stcd,@Param("start") Date start, @Param("end") Date end); + int delStRiverR(@Param("stcd")String stcd,@Param("start") Date start, @Param("end") Date end); +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/WaterRainReorganizeMapper.xml b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/WaterRainReorganizeMapper.xml new file mode 100644 index 0000000..576bbd8 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/mapper/WaterRainReorganizeMapper.xml @@ -0,0 +1,150 @@ + + + + + + insert into st_pptn_r(STCD,TM,DRP) values + + (#{cus.stcd}, #{cus.tm},#{cus.drp}) + + + + + insert into st_river_r(STCD,TM,Z,Q) + + (#{cus.stcd}, #{cus.tm},#{cus.z},#{cus.q}) + + + + + insert into st_rsvr_r(STCD,TM,RZ,INQ) + + (#{cus.stcd}, #{cus.tm},#{cus.rz},#{cus.inq}) + + + + + insert into st_pptn_r + + + STCD, + + + TM, + + + DRP, + + + + + #{stcd,jdbcType=CHAR}, + + + #{tm,jdbcType=TIMESTAMP}, + + + #{drp,jdbcType=DECIMAL}, + + + + + + + insert into st_river_r + + + STCD, + + + TM, + + + Z, + + + Q, + + + + + #{stcd,jdbcType=CHAR}, + + + #{tm,jdbcType=TIMESTAMP}, + + + #{z,jdbcType=DECIMAL}, + + + #{q,jdbcType=DECIMAL}, + + + + + + insert into st_rsvr_r + + + STCD, + + + TM, + + + RZ, + + + INQ, + + + + + #{stcd,jdbcType=CHAR}, + + + #{tm,jdbcType=TIMESTAMP}, + + + #{rz,jdbcType=DECIMAL}, + + + #{inq,jdbcType=DECIMAL}, + + + + + + + + + + + + delete from st_pptn_r + where stcd=#{stcd} and tm between #{start} and #{end} + + + + delete from st_rsvr_r + where stcd=#{stcd} and tm between #{start} and #{end} + + + + delete from st_river_r + where stcd=#{stcd} and tm between #{start} and #{end} + + + \ No newline at end of file diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IReorganizeLogService.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IReorganizeLogService.java new file mode 100644 index 0000000..a5e5f1e --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IReorganizeLogService.java @@ -0,0 +1,12 @@ +package com.hnac.hzims.waterrain.service; + +import com.hnac.hzims.waterrain.entity.ReorganizeLog; + +public interface IReorganizeLogService { + boolean getReorganizeLog(String stcd,String yearMonth); + ReorganizeLog queryReorganizeLog(String stcd, String yearMonth); + boolean insertReorganizeLog(ReorganizeLog reorganizeLog); + boolean check(String stcd,String yearMonth,String checkUser); + + boolean delReorganizeLog(String stcd,String yearMonth); +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IStStbprpBDataService.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IStStbprpBDataService.java new file mode 100644 index 0000000..944c3da --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IStStbprpBDataService.java @@ -0,0 +1,47 @@ +package com.hnac.hzims.waterrain.service; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.hnac.hzims.entity.Report; +import com.hnac.hzims.entity.YearReport; +import com.hnac.hzims.waterrain.bo.StationResp; +import com.hnac.hzinfo.datasearch.analyse.domain.FieldsData; +import com.hnac.hzinfo.datasearch.analyse.vo.AnalyzeInstanceFieldVO; + + +import java.util.Date; +import java.util.List; +import java.util.Map; + +public interface IStStbprpBDataService { + + //获取计算值(最大 最小 平均等等) + Map queryMaxOrMin(String deviceCode, Date startTime, Date endTime, + Integer calcType, String col); + + //获取最新值以及差值 + List> getLastValues(List stcds,String sttp); + + //过程线 + Report getReportData(List deviceCode, Date begin, Date end, String type , String sttp, String col); + + //水量过程线 + Report getWaterReportData(List deviceCodes, Date begin, Date end, String type, String sttp); + + //年报表 + YearReport getYearReport(String stcd, Integer year, String sttp, String col); + + //水量年报表 + YearReport getWaterYearReport(String deviceCode, Integer year,String sttp); + //将于年报 + YearReport getRainYearReport(String deviceCode, Integer year,String sttp,String col); + + Object getLastValue(String stcd); + + IPage pageData(LambdaQueryWrapper wrapper, IPage page); + + List getRealData(String stcd); + List getSignages(String stcd); + + List> getDataByHour(String stcd,String yearMonth); +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IStStbprpBService.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IStStbprpBService.java new file mode 100644 index 0000000..20abaf3 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IStStbprpBService.java @@ -0,0 +1,8 @@ +package com.hnac.hzims.waterrain.service; + +import org.springblade.core.mp.base.BaseService; +import com.hnac.hzims.waterrain.entity.StStbprpB; + +public interface IStStbprpBService extends BaseService { + +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IWaterRainReorganizeService.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IWaterRainReorganizeService.java new file mode 100644 index 0000000..6d8cff4 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IWaterRainReorganizeService.java @@ -0,0 +1,34 @@ +package com.hnac.hzims.waterrain.service; + + +import com.hnac.hzims.waterrain.entity.HzStPptnR; +import com.hnac.hzims.waterrain.entity.HzStRiverR; +import com.hnac.hzims.waterrain.entity.HzStRsvrR; +import com.hnac.hzims.waterrain.entity.ReorganizeData; + +import java.util.List; +import java.util.Map; + +public interface IWaterRainReorganizeService { + + boolean batchInsert(ReorganizeData data); + + void batchStPptnR(List list); + void batchStRiverR(List list); + void batchStRsvrR(List list); + + int insertHzStPptnR(HzStPptnR hzStPptnR); + int insertHzStRsvrR(HzStRsvrR hzStRsvrR); + int insertHzStRiverR(HzStRiverR hzStRiverR); + + List> queryStPptnR(String stcd,String yearMonth); + List> queryStRsvrR(String stcd,String yearMonth); + List> queryStRiverR(String stcd,String yearMonth); + + boolean delStPptnR(String stcd,String yearMonth); + boolean delStRsvrR(String stcd,String yearMonth); + boolean delStRiverR(String stcd,String yearMonth); + + List> queryData(String stcd,String sttp,String yearMonth); + boolean delData(String stcd,String sttp,String yearMonth); +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IWaterRainService.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IWaterRainService.java new file mode 100644 index 0000000..b1aaef2 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/IWaterRainService.java @@ -0,0 +1,4 @@ +package com.hnac.hzims.waterrain.service; + +public interface IWaterRainService { +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/ReorganizeLogServiceImpl.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/ReorganizeLogServiceImpl.java new file mode 100644 index 0000000..e05a484 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/ReorganizeLogServiceImpl.java @@ -0,0 +1,45 @@ +package com.hnac.hzims.waterrain.service.impl; + +import com.hnac.hzims.waterrain.entity.ReorganizeLog; +import com.hnac.hzims.waterrain.mapper.ReorganizeLogMapper; +import com.hnac.hzims.waterrain.service.IReorganizeLogService; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; + +@Service +public class ReorganizeLogServiceImpl implements IReorganizeLogService { + + @Resource + ReorganizeLogMapper reorganizeLogMapper; + + @Override + public boolean getReorganizeLog(String stcd, String yearMonth) { + ReorganizeLog reorganizeLog=queryReorganizeLog(stcd,yearMonth); + return reorganizeLog!=null; + } + + @Override + public ReorganizeLog queryReorganizeLog(String stcd, String yearMonth) { + return reorganizeLogMapper.queryReorganizeLog(stcd,yearMonth); + } + + @Override + public boolean insertReorganizeLog(ReorganizeLog reorganizeLog) { + return reorganizeLogMapper.insert(reorganizeLog)>0; + } + + @Override + public boolean check(String stcd, String yearMonth, String checkUser) { + ReorganizeLog reorganizeLog=new ReorganizeLog(); + reorganizeLog.setStcd(stcd); + reorganizeLog.setYearMonth(yearMonth); + reorganizeLog.setCheckUser(checkUser); + return reorganizeLogMapper.checkOk(reorganizeLog)>0; + } + + @Override + public boolean delReorganizeLog(String stcd, String yearMonth) { + return reorganizeLogMapper.delReorganizeLog(stcd,yearMonth)>0; + } +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/StStbprpBDataServiceImpl.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/StStbprpBDataServiceImpl.java new file mode 100644 index 0000000..ab4ba1e --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/StStbprpBDataServiceImpl.java @@ -0,0 +1,896 @@ +package com.hnac.hzims.waterrain.service.impl; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.hnac.hzims.entity.*; +import com.hnac.hzims.enums.QueryDateTypeEnum; +import com.hnac.hzims.util.CommonUtil; +import com.hnac.hzims.util.ReportDateUtil; +import com.hnac.hzinfo.datasearch.analyse.domain.FieldsData; +import com.hnac.hzinfo.datasearch.analyse.po.AnalyseCodeByAnalyseDataPO; +import com.hnac.hzinfo.datasearch.analyse.po.AnalyzeDataConditionPO; +import com.hnac.hzinfo.datasearch.analyse.vo.AnalyseDataTaosVO; +import com.hnac.hzinfo.datasearch.analyse.vo.AnalyzeDataConditionVO; +import com.hnac.hzinfo.datasearch.analyse.vo.AnalyzeInstanceFieldVO; +import com.hnac.hzinfo.datasearch.real.po.RealDataSearchPO; +import com.hnac.hzinfo.sdk.analyse.AnalyseDataSearchClient; +import com.hnac.hzinfo.sdk.analyse.po.ComputeBaseStrategyPO; +import com.hnac.hzinfo.sdk.analyse.vo.DeviceSinglePropsValueQuery; +import com.hnac.hzinfo.sdk.analyse.vo.DeviceSinglePropsValueVO; +import com.hnac.hzinfo.sdk.core.response.Result; +import com.hnac.hzinfo.sdk.real.RealDataSearchClient; +import org.apache.commons.lang3.time.DateUtils; +import com.hnac.hzims.waterrain.bo.*; +import com.hnac.hzims.waterrain.entity.StStbprpB; +import com.hnac.hzims.waterrain.service.IStStbprpBDataService; +import com.hnac.hzims.waterrain.service.IStStbprpBService; +import com.hnac.hzims.waterrain.util.DateUtil; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; + +import java.math.BigDecimal; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.time.*; +import java.util.*; + +@Service +public class StStbprpBDataServiceImpl implements IStStbprpBDataService { + + @Autowired + AnalyseDataSearchClient analyseDataSearchClient; + + @Autowired + RealDataSearchClient realDataSearchClient; + + @Autowired + IStStbprpBService stStbprpBService; + + @Override + public Object getLastValue(String stcd) { + LambdaQueryWrapper wrapper=new LambdaQueryWrapper(); + wrapper.eq(StStbprpB::getStcd,stcd); + wrapper.eq(StStbprpB::getIsDeleted,0); + StStbprpB resp = stStbprpBService.getOne(wrapper); + return getLastValue(resp); + } + + private Object getLastValue(StStbprpB resp){ + List stcds=new ArrayList<>(); + stcds.add(resp.getStcd()); + List> dataList = getLastValues(stcds, resp.getSttp()); + if(dataList!=null && !dataList.isEmpty()) { + return dataList.get(0); + }else{ + return null; + } + } + + @Override + public IPage pageData(LambdaQueryWrapper wrapper, IPage page) { + IPage pageList = stStbprpBService.page(page, wrapper); + IPage list = new Page(pageList.getCurrent(),pageList.getSize()); + int count=(int)pageList.getTotal(); + List stcds=new ArrayList<>(); + for (StStbprpB resp : pageList.getRecords()) { + stcds.add(resp.getStcd()); + } + + List records=new ArrayList<>(); + + for (StStbprpB resp : pageList.getRecords()) { + StationResp temp = new StationResp(); + temp.setStStbprpB(resp); + temp.setObj(getLastValue(resp)); + records.add(temp); + } + + list.setPages(pageList.getPages()); + list.setRecords(records); + list.setTotal(count); + + return list; + } + + @Override + public List getRealData(String stcd) { + RealDataSearchPO po=new RealDataSearchPO(); + po.setAnalyzeCode(stcd); + List list=getSignages(stcd); + if(list==null || list.isEmpty()){ + return null; + } + List signages=new ArrayList<>(); + for(AnalyzeInstanceFieldVO vo:list){ + signages.add(vo.getSignage()); + } + po.setSignages(signages); + Result> result=realDataSearchClient.getRealDataByDeviceCode(po); + if(result==null || !result.isSuccess()){ + return null; + } + return result.getData(); + } + + @Override + public List getSignages(String stcd){ + //查询列 + Result> result=analyseDataSearchClient.getInstanceFieldByAnalyseCode(stcd,1,""); + if(result==null || !result.isSuccess()){ + return null; + } + + List analyzeInstanceFieldVOS=result.getData(); + return analyzeInstanceFieldVOS; + } + + @Override + public List> getDataByHour(String stcd,String yearMonth) { + List> list=new ArrayList<>(); + Map dateMap=DateUtil.getStartEnd(yearMonth); + Date begin= dateMap.get("start"); + Date endSt= dateMap.get("end"); + + if(begin==null || endSt==null){ + return null; + } + + LocalDateTime start = LocalDateTime.ofInstant(begin.toInstant(), ZoneId.systemDefault()); + LocalDateTime end = LocalDateTime.ofInstant(endSt.toInstant(), ZoneId.systemDefault()); + + List vos=getSignages(stcd); + if(vos==null || vos.isEmpty()){ + return null; + } + + Map> map=new HashMap<>(); + int count=0; + for(AnalyzeInstanceFieldVO vo:vos) { + List reportDataList = getDataByDeviceCode(stcd, 6,2,start,end, vo.getSignage()); + map.put(vo.getSignage(),reportDataList); + count = reportDataList.size(); + } + + + for (int i = 0; i < count; i++) { + Map res=new HashMap<>(); + for(AnalyzeInstanceFieldVO vo:vos) { + List reportDataList=map.get(vo.getSignage()); + ReportData reportData=reportDataList.get(i); + res.put("tm",reportData.getKeyStr()); + res.put(vo.getSignage(),reportData.getVal()); + } + list.add(res); + } + + return list; + } + + + //获取测站 水量年报表 + @Override + public YearReport getWaterYearReport(String deviceCode, Integer year, String sttp) { + YearReport yearReport=getYearReport(deviceCode, year, sttp,"flow"); + dealYearReport(yearReport); + return yearReport; + } + + void dealRainYearReport(YearReport yearReport){ + if(yearReport!=null){ + List monthList=yearReport.getMonthList(); + dealMonthList(monthList,yearReport.getYear()); + List yearList=yearReport.getYearList(); + dealYearList(yearList,yearReport.getYear()); + } + } + + void dealYearReport(YearReport yearReport){ + if(yearReport!=null){ + List> dayList=yearReport.getDayList(); + dealDayList(dayList); + List monthList=yearReport.getMonthList(); + dealMonthList(monthList,yearReport.getYear()); + List yearList=yearReport.getYearList(); + dealYearList(yearList,yearReport.getYear()); + } + } + + void dealDayList(List> dayList){ + for(List list:dayList){ + if(list!=null && !list.isEmpty()) { + for (int i=0,size=list.size(); i monthList,int year){ + if(monthList!=null && !monthList.isEmpty()) { + for (ReportUnit reportUnit:monthList) { + String key=reportUnit.getKey(); + if(!key.contains("时间")){ + List list=reportUnit.getDataList(); + dealMonthDataList(list,year); + } + } + } + } + + void dealMonthDataList(List list,int year){ + if(list!=null && !list.isEmpty()){ + for (int i=0,size=list.size(); i yearList,int year){ + for(ReportData reportData:yearList){ + String keyStr=reportData.getKeyStr(); + if(!keyStr.contains("时间")){ + String str=reportData.getVal(); + if (!"-".equals(str)) { + reportData.setVal(getNewVal(str, "year", year + "")); + } + } + } + } + + + //获取测站 水量过程线 + @Override + public Report getWaterReportData(List deviceCodes, Date begin, Date end, String type, String sttp) { + Report report=getReportData(deviceCodes, begin, end, type, sttp,"flow"); + dealReportData(report,type); + return report; + } + + void dealReportData(Report report, String dateType){ + if(report!=null) { + List list = report.getData(); + if(list!=null && !list.isEmpty()) { + for (ReportUnit reportUnit : list) { + String key = reportUnit.getKey(); + List dataList = reportUnit.getDataList(); + dealDataList(dataList, dateType, key); + } + } + } + } + + void dealDataList(List dataList,String dateType,String key){ + if(dataList!=null && !dataList.isEmpty()) { + for (int i = 0,size=dataList.size(); i yearReportData = listDataReport(begin, end, QueryDateTypeEnum.DAY,deviceCode,sttp, col); + //年度数据转化到报表里,计算每月数据和年数据 + try { + toYearRainReport(yearReport, yearReportData, col,sttp); + } catch (Exception e) { + return null; + } + //返回数据 + return yearReport; + } + + @Override + public YearReport getYearReport(String deviceCode, Integer year, String sttp, String col) { + //初始化年份 + YearReport yearReport = new YearReport(); + yearReport.init(deviceCode, year); + //拿到一年数据 + Date begin = ReportDateUtil.getDate(year, 0, 1, 8, 0, 0); + Date end = ReportDateUtil.getNextDate(begin, Calendar.YEAR); + List yearReportData = listDataReport(begin, end, QueryDateTypeEnum.DAY,deviceCode,sttp, col); + //年度数据转化到报表里,计算每月数据和年数据 + try { + toYearReport(yearReport, yearReportData, col,sttp); + } catch (Exception e) { + return null; + } + //返回数据 + return yearReport; + } + + + /** + * 年度数据转化到报表里,然後计算每月统计数据和年统计数据 + * + * @param yearReport + * @param yearReportData + * @param col + * @throws ParseException + */ + private void toYearReport(YearReport yearReport, List yearReportData, String col,String sttp) + throws ParseException { + //先把数据转化到设计的二维链表里 + SimpleDateFormat sdf = ReportDateUtil.getSimpleDateFormatByType(QueryDateTypeEnum.DAY); + Calendar calendar = Calendar.getInstance(); + for (ReportData reportData : yearReportData) { + Date tempDay = sdf.parse(reportData.getKeyStr()); + calendar.setTime(tempDay); + int month = calendar.get(Calendar.MONTH); + int day = calendar.get(Calendar.DAY_OF_MONTH); + String value=reportData.getVal(); + + if(value!=null && !"-".equals(value) && !"".equals(value.trim())){ + value = new BigDecimal(value).setScale(3,BigDecimal.ROUND_DOWN).toString(); + } + yearReport.setDayValue(month, day,value); + } + //初始化每月列表 + yearReport.initMonthList(new String[]{ + StandardData.STANDARD_AVG, + StandardData.STANDARD_MAX, + StandardData.STANDARD_MAX_DATE, + StandardData.STANDARD_MIN, + StandardData.STANDARD_MIN_DATE + }); + //计算每月统计数据 + calcMonth(yearReport, col,sttp); + //计算年数据 + calcYear(yearReport, col,sttp); + } + + + private void toYearRainReport(YearReport yearReport, List yearReportData, String col,String sttp) + throws ParseException { + //先把数据转化到设计的二维链表里 + SimpleDateFormat sdf = ReportDateUtil.getSimpleDateFormatByType(QueryDateTypeEnum.DAY); + Calendar calendar = Calendar.getInstance(); + for (ReportData reportData : yearReportData) { + Date tempDay = sdf.parse(reportData.getKeyStr()); + calendar.setTime(tempDay); + int month = calendar.get(Calendar.MONTH); + int day = calendar.get(Calendar.DAY_OF_MONTH); + String value=reportData.getVal(); + + if(value!=null && !"-".equals(value) && !"".equals(value.trim())){ + value = new BigDecimal(value).setScale(3,BigDecimal.ROUND_DOWN).toString(); + } + yearReport.setDayValue(month, day,value); + } + //初始化每月列表 + yearReport.initMonthList(new String[]{ + StandardData.STANDARD_AVG, + StandardData.STANDARD_MAX, + StandardData.STANDARD_MAX_DATE, + StandardData.STANDARD_MIN, + StandardData.STANDARD_MIN_DATE + }); +// //计算每月统计数据 +// calcRainMonth(yearReport); +// //计算年数据 +// calcRainYear(yearReport, col,sttp); + } + +// private void calcRainMonth(YearReport yearReport) { +// StandardData standardData =null; +// String stcd = yearReport.getStcd(); +// List> dayList = yearReport.getDayList(); +// for (int month = 0; month < dayList.size(); month++) { +// if (Objects.isNull(standardData)) { +// standardData = new StandardData(); +// } +// standardData.dealNullData(); +// +// +// if(avgValue!=null && !avgValue.isEmpty()) { +// yearReport.setMonthValue(StandardData.STANDARD_AVG, month, avgValue.get(0).getVal()); +//// yearReport.setMonthValue(StandardData.STANDARD_AVG, month, avgValue.get(stcd)); +// }else{ +// yearReport.setMonthValue(StandardData.STANDARD_AVG, month, "-"); +// } +// +// if(maxValue!=null) { +// yearReport.setMonthValue(StandardData.STANDARD_MAX, month, maxValue.get(stcd)); +// yearReport.setMonthValue(StandardData.STANDARD_MAX_DATE, month, maxValue.get("tm")); +// }else{ +// yearReport.setMonthValue(StandardData.STANDARD_MAX, month, "-"); +// yearReport.setMonthValue(StandardData.STANDARD_MAX_DATE, month, "-"); +// } +// +// if(minValue!=null) { +// yearReport.setMonthValue(StandardData.STANDARD_MIN, month, minValue.get(stcd)); +// yearReport.setMonthValue(StandardData.STANDARD_MIN_DATE, month, minValue.get("tm")); +// }else{ +// yearReport.setMonthValue(StandardData.STANDARD_MIN, month, "-"); +// yearReport.setMonthValue(StandardData.STANDARD_MIN_DATE, month, "-"); +// } +// +// } +// } + + private void calcMonth(YearReport yearReport, String col,String sttp) { + //SimpleDateFormat sdf = ReportDateUtil.getSimpleDateFormatByType(QueryDateTypeEnum.DAY); + //获取日报表数据 + StandardData standardData =null; + String stcd = yearReport.getStcd(); + List> dayList = yearReport.getDayList(); + for (int month = 0; month < dayList.size(); month++) { + Date begin = ReportDateUtil.getDate(yearReport.getYear(), month, 1, 8, 0, 0); + Date end = ReportDateUtil.getNextDate(begin, Calendar.MONTH); + //拿到一个月的统计数据 + Map maxValue= queryMaxOrMin(stcd, begin, end,1,col); + Map minValue= queryMaxOrMin(stcd, begin, end,2,col); +// Map avgValue= queryMaxOrMin(stcd, begin, end,3,col); + List avgValue= listDataReport( begin, end,QueryDateTypeEnum.MONTH,stcd,sttp,col); + + if (Objects.isNull(standardData)) { + standardData = new StandardData(); + } + standardData.dealNullData(); + if(avgValue!=null && !avgValue.isEmpty()) { + yearReport.setMonthValue(StandardData.STANDARD_AVG, month, avgValue.get(0).getVal()); +// yearReport.setMonthValue(StandardData.STANDARD_AVG, month, avgValue.get(stcd)); + }else{ + yearReport.setMonthValue(StandardData.STANDARD_AVG, month, "-"); + } + + if(maxValue!=null && maxValue.get(stcd)!=null) { + yearReport.setMonthValue(StandardData.STANDARD_MAX, month, maxValue.get(stcd)); + yearReport.setMonthValue(StandardData.STANDARD_MAX_DATE, month, maxValue.get("tm")); + }else{ + yearReport.setMonthValue(StandardData.STANDARD_MAX, month, "-"); + yearReport.setMonthValue(StandardData.STANDARD_MAX_DATE, month, "-"); + } + + if(minValue!=null && minValue.get(stcd)!=null) { + yearReport.setMonthValue(StandardData.STANDARD_MIN, month, minValue.get(stcd)); + yearReport.setMonthValue(StandardData.STANDARD_MIN_DATE, month, minValue.get("tm")); + }else{ + yearReport.setMonthValue(StandardData.STANDARD_MIN, month, "-"); + yearReport.setMonthValue(StandardData.STANDARD_MIN_DATE, month, "-"); + } + } + } + + private void calcYear(YearReport yearReport, String col,String sttp) { + StandardData standardData =null; + String stcd = yearReport.getStcd(); + Date begin = ReportDateUtil.getDate(yearReport.getYear(), 0, 1, 8, 0, 0); + Date end = ReportDateUtil.getNextDate(begin, Calendar.YEAR); + Map maxValue= queryMaxOrMin(stcd, begin, end,1, col); + Map minValue= queryMaxOrMin(stcd, begin, end,2, col); +// Map avgValue= queryMaxOrMin(stcd, begin, end,3, col); + List avgValue= listDataReport( begin, end,QueryDateTypeEnum.YEAR,stcd,sttp,col); + if (Objects.isNull(standardData)) { + standardData = new StandardData(); + } + standardData.dealNullData(); + List yearList = new ArrayList<>(); + if(avgValue!=null && !avgValue.isEmpty()){ + yearList.add(new ReportData(StandardData.STANDARD_AVG, avgValue.get(0).getVal())); +// yearList.add(new ReportData(StandardData.STANDARD_AVG, avgValue.get(stcd))); + }else{ + yearList.add(new ReportData(StandardData.STANDARD_AVG, "-")); + } + + if(maxValue!=null && maxValue.get(stcd)!=null) { + yearList.add(new ReportData(StandardData.STANDARD_MAX, maxValue.get(stcd))); + yearList.add(new ReportData(StandardData.STANDARD_MAX_DATE, maxValue.get("tm"))); + }else{ + yearList.add(new ReportData(StandardData.STANDARD_MAX, "-")); + yearList.add(new ReportData(StandardData.STANDARD_MAX_DATE, "-")); + } + + if(minValue!=null && minValue.get(stcd)!=null) { + yearList.add(new ReportData(StandardData.STANDARD_MIN, minValue.get(stcd))); + yearList.add(new ReportData(StandardData.STANDARD_MIN_DATE, minValue.get("tm"))); + }else{ + yearList.add(new ReportData(StandardData.STANDARD_MIN, "-")); + yearList.add(new ReportData(StandardData.STANDARD_MIN_DATE, "-")); + } + + yearReport.setYearList(yearList); + } + + + //获取测站过程线 + @Override + public Report getReportData(List deviceCodes, Date begin, Date end, String type,String sttp,String col) { + //检查数据是否正常并转化 + final QueryDateTypeEnum dtEnum = CommonUtil.checkType(type); + if(deviceCodes==null || deviceCodes.size()<=0){ + return null; + } + + if(dtEnum ==null){ + return null; + } + + //初始化报表 + Report report = new Report(); + report.initBaseReport(deviceCodes.size(), begin, end, dtEnum); + //设置基础数据 + for (int i = 0; i < deviceCodes.size(); i++) { + String deviceCode = deviceCodes.get(i); + //获取数据库某个站点不同时间要求的数据 + List timeDataList = listDataReport(begin, end,dtEnum,deviceCode,sttp,col); + + for (ReportData reportData : timeDataList) { + String value=reportData.getVal(); +// if(value!=null && !"-".equals(value) && !"".equals(value.trim())){ +// value = new BigDecimal(value).setScale(3,BigDecimal.ROUND_DOWN).toString(); +// } + report.setBaseCell(reportData.getKeyStr(), i, value); + } + } + return report; + } + + private List listDataReport(Date begin,Date endSt,QueryDateTypeEnum dtEnum,String deviceCode,String sttp,String col) { + List list=new ArrayList<>(); + + //周期类型: 0-> s(秒) 1->、m(分)、2->h(小时)3->、d(天)4->、w(周)5->、n(自然月)、6->y(自然年) + Integer saveTimeType=2; + if(QueryDateTypeEnum.DAY.equals(dtEnum)){ + saveTimeType = 3; + } + if(QueryDateTypeEnum.MONTH.equals(dtEnum)){ + saveTimeType = 5; + } + if(QueryDateTypeEnum.YEAR.equals(dtEnum)){ + saveTimeType = 6; + } + + LocalDateTime start = LocalDateTime.ofInstant(begin.toInstant(), ZoneId.systemDefault()); + LocalDateTime end = LocalDateTime.ofInstant(endSt.toInstant(), ZoneId.systemDefault()); + + if(sttp.contains("RR") || sttp.contains("ZZ") || sttp.contains("ZQ")){ + return getDataByDeviceCode(deviceCode, 3, saveTimeType, start, end, col); + } + if("PP".equals(sttp)){ + return getDataByDeviceCode(deviceCode, 4, saveTimeType, start, end, col); + } + return list; + } + + List getDataByDeviceCode(String deviceCode,Integer accessRules,Integer saveTimeType, + LocalDateTime start,LocalDateTime end,String col){ + List reportData=new ArrayList<>(); + AnalyseCodeByAnalyseDataPO po=new AnalyseCodeByAnalyseDataPO(); + po.setDeviceCode(deviceCode); + + List signboardConditions=new ArrayList<>(); + AnalyzeDataConditionPO conditionPO=new AnalyzeDataConditionPO(); + conditionPO.setBeginTime(start); + conditionPO.setEndTime(end); + conditionPO.setSignages(col); +// conditionPO.setKeepFigures(3); + conditionPO.setAccessRules(accessRules); + conditionPO.setSaveTimeType(saveTimeType); + conditionPO.setTimeInterval(1); + conditionPO.setFull(1); + signboardConditions.add(conditionPO); + po.setSignboardConditions(signboardConditions); + + Result> result=analyseDataSearchClient.getAnalyzeDataByAnalyzeCodeAndSignages(po); + if(result==null || !result.isSuccess()){ + return reportData; + } + List datas=result.getData(); + if(datas==null || datas.isEmpty()){ + return reportData; + } + for(AnalyzeDataConditionVO vo:datas){ + List dataTaosVOs=vo.getList(); + for(AnalyseDataTaosVO vv:dataTaosVOs) { + if(vo.getSignage().equals(col)) { + ReportData data=new ReportData(); + data.setKeyStr(CommonUtil.getKeyBySaveTimeType(vv.getTs(),saveTimeType)); + String val=vv.getVal(); + data.setStcd(deviceCode); + data.setVal(val); + if(val!=null && !"".equals(val)) { + data.setValue(Double.valueOf(vv.getVal())); + }else{ + data.setValue(0.0); + } + data.setName(vo.getName()); + reportData.add(data); + } + } + } + return reportData; + } + + + + //获取测站最新值 + @Override + public List> getLastValues(List stcds,String sttp) { + List> result=new ArrayList<>(); + + List oldRzList=null; + List oldInqList=null; + List oldDrpList=null; + + List rzList=null; + List inqList=null; + List drpList=null; + + Date endTime =new Date(); + Date beginTime= DateUtils.addMinutes(endTime,-60); + Date beginTime1= DateUtils.addMinutes(beginTime,-60); + //获取一个最新值 + if("RR".equals(sttp) || "ZQ".equals(sttp)){ + rzList = getNewValue(stcds, "water_level", beginTime, endTime); + inqList = getNewValue(stcds, "flow", beginTime, endTime); + + oldRzList = getNewValue(stcds, "water_level", beginTime1, beginTime); + oldInqList = getNewValue(stcds, "flow", beginTime1, beginTime); + } + + if("PP".equals(sttp)) { + drpList = getNewValue(stcds, "rain", beginTime, endTime); + oldDrpList = getNewValue(stcds, "rain", beginTime1, beginTime); + } + + if("ZZ".equals(sttp)){ + rzList = getNewValue(stcds, "water_level", beginTime, endTime); +// inqList = getNewValue(stcds, "inq", beginTime, endTime); + + oldRzList = getNewValue(stcds, "water_level", beginTime1, beginTime); +// oldInqList = getNewValue(stcds, "inq", beginTime1, beginTime); + } + + for(String stcd:stcds) { + Map map=new HashMap<>(); + + + map.put("stcd",stcd); + if("RR".equals(sttp) || "ZQ".equals(sttp)){ + boolean inqFlag = true; + boolean rzFlag = true; + BigDecimal rz=getDataByStcd(stcd,rzList); + map.put("rz",rz); + BigDecimal inq=getDataByStcd(stcd,inqList); + map.put("inq",inq); + + + BigDecimal oldRz=getDataByStcd(stcd,oldRzList); + if (oldRz.compareTo(rz) > 0) { + rzFlag = false; + } + map.put("isRiseRz",rzFlag); + + BigDecimal oldInq=getDataByStcd(stcd,oldInqList); + if (oldInq.compareTo(inq) > 0) { + inqFlag = false; + } + map.put("isRiseInq",inqFlag); + } + if("PP".equals(sttp)){ + boolean inqDrp = true; + BigDecimal drp=getDataByStcd(stcd,drpList); + map.put("drp",drp); + + BigDecimal oldDrp=getDataByStcd(stcd,oldDrpList); + if (oldDrp.compareTo(drp) > 0) { + inqDrp = false; + } + map.put("isRiseDrp",inqDrp); + } + + if("ZZ".equals(sttp)){ + boolean rzFlag = true; + BigDecimal rz=getDataByStcd(stcd,rzList); + map.put("rz",rz); + + BigDecimal oldRz=getDataByStcd(stcd,oldRzList); + if (oldRz.compareTo(rz) > 0) { + rzFlag = false; + } + map.put("isRiseRz",rzFlag); + } + + result.add(map); + } + + return result; + } + + private BigDecimal getDataByStcd(String stcd,List data){ + if(data==null || data.isEmpty()){ + return BigDecimal.ZERO; + } + for(DeviceSinglePropsValueVO vo:data){ + if(stcd.equals(vo.getDeviceCode())){ + String value=String.valueOf(vo.getValue()); + if(vo.getValue()!=null && !"".equals(value)) { + return new BigDecimal(value); + }else{ + return BigDecimal.ZERO; + } + } + } + return BigDecimal.ZERO; + } + + List getNewValue(List stcds,String col,Date beginTime,Date endTime){ + //获取一个最新值 + DeviceSinglePropsValueQuery query = new DeviceSinglePropsValueQuery(); + query.setAccessRule("6"); + query.setDeviceCodes(stcds); + query.setSignage(col); + query.setBeginTime(beginTime); + query.setEndTime(endTime); + Result> res=analyseDataSearchClient.getValueOfBacthDeviceCode(query); + if(res==null || !res.isSuccess()){ + return null; + } + List list=res.getData(); + return list; + } + + /** + * 获取 对应(计算)值的遥测值 + * @param deviceCode 设备编码 + * @param startTime 开始时间 + * @param endTime 结束时间 + * @param calcType 0=最早值、1=最大值、2=最小值、3=平均值、4=（累计值/和值)、5=（变化值/差值） 6=最新值 +// * @param saveTimeType 0-> s(秒) 1->、m(分)、2->h(小时)3->、d(天)4->、w(周)5->、n(自然月)、6->y(自然年) + * @param col 对应的物理值 英文 + * @return + */ + @Override + public Map queryMaxOrMin(String deviceCode, Date startTime, Date endTime, + Integer calcType, String col) { + Map res=new HashMap<>(); + + List signages=new ArrayList<>(); + signages.add(col); + ComputeBaseStrategyPO po=new ComputeBaseStrategyPO(); + LocalDateTime start = LocalDateTime.ofInstant(startTime.toInstant(), ZoneId.systemDefault()); + po.setBeginTime(start); + LocalDateTime end = LocalDateTime.ofInstant(endTime.toInstant(), ZoneId.systemDefault()); + po.setEndTime(end); + po.setAccessRules(calcType); + po.setDeviceCode(deviceCode); + po.setSignages(signages); + Result> result=analyseDataSearchClient.getComputeBaseStrategy(po); + if(result==null || !result.isSuccess()){ + return res; + } + List datas=result.getData(); + + if(datas!=null && !datas.isEmpty()){ + for(AnalyseDataTaosVO vo:datas) { +// if(col.equals(vo.getSignage())) { + String value=vo.getVal(); + String tm=vo.getTs(); + res.put(deviceCode, value); + res.put("tm", tm); + +// } + } + } + + return res; + } + + private AnalyseCodeByAnalyseDataPO getAnalyseCodeByAnalyseDataPO(String deviceCode,Date startTime,Date endTime,Integer calcType, + Integer saveTimeType,Integer timeInterval,String col){ + AnalyseCodeByAnalyseDataPO analyzeDataCondition=new AnalyseCodeByAnalyseDataPO(); + analyzeDataCondition.setDeviceCode(deviceCode); + + List signboardConditions=new ArrayList<>(); + AnalyzeDataConditionPO conditionPO=new AnalyzeDataConditionPO(); + LocalDateTime start = LocalDateTime.ofInstant(startTime.toInstant(), ZoneId.systemDefault()); + conditionPO.setBeginTime(start); + LocalDateTime end = LocalDateTime.ofInstant(endTime.toInstant(), ZoneId.systemDefault()); + conditionPO.setEndTime(end); + conditionPO.setAccessRules(calcType); + if(timeInterval == null) { + timeInterval = calcTimeInterval(saveTimeType, start, end); + //加1的目的 就是对小数位进行统一处理 + conditionPO.setTimeInterval(timeInterval + 1); + }else{ + conditionPO.setTimeInterval(timeInterval); + } + conditionPO.setSaveTimeType(saveTimeType); + conditionPO.setFull(1); + conditionPO.setSignages(col); + +// conditionPO.setKeepFigures(3); + + signboardConditions.add(conditionPO); + analyzeDataCondition.setSignboardConditions(signboardConditions); + return analyzeDataCondition; + } + + //计算时间间隔 + private static Integer calcTimeInterval(Integer saveTimeType,LocalDateTime start,LocalDateTime end){ + Duration duration = Duration.between(start,end); + switch (saveTimeType) { + case 1://分 + return (int)duration.toMinutes(); + case 2://时 + return (int)duration.toHours(); + case 3://天 + return (int)duration.toDays(); + case 4://周 + return (int)duration.toDays()/7; + case 5://月 + LocalDate startDate = start.toLocalDate(); + LocalDate endDate = end.toLocalDate(); + return Period.between(startDate, endDate).getMonths(); + case 6://年 + startDate = start.toLocalDate(); + endDate = end.toLocalDate(); + return Period.between(startDate, endDate).getYears(); + default: + return (int)duration.getSeconds(); + } + } + +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/StStbprpBServiceImpl.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/StStbprpBServiceImpl.java new file mode 100644 index 0000000..be2a74c --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/StStbprpBServiceImpl.java @@ -0,0 +1,11 @@ +package com.hnac.hzims.waterrain.service.impl; + +import org.springblade.core.mp.base.BaseServiceImpl; +import com.hnac.hzims.waterrain.entity.StStbprpB; +import com.hnac.hzims.waterrain.mapper.StStbprpBMapper; +import com.hnac.hzims.waterrain.service.IStStbprpBService; +import org.springframework.stereotype.Service; + +@Service +public class StStbprpBServiceImpl extends BaseServiceImpl implements IStStbprpBService { +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/WaterRainReorganizeServiceImpl.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/WaterRainReorganizeServiceImpl.java new file mode 100644 index 0000000..b610bc2 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/WaterRainReorganizeServiceImpl.java @@ -0,0 +1,235 @@ +package com.hnac.hzims.waterrain.service.impl; + +import com.hnac.hzims.waterrain.entity.HzStPptnR; +import com.hnac.hzims.waterrain.entity.HzStRiverR; +import com.hnac.hzims.waterrain.entity.HzStRsvrR; +import com.hnac.hzims.waterrain.entity.ReorganizeData; +import com.hnac.hzims.waterrain.enums.WaterFlowRainEnum; +import com.hnac.hzims.waterrain.mapper.WaterRainReorganizeMapper; +import com.hnac.hzims.waterrain.service.IWaterRainReorganizeService; +import com.hnac.hzims.waterrain.util.DateUtil; +import org.springframework.stereotype.Service; + +import javax.annotation.Resource; +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.ArrayList; +import java.util.Date; +import java.util.List; +import java.util.Map; + +@Service +public class WaterRainReorganizeServiceImpl implements IWaterRainReorganizeService { + @Resource + WaterRainReorganizeMapper waterRainReorganizeMapper; + + @Override + public boolean batchInsert(ReorganizeData data) { + String sttp=data.getSttp(); + if(WaterFlowRainEnum.RR.getCode().equals(sttp)){ + List list=dealHzStRsvrR(data); + if(list!=null && !list.isEmpty()) { + batchStRsvrR(list); + return true; + } + } + if(WaterFlowRainEnum.ZZ.getCode().equals(sttp) || WaterFlowRainEnum.ZQ.getCode().equals(sttp)){ + List list=dealHzStRiverR(data); + if(list!=null && !list.isEmpty()) { + batchStRiverR(list); + return true; + } + } + if(WaterFlowRainEnum.PP.getCode().equals(sttp)){ + List list=dealHzStPptnR(data); + if(list!=null && !list.isEmpty()) { + batchStPptnR(list); + return true; + } + } + return false; + } + + private List dealHzStRsvrR(ReorganizeData data){ + SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH"); + List list=new ArrayList<>(); + List> mapList=data.getData(); + if(mapList!=null && !mapList.isEmpty()){ + for(Map param:mapList){ + + String tm=String.valueOf(param.get("tm")); + String rz=String.valueOf(param.get("water_level")); + String inq=String.valueOf(param.get("flow")); + + HzStRsvrR stRsvrR=new HzStRsvrR(); + stRsvrR.setStcd(data.getStcd()); + stRsvrR.setInq(Double.valueOf(inq)); + stRsvrR.setRz(Double.valueOf(rz)); + try { + stRsvrR.setTm(sdf.parse(tm)); + } catch (ParseException e) { + e.printStackTrace(); + } + list.add(stRsvrR); + } + } + return list; + } + + private List dealHzStRiverR(ReorganizeData data){ + SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH"); + List list=new ArrayList<>(); + List> mapList=data.getData(); + if(mapList!=null && !mapList.isEmpty()){ + for(Map param:mapList){ + + String tm=String.valueOf(param.get("tm")); + String z=String.valueOf(param.get("water_level")); + String q=String.valueOf(param.get("flow")); + + HzStRiverR stRiverR=new HzStRiverR(); + stRiverR.setStcd(data.getStcd()); + stRiverR.setQ(Double.valueOf(q)); + stRiverR.setZ(Double.valueOf(z)); + try { + stRiverR.setTm(sdf.parse(tm)); + } catch (ParseException e) { + e.printStackTrace(); + } + list.add(stRiverR); + } + } + return list; + } + + private List dealHzStPptnR(ReorganizeData data){ + SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH"); + List list=new ArrayList<>(); + List> mapList=data.getData(); + if(mapList!=null && !mapList.isEmpty()){ + for(Map param:mapList){ + + String tm=String.valueOf(param.get("tm")); + String drp=String.valueOf(param.get("rain")); + + HzStPptnR stPptnR=new HzStPptnR(); + stPptnR.setStcd(data.getStcd()); + stPptnR.setDrp(Double.valueOf(drp)); + try { + stPptnR.setTm(sdf.parse(tm)); + } catch (ParseException e) { + e.printStackTrace(); + } + list.add(stPptnR); + } + } + return list; + } + + @Override + public void batchStPptnR(List list) { + waterRainReorganizeMapper.batchStPptnR(list); + } + + @Override + public void batchStRiverR(List list) { + waterRainReorganizeMapper.batchStRiverR(list); + } + + @Override + public void batchStRsvrR(List list) { + waterRainReorganizeMapper.batchStRsvrR(list); + } + + @Override + public int insertHzStPptnR(HzStPptnR hzStPptnR) { + return waterRainReorganizeMapper.insertHzStPptnR(hzStPptnR); + } + + @Override + public int insertHzStRsvrR(HzStRsvrR hzStRsvrR) { + return waterRainReorganizeMapper.insertHzStRsvrR(hzStRsvrR); + } + + @Override + public int insertHzStRiverR(HzStRiverR hzStRiverR) { + return waterRainReorganizeMapper.insertHzStRiverR(hzStRiverR); + } + + @Override + public List> queryStPptnR(String stcd, String yearMonth) { + Map dateMap=DateUtil.getStartEnd(yearMonth); + Date begin= dateMap.get("start"); + Date endSt= dateMap.get("end"); + return waterRainReorganizeMapper.queryStPptnR(stcd,begin,endSt); + } + + @Override + public List> queryStRsvrR(String stcd, String yearMonth) { + Map dateMap=DateUtil.getStartEnd(yearMonth); + Date begin= dateMap.get("start"); + Date endSt= dateMap.get("end"); + return waterRainReorganizeMapper.queryStRsvrR(stcd,begin,endSt); + } + + @Override + public List> queryStRiverR(String stcd, String yearMonth) { + Map dateMap= DateUtil.getStartEnd(yearMonth); + Date begin= dateMap.get("start"); + Date endSt= dateMap.get("end"); + return waterRainReorganizeMapper.queryStRiverR(stcd,begin,endSt); + } + + @Override + public boolean delStPptnR(String stcd, String yearMonth) { + Map dateMap= DateUtil.getStartEnd(yearMonth); + Date begin= dateMap.get("start"); + Date endSt= dateMap.get("end"); + return waterRainReorganizeMapper.delStPptnR(stcd,begin,endSt)>0; + } + + @Override + public boolean delStRsvrR(String stcd, String yearMonth) { + Map dateMap= DateUtil.getStartEnd(yearMonth); + Date begin= dateMap.get("start"); + Date endSt= dateMap.get("end"); + return waterRainReorganizeMapper.delStRsvrR(stcd,begin,endSt)>0; + } + + @Override + public boolean delStRiverR(String stcd, String yearMonth) { + Map dateMap= DateUtil.getStartEnd(yearMonth); + Date begin= dateMap.get("start"); + Date endSt= dateMap.get("end"); + return waterRainReorganizeMapper.delStRiverR(stcd,begin,endSt)>0; + } + + + @Override + public List> queryData(String stcd, String sttp, String yearMonth) { + if(WaterFlowRainEnum.RR.getCode().equals(sttp)){ + return queryStRsvrR(stcd,yearMonth); + } + if(WaterFlowRainEnum.ZZ.getCode().equals(sttp) || WaterFlowRainEnum.ZQ.getCode().equals(sttp)){ + return queryStRiverR(stcd,yearMonth); + } + if(WaterFlowRainEnum.PP.getCode().equals(sttp)){ + return queryStPptnR(stcd,yearMonth); + } + return null; + } + + @Override + public boolean delData(String stcd, String sttp, String yearMonth) { + if(WaterFlowRainEnum.RR.getCode().equals(sttp)){ + return delStRsvrR(stcd,yearMonth); + } + if(WaterFlowRainEnum.ZZ.getCode().equals(sttp) || WaterFlowRainEnum.ZQ.getCode().equals(sttp)){ + return delStRiverR(stcd,yearMonth); + } + if(WaterFlowRainEnum.PP.getCode().equals(sttp)){ + return delStPptnR(stcd,yearMonth); + } + return false; + } +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/WaterRainServiceImpl.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/WaterRainServiceImpl.java new file mode 100644 index 0000000..9f6a5d5 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/service/impl/WaterRainServiceImpl.java @@ -0,0 +1,8 @@ +package com.hnac.hzims.waterrain.service.impl; + +import com.hnac.hzims.waterrain.service.IWaterRainService; +import org.springframework.stereotype.Service; + +@Service +public class WaterRainServiceImpl implements IWaterRainService { +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/util/DateUtil.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/util/DateUtil.java new file mode 100644 index 0000000..fa3c4ca --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/util/DateUtil.java @@ -0,0 +1,31 @@ +package com.hnac.hzims.waterrain.util; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Calendar; +import java.util.Date; +import java.util.HashMap; +import java.util.Map; + +public class DateUtil { + public static Map getStartEnd(String yearMonth){ + Map data=new HashMap<>(); + SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); + try { + Date begin = sdf.parse(yearMonth+"-01 00:00:00"); + // 最大天数 + Date endSt = sdf.parse(yearMonth+"-"+getMaxDayByYearMonth(begin)+" 23:59:59"); + data.put("start",begin); + data.put("end",endSt); + } catch (ParseException e) { + e.printStackTrace(); + } + return data; + } + + public static int getMaxDayByYearMonth(Date start) { + Calendar calendar = Calendar.getInstance(); + calendar.setTime(start); + return calendar.getActualMaximum(Calendar.DAY_OF_MONTH); + } +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/util/GisUtil.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/util/GisUtil.java new file mode 100644 index 0000000..d8779cb --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/util/GisUtil.java @@ -0,0 +1,64 @@ +package com.hnac.hzims.waterrain.util; + + +import com.hnac.hzims.waterrain.entity.StStbprpB; + +import java.math.BigDecimal; + +public class GisUtil { + public static void dealGisData(StStbprpB stStbprpB){ + if(stStbprpB!=null) { + stStbprpB.setLgtd(dealData(stStbprpB.getNlgtd())); + stStbprpB.setLttd(dealData(stStbprpB.getNlttd())); + } + } + +// public static void main(String[] args) { +// System.out.println(dealData(new BigDecimal("10.121806"))); +// } + + private static String dealData(Double data0){ + if(data0!=null && new BigDecimal(data0).compareTo(BigDecimal.ZERO)!=0) { + BigDecimal data=new BigDecimal(data0); + //度 + String str=intVal(data)+"°"; + + //分 + String dataStr = String.valueOf(data); + if(dataStr.indexOf(".")>-1) { + String[] dataArr = dataStr.split("\\."); + data = mul("0." + dataArr[1]); + str += intVal(data) + "'"; + }else{ + str += "0'"; + } + + //秒 + dataStr=String.valueOf(data); + if(dataStr.indexOf(".")>-1) { + String[] dataArr = dataStr.split("\\."); + data = mul("0." + dataArr[1]); + str+=data.setScale(5, BigDecimal.ROUND_DOWN).stripTrailingZeros()+"\""; + }else{ + str += "0\""; + } + + + return str; + } + return "0°"; + } + + private static int intVal(BigDecimal data){ + return data.setScale( 0, BigDecimal.ROUND_DOWN).intValue(); + } + + private static BigDecimal mul(String data){ + return new BigDecimal(data).multiply(new BigDecimal("60")); + } + +// public static void main(String[] args) { +// String str=dealData(new BigDecimal("0.0")); +// System.out.println(str); +// } +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/util/ParamUtil.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/util/ParamUtil.java new file mode 100644 index 0000000..8b9c7a6 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/util/ParamUtil.java @@ -0,0 +1,26 @@ +package com.hnac.hzims.waterrain.util; + +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; +import com.hnac.hzims.waterrain.entity.StStbprpB; + +import java.util.Map; + +public class ParamUtil { + public static LambdaQueryWrapper conditionStStbprpB(Map param){ + LambdaQueryWrapper wrapper=new LambdaQueryWrapper(); + if(param.get("stcd")!=null) { + wrapper.like(StStbprpB::getStcd,param.get("stcd")); + } + if(param.get("stnm")!=null && !"".equals(param.get("stnm").toString())) { + wrapper.like(StStbprpB::getStnm,param.get("stnm")); + } + if(param.get("sttp")!=null) { + String sttp=param.get("sttp").toString(); + wrapper.in(StStbprpB::getSttp,sttp.split(",")); + } + if(param.get("rscd")!=null) { + wrapper.like(StStbprpB::getRscd,param.get("rscd")); + } + return wrapper; + } +} diff --git a/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/wrapper/StStbprpBWrapper.java b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/wrapper/StStbprpBWrapper.java new file mode 100644 index 0000000..17adcb7 --- /dev/null +++ b/hzims-service/water-rain/src/main/java/com/hnac/hzims/waterrain/wrapper/StStbprpBWrapper.java @@ -0,0 +1,27 @@ +package com.hnac.hzims.waterrain.wrapper; + +import org.springblade.core.mp.support.BaseEntityWrapper; +import org.springblade.core.tool.utils.BeanUtil; +import org.springblade.core.tool.utils.Func; +import org.springblade.system.cache.DictCache; +import com.hnac.hzims.waterrain.entity.StStbprpB; +import com.hnac.hzims.waterrain.vo.StStbprpBVo; + +import java.util.Objects; + +public class StStbprpBWrapper extends BaseEntityWrapper { + public StStbprpBWrapper() { + } + + public static StStbprpBWrapper build() { + return new StStbprpBWrapper(); + } + + @Override + public StStbprpBVo entityVO(StStbprpB stStbprpB) { + StStbprpBVo stbprpBVo = (StStbprpBVo) Objects.requireNonNull(BeanUtil.copy(stStbprpB, StStbprpBVo.class)); + String sttpName = DictCache.getValue("st_station_type", Func.toStr(stbprpBVo.getSttp())); + stbprpBVo.setSttpName(sttpName); + return stbprpBVo; + } +} diff --git a/hzims-service/water-rain/src/main/resources/application-dev.yml b/hzims-service/water-rain/src/main/resources/application-dev.yml new file mode 100644 index 0000000..50a4ea7 --- /dev/null +++ b/hzims-service/water-rain/src/main/resources/application-dev.yml @@ -0,0 +1,30 @@ +#服务器端口 +server: + port: 8200 + +#数据源配置 +#spring: +# datasource: +# url: ${blade.datasource.dev.url} +# username: ${blade.datasource.dev.username} +# password: ${blade.datasource.dev.password} + +spring: + #排除DruidDataSourceAutoConfigure + autoconfigure: + exclude: com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure + datasource: + dynamic: + #设置默认的数据源或者数据源组,默认值即为master + primary: master + datasource: + master: + url: jdbc:mysql://127.0.0.1:3306/equipment?useSSL=false&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&transformedBitIsBoolean=true&tinyInt1isBit=false&allowMultiQueries=true&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true + username: root + password: 123456 + slave: + url: jdbc:mysql://127.0.0.1:3306/equipment?useSSL=false&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&transformedBitIsBoolean=true&tinyInt1isBit=false&allowMultiQueries=true&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true + username: root + password: 123456 +demo: + name: aaa diff --git a/hzims-service/water-rain/src/main/resources/application-prod.yml b/hzims-service/water-rain/src/main/resources/application-prod.yml new file mode 100644 index 0000000..da89262 --- /dev/null +++ b/hzims-service/water-rain/src/main/resources/application-prod.yml @@ -0,0 +1,28 @@ +#服务器端口 +server: + port: 8200 + +#数据源配置 +#spring: +# datasource: +# url: ${blade.datasource.prod.url} +# username: ${blade.datasource.prod.username} +# password: ${blade.datasource.prod.password} + +spring: + #排除DruidDataSourceAutoConfigure + autoconfigure: + exclude: com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure + datasource: + dynamic: + #设置默认的数据源或者数据源组,默认值即为master + primary: master + datasource: + master: + url: ${blade.datasource.demo.master.url} + username: ${blade.datasource.demo.master.username} + password: ${blade.datasource.demo.master.password} + slave: + url: ${blade.datasource.demo.slave.url} + username: ${blade.datasource.demo.slave.username} + password: ${blade.datasource.demo.slave.password} diff --git a/hzims-service/water-rain/src/main/resources/application-test.yml b/hzims-service/water-rain/src/main/resources/application-test.yml new file mode 100644 index 0000000..4b4e157 --- /dev/null +++ b/hzims-service/water-rain/src/main/resources/application-test.yml @@ -0,0 +1,28 @@ +#服务器端口 +server: + port: 8200 + +#数据源配置 +#spring: +# datasource: +# url: ${blade.datasource.test.url} +# username: ${blade.datasource.test.username} +# password: ${blade.datasource.test.password} + +spring: + #排除DruidDataSourceAutoConfigure + autoconfigure: + exclude: com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceAutoConfigure + datasource: + dynamic: + #设置默认的数据源或者数据源组,默认值即为master + primary: master + datasource: + master: + url: ${blade.datasource.demo.master.url} + username: ${blade.datasource.demo.master.username} + password: ${blade.datasource.demo.master.password} + slave: + url: ${blade.datasource.demo.slave.url} + username: ${blade.datasource.demo.slave.username} + password: ${blade.datasource.demo.slave.password} diff --git a/hzims-service/water-rain/src/main/resources/application.yml b/hzims-service/water-rain/src/main/resources/application.yml new file mode 100644 index 0000000..0952a13 --- /dev/null +++ b/hzims-service/water-rain/src/main/resources/application.yml @@ -0,0 +1,13 @@ +#mybatis-plus配置 +mybatis-plus: + mapper-locations: classpath:com/hnac/hzims/**/mapper/*Mapper.xml + #实体扫描，多个package用逗号或者分号分隔 + typeAliasesPackage: com.hnac.hzims.**.entity + +#swagger扫描路径配置 +swagger: + base-packages: + - org.springbalde + - com.hnac + + diff --git a/hzims-service/water-rain/src/main/resources/banner.txt b/hzims-service/water-rain/src/main/resources/banner.txt new file mode 100644 index 0000000..f171d84 --- /dev/null +++ b/hzims-service/water-rain/src/main/resources/banner.txt @@ -0,0 +1,7 @@ + _ _ ____ ___ __ __ ___ _ _ ___ _ _ ___ + | || | |_ / |_ _| | \/ | / __| o O O | | | | | _ \ o O O | | | | | _ \ + | __ | / / | | | |\/| | \__ \ o | |_| | | _/ o | |_| | | _/ + |_||_| /___| |___| |_|__|_| |___/ TS__[O] \___/ _|_|_ TS__[O] \___/ _|_|_ +_|"""""|_|"""""|_|"""""|_|"""""|_|"""""| {======|_|"""""|_| """ | {======|_|"""""|_| """ | +"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'"`-0-0-'./o--000'"`-0-0-'"`-0-0-'./o--000'"`-0-0-'"`-0-0-' +