From db229dbfe56b9c7a72fe496f9c0cbff60615c0fa Mon Sep 17 00:00:00 2001 From: LeoAnn <1297441823@qq.com> Date: Sun, 22 Jun 2025 17:08:34 +0800 Subject: [PATCH] =?UTF-8?q?feat:=20=E5=8D=97=E6=96=B9=E7=89=87=E4=BA=A4?= =?UTF-8?q?=E4=BA=92?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 2 +- .../src/main/resources/excel/dayDscs.xls | Bin 0 -> 20992 bytes ruoyi-common/pom.xml | 13 + .../controller/BaseExportController.java | 2 - .../basic/controller/BaseInfoController.java | 138 +- .../swlscx/basic/domain/po/FzTableId.java | 23 + .../ruoyi/swlscx/basic/domain/po/HyWfdzF.java | 23 + .../swlscx/basic/domain/po/YcShdpInfo.java | 20 + .../swlscx/basic/domain/ro/FormDataRo.java | 23 + .../domain/rowMapper/HyDmxpFRowMapper.java | 46 + .../domain/rowMapper/HyDpCRowMapper.java | 37 + .../domain/rowMapper/HyDqCRowMapper.java | 44 + .../domain/rowMapper/HyDzCRowMapper.java | 46 + .../domain/rowMapper/HyHltdzBRowMapper.java | 64 + .../domain/rowMapper/HyHmxpFRowMapper.java | 59 + .../domain/rowMapper/HyImxfwFRowMapper.java | 67 + .../domain/rowMapper/HyMmxpFRowMapper.java | 45 + .../domain/rowMapper/HyMtpERowMapper.java | 48 + .../domain/rowMapper/HyMtqERowMapper.java | 72 + .../domain/rowMapper/HyMttdzERowMapper.java | 126 + .../domain/rowMapper/HyMtzERowMapper.java | 75 + .../domain/rowMapper/HyPrexBRowMapper.java | 49 + .../domain/rowMapper/HyStscARowMapper.java | 61 + .../domain/rowMapper/HyWfdzFRowMapper.java | 54 + .../domain/rowMapper/HyWsfhexBRowMapper.java | 53 + .../domain/rowMapper/HyYrpFRowMapper.java | 52 + .../domain/rowMapper/HyYrqFRowMapper.java | 73 + .../domain/rowMapper/HyYrtdzFRowMapper.java | 125 + .../domain/rowMapper/HyYrzFRowMapper.java | 60 + .../basic/domain/vo/HyStscASelectVo.java | 31 + .../swlscx/basic/domain/vo/HyStscAVo.java | 3 + .../swlscx/basic/mapper/HyStscAMapper.java | 21 +- .../basic/mapper/YcExportTaskMapper.java | 7 + .../swlscx/basic/service/HyStscAService.java | 25 +- .../basic/service/YcExportTaskService.java | 9 + .../service/impl/HyStscAServiceImpl.java | 2388 ++++++++++++++++- .../service/impl/YcExportTaskServiceImpl.java | 65 +- .../common/constants/SystemConstants.java | 6 + .../swlscx/common/enums/SelectTableEnum.java | 84 + .../swlscx/common/utils/CommonUtils.java | 25 +- .../ruoyi/swlscx/common/utils/ExcelUtils.java | 1 - .../common/utils/SqlServerDataSourceUtil.java | 48 + .../day/controller/DayExportController.java | 13 + .../day/controller/DayTableController.java | 26 +- .../ruoyi/swlscx/day/domain/bo/HyZscsBBo.java | 32 + .../ruoyi/swlscx/day/domain/po/HyZscsB.java | 33 + .../ruoyi/swlscx/day/domain/vo/HyZscsBVo.java | 32 + .../swlscx/day/mapper/HyZscsBMapper.java | 30 + .../swlscx/day/service/HyDpCService.java | 4 + .../swlscx/day/service/HyDwtCService.java | 2 + .../swlscx/day/service/HyZscsBService.java | 39 + .../day/service/impl/HyDpCServiceImpl.java | 2 +- .../day/service/impl/HyZscsBServiceImpl.java | 226 ++ .../controller/ExcerptImportController.java | 4 +- .../controller/TimeTasksController.java | 271 ++ .../swlscx/synchronousData/dto/JHDayData.java | 860 ++++++ .../swlscx/synchronousData/dto/SWDayData.java | 25 + .../synchronousData/dto/SWMonthData.java | 25 + .../synchronousData/enums/JhhkTableEnum.java | 81 + .../synchronousData/enums/SWTableEnum.java | 94 + .../mapper/TimeTasksMapper.java | 151 ++ .../service/GetDateService.java | 15 + .../service/TimeTasksService.java | 83 + .../service/impl/GetDateServiceImpl.java | 210 ++ .../service/impl/TimeTasksServiceImpl.java | 1347 ++++++++++ .../swlscx/year/service/HyYrzFService.java | 3 + .../resources/mapper/basic/HyStscAMapper.xml | 172 +- .../mapper/basic/YcExportTaskMapper.xml | 49 + .../resources/mapper/day/HyDcsFMapper.xml | 7 +- .../main/resources/mapper/day/HyDpCMapper.xml | 6 +- .../main/resources/mapper/day/HyDqCMapper.xml | 6 +- .../resources/mapper/day/HyDweCMapper.xml | 6 +- .../resources/mapper/day/HyDwtCMapper.xml | 7 +- .../main/resources/mapper/day/HyDzCMapper.xml | 6 +- .../resources/mapper/day/HyZscsBMapper.xml | 38 + .../mapper/excerpt/HyFdheexBMapper.xml | 7 +- .../mapper/excerpt/HyPrexBMapper.xml | 7 +- .../mapper/excerpt/HyRvfhexBMapper.xml | 7 +- .../mapper/excerpt/HyWsfhexBMapper.xml | 7 +- .../resources/mapper/month/HyMtcsEMapper.xml | 7 +- .../resources/mapper/month/HyMtpEMapper.xml | 12 +- .../resources/mapper/month/HyMtqEMapper.xml | 7 +- .../resources/mapper/month/HyMtqsEMapper.xml | 12 +- .../resources/mapper/month/HyMttdzEMapper.xml | 12 +- .../resources/mapper/month/HyMtweEMapper.xml | 7 +- .../resources/mapper/month/HyMtwtEMapper.xml | 7 +- .../resources/mapper/month/HyMtzEMapper.xml | 12 +- .../synchronousData/TimeTasksMapper.xml | 1037 +++++++ .../resources/mapper/year/HyDmxpFMapper.xml | 7 +- .../resources/mapper/year/HyHmxpFMapper.xml | 7 +- .../resources/mapper/year/HyImxfwFMapper.xml | 7 +- .../resources/mapper/year/HyMmxpFMapper.xml | 7 +- .../resources/mapper/year/HyYrcsFMapper.xml | 6 +- .../resources/mapper/year/HyYrpFMapper.xml | 7 +- .../resources/mapper/year/HyYrqFMapper.xml | 6 +- .../resources/mapper/year/HyYrqsFMapper.xml | 6 +- .../resources/mapper/year/HyYrtdzFMapper.xml | 7 +- .../resources/mapper/year/HyYrweFMapper.xml | 6 +- .../resources/mapper/year/HyYrwtFMapper.xml | 6 +- .../resources/mapper/year/HyYrzFMapper.xml | 6 +- 100 files changed, 9103 insertions(+), 234 deletions(-) create mode 100644 ruoyi-admin/src/main/resources/excel/dayDscs.xls create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/FzTableId.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/HyWfdzF.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/YcShdpInfo.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/ro/FormDataRo.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDmxpFRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDpCRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDqCRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDzCRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyHltdzBRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyHmxpFRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyImxfwFRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMmxpFRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtpERowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtqERowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMttdzERowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtzERowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyPrexBRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyStscARowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyWfdzFRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyWsfhexBRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrpFRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrqFRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrtdzFRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrzFRowMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/vo/HyStscASelectVo.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/common/enums/SelectTableEnum.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/common/utils/SqlServerDataSourceUtil.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/day/domain/bo/HyZscsBBo.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/day/domain/po/HyZscsB.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/day/domain/vo/HyZscsBVo.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/day/mapper/HyZscsBMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyZscsBService.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/day/service/impl/HyZscsBServiceImpl.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/controller/TimeTasksController.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/JHDayData.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/SWDayData.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/SWMonthData.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/enums/JhhkTableEnum.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/enums/SWTableEnum.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/mapper/TimeTasksMapper.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/GetDateService.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/TimeTasksService.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/impl/GetDateServiceImpl.java create mode 100644 swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/impl/TimeTasksServiceImpl.java create mode 100644 swlscx/src/main/resources/mapper/day/HyZscsBMapper.xml create mode 100644 swlscx/src/main/resources/mapper/synchronousData/TimeTasksMapper.xml diff --git a/pom.xml b/pom.xml index 0758b18..c7ad927 100644 --- a/pom.xml +++ b/pom.xml @@ -18,7 +18,7 @@ UTF-8 1.8 3.1.1 - 1.2.8 + 1.2.16 1.21 3.0.0 2.3.2 diff --git a/ruoyi-admin/src/main/resources/excel/dayDscs.xls b/ruoyi-admin/src/main/resources/excel/dayDscs.xls new file mode 100644 index 0000000000000000000000000000000000000000..7a0a205f567ecfe08b7290ca51cc6f5b9768e51b GIT binary patch literal 20992 zcmeHv2V4|K`~Tc=z#$+3IYuhT2yucFysl9yl{AqMIQ?(<2U*}F=-M0_PY0p| zqAo;ibA5oLPQ_J*bL5HSl9m`Q~o1W?L(5_FB#e*f{cT7BAE)-uYa%tk6|h< z1~Iu5kAxIaN79K-=%ak{;%5C%-4Z$DB{~{}fl&HHGKLJN^cX`EKjCOb#3H7AOzR_x z8v2LPoDrlS)I1ex-jNK0d=Xq@|EX{JDE=?nOkjq-WHK2Gf5Rx-cZF7n zr)+|hWHJiQ$Dx2gaILLB_TBoHkNvr*7SBKmy;x6|95F7{KbavSdeHeRiJ0t`oP;AG zcOgcT@t~*3m-vxZB!~nM`TzgWp3-5M2z4j|1Gj@S5sW5y4Q&obbLzN@;y6kj+fgGC zA#P)T^$rFOygPj%4x{*TsG}owYzRjYIY`Oeq$s{HcD(?8W%?p)Ofm5uyj_ghE_%dwH0a5Ed=ONimq9^20ZixKyFEnqMh`dFA<=lRr&D=3E{y<{!m_h2niIR8wk(?1@NT;{H6l@G6A}|0Np@<&TSVv zi3jvIb0Tsi50sAZnB@u4iTIEZvI!63NLTWbn> zL0Lkj(Rp@~aCkhh6BgB8G6OP-xWk|#8cO7~3cACYs=i2XL)3HC>(0mF2-b0=q-fbN z>fBB;khsAgRhUpQNEa#q^Ms(MLKC$Xt_NLRK3&xd6Xv4}4uvkDLSgDPl6b&S!Ba0T zoM!F#IJ6bz4SnB|h@y$JS}VChD@7Amh-`W^Sldq03Ov(>Uqt02Lc(ppJ8ikbjMDt2 z(z$fm5m2&Ro47U&R6rHflPw{ymH5QVgd#c8MQ};c|EwP!2UI?OAv&V+@&6~&Mbyj! zYlwliGXW>3?C=*&Rna{K=mr9GHvzgkFCFJVjQzvpVREKioEP!Y@!5)^7nqt_8Cn?< zi4El^IDg{f$2k=r9p_nmbewxp^lJpP34*DE=bek<7xgNiXZ2P6#W{Bg>qqP zNb7@h##;KYFu6}%y>K2$(f8HrDRHN8fPq7ALD6x(sm|{~(Qyu{PWPecI4@PF+iRt3 z;xrb(4-mki{Xw%_+RmEzLUjL6#22!I5PmBGeA@n+`qOkx{jCJ-<12t~D?s-Yz!9Q1 z6~Ga)KkYx7`qMZ#T@~T{B2{D>20e!HTNNFbLip%1Q|ze>KTNM`aZF`WNf=DqX#dye zq0f+7kQq1t)rAPsSY0?%XO^uGdN(^f=FdL;^=jIrh zAW#A}y{d%t^mJ|s;T)S_AJBovV2irdGo}P=34v0%Ah;;@{|thwY7B@n6xRZnphXj| z6XCL)R)a0()ZZQi^y_?rZ7{|s*fho`*fho`*t9yIDEYds0T|B?4Na+|)wUv6DY=?b zp`oF50*q2@8lx1O#wf+6F-pC9^{Ng}rIe}+0i_(&lw#MGQHo7tlw#8urPwrWO1(?d z=pbB6IjSket}UY!o5m=`rZGyfX^c{vH*eOk6nlZH)>7Q=-~>w1o{S@zGDD;R!c(*U z9LK~3MhUp4X2(R0v19Ue5fRXtAfO$tPV0a$Jqn(Cepy31Sh%U934kwcB=L4bCsyztU z#D@h!Zx1m-pI{ST7KkDqpM#jdfYie#ejvj*TS<@41o3Bq`1$jJFq&a1V3PnA2)$j# z2r<=Rt}zt=34|=BI*NFF24n&QQV*N71Q`aTq{nB11hGK;{P{o_%`g?HPB06E-acf6 znCdXsm}@fq@>4Zf`qa_{QUVq7|k%Hs*^8_t=rWq0{HOtVYQu7QwDz(Var&7xdDV17f7(i+Oi;}RR z^Cr9fiitC6H*2o0hNP)dO1NA!gafSPHzXoI*c56;+(q8lPR9Yhj4 zWkcB85tcx{e6a)U00DG>7Di2Idw|v^!9aT;bjweImIJgl2^!iG_IosJiU#1?)Ir0h zOn-C$GitRd!f|ctsMV$_XfN$H<%4$8YEu=ow|1NIK|5=;DFbZ@?WAE-9H_W9ZKh#U zX25cQ;Zv(k5squq=2~s4g7(vHQ$A=Htu|Fb`)ju;AGE7hn=;Ur&`mUKiX%DKrfwQG zWkz%d*k0FaQ-tH%)LpAhRnRT9+msL5L#s_y&_UX5$_MSK)us%zB?;EFX&{eHTWHu6 zANT1&ua$P2A{^JIURrIcf^MzdrhL%eT5YO=Zlm3%e9%5xZOTAflD3*QZOLO(Uk#h$ z?1#2#JMA__IId0owAxe!9irW)e9-<{ZK{F})oxQh=m4!YrJ+Yit;h)0{n&~!6CRdH zpBOD;uwmPOu*T3a)M&4!dsXJ_b_Q56{iKzq!ikismrX=;A%cZ zTq!M#~Qmw&Y=U)9}skY|Cu@q9(8*W80IW_T9bZoS#1$yv|D%3{lhk5e08*q3Ae zYuEFWqSBno7tQ{5{~h^H`#s7Xo_pSj`QCYSy9J#GKKilR?QTSsNAm{a;Ey7#pi1q` zckhk zNS&R9Vp7#P^w4BM1mdAVk3(|yYgqrMOSDX;3uP_N~N*;^FtT-F-R@9MF1^yZY_ zkFFE<>l0Q_EBtAj<+}i4oK>;qyR%onAG~Yd%2q##zwVs-?DDwpZ%=-)tfu>zmQya3 z&f5BWMd0~IyS}NcDvv*M_io_%iXCJA>K^4WdO(wpHgPZZ2hJ$`*Qow&8pg~T-mUDh zP3!p=_xB3y+-Q;S#;lmsV|}04?VI$MnQo%%*3DZQ@9j5j-m-P?v!_(CyywKlx$+T_9$7if&ye%zEpYb~C#rq$34GpQeo!h8o&GP4= zHE#=l_z>p0VRMA{@zhsUdtJPbf4F}z$$ol;eiP%w)V0oENP=Dr8o!`f#j1wcV_Mn0 zxSs#0cy6$ntKJ>E@}|~pifku!Ogq#(W!99e4$2pzU8T?39C$N4B>#;6AFqQaWE5v# zZGP_;5RmeuUC3i79f9du}`KFumN?)#CcVX)f zRV_m%FYYayJ1zV9h$opZZB}+&@>jn%QSF~**gIIi&;Gsi?Ui$rGc$Wc`Y6IjX3llH-f$!|+y7jiub?Nc0 zqPXN++3SW=!ycbY{?*~wAASN%@n7$6=w#w&GIOnX8tVw=MA?KmaU21I{$UECquHnyuSYQ!Q&m0wm(Qe z?(IF;H+j^4>wsHhkG<{nVfu65_4{0Yv#>Wf_R(thyX?b0TQmO*H*ci>o#&j+{m-qt zbFyc!dt7tJ>j9?W=Oj%`PUmdDrr)~zxP`?JQwMDyxG}-^tB|}?nbQu>3)$w?Z&}H_ zNgHEEY{(OJH=GsgBrAHe-gH@2C%azybMG$p^Ig9CkW-V>Um4lu8{Kuj7O#8NAbNyRv!JPI=Evir&$l%D z?!w_Md4rmoIr^HocD1S8d0}x^qn?5Ne{sK8)9Y%mWJki6ErO%3{eGf%P_xK8N2A7l zwcN|(WomX-S^Sp34ToZ5{uppNK5SJ?+t!A9$>)+B){S;^FSp3*+_C882^-PsYlhJS z`+H1%?LDu__~y^etgDAFIl1)ovW2q~teiRwSuwnWqEYk50bl$yb4Sd;eY?i2nb3BN zOnRtQrpGCr2Xj}-o|$xhG0`o(ZPeHS)AzqP_)S6d>wzV#>K?ASiUJ=J)Z;@wpWZ4&x~4<@m1CNMh_D&&04j*;EP%F z{?%ZtP3x+ds4;VlZLb$UZGX}BP<39XtBR%ZKbq?16(`2c=|1hw#W6cq3~uwVWcMRa zk8Ld;uduvSIo$Wosgz6GBjyf!eeheq0?Eyy)a*{d)!~8T@9B8H>~8N^{_W9_Lt~C! z-M-W-MVzu^p!h&RiEqzAN2Qw-Hz!^T99t=jZLCtaNUwVRrG1qbCwJQH(==?>8>K|}W{5Y; zp%WE}lc*b}>VC5Mr^4S3LtaZ*sl%6nXdW-*oSpl_=+iz%S3Q|Gb~QT}yscdFo7`&UcD>VgJA__Js7z^h zB7NqC*_#TRNe8EnpR;lLt^Grf_P)BYZK<#A<}L?(mYSK&y%Bk|&(8L7S1-uQx<%Xy z819^2xOl?Q>-H{@#AZ&KG%a{cjj)rpxk@fr({j!$@E>G4JQj-9zMDd?%?$i>}Vdp39Ou`_sM?tuG_8@Gg?KXRo@_2jg5FIS0XoOM1nTsFO&STF0nQn~kIu+6-Y z-u6~QYNEm?-I%TGy5U?&h106-JtP+gA3l8MSM|pV`8UpGe?eWF!1ks&q=P#ojZ0RH zOCH*9>UhPZA^1%3?cz(lPW#9rs=Iuc^`J$!f<0l&$Zb z=1)<6%=P7s9z2x!xINy|@9~;ex2^LNbDcKb)_2~vFJxiSo}ASNv7zfaOd4VlbZ**k z=gX-VuS|ZM(IQcQK<@NbAuBsJ$s15zyuf@%ne0@B=k66Nn+E>sdZYdM&6AGjPis`R zG$CQqGN1lm>UpN^@>}`HreBimt!}5QKAyQ}c2&76+f`+MlQekbcP~@gT$I0R_3HjR zmxum~vi)mJrW&*{Sn)QgDzbNXk=O#ZR+$G!uBjjcmd508j5gpk91XzlkE&fBeDlp0 zHaHlMR4%sD`5zz-dAt?1=Ql?LDAj6`ozS@;k?aDyy z%80u1!{rx{%aMj_l!H64u+S{R!fFc;v(70cPz3<62BnUQb70cSRaQq(Sv}aTprxEO zq{M1cpUUU0frn*#pXW$FLu7zPDY|M}e{RG4pEkwcc!8$r*sl1g?IhQ* zAbixN=A=2WBf|Bl`thi{K0gkZCsLyF~txKNZhZkCnRkP29m#k z&v4w&5DC+$hNRxU&X}UUz1&lyEcMYq-3~dhFRJMw?1ssacF^EZ8`?CTTD=IS0_`+l za8%UNmg+DIrKw~gYbehLVQcv72k&7GhfnAf@Ofo2eA0?%z2U<;1(^gf8J2K|l5jEt z{uI<_ufC8wilo5DmdOGVei{ujtjd_@I^U&;=hbcD?TNd*$<>q0XF%NrnuCx=!BJiO0S*^h>1z@OB zurzKSmW~mP$IWA`fqHQB7;E5j0ymGb2F}#Dd5ksiiH)0wRzO|w^9^nuV=4TEgPVuC zqa1$5!L_28`T*bhGdz@A3S%jJPUPk>mNMnZV`_{~np`=iRydjA=3zNlCO#r^^ROJu zv*gLcm(4K`*Il`CupCR}ArChX-{3|$7uO0Yi4bc8|!>Myr5wKTER;W@P|6X zddPuT_^$|MQV}VD9m)a*fQAt`_6H0pNu%m2Cb7m?TM2co2dz=jP<7o9o`PZx>1!g! zUPzCUwLf+tMsLOQrgVdgOo$X{c)_N9q}qazFk~jjsZY*Da4%v0+C!QSQdob17w?$@Z4!Gl_bQBaSJls1Bh=X3y9!Z){dI?{f~ zkpG+h2Uq~z6x|Y?5nT|6dh{i9GIRmFapLc?;EfOmB0R^ggEuPdFgT3kZ2^aW%=>Tn zXITJmDk42%vQk`*O-{A>dlN5l_rLVaBk&hRz(I;?zb*LRPEj9f1g%dBJS_dz{Dv~M zfkme%a4kb$=Si7-N*?lsQbxWp_7%jh_>W9Kta?b*>w|S|+7#_tr2IgAU>Nolofavp zO>k^5ASc5K$@Kb^+e8i6t^qXy0RSuDxKuHF?W?zu39=oFrNqN!?+qWIErN(P$NXT3 z5HiBxfMZn`h^WUG5b*&VZ-qEEjfaS1+-_)e9H%6}Y!4}pc^*kqmO?_p@Ni(A{7mKz z5uRr>2&R6k2>EdA8wiizeTkez!msnh!&DI`ju?dW$MVGGrR4=)wzB-?pugwaogIOu z%b{fh4fRHU#5%b`gph%C#d5KZGKgUixplyN3`~juIDTV5dBjV`3&5KJ2b9l*i1prG zdyS75Nl+X74I+9f{As^O6bz{B5f5PhHelOiqjLYI@Tukhn~JT2`6ri;K7oCrJ9u{_ z`1nNdhB)ws5#TxPAsq!vCvh<0Q9up`<~gA&JhBdeYpzdXf5AS7Z~g|tu>~w`_z^ES z;_qo-8VEljg*3VkIzt)(IsWjbVjy7pz}vS0;FCcVB>?#Rpbz)~PaypGR0QO;0_gyt W1p&1KoJGLG42=g+{|%pLf&T&33FG|$ literal 0 HcmV?d00001 diff --git a/ruoyi-common/pom.xml b/ruoyi-common/pom.xml index 0612064..41360cb 100644 --- a/ruoyi-common/pom.xml +++ b/ruoyi-common/pom.xml @@ -17,6 +17,19 @@ + + cn.hutool + hutool-all + 5.8.22 + + + + com.alibaba + druid + 1.2.16 + + + org.springframework diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/controller/BaseExportController.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/controller/BaseExportController.java index ad11c6b..4285541 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/basic/controller/BaseExportController.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/controller/BaseExportController.java @@ -21,8 +21,6 @@ import javax.servlet.http.HttpServletResponse; public class BaseExportController { private final HyStscAService hyStscAService; - - /** * 导出测站一览表 */ diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/controller/BaseInfoController.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/controller/BaseInfoController.java index 06ab7aa..68c0b03 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/basic/controller/BaseInfoController.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/controller/BaseInfoController.java @@ -1,17 +1,32 @@ package com.ruoyi.swlscx.basic.controller; +import cn.hutool.core.io.IoUtil; +import cn.hutool.core.io.resource.InputStreamResource; +import cn.hutool.http.HttpRequest; +import cn.hutool.http.HttpResponse; +import cn.hutool.http.HttpUtil; import com.baomidou.mybatisplus.core.metadata.IPage; import com.ruoyi.common.core.page.R; import com.ruoyi.swlscx.basic.domain.po.YcExportTask; +import com.ruoyi.swlscx.basic.domain.ro.FormDataRo; +import com.ruoyi.swlscx.basic.domain.vo.HyStscASelectVo; import com.ruoyi.swlscx.basic.domain.vo.HyStscAVo; import com.ruoyi.swlscx.basic.service.YcExportTaskService; import com.ruoyi.swlscx.common.PageParams; import com.ruoyi.swlscx.basic.service.HyStscAService; import lombok.RequiredArgsConstructor; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.http.HttpHeaders; import org.springframework.security.access.prepost.PreAuthorize; import org.springframework.web.bind.annotation.*; +import org.springframework.web.multipart.MultipartFile; import javax.servlet.http.HttpServletResponse; +import java.io.InputStream; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.util.HashMap; import java.util.Map; /** @@ -33,12 +48,23 @@ public class BaseInfoController { * 查询站点信息 */ @GetMapping("/getStationPageByInfo") - public R getStationPageByInfo(Integer pageNum,Integer pageSize, String stnm,String stcd, String startTime, String endTime) { + public R getStationPageByInfo(Integer pageNum,Integer pageSize, String stnm,String stcds, String startTime, String endTime) { PageParams pageParams = new PageParams(pageNum.longValue(), pageSize.longValue()); - IPage stationPageByInfo = hyStscAService.getStationPageByInfo(pageParams, stnm, stcd, startTime, endTime); + IPage stationPageByInfo = hyStscAService.getStationPageByInfo(pageParams, stnm, stcds, startTime, endTime); return R.ok().put("data", stationPageByInfo.getRecords()).put("count", stationPageByInfo.getTotal()); } + + /** + * 站点下拉框 + */ + @GetMapping("/getStationList") + public R getStationList(@RequestParam(value = "startTime",defaultValue = "") String startTime, + @RequestParam(value = "endTime",defaultValue = "")String endTime, + @RequestParam(value = "type",defaultValue = "") String type) { + return R.ok().put("data", hyStscAService.getList(startTime,endTime,type)); + } + /** * 查询列表 */ @@ -53,6 +79,65 @@ public class BaseInfoController { ycExportTaskService.downloadExcel(response,t); } + @Value("${softurl}") + private String sqlServerUrl; + + @RequestMapping("/downloadSoftFile") + public void downloadSoftFile(HttpServletResponse response){ + try (HttpResponse remoteResponse = HttpRequest.post(sqlServerUrl+"/downloadSoftFile") + .header(HttpHeaders.ACCEPT, "application/octet-stream") + .execute()) { + // 检查远程响应状态 + if (!remoteResponse.isOk()) { + response.sendError(remoteResponse.getStatus(), "远程服务器错误"); + return; + } + + // 设置当前响应头 + remoteResponse.headers().forEach((key, values) -> { + if (!"Transfer-Encoding".equalsIgnoreCase(key)) { // 排除特殊头 + values.forEach(value -> response.addHeader(key, value)); + } + }); + + // 将远程文件流写入当前响应 + try (InputStream remoteStream = remoteResponse.bodyStream()) { + IoUtil.copy(remoteStream, response.getOutputStream()); + } + response.flushBuffer(); + + } catch (Exception e) { + throw new RuntimeException("文件下载失败", e); + } + } + + @RequestMapping("/uploadSoftFile") + public R uploadSoftFile(@RequestParam("file") MultipartFile file, @RequestParam("type") String type){ + try { + // 1. 将 MultipartFile 转为 Hutool 的 Resource 对象 + InputStreamResource resource = new InputStreamResource( + file.getInputStream(), + file.getOriginalFilename() // 保留原始文件名 + ); + // 2. 构建 HTTP 请求 + HttpResponse response = HttpRequest.post(sqlServerUrl+"/uploadSoftFile") + .form("file", resource) // 关键！参数名需与 @RequestParam("file") 一致 + .form("type", type) + .execute(); + + // 3. 处理响应 + if (response.isOk()) { + return R.ok(); + } else { + return R.error(); + } + } catch (Exception e) { + e.printStackTrace(); + } + return R.ok(); + } + + @DeleteMapping("/cgtask/delete/{id}") public R delete(@PathVariable("id")Integer id){ return ycExportTaskService.removeTask(id); @@ -61,8 +146,53 @@ public class BaseInfoController { @PostMapping("/importDateToSoft") - public R importDateToSoft(String startTime, String endTime){ - return hyStscAService.importDateTosoft(startTime,endTime); + public R importDateToSoft(){ + return hyStscAService.importDateTosoft(); + } + + @RequestMapping("/getStationListByType") + public R getStationListByType(@RequestParam(value = "type",defaultValue = "") String type, + @RequestParam(value = "startTime",defaultValue = "") String startTime, + @RequestParam(value = "endTime",defaultValue = "")String endTime) { + return R.ok().put("data", hyStscAService.getStationListByType(startTime,endTime,type)); + } + + @RequestMapping("/testConnection") + public R testConnection(@RequestParam Map params) { + // 从参数中提取连接信息（注意：前端参数键名需保持一致） + String ip = params.get("sqlseverIp").toString(); + String userName = params.get("userName").toString(); + String password = params.get("password").toString(); + String database = params.get("dataBase").toString(); + + String url = "jdbc:sqlserver://" + ip + ":1433;databaseName=" + database+";ncrypt=false;allowMultiQueries=true"; + + // 测试连接 + try { + // 加载JDBC驱动（需确保驱动包在类路径中） + Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); + + // 尝试建立连接 + try (Connection conn = DriverManager.getConnection(url, userName, password)) { + return R.ok().put("data", "数据库连接成功"); + } + } catch (ClassNotFoundException | SQLException e) { + return R.error("连接失败"); + } + } + + + @RequestMapping("/importDateToSoftOrExportSoft") + public R importDateToSoftOrExportSoft(@RequestBody FormDataRo formDataRo) { + if (formDataRo.getIds().isEmpty() || formDataRo.getStationTypeValue().isEmpty() || formDataRo.getStartTime().isEmpty() || formDataRo.getEndTime().isEmpty() || formDataRo.getSoftTypeValue().isEmpty() || formDataRo.getStcds().isEmpty()){ + return R.error("还有未填的选项"); + } + if ("1".equals(formDataRo.getSoftTypeValue())) { + return hyStscAService.importDateToHydp(formDataRo); + } else { + return hyStscAService.exportSoftToDate(formDataRo); + } + } } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/FzTableId.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/FzTableId.java new file mode 100644 index 0000000..b3b3563 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/FzTableId.java @@ -0,0 +1,23 @@ +package com.ruoyi.swlscx.basic.domain.po; + +import lombok.Data; + +/** + * @Author al + * @Date 2025/6/8 14:56 + * @Description: TODO + * @Version + */ +@Data +public class FzTableId { + + private String stcd; + + private Integer yr; + + private String rtno; + + private String yn; + + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/HyWfdzF.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/HyWfdzF.java new file mode 100644 index 0000000..98e4531 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/HyWfdzF.java @@ -0,0 +1,23 @@ + +package com.ruoyi.swlscx.basic.domain.po; + +import lombok.Data; + +import java.math.BigDecimal; + +/** + * @Author al + * @Date 2025/6/7 22:06 + * @Description: TODO + * @Version + */ +@Data +public class HyWfdzF +{ + private String stcd; + private BigDecimal yr; + private BigDecimal wf; + private BigDecimal rfz; + private String rzrcd; + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/YcShdpInfo.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/YcShdpInfo.java new file mode 100644 index 0000000..5c9f38c --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/po/YcShdpInfo.java @@ -0,0 +1,20 @@ +package com.ruoyi.swlscx.basic.domain.po; + +import lombok.Data; + +/** + * @Author al + * @Date 2025/6/7 22:06 + * @Description: TODO + * @Version + */ +@Data +public class YcShdpInfo +{ + private Integer tableId; + private String name; + private String tableName; + + private String yn; + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/ro/FormDataRo.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/ro/FormDataRo.java new file mode 100644 index 0000000..1387355 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/ro/FormDataRo.java @@ -0,0 +1,23 @@ +package com.ruoyi.swlscx.basic.domain.ro; + +import lombok.Data; + +/** + * @Author al + * @Date 2025/6/7 21:40 + * @Description: TODO + * @Version + */ +@Data +public class FormDataRo { + private String sqlseverIp; + private String userName; + private String password; + private String dataBase; + private String startTime; + private String endTime; + private String stcds; + private String softTypeValue; + private String stationTypeValue; + private String ids; +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDmxpFRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDmxpFRowMapper.java new file mode 100644 index 0000000..86bf9a0 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDmxpFRowMapper.java @@ -0,0 +1,46 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.year.domain.po.HyDmxpF; +import com.ruoyi.swlscx.year.domain.po.HyYrpF; +import org.springframework.jdbc.core.RowMapper; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyDmxpFRowMapper implements RowMapper { + + @Override + public HyDmxpF mapRow(ResultSet rs, int rowNum) throws SQLException { + HyDmxpF hyDmxpF = new HyDmxpF(); + + // 映射基础字段 + hyDmxpF.setStcd(rs.getString("stcd")); // 站码[7](@ref) + hyDmxpF.setMxpdr(rs.getInt("mxpdr")); // 最大降水量时段长 + hyDmxpF.setYr(rs.getInt("yr")); // 年[7](@ref) + + // 映射数值字段（BigDecimal类型） + hyDmxpF.setMxp(rs.getBigDecimal("mxp")); // 最大降水量[6](@ref) + hyDmxpF.setMxprc(rs.getString("mxprc")); // 注解码[7](@ref) + + // 安全处理日期字段（避免空指针） + mapNullableDate(rs, "bgdt", hyDmxpF::setBgdt); // 起始日期[6](@ref) + + return hyDmxpF; + } + + // 辅助方法：安全处理日期空值 + private void mapNullableDate(ResultSet rs, String column, java.util.function.Consumer setter) + throws SQLException { + java.sql.Date sqlDate = rs.getDate(column); + if (sqlDate != null && !rs.wasNull()) { // 双重空值检查[6](@ref) + setter.accept(new Date(sqlDate.getTime())); // 转换为java.util.Date[6](@ref) + } + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDpCRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDpCRowMapper.java new file mode 100644 index 0000000..3dfeb12 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDpCRowMapper.java @@ -0,0 +1,37 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.day.domain.po.HyDpC; +import org.springframework.jdbc.core.RowMapper; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 15:15 + * @Description: TODO + * @Version + */ +public class HyDpCRowMapper implements RowMapper { + + @Override + public HyDpC mapRow(ResultSet rs, int rowNum) throws SQLException { + HyDpC hyDpC = new HyDpC(); + + // 字符串类型字段（主键+普通字段） + hyDpC.setStcd(rs.getString("stcd")); // 站码 + hyDpC.setPrcd(rs.getString("prcd")); // 降水量注解码 + + // 日期类型字段（需转换java.sql.Date → java.util.Date） + java.sql.Date sqlDate = rs.getDate("dt"); + if (sqlDate != null) { + hyDpC.setDt(new Date(sqlDate.getTime())); // 日期 + } + + // 数值类型字段（BigDecimal精确处理） + hyDpC.setP(rs.getBigDecimal("p")); // 降水量(毫米) + + return hyDpC; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDqCRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDqCRowMapper.java new file mode 100644 index 0000000..ca68e2f --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDqCRowMapper.java @@ -0,0 +1,44 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.day.domain.po.HyDpC; +import com.ruoyi.swlscx.day.domain.po.HyDqC; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 15:15 + * @Description: TODO + * @Version + */ +public class HyDqCRowMapper implements RowMapper { + + @Override + public HyDqC mapRow(ResultSet rs, int rowNum) throws SQLException { + HyDqC entity = new HyDqC(); + + // 1. 站码（空值安全处理） + entity.setStcd(rs.getString("stcd") != null ? rs.getString("stcd") : ""); + + // 2. 日期（精确到毫秒的时间戳处理） + Timestamp dtTimestamp = rs.getTimestamp("dt"); + if (dtTimestamp != null) { + entity.setDt(new Date(dtTimestamp.getTime())); + } + + // 3. 平均流量（保留NULL语义） + BigDecimal avq = rs.getBigDecimal("avq"); + entity.setAvq(avq); // 保留NULL表示数据缺失 + + // 4. 平均流量注解码（空值安全处理） + String avqrcd = rs.getString("avqrcd"); + entity.setAvqrcd(avqrcd != null ? avqrcd : ""); // NULL → 空字符串 + + return entity; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDzCRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDzCRowMapper.java new file mode 100644 index 0000000..d44edd3 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyDzCRowMapper.java @@ -0,0 +1,46 @@ + +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.day.domain.po.HyDzC; +import com.ruoyi.swlscx.excerpt.domain.po.HyPrexB; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyDzCRowMapper implements RowMapper { + + + @Override + public HyDzC mapRow(ResultSet rs, int rowNum) throws SQLException { + HyDzC hyDzC = new HyDzC(); + + // 1. 站码（字符串） + hyDzC.setStcd(rs.getString("stcd")); + + // 2. 日期（带空值检查） + Timestamp dtTimestamp = rs.getTimestamp("dt"); + if (dtTimestamp != null) { + hyDzC.setDt(new Date(dtTimestamp.getTime())); // SQL Timestamp → Java Date + } + + // 3. 平均水位（精确数值） + BigDecimal avz = rs.getBigDecimal("avz"); + hyDzC.setAvz(avz != null ? avz : BigDecimal.ZERO); // NULL 转为 0.00 + + // 4. 注解码（空值安全处理） + String avzrcd = rs.getString("avzrcd"); + hyDzC.setAvzrcd(avzrcd != null ? avzrcd : ""); // NULL 转空字符串 + + return hyDzC; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyHltdzBRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyHltdzBRowMapper.java new file mode 100644 index 0000000..707c3e5 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyHltdzBRowMapper.java @@ -0,0 +1,64 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.excerpt.domain.po.HyHltdzB; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyHltdzBRowMapper implements RowMapper { + + @Override + public HyHltdzB mapRow(ResultSet rs, int rowNum) throws SQLException { + HyHltdzB hyHltdzB = new HyHltdzB(); + + // 1. 站码（空值安全处理） + hyHltdzB.setStcd(rs.getString("stcd") != null ? rs.getString("stcd") : ""); + + // 2. 时间（精确到毫秒的时间戳处理） + Timestamp tmTimestamp = rs.getTimestamp("tm"); + if (tmTimestamp != null) { + hyHltdzB.setTm(new Date(tmTimestamp.getTime())); + } + + // 3. 潮别（空值安全处理） + hyHltdzB.setTdtp(rs.getString("tdtp") != null ? rs.getString("tdtp") : ""); + + // 4. 潮位（精确数值，保留NULL语义） + BigDecimal tdz = rs.getBigDecimal("tdz"); + hyHltdzB.setTdz(tdz); // 保持NULL表示数据缺失 + + // 5. 潮位注解码（空值安全处理） + hyHltdzB.setTdzrcd(rs.getString("tdzrcd") != null ? rs.getString("tdzrcd") : ""); + + // 6. 潮差（精确数值，保留NULL语义） + BigDecimal tdrng = rs.getBigDecimal("tdrng"); + hyHltdzB.setTdrng(tdrng); // 保持NULL表示数据缺失 + + // 7. 历时（空值安全处理） + hyHltdzB.setDr(rs.getString("dr") != null ? rs.getString("dr") : ""); + + // 8. 备注（空值安全处理） + hyHltdzB.setNt(rs.getString("nt") != null ? rs.getString("nt") : ""); + + return hyHltdzB; + } + + // 辅助方法：安全处理日期空值（已集成到主逻辑） + private void mapNullableDate(ResultSet rs, String column, java.util.function.Consumer setter) + throws SQLException { + java.sql.Date sqlDate = rs.getDate(column); + if (sqlDate != null && !rs.wasNull()) { + setter.accept(new Date(sqlDate.getTime())); + } + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyHmxpFRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyHmxpFRowMapper.java new file mode 100644 index 0000000..e4bb336 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyHmxpFRowMapper.java @@ -0,0 +1,59 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.day.domain.po.HyDpC; +import com.ruoyi.swlscx.year.domain.po.HyHmxpF; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 15:15 + * @Description: TODO + * @Version + */ +public class HyHmxpFRowMapper implements RowMapper { + + @Override + public HyHmxpF mapRow(ResultSet rs, int rowNum) throws SQLException { + HyHmxpF hyHmxpF = new HyHmxpF(); + + // 映射基础字段（空值安全处理） + hyHmxpF.setStcd(rs.getString("stcd")); // 站码 + + // 整数类型字段（处理数据库NULL值） + setNullableInt(rs, "mxpdr", hyHmxpF::setMxpdr); // 最大降水量时段长(小时) + setNullableInt(rs, "yr", hyHmxpF::setYr); // 年 + + // 精度数值字段 + hyHmxpF.setMxp(rs.getObject("mxp", BigDecimal.class)); // 最大降水量(毫米) + hyHmxpF.setMxprc(rs.getString("mxprc")); // 注解码 + + // 日期时间字段（精确到秒） + mapNullableTimestamp(rs, "bgtm", hyHmxpF::setBgtm); // 起时间 + + return hyHmxpF; + } + + // 辅助方法：安全处理整数空值 + private void setNullableInt(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + int value = rs.getInt(column); + setter.accept(rs.wasNull() ? null : value); + } + + // 辅助方法：安全处理时间戳（精确到秒） + private void mapNullableTimestamp(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + Timestamp timestamp = rs.getTimestamp(column); + if (timestamp != null && !rs.wasNull()) { + setter.accept(new Date(timestamp.getTime())); // 转为java.util.Date + } + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyImxfwFRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyImxfwFRowMapper.java new file mode 100644 index 0000000..c9c1f07 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyImxfwFRowMapper.java @@ -0,0 +1,67 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.day.domain.po.HyDpC; +import com.ruoyi.swlscx.year.domain.po.HyImxfwF; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; +import java.util.function.Consumer; + +/** + * @Author al + * @Date 2025/6/20 15:15 + * @Description: TODO + * @Version + */ +public class HyImxfwFRowMapper implements RowMapper { + + @Override + public HyImxfwF mapRow(ResultSet rs, int rowNum) throws SQLException { + HyImxfwF entity = new HyImxfwF(); + + // 基础信息映射 + entity.setStcd(handleStringNull(rs, "stcd")); // 站码（空值→空字符串）[5](@ref) + entity.setMxwdr(handleStringNull(rs, "mxwdr")); // 洪量时段长（空值→空字符串） + setNullableInt(rs, "yr", entity::setYr); // 年份（保留NULL语义）[5](@ref) + + // 洪量特征数据 + mapNullableTimestamp(rs, "bgdt", entity::setBgdt); // 起始日期（精确时间戳）[4,5](@ref) + mapBigDecimal(rs, "mxw", entity::setMxw); // 最大洪量（保留NULL）[5](@ref) + entity.setMxwrc(handleStringNull(rs, "mxwrc")); // 洪量注解码（空值→空字符串） + + return entity; + } + + // 辅助方法：安全处理字符串空值 + private String handleStringNull(ResultSet rs, String column) throws SQLException { + String value = rs.getString(column); + return value != null ? value : ""; // NULL → 空字符串[5](@ref) + } + + // 辅助方法：安全处理整数空值（保留NULL语义） + private void setNullableInt(ResultSet rs, String column, + Consumer setter) throws SQLException { + int value = rs.getInt(column); + setter.accept(rs.wasNull() ? null : value); // 区分0值与数据缺失[1,4](@ref) + } + + // 辅助方法：安全处理时间戳（精确到毫秒） + private void mapNullableTimestamp(ResultSet rs, String column, + Consumer setter) throws SQLException { + Timestamp timestamp = rs.getTimestamp(column); + if (timestamp != null && !rs.wasNull()) { + setter.accept(new Date(timestamp.getTime())); // 确保时间精度[4,5](@ref) + } + } + + // 辅助方法：安全处理BigDecimal（保留NULL语义） + private void mapBigDecimal(ResultSet rs, String column, + Consumer setter) throws SQLException { + BigDecimal value = rs.getBigDecimal(column); + setter.accept(value); // 不转换NULL，区分真实0值与数据缺失[5](@ref) + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMmxpFRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMmxpFRowMapper.java new file mode 100644 index 0000000..c4f5dcd --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMmxpFRowMapper.java @@ -0,0 +1,45 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.year.domain.po.HyMmxpF; +import com.ruoyi.swlscx.year.domain.po.HyYrpF; +import org.springframework.jdbc.core.RowMapper; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyMmxpFRowMapper implements RowMapper { + + @Override + public HyMmxpF mapRow(ResultSet rs, int rowNum) throws SQLException { + HyMmxpF hyMmxpF = new HyMmxpF(); + // 映射基础字段 + hyMmxpF.setStcd(rs.getString("stcd")); // 站码 + hyMmxpF.setMxpdr(rs.getInt("mxpdr")); // 最大降水量时段长 + hyMmxpF.setYr(rs.getInt("yr")); // 年 + + // 映射精度数值字段 + hyMmxpF.setMxp(rs.getBigDecimal("mxp")); // 最大降水量 + hyMmxpF.setMxprc(rs.getString("mxprc")); // 注解码 + + // 安全处理日期字段（空值保护） + mapNullableDate(rs, "bgtm", hyMmxpF::setBgdt); // 起时间 + + return hyMmxpF; + } + // 辅助方法：安全处理日期空值（双重检查） + private void mapNullableDate(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + java.sql.Date sqlDate = rs.getDate(column); + if (sqlDate != null && !rs.wasNull()) { + setter.accept(new Date(sqlDate.getTime())); // 转换为java.util.Date + } + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtpERowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtpERowMapper.java new file mode 100644 index 0000000..ecb73f3 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtpERowMapper.java @@ -0,0 +1,48 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.basic.domain.po.HyStscA; +import com.ruoyi.swlscx.month.domain.po.HyMtpE; +import org.springframework.jdbc.core.RowMapper; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyMtpERowMapper implements RowMapper { + + @Override + public HyMtpE mapRow(ResultSet rs, int rowNum) throws SQLException { + HyMtpE hyMtpE = new HyMtpE(); + + // 映射基础字段 + hyMtpE.setStcd(rs.getString("stcd")); // 站码 + hyMtpE.setYr(rs.getInt("yr")); // 年 + hyMtpE.setMth(rs.getInt("mth")); // 月 + + // 映射降水量相关字段 + hyMtpE.setP(rs.getBigDecimal("p")); // 降水量(毫米) + hyMtpE.setPrcd(rs.getString("prcd")); // 降水量注解码 + + // 映射降水日数字段 + hyMtpE.setPdynum(rs.getString("pdynum")); // 降水日数 + hyMtpE.setPdynumrcd(rs.getString("pdynumrcd")); // 降水日数注解码 + + // 映射最大降水量字段 + hyMtpE.setMxdyp(rs.getBigDecimal("mxdyp")); // 最大降水量(毫米) + hyMtpE.setMxdyprcd(rs.getString("mxdyprcd")); // 最大降水量注解码 + + // 映射日期字段 + java.sql.Date sqlDate = rs.getDate("mxdypodt"); + if (sqlDate != null) { + hyMtpE.setMxdypodt(new Date(sqlDate.getTime())); // 最大日降水量出现日期 + } + + return hyMtpE; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtqERowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtqERowMapper.java new file mode 100644 index 0000000..a9dcca6 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtqERowMapper.java @@ -0,0 +1,72 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.day.domain.po.HyDqC; +import com.ruoyi.swlscx.month.domain.po.HyMtqE; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 15:15 + * @Description: TODO + * @Version + */ +public class HyMtqERowMapper implements RowMapper { + + @Override + public HyMtqE mapRow(ResultSet rs, int rowNum) throws SQLException { + HyMtqE entity = new HyMtqE(); + + // 1. 基础信息映射 + entity.setStcd(rs.getString("stcd") != null ? rs.getString("stcd") : ""); // 站码（空值→空字符串） + setNullableInt(rs, "yr", entity::setYr); // 年份（保留NULL语义） + setNullableInt(rs, "mth", entity::setMth); // 月份（保留NULL语义） + + // 2. 平均流量数据 + mapBigDecimal(rs, "avq", entity::setAvq); // 平均流量（保留NULL） + entity.setAvqrcd(rs.getString("avqrcd") != null ? rs.getString("avqrcd") : ""); // 注解码 + + // 3. 最高流量数据 + mapBigDecimal(rs, "mxq", entity::setMxq); // 最高流量（保留NULL） + entity.setMxqrcd(rs.getString("mxqrcd") != null ? rs.getString("mxqrcd") : ""); + mapNullableTimestamp(rs, "mxqdt", entity::setMxqdt); // 最高流量日期（精确时间戳） + + // 4. 最低流量数据 + mapBigDecimal(rs, "mnq", entity::setMnq); // 最低流量（保留NULL） + entity.setMnqrcd(rs.getString("mnqrcd") != null ? rs.getString("mnqrcd") : ""); + mapNullableTimestamp(rs, "mnqdt", entity::setMnqdt); // 最低流量日期 + + return entity; + } + + // 辅助方法：安全处理整数空值（保留NULL语义） + private void setNullableInt(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + int value = rs.getInt(column); + setter.accept(rs.wasNull() ? null : value); // 明确区分0值和数据缺失[3](@ref) + } + + // 辅助方法：安全处理时间戳（精确到毫秒） + private void mapNullableTimestamp(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + Timestamp timestamp = rs.getTimestamp(column); + if (timestamp != null && !rs.wasNull()) { + setter.accept(new Date(timestamp.getTime())); // 确保时间精度[1](@ref) + } + } + + // 辅助方法：安全处理BigDecimal（保留NULL语义） + private void mapBigDecimal(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + BigDecimal value = rs.getBigDecimal(column); + setter.accept(value); // 不转换NULL，区分真实0值与数据缺失[4](@ref) + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMttdzERowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMttdzERowMapper.java new file mode 100644 index 0000000..59b89e8 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMttdzERowMapper.java @@ -0,0 +1,126 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.month.domain.po.HyMttdzE; +import com.ruoyi.swlscx.year.domain.po.HyHmxpF; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 15:15 + * @Description: TODO + * @Version + */ +public class HyMttdzERowMapper implements RowMapper { + + @Override + public HyMttdzE mapRow(ResultSet rs, int rowNum) throws SQLException { + HyMttdzE entity = new HyMttdzE(); + + // 基础信息映射 + entity.setStcd(rs.getString("stcd") != null ? rs.getString("stcd") : ""); + setNullableInt(rs, "yr", entity::setYr); + setNullableInt(rs, "mth", entity::setMth); + + // 高潮潮位数据 + mapBigDecimal(rs, "avhtdz", entity::setAvhtdz); + entity.setAvhtdzrcd(rs.getString("avhtdzrcd") != null ? rs.getString("avhtdzrcd") : ""); + mapBigDecimal(rs, "hthtdz", entity::setHthtdz); + entity.setHthtdzrcd(rs.getString("hthtdzrcd") != null ? rs.getString("hthtdzrcd") : ""); + mapNullableTimestamp(rs, "hthtdzotm", entity::setHthtdzotm); + mapBigDecimal(rs, "lthtdz", entity::setLthtdz); + entity.setLthtdzrcd(rs.getString("lthtdzrcd") != null ? rs.getString("lthtdzrcd") : ""); + mapNullableTimestamp(rs, "lthtdzotm", entity::setLthtdzotm); + + // 低潮潮位数据 + mapBigDecimal(rs, "avltdz", entity::setAvltdz); + entity.setAvltdzrcd(rs.getString("avltdzrcd") != null ? rs.getString("avltdzrcd") : ""); + mapBigDecimal(rs, "htltdz", entity::setHtltdz); + entity.setHtltdzrcd(rs.getString("htltdzrcd") != null ? rs.getString("htltdzrcd") : ""); + mapNullableTimestamp(rs, "htltdzotm", entity::setHtltdzotm); + mapBigDecimal(rs, "ltltdz", entity::setLtltdz); + entity.setLtltdzrcd(rs.getString("ltltdzrcd") != null ? rs.getString("ltltdzrcd") : ""); + mapNullableTimestamp(rs, "ltltdzotm", entity::setLtltdzotm); + + // 涨潮潮差数据 + mapBigDecimal(rs, "avftdr", entity::setAvftdr); + entity.setAvftdrrcd(rs.getString("avftdrrcd") != null ? rs.getString("avftdrrcd") : ""); + mapBigDecimal(rs, "mxfltdr", entity::setMxfltdr); + entity.setMxfltdrrcd(rs.getString("mxfltdrrcd") != null ? rs.getString("mxfltdrrcd") : ""); + mapNullableTimestamp(rs, "mxfltdrhtm", entity::setMxfltdrhtm); + mapBigDecimal(rs, "mnfltdr", entity::setMnfltdr); + entity.setMnfltdrrcd(rs.getString("mnfltdrrcd") != null ? rs.getString("mnfltdrrcd") : ""); + mapNullableTimestamp(rs, "mnfltdrhtm", entity::setMnfltdrhtm); + + // 落潮潮差数据 + mapBigDecimal(rs, "aver", entity::setAver); + entity.setAverbbrrcd(rs.getString("averbbrrcd") != null ? rs.getString("averbbrrcd") : ""); + mapBigDecimal(rs, "mxebtdr", entity::setMxebtdr); + entity.setMxebtdrrcd(rs.getString("mxebtdrrcd") != null ? rs.getString("mxebtdrrcd") : ""); + mapNullableTimestamp(rs, "mxebtdrht", entity::setMxebtdrht); + mapBigDecimal(rs, "mnebtdr", entity::setMnebtdr); + entity.setMnebtdrrcd(rs.getString("mnebtdrrcd") != null ? rs.getString("mnebtdrrcd") : ""); + mapNullableTimestamp(rs, "mnebtdrhtm", entity::setMnebtdrhtm); + + // 涨潮历时数据 + setNullableInt(rs, "avftd", entity::setAvftd); + entity.setAvftdrcd(rs.getString("avftdrcd") != null ? rs.getString("avftdrcd") : ""); + setNullableInt(rs, "mxfltddr", entity::setMxfltddr); + entity.setMxfltddrrcd(rs.getString("mxfltddrrcd") != null ? rs.getString("mxfltddrrcd") : ""); + mapNullableTimestamp(rs, "mxfltddrhtm", entity::setMxfltddrhtm); + setNullableInt(rs, "mnfltddr", entity::setMnfltddr); + entity.setMnfltddrrcd(rs.getString("mnfltddrrcd") != null ? rs.getString("mnfltddrrcd") : ""); + mapNullableTimestamp(rs, "mnfltddrhtm", entity::setMnfltddrhtm); + + // 落潮历时数据 + setNullableInt(rs, "avebbdr", entity::setAvebbdr); + entity.setAvedrc(rs.getString("avedrc") != null ? rs.getString("avedrc") : ""); + setNullableInt(rs, "mxebtddr", entity::setMxebtddr); + entity.setMxebtddrrcd(rs.getString("mxebtddrrcd") != null ? rs.getString("mxebtddrrcd") : ""); + mapNullableTimestamp(rs, "mxebtddrhtm", entity::setMxebtddrhtm); + setNullableInt(rs, "mnbtddr", entity::setMnbtddr); + entity.setMnebtddrrcd(rs.getString("mnebtddrrcd") != null ? rs.getString("mnebtddrrcd") : ""); + mapNullableTimestamp(rs, "mnebtddrhtm", entity::setMnebtddrhtm); + + // 综合潮位数据 + mapBigDecimal(rs, "hravtdz", entity::setHravtdz); + entity.setHravtdzrcd(rs.getString("hravtdzrcd") != null ? rs.getString("hravtdzrcd") : ""); + mapBigDecimal(rs, "avtdr", entity::setAvtdr); + entity.setAvtdrrcd(rs.getString("avtdrrcd") != null ? rs.getString("avtdrrcd") : ""); + setNullableInt(rs, "avtddr", entity::setAvtddr); + entity.setAvtddrrcd(rs.getString("avtddrrcd") != null ? rs.getString("avtddrrcd") : ""); + + return entity; + } + + // 辅助方法：安全处理整数空值 + private void setNullableInt(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + int value = rs.getInt(column); + setter.accept(rs.wasNull() ? null : value); + } + + // 辅助方法：安全处理时间戳（精确到秒） + private void mapNullableTimestamp(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + Timestamp timestamp = rs.getTimestamp(column); + if (timestamp != null && !rs.wasNull()) { + setter.accept(new Date(timestamp.getTime())); + } + } + + // 新增辅助方法：安全处理BigDecimal空值（保留NULL语义） + private void mapBigDecimal(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + BigDecimal value = rs.getBigDecimal(column); + setter.accept(value); // 保留NULL表示数据缺失 + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtzERowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtzERowMapper.java new file mode 100644 index 0000000..0614e25 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyMtzERowMapper.java @@ -0,0 +1,75 @@ + +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.day.domain.po.HyDzC; +import com.ruoyi.swlscx.month.domain.po.HyMtzE; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyMtzERowMapper implements RowMapper { + + @Override + public HyMtzE mapRow(ResultSet rs, int rowNum) throws SQLException { + HyMtzE hyMtzE = new HyMtzE(); + + // 1. 站码（字符串） + hyMtzE.setStcd(rs.getString("stcd")); + + // 2. 年份（整数） + Integer yr = rs.getInt("yr"); + hyMtzE.setYr(rs.wasNull() ? null : yr); // 处理SQL NULL + + // 3. 月份（整数） + Integer mth = rs.getInt("mth"); + hyMtzE.setMth(rs.wasNull() ? null : mth); + + // 4. 平均水位（精确数值） + BigDecimal avz = rs.getBigDecimal("avz"); + hyMtzE.setAvz(avz != null ? avz : BigDecimal.ZERO); // NULL 转为 0.00 + + // 5. 平均水位注解码 + String avzrcd = rs.getString("avzrcd"); + hyMtzE.setAvzrcd(avzrcd != null ? avzrcd : ""); + + // 6. 最高水位（精确数值） + BigDecimal htz = rs.getBigDecimal("htz"); + hyMtzE.setHtz(htz != null ? htz : BigDecimal.ZERO); + + // 7. 最高水位注解码 + String htzrcd = rs.getString("htzrcd"); + hyMtzE.setHtzrcd(htzrcd != null ? htzrcd : ""); + + // 8. 最高水位日期（带空值检查） + Timestamp htzdtTimestamp = rs.getTimestamp("htzdt"); + if (htzdtTimestamp != null) { + hyMtzE.setHtzdt(new Date(htzdtTimestamp.getTime())); + } + + // 9. 最低水位（精确数值） + BigDecimal mnz = rs.getBigDecimal("mnz"); + hyMtzE.setMnz(mnz != null ? mnz : BigDecimal.ZERO); + + // 10. 最低水位注解码 + String mnzrcd = rs.getString("mnzrcd"); + hyMtzE.setMnzrcd(mnzrcd != null ? mnzrcd : ""); + + // 11. 最低水位日期（带空值检查） + Timestamp mnzdtTimestamp = rs.getTimestamp("mnzdt"); + if (mnzdtTimestamp != null) { + hyMtzE.setMnzdt(new Date(mnzdtTimestamp.getTime())); + } + + return hyMtzE; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyPrexBRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyPrexBRowMapper.java new file mode 100644 index 0000000..08c1e58 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyPrexBRowMapper.java @@ -0,0 +1,49 @@ + +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.excerpt.domain.po.HyPrexB; +import com.ruoyi.swlscx.year.domain.po.HyMmxpF; +import org.springframework.jdbc.core.RowMapper; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyPrexBRowMapper implements RowMapper { + + + @Override + public HyPrexB mapRow(ResultSet rs, int rowNum) throws SQLException { + HyPrexB hyPrexB = new HyPrexB(); + + // 1. 站码（字符串） + hyPrexB.setStcd(rs.getString("stcd")); + + // 2. 起止时间（带时区转换） + Timestamp bgTimestamp = rs.getTimestamp("bgtm"); + if (bgTimestamp != null) { + hyPrexB.setBgtm(new Date(bgTimestamp.getTime())); // SQL Timestamp -> Java Date + } + + Timestamp endTimestamp = rs.getTimestamp("endtm"); + if (endTimestamp != null) { + hyPrexB.setEndtm(new Date(endTimestamp.getTime())); + } + + // 3. 降水量（精确数值） + hyPrexB.setP(rs.getBigDecimal("p")); // 直接映射BigDecimal + + // 4. 注解码（空值安全处理） + String prcd = rs.getString("prcd"); + hyPrexB.setPrcd(prcd != null ? prcd : ""); // NULL转空字符串 + + return hyPrexB; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyStscARowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyStscARowMapper.java new file mode 100644 index 0000000..0e47d33 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyStscARowMapper.java @@ -0,0 +1,61 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.basic.domain.po.HyStscA; +import org.springframework.jdbc.core.RowMapper; + +import java.sql.ResultSet; +import java.sql.SQLException; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyStscARowMapper implements RowMapper { + + @Override + public HyStscA mapRow(java.sql.ResultSet rs, int rowNum) throws java.sql.SQLException { + HyStscA hyStscA = new HyStscA(); + // 主键字段 + hyStscA.setStcd(rs.getString("stcd")); + hyStscA.setStnm(rs.getString("stnm")); + + // 字符串类型字段 + hyStscA.setStct(rs.getString("stct")); + hyStscA.setBshncd(rs.getString("bshncd")); + hyStscA.setHnnm(rs.getString("hnnm")); + hyStscA.setRvnm(rs.getString("rvnm")); + hyStscA.setObitmcd(rs.getString("obitmcd")); + hyStscA.setAddvcd(rs.getString("addvcd")); + hyStscA.setWrrgcd(rs.getString("wrrgcd")); + hyStscA.setFlto(rs.getString("flto")); + hyStscA.setFdtmnm(rs.getString("fdtmnm")); + hyStscA.setAdmag(rs.getString("admag")); + hyStscA.setAdmnst(rs.getString("admnst")); + hyStscA.setStlc(rs.getString("stlc")); + hyStscA.setStgrd(rs.getString("stgrd")); + hyStscA.setFrgrd(rs.getString("frgrd")); + hyStscA.setNt(rs.getString("nt")); + + // 整数类型字段（注意处理 NULL 值） + hyStscA.setEsstyr(getNullableInt(rs, "esstyr")); + hyStscA.setEsstmth(getNullableInt(rs, "esstmth")); + hyStscA.setWdstyr(getNullableInt(rs, "wdstyr")); + hyStscA.setWdstmth(getNullableInt(rs, "wdstmth")); + + // 小数类型字段（使用 BigDecimal 精确计算） + hyStscA.setDrar(rs.getBigDecimal("drar")); + hyStscA.setDstrvm(rs.getBigDecimal("dstrvm")); + hyStscA.setLgtd(rs.getBigDecimal("lgtd")); + hyStscA.setLttd(rs.getBigDecimal("lttd")); + + return hyStscA; + } + + // 处理可能为 NULL 的整数字段 + private Integer getNullableInt(ResultSet rs, String column) throws SQLException { + Object value = rs.getObject(column); + return (value != null) ? rs.getInt(column) : null; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyWfdzFRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyWfdzFRowMapper.java new file mode 100644 index 0000000..d3061f1 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyWfdzFRowMapper.java @@ -0,0 +1,54 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.basic.domain.po.HyWfdzF; +import com.ruoyi.swlscx.year.domain.po.HyYrpF; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyWfdzFRowMapper implements RowMapper { + + @Override + public HyWfdzF mapRow(ResultSet rs, int rowNum) throws SQLException { + HyWfdzF hyWfdzF = new HyWfdzF(); + + // 1. 站码（直接映射） + hyWfdzF.setStcd(rs.getString("stcd")); + + // 2. 年份（BigDecimal类型） + BigDecimal yr = rs.getBigDecimal("yr"); + hyWfdzF.setYr(yr != null ? yr : BigDecimal.ZERO); // NULL → 0 + + // 3. 降水量（BigDecimal类型） + BigDecimal wf = rs.getBigDecimal("wf"); + hyWfdzF.setWf(wf != null ? wf : BigDecimal.ZERO); // NULL → 0.00 + + // 4. 水位值（BigDecimal类型） + BigDecimal rfz = rs.getBigDecimal("rfz"); + hyWfdzF.setRfz(rfz != null ? rfz : BigDecimal.ZERO); // NULL → 0.00 + + // 5. 注解码（空值安全处理） + String rzrcd = rs.getString("rzrcd"); + hyWfdzF.setRzrcd(rzrcd != null ? rzrcd : ""); // NULL → 空字符串 + + return hyWfdzF; + } + + // 辅助方法：安全处理日期空值 + private void mapNullableDate(ResultSet rs, String column, java.util.function.Consumer setter) + throws SQLException { + java.sql.Date sqlDate = rs.getDate(column); + if (sqlDate != null && !rs.wasNull()) { + setter.accept(new Date(sqlDate.getTime())); + } + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyWsfhexBRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyWsfhexBRowMapper.java new file mode 100644 index 0000000..226a69e --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyWsfhexBRowMapper.java @@ -0,0 +1,53 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.excerpt.domain.po.HyWsfhexB; +import com.ruoyi.swlscx.year.domain.po.HyMmxpF; +import org.springframework.jdbc.core.RowMapper; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyWsfhexBRowMapper implements RowMapper { + + @Override + public HyWsfhexB mapRow(ResultSet rs, int rowNum) throws SQLException { + HyWsfhexB entity = new HyWsfhexB(); + + // 站码（字符串，处理空值） + entity.setStcd(rs.getString("stcd") != null ? rs.getString("stcd") : ""); + + // 时间（使用getTimestamp获取时间戳，然后转换为Date） + Timestamp tmTimestamp = rs.getTimestamp("tm"); + if (tmTimestamp != null) { + entity.setTm(new Date(tmTimestamp.getTime())); + } + + // 闸上水位（BigDecimal，允许为NULL） + entity.setUpz(rs.getBigDecimal("upz")); + + // 闸上水位注解码（字符串，处理空值） + entity.setUpzrcd(rs.getString("upzrcd") != null ? rs.getString("upzrcd") : ""); + + // 闸下水位（BigDecimal，允许为NULL） + entity.setDwz(rs.getBigDecimal("dwz")); + + // 闸下水位注解码（字符串，处理空值） + entity.setDwzrcd(rs.getString("dwzrcd") != null ? rs.getString("dwzrcd") : ""); + + // 流量（BigDecimal，允许为NULL） + entity.setQ(rs.getBigDecimal("q")); + + // 含沙量（BigDecimal，允许为NULL） + entity.setS(rs.getBigDecimal("s")); + + return entity; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrpFRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrpFRowMapper.java new file mode 100644 index 0000000..a9b31de --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrpFRowMapper.java @@ -0,0 +1,52 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.month.domain.po.HyMtpE; +import com.ruoyi.swlscx.year.domain.po.HyYrpF; +import org.springframework.jdbc.core.RowMapper; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyYrpFRowMapper implements RowMapper { + + @Override + public HyYrpF mapRow(ResultSet rs, int rowNum) throws SQLException { + HyYrpF hyYrpF = new HyYrpF(); + + // 映射基础字段 + hyYrpF.setStcd(rs.getString("stcd")); // 站码 + hyYrpF.setYr(rs.getInt("yr")); // 年 + + // 映射降水量相关字段 + hyYrpF.setP(rs.getBigDecimal("p")); // 降水量(毫米) + hyYrpF.setPrcd(rs.getString("prcd")); // 降水量注解码 + + // 映射降水日数字段 + hyYrpF.setPdynum(rs.getString("pdynum")); // 降水日数 + hyYrpF.setPdynumrcd(rs.getString("pdynumrcd")); // 降水日数注解码 + + // 映射日期字段（处理空值） + mapNullableDate(rs, "frdsdt", hyYrpF::setFrdsdt); // 终霜日期 + mapNullableDate(rs, "frapdt", hyYrpF::setFrapdt); // 初霜日期 + mapNullableDate(rs, "sndsdt", hyYrpF::setSndsdt); // 终雪日期 + mapNullableDate(rs, "snapdt", hyYrpF::setSnapdt); // 初雪日期 + + return hyYrpF; + } + + // 辅助方法：安全处理日期空值 + private void mapNullableDate(ResultSet rs, String column, java.util.function.Consumer setter) + throws SQLException { + java.sql.Date sqlDate = rs.getDate(column); + if (sqlDate != null && !rs.wasNull()) { + setter.accept(new Date(sqlDate.getTime())); + } + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrqFRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrqFRowMapper.java new file mode 100644 index 0000000..38260f5 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrqFRowMapper.java @@ -0,0 +1,73 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.month.domain.po.HyMtpE; +import com.ruoyi.swlscx.year.domain.po.HyYrqF; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyYrqFRowMapper implements RowMapper { + + @Override + public HyYrqF mapRow(ResultSet rs, int rowNum) throws SQLException { + HyYrqF entity = new HyYrqF(); + + // 基础信息映射 + entity.setStcd(rs.getString("stcd") != null ? rs.getString("stcd") : ""); // 站码（空值→空字符串）[2,4](@ref) + setNullableInt(rs, "yr", entity::setYr); // 年份（保留NULL语义） + + // 流量核心数据 + mapBigDecimal(rs, "avq", entity::setAvq); // 平均流量（保留NULL） + entity.setAvqrcd(rs.getString("avqrcd") != null ? rs.getString("avqrcd") : ""); + mapBigDecimal(rs, "mxq", entity::setMxq); // 最高流量（保留NULL） + entity.setMxqrcd(rs.getString("mxqrcd") != null ? rs.getString("mxqrcd") : ""); + mapNullableTimestamp(rs, "mxqdt", entity::setMxqdt); // 最高流量日期（精确时间戳） + mapBigDecimal(rs, "mnq", entity::setMnq); // 最低流量（保留NULL） + entity.setMnqrcd(rs.getString("mnqrcd") != null ? rs.getString("mnqrcd") : ""); + mapNullableTimestamp(rs, "mnqdt", entity::setMnqdt); // 最低流量日期 + + // 径流特征数据 + mapBigDecimal(rs, "rw", entity::setRw); // 径流量（万立方米） + entity.setRwrcd(rs.getString("rwrcd") != null ? rs.getString("rwrcd") : ""); + mapBigDecimal(rs, "rm", entity::setRm); // 径流模数 + mapBigDecimal(rs, "rd", entity::setRd); // 径流深 + + return entity; + } + + // 辅助方法：安全处理整数空值（保留NULL语义）[3,5](@ref) + private void setNullableInt(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + int value = rs.getInt(column); + setter.accept(rs.wasNull() ? null : value); // 明确区分0值和数据缺失 + } + + // 辅助方法：安全处理时间戳（精确到毫秒）[4](@ref) + private void mapNullableTimestamp(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + Timestamp timestamp = rs.getTimestamp(column); + if (timestamp != null && !rs.wasNull()) { + setter.accept(new Date(timestamp.getTime())); // 确保时间精度 + } + } + + // 辅助方法：安全处理BigDecimal（保留NULL语义）[6](@ref) + private void mapBigDecimal(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + BigDecimal value = rs.getBigDecimal(column); + setter.accept(value); // 不转换NULL，区分真实0值与数据缺失 + } +} \ No newline at end of file diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrtdzFRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrtdzFRowMapper.java new file mode 100644 index 0000000..daff6c0 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrtdzFRowMapper.java @@ -0,0 +1,125 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.month.domain.po.HyMttdzE; +import com.ruoyi.swlscx.year.domain.po.HyYrtdzF; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 15:15 + * @Description: TODO + * @Version + */ +public class HyYrtdzFRowMapper implements RowMapper { + + @Override + public HyYrtdzF mapRow(ResultSet rs, int rowNum) throws SQLException { + HyYrtdzF entity = new HyYrtdzF(); + + // 基础信息映射 + entity.setStcd(rs.getString("stcd") != null ? rs.getString("stcd") : ""); + setNullableInt(rs, "yr", entity::setYr); + + // 高潮潮位数据 + mapBigDecimal(rs, "avhtdz", entity::setAvhtdz); + entity.setAvhtdzrcd(rs.getString("avhtdzrcd") != null ? rs.getString("avhtdzrcd") : ""); + mapBigDecimal(rs, "hthtdz", entity::setHthtdz); + entity.setHthtdzrcd(rs.getString("hthtdzrcd") != null ? rs.getString("hthtdzrcd") : ""); + mapNullableTimestamp(rs, "hthtdzotm", entity::setHthtdzotm); + mapBigDecimal(rs, "lthtdz", entity::setLthtdz); + entity.setLthtdzrcd(rs.getString("lthtdzrcd") != null ? rs.getString("lthtdzrcd") : ""); + mapNullableTimestamp(rs, "lthtdzotm", entity::setLthtdzotm); + + // 低潮潮位数据 + mapBigDecimal(rs, "avltdz", entity::setAvltdz); + entity.setAvltdzrcd(rs.getString("avltdzrcd") != null ? rs.getString("avltdzrcd") : ""); + mapBigDecimal(rs, "htltdz", entity::setHtltdz); + entity.setHtltdzrcd(rs.getString("htltdzrcd") != null ? rs.getString("htltdzrcd") : ""); + mapNullableTimestamp(rs, "htltdzotm", entity::setHtltdzotm); + mapBigDecimal(rs, "ltltdz", entity::setLtltdz); + entity.setLtltdzrcd(rs.getString("ltltdzrcd") != null ? rs.getString("ltltdzrcd") : ""); + mapNullableTimestamp(rs, "ltltdzotm", entity::setLtltdzotm); + + // 涨潮潮差数据 + mapBigDecimal(rs, "avftdr", entity::setAvftdr); + entity.setAvftdrrcd(rs.getString("avftdrrcd") != null ? rs.getString("avftdrrcd") : ""); + mapBigDecimal(rs, "mxfltdr", entity::setMxfltdr); + entity.setMxfltdrrcd(rs.getString("mxfltdrrcd") != null ? rs.getString("mxfltdrrcd") : ""); + mapNullableTimestamp(rs, "mxfltdrhtm", entity::setMxfltdrhtm); + mapBigDecimal(rs, "mnfltdr", entity::setMnfltdr); + entity.setMnfltdrrcd(rs.getString("mnfltdrrcd") != null ? rs.getString("mnfltdrrcd") : ""); + mapNullableTimestamp(rs, "mnfltdrhtm", entity::setMnfltdrhtm); + + // 落潮潮差数据 + mapBigDecimal(rs, "aver", entity::setAver); + entity.setAverbbrrcd(rs.getString("averbbrrcd") != null ? rs.getString("averbbrrcd") : ""); + mapBigDecimal(rs, "mxebtdr", entity::setMxebtdr); + entity.setMxebtdrrcd(rs.getString("mxebtdrrcd") != null ? rs.getString("mxebtdrrcd") : ""); + mapNullableTimestamp(rs, "mxebtdrht", entity::setMxebtdrht); + mapBigDecimal(rs, "mnebtdr", entity::setMnebtdr); + entity.setMnebtdrrcd(rs.getString("mnebtdrrcd") != null ? rs.getString("mnebtdrrcd") : ""); + mapNullableTimestamp(rs, "mnebtdrhtm", entity::setMnebtdrhtm); + + // 涨潮历时数据 + setNullableInt(rs, "avftd", entity::setAvftd); + entity.setAvftdrcd(rs.getString("avftdrcd") != null ? rs.getString("avftdrcd") : ""); + setNullableInt(rs, "mxfltddr", entity::setMxfltddr); + entity.setMxfltddrrcd(rs.getString("mxfltddrrcd") != null ? rs.getString("mxfltddrrcd") : ""); + mapNullableTimestamp(rs, "mxfltddrhtm", entity::setMxfltddrhtm); + setNullableInt(rs, "mnfltddr", entity::setMnfltddr); + entity.setMnfltddrrcd(rs.getString("mnfltddrrcd") != null ? rs.getString("mnfltddrrcd") : ""); + mapNullableTimestamp(rs, "mnfltddrhtm", entity::setMnfltddrhtm); + + // 落潮历时数据 + setNullableInt(rs, "avebbdr", entity::setAvebbdr); + entity.setAvedrc(rs.getString("avedrc") != null ? rs.getString("avedrc") : ""); + setNullableInt(rs, "mxebtddr", entity::setMxebtddr); + entity.setMxebtddrrcd(rs.getString("mxebtddrrcd") != null ? rs.getString("mxebtddrrcd") : ""); + mapNullableTimestamp(rs, "mxebtddrhtm", entity::setMxebtddrhtm); + setNullableInt(rs, "mnbtddr", entity::setMnbtddr); + entity.setMnebtddrrcd(rs.getString("mnebtddrrcd") != null ? rs.getString("mnebtddrrcd") : ""); + mapNullableTimestamp(rs, "mnebtddrhtm", entity::setMnebtddrhtm); + + // 综合潮位数据 + mapBigDecimal(rs, "hravtdz", entity::setHravtdz); + entity.setHravtdzrcd(rs.getString("hravtdzrcd") != null ? rs.getString("hravtdzrcd") : ""); + mapBigDecimal(rs, "avtdr", entity::setAvtdr); + entity.setAvtdrrcd(rs.getString("avtdrrcd") != null ? rs.getString("avtdrrcd") : ""); + setNullableInt(rs, "avtddr", entity::setAvtddr); + entity.setAvtddrrcd(rs.getString("avtddrrcd") != null ? rs.getString("avtddrrcd") : ""); + + return entity; + } + + // 辅助方法：安全处理整数空值 + private void setNullableInt(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + int value = rs.getInt(column); + setter.accept(rs.wasNull() ? null : value); + } + + // 辅助方法：安全处理时间戳（精确到秒） + private void mapNullableTimestamp(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + Timestamp timestamp = rs.getTimestamp(column); + if (timestamp != null && !rs.wasNull()) { + setter.accept(new Date(timestamp.getTime())); + } + } + + // 新增辅助方法：安全处理BigDecimal空值（保留NULL语义） + private void mapBigDecimal(ResultSet rs, String column, + java.util.function.Consumer setter) + throws SQLException { + BigDecimal value = rs.getBigDecimal(column); + setter.accept(value); // 保留NULL表示数据缺失 + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrzFRowMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrzFRowMapper.java new file mode 100644 index 0000000..f4a1d58 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/rowMapper/HyYrzFRowMapper.java @@ -0,0 +1,60 @@ +package com.ruoyi.swlscx.basic.domain.rowMapper; + +import com.ruoyi.swlscx.month.domain.po.HyMtpE; +import com.ruoyi.swlscx.year.domain.po.HyYrzF; +import org.springframework.jdbc.core.RowMapper; + +import java.math.BigDecimal; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Timestamp; +import java.util.Date; + +/** + * @Author al + * @Date 2025/6/20 0:01 + * @Description: TODO + * @Version + */ +public class HyYrzFRowMapper implements RowMapper { + + @Override + public HyYrzF mapRow(ResultSet rs, int rowNum) throws SQLException { + HyYrzF hyYrzF = new HyYrzF(); + + // 1. 站码（直接映射） + hyYrzF.setStcd(rs.getString("stcd")); + + // 2. 年份（处理SQL NULL） + int yrValue = rs.getInt("yr"); + hyYrzF.setYr(rs.wasNull() ? null : yrValue); + + // 3. 平均水位及注解码 + BigDecimal avz = rs.getBigDecimal("avz"); + hyYrzF.setAvz(avz != null ? avz : BigDecimal.ZERO); // NULL → 0.00 + String avzrcd = rs.getString("avzrcd"); + hyYrzF.setAvzrcd(avzrcd != null ? avzrcd : ""); // NULL → 空字符串 + + // 4. 最高水位及关联字段 + BigDecimal htz = rs.getBigDecimal("htz"); + hyYrzF.setHtz(htz != null ? htz : BigDecimal.ZERO); + String htzrcd = rs.getString("htzrcd"); + hyYrzF.setHtzrcd(htzrcd != null ? htzrcd : ""); + Timestamp htzdtTimestamp = rs.getTimestamp("htzdt"); + if (htzdtTimestamp != null) { + hyYrzF.setHtzdt(new Date(htzdtTimestamp.getTime())); // SQL → Java Date + } + + // 5. 最低水位及关联字段 + BigDecimal mnz = rs.getBigDecimal("mnz"); + hyYrzF.setMnz(mnz != null ? mnz : BigDecimal.ZERO); + String mnzrcd = rs.getString("mnzrcd"); + hyYrzF.setMnzrcd(mnzrcd != null ? mnzrcd : ""); + Timestamp mnzdtTimestamp = rs.getTimestamp("mnzdt"); + if (mnzdtTimestamp != null) { + hyYrzF.setMnzdt(new Date(mnzdtTimestamp.getTime())); + } + + return hyYrzF; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/vo/HyStscASelectVo.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/vo/HyStscASelectVo.java new file mode 100644 index 0000000..1b77e5d --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/vo/HyStscASelectVo.java @@ -0,0 +1,31 @@ +package com.ruoyi.swlscx.basic.domain.vo; + +import lombok.Data; + +import java.io.Serializable; +import java.util.List; + +/** + * 测站一览表 + * @Author al + * @Date 2024/7/30 13:52 + * @Description: TODO + * @Version + */ + +@Data +public class HyStscASelectVo implements Serializable { + + /** 站码 */ + private String value; + + private Boolean disabled; + + /**站名**/ + private String label; + + private List children; + + private static final long serialVersionUID = 1L; + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/vo/HyStscAVo.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/vo/HyStscAVo.java index 808b014..012f97d 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/vo/HyStscAVo.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/domain/vo/HyStscAVo.java @@ -100,6 +100,9 @@ public class HyStscAVo implements Serializable { /**备注**/ private String nt; + /**站名+站码 **/ + private String stnmAndStcd; + private static final long serialVersionUID = 1L; } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/mapper/HyStscAMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/mapper/HyStscAMapper.java index b656999..f43716b 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/basic/mapper/HyStscAMapper.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/mapper/HyStscAMapper.java @@ -4,7 +4,10 @@ import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; import com.ruoyi.swlscx.basic.domain.po.HyStscA; +import com.ruoyi.swlscx.basic.domain.po.HyWfdzF; +import com.ruoyi.swlscx.basic.domain.po.YcShdpInfo; import com.ruoyi.swlscx.basic.domain.vo.HyStscAVo; +import com.ruoyi.swlscx.synchronousData.dto.JHDayData; import org.apache.ibatis.annotations.Mapper; import org.apache.ibatis.annotations.Param; @@ -28,11 +31,23 @@ public interface HyStscAMapper extends BaseMapper { - void deleteTempData(); + void deleteData(); - void mergeToData(); + void mergeToData(@Param("list") List records); - void insertTempData(@Param("list") List records); + void insertData(@Param("list") List records); + + void copyFile(@Param("path") String backupPath); + + void remoteFile(@Param("path") String backupPath); + + List getRainStationListByType(@Param("startYear") String startYear, @Param("startMth") String startMth, @Param("endYear") String endYear, @Param("endMth") String endMth, @Param("type") String type); + + List getYcShdpInfoByTableId(@Param("ids") List ids); + + List> testSqlServer(); + + List listByHyWfdzF(@Param("startYear") String startYear, @Param("endYear") String endYear, @Param("list") List stringList); } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/mapper/YcExportTaskMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/mapper/YcExportTaskMapper.java index 4769bac..7aa5130 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/basic/mapper/YcExportTaskMapper.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/mapper/YcExportTaskMapper.java @@ -2,8 +2,10 @@ package com.ruoyi.swlscx.basic.mapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.swlscx.basic.domain.po.HyStscA; import com.ruoyi.swlscx.basic.domain.po.YcExportTask; import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.ruoyi.swlscx.synchronousData.dto.JHDayData; import org.apache.ibatis.annotations.Param; import java.util.List; @@ -20,6 +22,11 @@ public interface YcExportTaskMapper extends BaseMapper { IPage queryPage(Page page,@Param("map") Map params); List> test(); + + List getDataBySqlServer(); + + + void insertOrUpataData(@Param("list") List dataList); } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/HyStscAService.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/HyStscAService.java index 05f11bd..74f683a 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/HyStscAService.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/HyStscAService.java @@ -3,14 +3,19 @@ package com.ruoyi.swlscx.basic.service; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.service.IService; import com.ruoyi.common.core.page.R; +import com.ruoyi.swlscx.basic.domain.ro.FormDataRo; +import com.ruoyi.swlscx.basic.domain.vo.HyStscASelectVo; import com.ruoyi.swlscx.basic.domain.vo.HyStscAVo; import com.ruoyi.swlscx.common.PageParams; import com.ruoyi.swlscx.basic.domain.po.HyStscA; import org.springframework.web.multipart.MultipartFile; import javax.servlet.http.HttpServletResponse; +import java.util.List; +import java.util.Map; /** + * @author 12974 * @description 针对表【hy_stsc_a】的数据库操作Service * @createDate 2024-07-30 13:37:07 @@ -32,11 +37,21 @@ public interface HyStscAService extends IService { */ R exportStation(HttpServletResponse response, String startTime, String endTime, String stcd, String stnm); - R importDateTosoft(String startTime, String endTime); + R importDateTosoft(); - /** - * 导出测站一览表 - */ - R testSqlServer(); +// /** +// * 导出测站一览表 +// */ +// R testSqlServer(); + + HyStscASelectVo getList(String startTime, String endTime, String type); + + HyStscASelectVo getStationListByType(String startTime,String endTime,String type); + + R importDateToHydp(FormDataRo formDataRo); + + List> testSqlServer(); + + R exportSoftToDate(FormDataRo formDataRo); } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/YcExportTaskService.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/YcExportTaskService.java index 79318ac..8d4c174 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/YcExportTaskService.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/YcExportTaskService.java @@ -3,8 +3,11 @@ package com.ruoyi.swlscx.basic.service; import com.ruoyi.common.core.page.R; import com.ruoyi.swlscx.basic.domain.po.YcExportTask; import com.baomidou.mybatisplus.extension.service.IService; +import com.ruoyi.swlscx.synchronousData.dto.JHDayData; +import org.springframework.web.multipart.MultipartFile; import javax.servlet.http.HttpServletResponse; +import java.util.List; import java.util.Map; /** @@ -23,4 +26,10 @@ public interface YcExportTaskService extends IService { R removeTask(Integer id); R getTest(); + + void updateOrInsertDataToMysql(List jhDayDataList,String type); + +// void downloadSoftFile(HttpServletResponse response); +// +// R uploadSoftFile(MultipartFile file); } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/impl/HyStscAServiceImpl.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/impl/HyStscAServiceImpl.java index 1b984f7..18e0901 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/impl/HyStscAServiceImpl.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/impl/HyStscAServiceImpl.java @@ -1,7 +1,11 @@ package com.ruoyi.swlscx.basic.service.impl; +import cn.hutool.http.HttpRequest; +import com.alibaba.fastjson.JSON; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.core.toolkit.Wrappers; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.ruoyi.common.annotation.DataSource; import com.ruoyi.common.config.RuoYiConfig; @@ -11,23 +15,41 @@ import com.ruoyi.common.enums.DataSourceType; import com.ruoyi.common.utils.DateUtils; import com.ruoyi.common.utils.SecurityUtils; import com.ruoyi.common.utils.bean.BeanUtils; -import com.ruoyi.swlscx.basic.domain.po.YcExportTask; -import com.ruoyi.swlscx.basic.service.YcExportTaskService; -import com.ruoyi.swlscx.common.PageParams; import com.ruoyi.swlscx.basic.domain.bo.HyStscABo; -import com.ruoyi.swlscx.basic.domain.po.HyStscA; +import com.ruoyi.swlscx.basic.domain.po.*; +import com.ruoyi.swlscx.basic.domain.ro.FormDataRo; +import com.ruoyi.swlscx.basic.domain.rowMapper.*; +import com.ruoyi.swlscx.basic.domain.vo.HyStscASelectVo; import com.ruoyi.swlscx.basic.domain.vo.HyStscAVo; import com.ruoyi.swlscx.basic.mapper.HyStscAMapper; import com.ruoyi.swlscx.basic.service.HyStscAService; +import com.ruoyi.swlscx.basic.service.YcExportTaskService; +import com.ruoyi.swlscx.common.PageParams; +import com.ruoyi.swlscx.common.enums.SelectTableEnum; import com.ruoyi.swlscx.common.utils.CommonUtils; import com.ruoyi.swlscx.common.utils.ExcelUtils; import com.ruoyi.swlscx.common.utils.Query; +import com.ruoyi.swlscx.common.utils.SqlServerDataSourceUtil; +import com.ruoyi.swlscx.day.domain.po.*; +import com.ruoyi.swlscx.day.service.*; +import com.ruoyi.swlscx.excerpt.domain.po.*; +import com.ruoyi.swlscx.excerpt.service.*; +import com.ruoyi.swlscx.month.domain.po.*; +import com.ruoyi.swlscx.month.service.*; +import com.ruoyi.swlscx.synchronousData.dto.JHDayData; +import com.ruoyi.swlscx.synchronousData.enums.SWTableEnum; +import com.ruoyi.swlscx.synchronousData.mapper.TimeTasksMapper; +import com.ruoyi.swlscx.year.domain.po.*; +import com.ruoyi.swlscx.year.service.*; import org.apache.commons.lang3.ObjectUtils; +import org.apache.commons.lang3.StringUtils; import org.apache.poi.ss.usermodel.CellStyle; import org.apache.poi.ss.usermodel.Row; import org.apache.poi.ss.usermodel.Sheet; import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.beans.factory.annotation.Value; import org.springframework.context.ApplicationContext; +import org.springframework.jdbc.core.JdbcTemplate; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.web.multipart.MultipartFile; @@ -35,43 +57,33 @@ import org.springframework.web.multipart.MultipartFile; import javax.annotation.Resource; import javax.servlet.http.HttpServletResponse; import java.io.File; +import java.sql.Timestamp; +import java.sql.Types; +import java.text.SimpleDateFormat; +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; import java.util.*; import java.util.concurrent.CompletableFuture; import java.util.concurrent.ThreadPoolExecutor; +import java.util.regex.Pattern; import java.util.stream.Collectors; -/** -* @author 12974 -* @description 针对表【hy_stsc_a】的数据库操作Service实现 -* @createDate 2024-07-30 13:37:07 -*/ @Service -public class HyStscAServiceImpl extends ServiceImpl - implements HyStscAService { - +public class HyStscAServiceImpl extends ServiceImpl implements HyStscAService { @Resource private ThreadPoolExecutor labelThreadPool; - @Resource private YcExportTaskService ycExportTaskService; - @Resource private ThreadPoolExecutor importThreadPool; - @Autowired private ApplicationContext context; - - - - - @Override @Transactional(rollbackFor = Exception.class) public void importHyStsc(MultipartFile file) { try { List hyStationBoList = ExcelUtils.readExcel(file.getInputStream(), HyStscABo.class, 2); - List hyStationList = hyStationBoList.stream().map(i -> { HyStscA hyStscA = new HyStscA(); BeanUtils.copyProperties(i, hyStscA); @@ -91,33 +103,25 @@ public class HyStscAServiceImpl extends ServiceImpl } } - /** - * 查询站点信息 - */ + /*** 查询站点信息*/ @Override @DataSource(DataSourceType.MASTER) - public IPage getStationPageByInfo(PageParams pageParams, String stnm,String stcd , String startTime, String endTime) { + public IPage getStationPageByInfo(PageParams pageParams, String stnm, String stcd, String startTime, String endTime) { Map map = CommonUtils.getMonthDataMap(pageParams, startTime, endTime, stcd, stnm); return this.baseMapper.selectHyStscAPageByInfo(new Query().getPage(map), map); } - /** - * 导出测站一览表 - */ @Override public R exportStation(HttpServletResponse response, String startTime, String endTime, String stcd, String stnm) { Long userId = SecurityUtils.getUserId(); - String tableName = "测站一览表"; - return taskAndExport(tableName,startTime, endTime, stcd, stnm, userId); + String tableName = ""; + return taskAndExport(tableName, startTime, endTime, stcd, stnm, userId); } - /** - * 从mysql导入到sqlserver中 - */ @Transactional(rollbackFor = Exception.class) @DataSource(DataSourceType.SHARDING) public void importMysqlToSqlserver(List hyStscAVoList) { - List records = hyStscAVoList.stream().map(i->{ + List records = hyStscAVoList.stream().map(i -> { HyStscA hyStscA = new HyStscA(); BeanUtils.copyProperties(i, hyStscA); hyStscA.setDstrvm(Convert.toBigDecimal(i.getDstrvm())); @@ -131,72 +135,2321 @@ public class HyStscAServiceImpl extends ServiceImpl return hyStscA; }).collect(Collectors.toList()); //先清空临时表的数据 - this.baseMapper.deleteTempData(); + this.baseMapper.deleteData(); //插入临时表数据 int batchSize = 50; for (int i = 0; i < records.size(); i += batchSize) { int end = Math.min(i + batchSize, records.size()); List batch = records.subList(i, end); // 执行批量插入 - this.baseMapper.insertTempData(batch); + this.baseMapper.insertData(batch); } - //从临时表增或修改主表 - this.baseMapper.mergeToData(); } + @Value("${softurl}") + private String sqlServerUrl; + @Override - public R importDateTosoft(String startTime, String endTime) { + public R importDateTosoft() { Long userId = SecurityUtils.getUserId(); - String filename = "测站一览表" + startTime + "-" + endTime+"导入到南方片"; - // 查询是否已存在相同条件且未完成的任务 + Date date = new Date(); + SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm"); + String filename = "-" + sdf.format(date) + "-"; List ongoingTasks = ycExportTaskService.list( - new QueryWrapper() - .eq("user_id", userId) - .eq("status", 0) // 状态为0表示任务未完成 - .like("filename", "测站一览表")); + new QueryWrapper().eq("user_id", userId) + .eq("status", 0).like("filename", "")); if (!ongoingTasks.isEmpty()) { return R.error("当前任务正在下载中，请稍后重试"); } YcExportTask ycExportTask = new YcExportTask(); ycExportTask.setFilename(filename); ycExportTask.setUserId(userId); - ycExportTask.setStartTime(new Date()); + ycExportTask.setStartTime(date); ycExportTask.setStatus(0); ycExportTaskService.save(ycExportTask); CompletableFuture.runAsync(() -> { try { - IPage stationPageByInfo = this.getStationPageByInfo(new PageParams(0L, 1000000000L), null, null, startTime, endTime); - HyStscAServiceImpl hyStscAServiceImpl = context.getBean(HyStscAServiceImpl.class); - hyStscAServiceImpl.importMysqlToSqlserver(stationPageByInfo.getRecords()); - ycExportTask.setStatus(2); + IPage stationPageByInfo = this.getStationPageByInfo(new PageParams(0L, 1000000000L), null, null, null, null); + boolean isFirstBatch = true; + int batchSize = 10000; + List allRecords = stationPageByInfo.getRecords(); + int total = allRecords.size(); + for (int i = 0; i < total; i += batchSize) { + List batchList = allRecords.subList(i, Math.min(i + batchSize, total)); + String jsonData = JSON.toJSONString(batchList); + HttpRequest.post(sqlServerUrl + "/import") + .header("Content-Type", "application/json").header("X-First-Batch", String.valueOf(isFirstBatch)). + body(jsonData).execute().body(); + if (isFirstBatch) { + isFirstBatch = false; + } + Thread.sleep(500); + } + ycExportTask.setStatus(3); } catch (Exception e) { ycExportTask.setStatus(4); log.error(e.getMessage()); R.error("任务下载失败"); - }finally { + } finally { ycExportTask.setEndTime(new Date()); + if (ycExportTask.getStatus() == 3) { + ycExportTaskService.update(Wrappers.lambdaUpdate(YcExportTask.class).set(YcExportTask::getStatus, 2).eq(YcExportTask::getStatus, 3)); + } ycExportTaskService.updateById(ycExportTask); } }, importThreadPool); - return R.ok("任务已提交"); + return R.ok("任务已提交"); + } + + @Autowired + private HyYrpFService hyYrpFService; + @Autowired + private HyMmxpFService hyMmxpFService; + @Autowired + private HyHmxpFService hyHmxpFService; + @Autowired + private HyDmxpFService hyDmxpFService; + @Autowired + private HyYrweFService hyYrweFService; + @Autowired + private HyYrzFService hyYrzFService; + @Autowired + private HyYrwtFService hyYrwtFService; + @Autowired + private HyYrqsFService hyYrqsFService; + @Autowired + private HyYrcsFService hyYrcsFService; + @Autowired + private HyImxfwFService hyImxfwFService; + @Autowired + private HyYrqFService hyYrqFService; + @Autowired + private HyYrtdzFService hyYrtdzFService; + @Autowired + private HyMtpEService hyMtpEService; + @Autowired + private HyMtweEService hyMtweEService; + @Autowired + private HyMtqsEService hyMtqsEService; + @Autowired + private HyMtcsEService hyMtcsEService; + @Autowired + private HyMtqEService hyMtqEService; + @Autowired + private HyMtzEService hyMtzEService; + @Autowired + private HyMtwtEService hyMtwtEService; + @Autowired + private HyMttdzEService hyMttdzEService; + @Autowired + private HyDpCService hyDpCService; + @Autowired + private HyDweCService hyDweCService; + @Autowired + private HyDqCService hyDqCService; + @Autowired + private HyDzCService hyDzCService; + @Autowired + private HyDcsFService hyDcsFService; + @Autowired + private HyDwtCService hyDwtCService; + @Autowired + private HyZscsBService hyZscsBService; + @Autowired + private HyFdheexBService hyFdheexBService; + @Autowired + private HyPrexBService hyPrexBService; + @Autowired + private HyRvfhexBService hyRvfhexBService; + @Autowired + private HyWsfhexBService hyWsfhexBService; + @Autowired + private HyHltdzBService hyHltdzBService; + @Autowired + private HyStscAService hyStscAService; + + @Override + public HyStscASelectVo getList(String startTime, String endTime, String type) { + List list = new ArrayList<>(); + if (type.equals(SelectTableEnum.YEAR_RAIN.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyYrpF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyYrpF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyYrpF::getYr, endTime); + } + List stcds = hyYrpFService.list(queryWrapper).stream().map(HyYrpF::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DP_MMXP.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyMmxpF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyMmxpF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyMmxpF::getYr, endTime); + } + List stcds = hyMmxpFService.list(queryWrapper).stream().map(HyMmxpF::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DP_HMXP.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyHmxpF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyHmxpF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyHmxpF::getYr, endTime); + } + List stcds = hyHmxpFService.list(queryWrapper).stream().map(HyHmxpF::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DAY_DMXP.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyDmxpF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyDmxpF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyDmxpF::getYr, endTime); + } + List stcds = hyDmxpFService.list(queryWrapper).stream().map(HyDmxpF::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.YEAR_YRWE.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyYrweF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyYrweF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyYrweF::getYr, endTime); + } + List stcds = hyYrweFService.list(queryWrapper).stream().map(HyYrweF::getStcd).distinct().collect(Collectors.toList()); + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(!stcds.isEmpty(), HyStscA::getStcd, stcds)); + } else if (type.equals(SelectTableEnum.YEAR_YRZ.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyYrzF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyYrzF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyYrzF::getYr, endTime); + } + List stcds = hyYrzFService.list(queryWrapper).stream().map(HyYrzF::getStcd).collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.YEAR_YRWT.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyYrwtF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyYrwtF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyYrwtF::getYr, endTime); + } + List stcds = hyYrwtFService.list(queryWrapper).stream().map(HyYrwtF::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.YEAR_YRQS.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyYrqsF.class).select(HyYrqsF::getStcd); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyYrqsF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyYrqsF::getYr, endTime); + } + List stcds = hyYrqsFService.list(queryWrapper).stream().map(HyYrqsF::getStcd).collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.YEAR_YRCS.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyYrcsF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyYrcsF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyYrcsF::getYr, endTime); + } + List stcds = hyYrcsFService.list(queryWrapper).stream().map(HyYrcsF::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DAY_MXFW.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyImxfwF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyImxfwF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyImxfwF::getYr, endTime); + } + List stcds = hyImxfwFService.list(queryWrapper).stream().map(HyImxfwF::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.YEAR_Q.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyYrqF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyYrqF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyYrqF::getYr, endTime); + } + List stcds = hyYrqFService.list(queryWrapper).stream().map(HyYrqF::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.YEAR_TIDE.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyYrtdzF.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyYrtdzF::getYr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyYrtdzF::getYr, endTime); + } + List stcds = hyYrtdzFService.list(queryWrapper).stream().map(HyYrtdzF::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.MONTH_RAIN.value())) { + String startYear = ""; + String endYear = ""; + if (StringUtils.isNotBlank(startTime)) { + startYear = startTime.length() > 4 ? startTime.substring(0, 4) : startTime; + } + if (StringUtils.isNotBlank(endTime)) { + endYear = endTime.length() > 4 ? endTime.substring(0, 4) : endTime; + } + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyMtpE.class); + if (ObjectUtils.isNotEmpty(startYear)) { + queryWrapper.ge(HyMtpE::getYr, startYear); + } + if (ObjectUtils.isNotEmpty(endYear)) { + queryWrapper.le(HyMtpE::getYr, endYear); + } + List stcds = hyMtpEService.list(queryWrapper).stream().map(HyMtpE::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.MONTH_MTWE.value())) { + String startYear = ""; + String endYear = ""; + if (StringUtils.isNotBlank(startTime)) { + startYear = startTime.length() > 4 ? startTime.substring(0, 4) : startTime; + } + if (StringUtils.isNotBlank(endTime)) { + endYear = endTime.length() > 4 ? endTime.substring(0, 4) : endTime; + } + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyMtweE.class); + if (ObjectUtils.isNotEmpty(startYear)) { + queryWrapper.ge(HyMtweE::getYr, startYear); + } + if (ObjectUtils.isNotEmpty(endYear)) { + queryWrapper.le(HyMtweE::getYr, endYear); + } + List stcds = hyMtweEService.list(queryWrapper).stream().map(HyMtweE::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.MONTH_MTQS.value())) { + String startYear = ""; + String endYear = ""; + if (StringUtils.isNotBlank(startTime)) { + startYear = startTime.length() > 4 ? startTime.substring(0, 4) : startTime; + } + if (StringUtils.isNotBlank(endTime)) { + endYear = endTime.length() > 4 ? endTime.substring(0, 4) : endTime; + } + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyMtqsE.class); + if (ObjectUtils.isNotEmpty(startYear)) { + queryWrapper.ge(HyMtqsE::getYr, startYear); + } + if (ObjectUtils.isNotEmpty(endYear)) { + queryWrapper.le(HyMtqsE::getYr, endYear); + } + List stcds = hyMtqsEService.list(queryWrapper).stream().map(HyMtqsE::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.MONTH_MTCS.value())) { + String startYear = ""; + String endYear = ""; + if (StringUtils.isNotBlank(startTime)) { + startYear = startTime.length() > 4 ? startTime.substring(0, 4) : startTime; + } + if (StringUtils.isNotBlank(endTime)) { + endYear = endTime.length() > 4 ? endTime.substring(0, 4) : endTime; + } + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyMtcsE.class); + if (ObjectUtils.isNotEmpty(startYear)) { + queryWrapper.ge(HyMtcsE::getYr, startYear); + } + if (ObjectUtils.isNotEmpty(endYear)) { + queryWrapper.le(HyMtcsE::getYr, endYear); + } + List stcds = hyMtcsEService.list(queryWrapper).stream().map(HyMtcsE::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.MONTH_Q.value())) { + String startYear = ""; + String endYear = ""; + if (StringUtils.isNotBlank(startTime)) { + startYear = startTime.length() > 4 ? startTime.substring(0, 4) : startTime; + } + if (StringUtils.isNotBlank(endTime)) { + endYear = endTime.length() > 4 ? endTime.substring(0, 4) : endTime; + } + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyMtqE.class); + if (ObjectUtils.isNotEmpty(startYear)) { + queryWrapper.ge(HyMtqE::getYr, startYear); + } + if (ObjectUtils.isNotEmpty(endYear)) { + queryWrapper.le(HyMtqE::getYr, endYear); + } + List stcds = hyMtqEService.list(queryWrapper).stream().map(HyMtqE::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.MONTH_MTZ.value())) { + String startYear = ""; + String endYear = ""; + if (StringUtils.isNotBlank(startTime)) { + startYear = startTime.length() > 4 ? startTime.substring(0, 4) : startTime; + } + if (StringUtils.isNotBlank(endTime)) { + endYear = endTime.length() > 4 ? endTime.substring(0, 4) : endTime; + } + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyMtzE.class); + if (ObjectUtils.isNotEmpty(startYear)) { + queryWrapper.ge(HyMtzE::getYr, startYear); + } + if (ObjectUtils.isNotEmpty(endYear)) { + queryWrapper.le(HyMtzE::getYr, endYear); + } + List stcds = hyMtzEService.list(queryWrapper).stream().map(HyMtzE::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.MONTH_MTWT.value())) { + String startYear = ""; + String endYear = ""; + if (StringUtils.isNotBlank(startTime)) { + startYear = startTime.length() > 4 ? startTime.substring(0, 4) : startTime; + } + if (StringUtils.isNotBlank(endTime)) { + endYear = endTime.length() > 4 ? endTime.substring(0, 4) : endTime; + } + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyMtwtE.class); + if (ObjectUtils.isNotEmpty(startYear)) { + queryWrapper.ge(HyMtwtE::getYr, startYear); + } + if (ObjectUtils.isNotEmpty(endYear)) { + queryWrapper.le(HyMtwtE::getYr, endYear); + } + List stcds = hyMtwtEService.list(queryWrapper).stream().map(HyMtwtE::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.MONTH_MTTDZ.value())) { + String startYear = ""; + String endYear = ""; + if (StringUtils.isNotBlank(startTime)) { + startYear = startTime.length() > 4 ? startTime.substring(0, 4) : startTime; + } + if (StringUtils.isNotBlank(endTime)) { + endYear = endTime.length() > 4 ? endTime.substring(0, 4) : endTime; + } + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyMttdzE.class); + if (ObjectUtils.isNotEmpty(startYear)) { + queryWrapper.ge(HyMttdzE::getYr, startYear); + } + if (ObjectUtils.isNotEmpty(endYear)) { + queryWrapper.le(HyMttdzE::getYr, endYear); + } + List stcds = hyMttdzEService.list(queryWrapper).stream().map(HyMttdzE::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DAY_RAIN.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("dt", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("dt", endTime); + } + List stcds = hyDpCService.list(queryWrapper).stream().map(HyDpC::getStcd).collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DAY_DWE.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("dt", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("dt", endTime); + } + List stcds = hyDweCService.list(queryWrapper).stream().map(HyDweC::getStcd).collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DAY_Q.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("dt", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("dt", endTime); + } + List stcds = hyDqCService.list(queryWrapper).stream().map(HyDqC::getStcd).collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DAY_DZ.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("dt", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("dt", endTime); + } + List stcds = hyDzCService.list(queryWrapper).stream().map(HyDzC::getStcd).collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DAY_DCS.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("dt", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("dt", endTime); + } + List stcds = hyDcsFService.list(queryWrapper).stream().map(HyDcsF::getStcd).collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DAY_DWT.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("dt", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("dt", endTime); + } + List stcds = hyDwtCService.list(queryWrapper).stream().map(HyDwtC::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DAY_ZSCS.value())) { + + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("tm", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("tm", endTime); + } + List stcds = hyZscsBService.list(queryWrapper).stream().map(HyZscsB::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DP_FDHEEX.value())) { + + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("tm", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("tm", endTime); + } + + List stcds = hyFdheexBService.list(queryWrapper).stream().map(HyFdheexB::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DP_PREX.value())) { + + + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("bgtm", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("bgtm", endTime); + } + List stcds = hyPrexBService.list(queryWrapper).stream().map(HyPrexB::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DP_RVFHEX.value())) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyRvfhexB.class); + + + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyRvfhexB::getTm, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyRvfhexB::getTm, endTime); + } + List stcds = hyRvfhexBService.list(queryWrapper).stream().map(HyRvfhexB::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DP_WSFHEX.value())) { + + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("tm", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("tm", endTime); + } + List stcds = hyWsfhexBService.list(queryWrapper).stream().map(HyWsfhexB::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals(SelectTableEnum.DP_HLTDZ.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.select("DISTINCT stcd"); // 指定查询字段 + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge("tm", startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le("tm", endTime); + } + + List stcds = hyHltdzBService.list(queryWrapper).stream().map(HyHltdzB::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } else if (type.equals("Stsc")) { + LambdaQueryWrapper queryWrapper = Wrappers.lambdaQuery(HyStscA.class); + if (ObjectUtils.isNotEmpty(startTime)) { + queryWrapper.ge(HyStscA::getEsstyr, startTime); + } + if (ObjectUtils.isNotEmpty(endTime)) { + queryWrapper.le(HyStscA::getEsstyr, endTime); + } + List stcds = hyStscAService.list(queryWrapper).stream().map(HyStscA::getStcd).distinct().collect(Collectors.toList()); + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + } + + + List hyStscASelectParentVoList = list.stream().map(i -> { + HyStscASelectVo hyStscASelectVo = new HyStscASelectVo(); + hyStscASelectVo.setValue(i.getStcd()); + hyStscASelectVo.setLabel(i.getStnm() + "(" + i.getStcd() + ")"); + return hyStscASelectVo; + }).collect(Collectors.toList()); + HyStscASelectVo hyStscASelectVoTop = new HyStscASelectVo(); + hyStscASelectVoTop.setLabel("全部站点"); + hyStscASelectVoTop.setValue("all"); + hyStscASelectParentVoList.add(0, hyStscASelectVoTop); + HyStscASelectVo hyStscASelectVo = new HyStscASelectVo(); + hyStscASelectVo.setValue("1"); + hyStscASelectVo.setLabel("国家站"); + hyStscASelectVo.setChildren(hyStscASelectParentVoList); + return hyStscASelectVo; + } + + @Override + public HyStscASelectVo getStationListByType(String startTime, String endTime, String type) { + List list = new ArrayList<>(); + String[] splitStartTime = startTime.split("-"); + String startYear = splitStartTime[0]; + String startMth = splitStartTime[1]; + String[] splitEndTime = endTime.split("-"); + String endYear = splitEndTime[0]; + String endMth = splitEndTime[1]; + List stcds = new ArrayList<>(); + if (type.equals("P")) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.and(wrapper -> { + if (startYear.equals(endYear)) { + wrapper.apply("(yr = {0} AND mth BETWEEN {1} AND {2})", startYear, "01", "12"); + } else { + wrapper.apply("(yr = {0} AND mth >= {1})", startYear, "01"); + for (int year = Integer.parseInt(startYear) + 1; year < Integer.parseInt(endYear); year++) { + wrapper.or().apply("yr = {0}", year); // 中间整年 + } + wrapper.or().apply("(yr = {0} AND mth <= {1})", endYear, "12"); // 结束年（1-12月） + } + }); + List rainStationList = hyMtpEService.list(queryWrapper); + stcds = rainStationList.stream().map(HyMtpE::getStcd).distinct().collect(Collectors.toList()); + } else if (type.equals("H")) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.and(wrapper -> { + if (startYear.equals(endYear)) { + // 同一年：直接范围查询 + wrapper.apply("(yr = {0} AND mth BETWEEN {1} AND {2})", startYear, "01", "12"); + } else { + // 跨年：组合三段条件 + wrapper.apply("(yr = {0} AND mth >= {1})", startYear, "01"); // 起始年（1月至今） + for (int year = Integer.parseInt(startYear) + 1; year < Integer.parseInt(endYear); year++) { + wrapper.or().apply("yr = {0}", year); // 中间整年 + } + wrapper.or().apply("(yr = {0} AND mth <= {1})", endYear, "12"); // 结束年（1-12月） + } + }); + List rainStationList = hyMtzEService.list(queryWrapper); + stcds = rainStationList.stream().map(HyMtzE::getStcd).distinct().collect(Collectors.toList()); + } else if (type.equals("Q")) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.and(wrapper -> { + if (startYear.equals(endYear)) { + // 同一年：直接范围查询 + wrapper.apply("(yr = {0} AND mth BETWEEN {1} AND {2})", startYear, "01", "12"); + } else { + // 跨年：组合三段条件 + wrapper.apply("(yr = {0} AND mth >= {1})", startYear, "01"); // 起始年（1月至今） + for (int year = Integer.parseInt(startYear) + 1; year < Integer.parseInt(endYear); year++) { + wrapper.or().apply("yr = {0}", year); // 中间整年 + } + wrapper.or().apply("(yr = {0} AND mth <= {1})", endYear, "12"); // 结束年（1-12月） + } + }); + List rainStationList = hyMtqEService.list(queryWrapper); + stcds = rainStationList.stream().map(HyMtqE::getStcd).distinct().collect(Collectors.toList()); + } + if (!stcds.isEmpty()) { + list = this.list(Wrappers.lambdaQuery(HyStscA.class).in(HyStscA::getStcd, stcds)); + } + List hyStscASelectParentVoList = list.stream().map(i -> { + HyStscASelectVo hyStscASelectVo = new HyStscASelectVo(); + hyStscASelectVo.setValue(i.getStcd()); + hyStscASelectVo.setLabel(i.getStnm() + "(" + i.getStcd() + ")"); + return hyStscASelectVo; + }).collect(Collectors.toList()); + HyStscASelectVo hyStscASelectVoTop = new HyStscASelectVo(); + hyStscASelectVoTop.setLabel("全部站点"); + hyStscASelectVoTop.setValue("all"); + hyStscASelectParentVoList.add(0, hyStscASelectVoTop); + HyStscASelectVo hyStscASelectVo = new HyStscASelectVo(); + hyStscASelectVo.setValue("1"); + hyStscASelectVo.setLabel("国家站"); + hyStscASelectVo.setChildren(hyStscASelectParentVoList); + return hyStscASelectVo; + } + + @Autowired + private TimeTasksMapper timeTasksMapper; + + + @Override + public R importDateToHydp(FormDataRo formDataRo) { + Long userId = SecurityUtils.getUserId(); + Date date = new Date(); + // 定义格式 + SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm"); + String filename = sdf.format(date) + "-数据导入到南方片"; + + YcExportTask ycExportTask = new YcExportTask(); + ycExportTask.setFilename(filename); + ycExportTask.setUserId(userId); + ycExportTask.setStartTime(date); + ycExportTask.setStatus(0); + ycExportTaskService.save(ycExportTask); + CompletableFuture.runAsync(() -> { + try { + importSoft(formDataRo); + ycExportTask.setStatus(2); + } catch (Exception e) { + ycExportTask.setStatus(4); + log.error(e.getMessage()); + R.error("数据导出失败"); + } finally { + ycExportTask.setEndTime(new Date()); + ycExportTaskService.updateById(ycExportTask); + } + }, importThreadPool); + return R.ok("任务已提交"); + } + + + private void importSoft(FormDataRo formDataRo) { + if (formDataRo.getStationTypeValue().equals("Q")) { + formDataRo.setStationTypeValue("H"); + } + String startTime = formDataRo.getStartTime(); + String endTime = formDataRo.getEndTime(); + + + String[] dateDay = getDateDay(startTime, endTime); + String startTimeDay = dateDay[0]; + String endTimeDay = dateDay[1]; + + + String[] splitStartTime = startTime.split("-"); + String startYear = splitStartTime[0]; + String startMth = splitStartTime[1]; + String[] splitEndTime = endTime.split("-"); + String endYear = splitEndTime[0]; + String endMth = splitEndTime[1]; + + + String tableIds = formDataRo.getIds(); + String stcds = formDataRo.getStcds(); + List ids = Pattern.compile(",") + .splitAsStream(tableIds) + .collect(Collectors.toList()); + + List stcdsList = Pattern.compile(",") + .splitAsStream(stcds) + .collect(Collectors.toList()); + + List ycShdpInfos = this.baseMapper.getYcShdpInfoByTableId(ids); + List tableNames = ycShdpInfos.stream().map(YcShdpInfo::getTableName).distinct().collect(Collectors.toList()); + List yn = ycShdpInfos.stream() + .filter(info -> info.getYn() != null) // 先过滤null + .map(YcShdpInfo::getYn) + .filter(str -> !str.trim().isEmpty()) // 再过滤空字符串 + .distinct() + .collect(Collectors.toList()); + javax.sql.DataSource sqlServerDataSource = SqlServerDataSourceUtil.createDataSource(formDataRo); + JdbcTemplate jdbcTemplate = new JdbcTemplate(sqlServerDataSource); + + + List yearRange = getYearRange(Convert.toInt(startYear), Convert.toInt(endYear)); + List fzTableIds = new ArrayList<>(); + + for (String item : yn) { + for (String s : stcdsList) { + for (Integer year : yearRange) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setYn(formDataRo.getStationTypeValue()); + fzTableId.setYr(year); + fzTableId.setRtno(item); + fzTableIds.add(fzTableId); + } + } + } + + List removeFzTableId = new ArrayList<>(); + for (String tableName : tableNames) { + if (tableName.equals(SWTableEnum.DAY_RAIN.value())) { + List hyDpCList = hyDpCService.list(Wrappers.lambdaQuery(HyDpC.class) + .between(HyDpC::getDt, startTimeDay, endTimeDay) + .in(HyDpC::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyDpCList)) { + List stcdList = hyDpCList.stream().map(HyDpC::getStcd).distinct().collect(Collectors.toList()); + Set stcdSet = new HashSet<>(stcdList); // 将小集合转为HashSet + List missingList = stcdsList.stream() + .filter(stcd -> !stcdSet.contains(stcd)) // 过滤未出现在stcdList中的元素 + .collect(Collectors.toList()); + for (String s : missingList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("321"); + removeFzTableId.add(fzTableId); + } + + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?)) AS source (stcd, dt, p, prcd) " + + "ON target.stcd = source.stcd AND target.dt = source.dt " + + "WHEN MATCHED THEN UPDATE SET p = source.p, prcd = source.prcd " + + "WHEN NOT MATCHED THEN INSERT (stcd, dt, p, prcd) VALUES (source.stcd, source.dt, source.p, source.prcd);"; + jdbcTemplate.batchUpdate(sql, hyDpCList, 50, (ps, hyDpC) -> { + ps.setString(1, hyDpC.getStcd()); + ps.setTimestamp(2, new Timestamp(hyDpC.getDt().getTime())); // 保留时间 + ps.setBigDecimal(3, hyDpC.getP()); + ps.setString(4, hyDpC.getPrcd()); + }); + + }else { + for (String stcd : stcdsList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(stcd); + fzTableId.setRtno("321"); + removeFzTableId.add(fzTableId); + } + } + } else if (tableName.equals(SWTableEnum.MONTH_RAIN.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.and(wrapper -> { + if (startYear.equals(endYear)) { + // 同一年：直接范围查询 + wrapper.apply("(yr = {0} AND mth BETWEEN {1} AND {2})", startYear, "01", "12"); + } else { + // 跨年：组合三段条件 + wrapper.apply("(yr = {0} AND mth >= {1})", startYear, "01"); // 起始年（1月至今） + for (int year = Integer.parseInt(startYear) + 1; year < Integer.parseInt(endYear); year++) { + wrapper.or().apply("yr = {0}", year); // 中间整年 + } + wrapper.or().apply("(yr = {0} AND mth <= {1})", endYear, "12"); // 结束年（1-12月） + } + }); + queryWrapper.in("stcd", stcdsList); + List hyMtpEList = hyMtpEService.list(queryWrapper); + if (ObjectUtils.isNotEmpty(hyMtpEList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?,?, ?, ?, ?,?, ?)) AS source (stcd, yr, mth, p,prcd,pdynum,pdynumrcd,mxdyp,mxdyprcd,mxdypodt) " + + "ON target.stcd = source.stcd AND target.yr = source.yr AND target.mth = source.mth " + + "WHEN MATCHED THEN UPDATE SET p = source.p, prcd = source.prcd, pdynum = source.pdynum, pdynumrcd = source.pdynumrcd, mxdyp = source.mxdyp, mxdyprcd = source.mxdyprcd, mxdypodt = source.mxdypodt " + + "WHEN NOT MATCHED THEN INSERT (stcd, yr, mth, p, prcd, pdynum, pdynumrcd, mxdyp, mxdyprcd, mxdypodt) VALUES (source.stcd, source.yr, source.mth, source.p, source.prcd, source.pdynum, source.pdynumrcd, source.mxdyp, source.mxdyprcd, source.mxdypodt);"; + + jdbcTemplate.batchUpdate(sql, hyMtpEList, 50, (ps, hyMtpE) -> { + ps.setString(1, hyMtpE.getStcd()); + ps.setInt(2, hyMtpE.getYr()); + ps.setInt(3, hyMtpE.getMth()); + ps.setBigDecimal(4, hyMtpE.getP()); + ps.setString(5, hyMtpE.getPrcd()); + if (hyMtpE.getPdynum() == null) { + ps.setNull(6, Types.INTEGER); + } else { + ps.setInt(6, Convert.toInt(hyMtpE.getPdynum())); + } + ps.setString(7, hyMtpE.getPdynumrcd()); + ps.setBigDecimal(8, hyMtpE.getMxdyp()); + ps.setString(9, hyMtpE.getMxdyprcd()); + if (hyMtpE.getMxdypodt() == null) { + ps.setTimestamp(10, null); + } else { + ps.setTimestamp(10, new Timestamp(hyMtpE.getMxdypodt().getTime())); + } + + }); + } + } else if (tableName.equals(SWTableEnum.YEAR_RAIN.value())) { + List hyYrpFList = hyYrpFService.list(Wrappers.lambdaQuery(HyYrpF.class) + .between(HyYrpF::getYr, startYear, endYear) + .in(HyYrpF::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyYrpFList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?,?,?, ?, ?, ?,?)) AS source (stcd, yr, p,prcd,pdynum,pdynumrcd,frdsdt,frapdt,sndsdt,snapdt) " + + "ON target.stcd = source.stcd AND target.yr = source.yr " + + "WHEN MATCHED THEN UPDATE SET p = source.p, prcd = source.prcd, pdynum = source.pdynum, pdynumrcd = source.pdynumrcd, frdsdt = source.frdsdt, frapdt = source.frapdt, sndsdt = source.sndsdt, snapdt = source.snapdt " + + "WHEN NOT MATCHED THEN INSERT (stcd, yr, p, prcd, pdynum, pdynumrcd, frdsdt, frapdt, sndsdt, snapdt) VALUES (source.stcd, source.yr, source.p, source.prcd, source.pdynum, source.pdynumrcd, source.frdsdt, source.frapdt, source.sndsdt, source.snapdt);"; + jdbcTemplate.batchUpdate(sql, hyYrpFList, 50, (ps, hyYrpF) -> { + ps.setString(1, hyYrpF.getStcd()); + ps.setInt(2, hyYrpF.getYr()); + ps.setBigDecimal(3, hyYrpF.getP()); + ps.setString(4, hyYrpF.getPrcd()); + if (hyYrpF.getPdynum() == null) { + ps.setNull(5, Types.INTEGER); + } else { + ps.setInt(5, Convert.toInt(hyYrpF.getPdynum())); + } + ps.setString(6, hyYrpF.getPdynumrcd()); + if (hyYrpF.getFrdsdt() == null) { + ps.setTimestamp(7, null); + } else { + ps.setTimestamp(7, new Timestamp(hyYrpF.getFrdsdt().getTime())); + } + if (hyYrpF.getFrapdt() == null) { + ps.setTimestamp(8, null); + } else { + ps.setTimestamp(8, new Timestamp(hyYrpF.getFrapdt().getTime())); + } + if (hyYrpF.getSndsdt() == null) { + ps.setTimestamp(9, null); + } else { + ps.setTimestamp(9, new Timestamp(hyYrpF.getSndsdt().getTime())); + } + if (hyYrpF.getSnapdt() == null) { + ps.setTimestamp(10, null); + } else { + ps.setTimestamp(10, new Timestamp(hyYrpF.getSnapdt().getTime())); + } + + }); + } + } else if (tableName.equals(SWTableEnum.HY_STSC.value())) { + List hyStscAList = hyStscAService.list(Wrappers.lambdaQuery(HyStscA.class) + .in(HyStscA::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyStscAList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,?,?, ?, ?, ?, ?, ?, ?, ?, ?,?,?,?,?,?,?)) AS source (stcd,stnm,stct,bshncd,hnnm,rvnm,obitmcd,addvcd,wrrgcd,esstyr,esstmth,wdstyr,wdstmth,drar,flto,dstrvm,fdtmnm,admag,admnst,stlc,lgtd,lttd,stgrd,frgrd,nt) " + + "ON target.stcd = source.stcd " + + "WHEN MATCHED THEN UPDATE SET stnm = source.stnm, stct = source.stct, bshncd = source.bshncd, hnnm = source.hnnm, rvnm = source.rvnm, obitmcd = source.obitmcd, addvcd = source.addvcd, wrrgcd = source.wrrgcd, esstyr = source.esstyr, esstmth = source.esstmth, wdstyr = source.wdstyr, wdstmth = source.wdstmth, drar = source.drar, flto = source.flto, dstrvm = source.dstrvm, fdtmnm = source.fdtmnm, admag = source.admag, admnst = source.admnst, stlc = source.stlc, lgtd = source.lgtd, lttd = source.lttd, stgrd = source.stgrd, frgrd = source.frgrd, nt = source.nt " + + "WHEN NOT MATCHED THEN INSERT (stcd, stnm, stct, bshncd, hnnm, rvnm, obitmcd, addvcd, wrrgcd, esstyr, esstmth, wdstyr, wdstmth, drar, flto, dstrvm, fdtmnm, admag, admnst, stlc, lgtd, lttd, stgrd, frgrd, nt) VALUES (source.stcd, source.stnm, source.stct, source.bshncd, source.hnnm, source.rvnm, source.obitmcd, source.addvcd, source.wrrgcd, source.esstyr, source.esstmth, source.wdstyr, source.wdstmth, source.drar, source.flto, source.dstrvm, source.fdtmnm, source.admag, source.admnst, source.stlc, source.lgtd, source.lttd ,source.stgrd ,source.frgrd ,source.nt);"; + jdbcTemplate.batchUpdate(sql, hyStscAList, 50, (ps, hyStscA) -> { + ps.setString(1, hyStscA.getStcd()); + ps.setString(2, hyStscA.getStnm()); + ps.setString(3, hyStscA.getStct()); + ps.setString(4, hyStscA.getBshncd()); + ps.setString(5, hyStscA.getHnnm()); + ps.setString(6, hyStscA.getRvnm()); + ps.setString(7, hyStscA.getObitmcd()); + ps.setString(8, hyStscA.getAddvcd()); + ps.setString(9, hyStscA.getWrrgcd()); + if (hyStscA.getEsstyr() == null) { + ps.setNull(10, Types.INTEGER); + } else { + ps.setInt(10, Convert.toInt(hyStscA.getEsstyr())); + } + if (hyStscA.getEsstmth() == null) { + ps.setNull(11, Types.INTEGER); + } else { + ps.setInt(11, Convert.toInt(hyStscA.getEsstmth())); + } + if (hyStscA.getWdstyr() == null) { + ps.setNull(12, Types.INTEGER); + } else { + ps.setInt(12, Convert.toInt(hyStscA.getWdstyr())); + } + if (hyStscA.getWdstmth() == null) { + ps.setNull(13, Types.INTEGER); + } else { + ps.setInt(13, Convert.toInt(hyStscA.getWdstmth())); + } + ps.setBigDecimal(14, hyStscA.getDrar()); + ps.setString(15, hyStscA.getFlto()); + ps.setBigDecimal(16, hyStscA.getDstrvm()); + ps.setString(17, hyStscA.getFdtmnm()); + ps.setString(18, hyStscA.getAdmag()); + ps.setString(19, hyStscA.getAdmnst()); + ps.setString(20, hyStscA.getStlc()); + ps.setBigDecimal(21, hyStscA.getLgtd()); + ps.setBigDecimal(22, hyStscA.getLttd()); + ps.setString(23, hyStscA.getStgrd()); + ps.setString(24, hyStscA.getFrgrd()); + ps.setString(25, hyStscA.getNt()); + }); + } + } else if (tableName.equals(SWTableEnum.HY_DMXP_F.value())) { + List hyDmxpFList = hyDmxpFService.list(Wrappers.lambdaQuery(HyDmxpF.class) + .between(HyDmxpF::getYr, startYear, endYear) + .in(HyDmxpF::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyDmxpFList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?, ?, ?)) AS source (stcd,yr,bgdt,mxpdr,mxp,mxprc) " + + "ON target.stcd = source.stcd AND target.yr = source.yr AND target.mxpdr = source.mxpdr " + + "WHEN MATCHED THEN UPDATE SET mxp = source.mxp, mxprc = source.mxprc , bgdt = source.bgdt " + + "WHEN NOT MATCHED THEN INSERT (stcd, yr, bgdt, mxpdr, mxp, mxprc) VALUES (source.stcd, source.yr, source.bgdt, source.mxpdr, source.mxp, source.mxprc);"; + jdbcTemplate.batchUpdate(sql, hyDmxpFList, 50, (ps, hyDmxpF) -> { + ps.setString(1, hyDmxpF.getStcd()); + ps.setInt(2, hyDmxpF.getYr()); + if (hyDmxpF.getBgdt() == null) { + ps.setTimestamp(3, null); + } else { + ps.setTimestamp(3, new Timestamp(hyDmxpF.getBgdt().getTime())); + } + ps.setString(4, String.valueOf(hyDmxpF.getMxpdr())); + ps.setBigDecimal(5, hyDmxpF.getMxp()); + ps.setString(6, hyDmxpF.getMxprc()); + }); + } + } else if (tableName.equals(SWTableEnum.DP_MMXP.value())) { + List hyMmxpFList = hyMmxpFService.list(Wrappers.lambdaQuery(HyMmxpF.class) + .between(HyMmxpF::getYr, startYear, endYear) + .in(HyMmxpF::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyMmxpFList)) { + List stcdList = hyMmxpFList.stream().map(HyMmxpF::getStcd).distinct().collect(Collectors.toList()); + Set stcdSet = new HashSet<>(stcdList); // 将小集合转为HashSet + List missingList = stcdsList.stream() + .filter(stcd -> !stcdSet.contains(stcd)) // 过滤未出现在stcdList中的元素 + .collect(Collectors.toList()); + for (String s : missingList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("622"); + removeFzTableId.add(fzTableId); + } + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?, ?, ?)) AS source (stcd,yr,bgtm,mxpdr,mxp,mxprc) " + + "ON target.stcd = source.stcd AND target.yr = source.yr AND target.mxpdr = source.mxpdr " + + "WHEN MATCHED THEN UPDATE SET mxp = source.mxp, mxprc = source.mxprc , bgtm = source.bgtm " + + "WHEN NOT MATCHED THEN INSERT (stcd, yr, bgtm, mxpdr, mxp, mxprc) VALUES (source.stcd, source.yr, source.bgtm, source.mxpdr, source.mxp, source.mxprc);"; + jdbcTemplate.batchUpdate(sql, hyMmxpFList, 50, (ps, hyMmxpF) -> { + ps.setString(1, hyMmxpF.getStcd()); + ps.setInt(2, hyMmxpF.getYr()); + if (hyMmxpF.getBgdt() == null) { + ps.setTimestamp(3, null); + } else { + ps.setTimestamp(3, new Timestamp(hyMmxpF.getBgdt().getTime())); + } + ps.setString(4, String.valueOf(hyMmxpF.getMxpdr())); + ps.setBigDecimal(5, hyMmxpF.getMxp()); + ps.setString(6, hyMmxpF.getMxprc()); + }); + }else { + for (String s : stcdsList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("622"); + removeFzTableId.add(fzTableId); + } + } + } else if (tableName.equals(SWTableEnum.DP_HMXP.value())) { + List hyHmxpFList = hyHmxpFService.list(Wrappers.lambdaQuery(HyHmxpF.class) + .between(HyHmxpF::getYr, startYear, endYear) + .in(HyHmxpF::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyHmxpFList)) { + List stcdList = hyHmxpFList.stream().map(HyHmxpF::getStcd).distinct().collect(Collectors.toList()); + Set stcdSet = new HashSet<>(stcdList); // 将小集合转为HashSet + List missingList = stcdsList.stream() + .filter(stcd -> !stcdSet.contains(stcd)) // 过滤未出现在stcdList中的元素 + .collect(Collectors.toList()); + for (String s : missingList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("623"); + removeFzTableId.add(fzTableId); + } + + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?, ?, ?)) AS source (stcd,yr,bgtm,mxpdr,mxp,mxprc) " + + "ON target.stcd = source.stcd AND target.yr = source.yr AND target.mxpdr = source.mxpdr " + + "WHEN MATCHED THEN UPDATE SET mxp = source.mxp, mxprc = source.mxprc ,bgtm = source.bgtm " + + "WHEN NOT MATCHED THEN INSERT (stcd, yr, bgtm, mxpdr, mxp, mxprc) VALUES (source.stcd, source.yr, source.bgtm, source.mxpdr, source.mxp, source.mxprc);"; + jdbcTemplate.batchUpdate(sql, hyHmxpFList, 50, (ps, hyHmxpF) -> { + ps.setString(1, hyHmxpF.getStcd()); + ps.setInt(2, hyHmxpF.getYr()); + if (hyHmxpF.getBgtm() == null) { + ps.setTimestamp(3, null); + } else { + ps.setTimestamp(3, new Timestamp(hyHmxpF.getBgtm().getTime())); + } + ps.setString(4, String.valueOf(hyHmxpF.getMxpdr())); + ps.setBigDecimal(5, hyHmxpF.getMxp()); + ps.setString(6, hyHmxpF.getMxprc()); + }); + }else { + for (String s : stcdsList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("623"); + removeFzTableId.add(fzTableId); + } + } + } else if (tableName.equals(SWTableEnum.DP_HOUR.value())) { + List hyPrexBList = hyPrexBService.list(Wrappers.lambdaQuery(HyPrexB.class) + .between(HyPrexB::getBgtm, startTimeDay, endTimeDay) + .in(HyPrexB::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyPrexBList)) { + List stcdList = hyPrexBList.stream().map(HyPrexB::getStcd).distinct().collect(Collectors.toList()); + Set stcdSet = new HashSet<>(stcdList); // 将小集合转为HashSet + List missingList = stcdsList.stream() + .filter(stcd -> !stcdSet.contains(stcd)) // 过滤未出现在stcdList中的元素 + .collect(Collectors.toList()); + for (String s : missingList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("221"); + removeFzTableId.add(fzTableId); + } + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?, ?)) AS source (stcd,bgtm,endtm,p,prcd) " + + "ON target.stcd = source.stcd AND target.bgtm = source.bgtm " + + "WHEN MATCHED THEN UPDATE SET endtm = source.endtm, p = source.p, prcd = source.prcd " + + "WHEN NOT MATCHED THEN INSERT (stcd, bgtm, endtm, p, prcd) VALUES (source.stcd, source.bgtm, source.endtm, source.p, source.prcd);"; + jdbcTemplate.batchUpdate(sql, hyPrexBList, 50, (ps, hyPrexB) -> { + ps.setString(1, hyPrexB.getStcd()); + ps.setTimestamp(2, new Timestamp(hyPrexB.getBgtm().getTime())); + if (hyPrexB.getEndtm() == null) { + ps.setTimestamp(3, null); + } else { + ps.setTimestamp(3, new Timestamp(hyPrexB.getEndtm().getTime())); + } + ps.setBigDecimal(4, hyPrexB.getP()); + ps.setString(5, hyPrexB.getPrcd()); + }); + }else { + for (String s : stcdsList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("221"); + removeFzTableId.add(fzTableId); + } + } + } else if (tableName.equals(SWTableEnum.DAY_DZC.value())) { + List hyDzCList = hyDzCService.list(Wrappers.lambdaQuery(HyDzC.class) + .between(HyDzC::getDt, startTimeDay, endTimeDay) + .in(HyDzC::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyDzCList)) { + List stcdList = hyDzCList.stream().map(HyDzC::getStcd).distinct().collect(Collectors.toList()); + Set stcdSet = new HashSet<>(stcdList); // 将小集合转为HashSet + List missingList = stcdsList.stream() + .filter(stcd -> !stcdSet.contains(stcd)) // 过滤未出现在stcdList中的元素 + .collect(Collectors.toList()); + for (String s : missingList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("341"); + removeFzTableId.add(fzTableId); + } + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?)) AS source (stcd,dt,avz,avzrcd) " + + "ON target.stcd = source.stcd AND target.dt = source.dt " + + "WHEN MATCHED THEN UPDATE SET avz = source.avz, avzrcd = source.avzrcd " + + "WHEN NOT MATCHED THEN INSERT (stcd, dt, avz, avzrcd) VALUES (source.stcd, source.dt, source.avz, source.avzrcd);"; + jdbcTemplate.batchUpdate(sql, hyDzCList, 50, (ps, hyDzC) -> { + ps.setString(1, hyDzC.getStcd()); + ps.setTimestamp(2, new Timestamp(hyDzC.getDt().getTime())); + ps.setBigDecimal(3, hyDzC.getAvz()); + ps.setString(4, hyDzC.getAvzrcd()); + }); + }else { + for (String s : stcdsList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("341"); + removeFzTableId.add(fzTableId); + } + } + } else if (tableName.equals(SWTableEnum.MONTH_RIVER.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.and(wrapper -> { + if (startYear.equals(endYear)) { + // 同一年：直接范围查询 + wrapper.apply("(yr = {0} AND mth BETWEEN {1} AND {2})", startYear, "01", "12"); + } else { + // 跨年：组合三段条件 + wrapper.apply("(yr = {0} AND mth >= {1})", startYear, "01"); // 起始年（1月至今） + for (int year = Integer.parseInt(startYear) + 1; year < Integer.parseInt(endYear); year++) { + wrapper.or().apply("yr = {0}", year); // 中间整年 + } + wrapper.or().apply("(yr = {0} AND mth <= {1})", endYear, "12"); // 结束年（1-12月） + } + }); + queryWrapper.in("stcd", stcdsList); + List hyMtzEList = hyMtzEService.list(queryWrapper); + if (ObjectUtils.isNotEmpty(hyMtzEList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?,?,?,?,?,?,?,?)) AS source (stcd,yr,mth,avz,avzrcd,htz,htzrcd,htzdt,mnz,mnzrcd,mnzdt) " + + "ON target.stcd = source.stcd AND target.yr = source.yr AND target.mth = source.mth " + + "WHEN MATCHED THEN UPDATE SET avz = source.avz, avzrcd = source.avzrcd, htz = source.htz, htzrcd = source.htzrcd, htzdt = source.htzdt, mnz = source.mnz, mnzrcd = source.mnzrcd, mnzdt = source.mnzdt " + + "WHEN NOT MATCHED THEN INSERT (stcd, yr, mth, avz, avzrcd, htz, htzrcd, htzdt, mnz, mnzrcd, mnzdt) VALUES (source.stcd, source.yr, source.mth, source.avz, source.avzrcd, source.htz, source.htzrcd, source.htzdt, source.mnz, source.mnzrcd, source.mnzdt);"; + + jdbcTemplate.batchUpdate(sql, hyMtzEList, 50, (ps, hyMtzE) -> { + ps.setString(1, hyMtzE.getStcd()); + ps.setInt(2, hyMtzE.getYr()); + ps.setInt(3, hyMtzE.getMth()); + ps.setBigDecimal(4, hyMtzE.getAvz()); + ps.setString(5, hyMtzE.getAvzrcd()); + ps.setBigDecimal(6, hyMtzE.getHtz()); + ps.setString(7, hyMtzE.getHtzrcd()); + if (hyMtzE.getHtzdt() == null) { + ps.setTimestamp(8, null); + } else { + ps.setTimestamp(8, new Timestamp(hyMtzE.getHtzdt().getTime())); + } + ps.setBigDecimal(9, hyMtzE.getMnz()); + ps.setString(10, hyMtzE.getMnzrcd()); + if (hyMtzE.getMnzdt() == null) { + ps.setTimestamp(11, null); + } else { + ps.setTimestamp(11, new Timestamp(hyMtzE.getMnzdt().getTime())); + } + }); + } + } else if (tableName.equals(SWTableEnum.YEAR_RIVER.value())) { + List hyYrzFList = hyYrzFService.list(Wrappers.lambdaQuery(HyYrzF.class) + .between(HyYrzF::getYr, startYear, endYear) + .in(HyYrzF::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyYrzFList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?, ?, ?,?,?,?,?)) AS source (stcd,yr,avz,avzrcd,htz,htzrcd,htzdt,mnz,mnzrcd,mnzdt) " + + "ON target.stcd = source.stcd AND target.yr = source.yr " + + "WHEN MATCHED THEN UPDATE SET avz = source.avz, avzrcd = source.avzrcd, htz = source.htz, htzrcd = source.htzrcd, htzdt = source.htzdt, mnz = source.mnz, mnzrcd = source.mnzrcd, mnzdt = source.mnzdt " + + "WHEN NOT MATCHED THEN INSERT (stcd, yr, avz, avzrcd, htz, htzrcd, htzdt, mnz, mnzrcd, mnzdt) VALUES (source.stcd, source.yr, source.avz, source.avzrcd, source.htz, source.htzrcd, source.htzdt, source.mnz, source.mnzrcd, source.mnzdt);"; + jdbcTemplate.batchUpdate(sql, hyYrzFList, 50, (ps, hyYrzF) -> { + ps.setString(1, hyYrzF.getStcd()); + ps.setInt(2, hyYrzF.getYr()); + ps.setBigDecimal(3, hyYrzF.getAvz()); + ps.setString(4, hyYrzF.getAvzrcd()); + ps.setBigDecimal(5, hyYrzF.getHtz()); + ps.setString(6, hyYrzF.getHtzrcd()); + if (hyYrzF.getHtzdt() == null) { + ps.setTimestamp(7, null); + } else { + ps.setTimestamp(7, new Timestamp(hyYrzF.getHtzdt().getTime())); + } + ps.setBigDecimal(8, hyYrzF.getMnz()); + ps.setString(9, hyYrzF.getMnzrcd()); + if (hyYrzF.getMnzdt() == null) { + ps.setTimestamp(10, null); + } else { + ps.setTimestamp(10, new Timestamp(hyYrzF.getMnzdt().getTime())); + } + }); + } + } else if (tableName.equals(SWTableEnum.HY_WFDZ_F.value())) { + List hyWfdzFList = this.baseMapper.listByHyWfdzF(startYear, endYear, stcdsList); + if (ObjectUtils.isNotEmpty(hyWfdzFList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?,?)) AS source (stcd,yr,wf,rfz,rzrcd) " + + "ON target.stcd = source.stcd AND target.yr = source.yr AND target.wf = source.wf " + + "WHEN MATCHED THEN UPDATE SET rfz = source.rfz, rzrcd = source.rzrcd " + + "WHEN NOT MATCHED THEN INSERT (stcd, yr, wf, rfz, rzrcd) VALUES (source.stcd, source.yr, source.wf, source.rfz, source.rzrcd);"; + jdbcTemplate.batchUpdate(sql, hyWfdzFList, 50, (ps, hyWfdzF) -> { + ps.setString(1, hyWfdzF.getStcd()); + ps.setBigDecimal(2, hyWfdzF.getYr()); + ps.setBigDecimal(3, hyWfdzF.getWf()); + ps.setBigDecimal(4, hyWfdzF.getRfz()); + ps.setString(5, hyWfdzF.getRzrcd()); + }); + } + } else if (tableName.equals(SWTableEnum.DP_HLTDZ.value())) { + List hyHltdzBList = hyHltdzBService.list(Wrappers.lambdaQuery(HyHltdzB.class) + .between(HyHltdzB::getTm, startTimeDay, endTimeDay) + .in(HyHltdzB::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyHltdzBList)) { + List stcdList = hyHltdzBList.stream().map(HyHltdzB::getStcd).distinct().collect(Collectors.toList()); + Set stcdSet = new HashSet<>(stcdList); // 将小集合转为HashSet + List missingList = stcdsList.stream() + .filter(stcd -> !stcdSet.contains(stcd)) // 过滤未出现在stcdList中的元素 + .collect(Collectors.toList()); + for (String s : missingList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("291"); + removeFzTableId.add(fzTableId); + } + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?, ?, ?,?,?)) AS source (stcd,tm,tdtp,tdz,tdzrcd,tdrng,dr,nt) " + + "ON target.stcd = source.stcd AND target.tm = source.tm " + + "WHEN MATCHED THEN UPDATE SET tdtp = source.tdtp, tdz = source.tdz, tdzrcd = source.tdzrcd, tdrng = source.tdrng, dr = source.dr, nt = source.nt " + + "WHEN NOT MATCHED THEN INSERT (stcd, tm, tdtp, tdz, tdzrcd, tdrng, dr, nt) VALUES (source.stcd, source.tm, source.tdtp, source.tdz, source.tdzrcd, source.tdrng, source.dr, source.nt);"; + + jdbcTemplate.batchUpdate(sql, hyHltdzBList, 50, (ps, hyHltdzB) -> { + ps.setString(1, hyHltdzB.getStcd()); + ps.setTimestamp(2, new Timestamp(hyHltdzB.getTm().getTime())); + ps.setString(3, hyHltdzB.getTdtp()); + ps.setBigDecimal(4, hyHltdzB.getTdz()); + ps.setString(5, hyHltdzB.getTdzrcd()); + ps.setBigDecimal(6, hyHltdzB.getTdrng()); + ps.setString(7, hyHltdzB.getDr()); + ps.setString(8, hyHltdzB.getNt()); + }); + }else { + for (String s : stcdsList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("291"); + removeFzTableId.add(fzTableId); + } + } + } else if (tableName.equals(SWTableEnum.MONTH_MTTDZ.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.and(wrapper -> { + if (startYear.equals(endYear)) { + // 同一年：直接范围查询 + wrapper.apply("(yr = {0} AND mth BETWEEN {1} AND {2})", startYear, "01", "12"); + } else { + // 跨年：组合三段条件 + wrapper.apply("(yr = {0} AND mth >= {1})", startYear, "01"); // 起始年（1月至今） + for (int year = Integer.parseInt(startYear) + 1; year < Integer.parseInt(endYear); year++) { + wrapper.or().apply("yr = {0}", year); // 中间整年 + } + wrapper.or().apply("(yr = {0} AND mth <= {1})", endYear, "12"); // 结束年（1-12月） + } + }); + queryWrapper.in("stcd", stcdsList); + + List hyMtzEList = hyMttdzEService.list(queryWrapper); + if (ObjectUtils.isNotEmpty(hyMtzEList)) { + List stcdList = hyMtzEList.stream().map(HyMttdzE::getStcd).distinct().collect(Collectors.toList()); + Set stcdSet = new HashSet<>(stcdList); // 将小集合转为HashSet + List missingList = stcdsList.stream() + .filter(stcd -> !stcdSet.contains(stcd)) // 过滤未出现在stcdList中的元素 + .collect(Collectors.toList()); + for (String s : missingList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("591"); + removeFzTableId.add(fzTableId); + } + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?," + + " ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, " + + "?, ?, ?, ?, ?, ?, ?, ?, ?, ?, " + + "?, ?, ?, ?, ?, ?, ?, ?, ?, ?," + + " ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, " + + "?, ?, ?, ?, ?, ?, ? )) " + // 共 52 个占位符 + "AS source (stcd, yr, mth, avhtdz, avhtdzrcd, hthtdz, hthtdzrcd, hthtdzotm, " + //8 + "lthtdz, lthtdzrcd, lthtdzotm, avltdz, avltdzrcd, htltdz, htltdzrcd, " + //7 + "htltdzotm, ltltdz, ltltdzrcd, ltltdzotm, avftdr, avftdrrcd, mxfltdr, " + //7 + "mxfltdrrcd, mxfltdrhtm, mnfltdr, mnfltdrrcd, mnfltdrhtm, aver, avebbrrcd, " + //7 + "mxebtdr, mxebtdrrcd, mxebtdrhtm, mnebtdr, mnebtdrrcd, mnebtdrhtm, avftd, " + //7 + "avftdrcd, mxfltddr, mxfltddrrcd, mxfltddrhtm, mnfltddr, mnfltddrrcd, " + //6 + "mnfltddrhtm, avebbdr, avedrc, mxebtddr, mxebtddrrcd, mxebtddrhtm, " + //6 + "mnebtddr, mnebtddrrcd, mnebtddrhtm, hravtdz, hravtdzrcd, avtdr, avtdrrcd, " + // 7 + "avtddr, avtddrrcd) " + //2 + "ON target.stcd = source.stcd " + + " AND target.yr = source.yr " + + " AND target.mth = source.mth " + + "WHEN MATCHED THEN " + + " UPDATE SET " + + " avhtdz = source.avhtdz, " + + " avhtdzrcd = source.avhtdzrcd, " + + " hthtdz = source.hthtdz, " + + " hthtdzrcd = source.hthtdzrcd, " + + " hthtdzotm = source.hthtdzotm, " + + " lthtdz = source.lthtdz, " + + " lthtdzrcd = source.lthtdzrcd, " + + " lthtdzotm = source.lthtdzotm, " + + " avltdz = source.avltdz, " + + " avltdzrcd = source.avltdzrcd, " + + " htltdz = source.htltdz, " + + " htltdzrcd = source.htltdzrcd, " + + " htltdzotm = source.htltdzotm, " + + " ltltdz = source.ltltdz, " + + " ltltdzrcd = source.ltltdzrcd, " + + " ltltdzotm = source.ltltdzotm, " + + " avftdr = source.avftdr, " + + " avftdrrcd = source.avftdrrcd, " + + " mxfltdr = source.mxfltdr, " + + " mxfltdrrcd = source.mxfltdrrcd, " + + " mxfltdrhtm = source.mxfltdrhtm, " + + " mnfltdr = source.mnfltdr, " + + " mnfltdrrcd = source.mnfltdrrcd, " + + " mnfltdrhtm = source.mnfltdrhtm, " + + " aver = source.aver, " + + " avebbrrcd = source.avebbrrcd, " + + " mxebtdr = source.mxebtdr, " + + " mxebtdrrcd = source.mxebtdrrcd, " + + " mxebtdrhtm = source.mxebtdrhtm, " + + " mnebtdr = source.mnebtdr, " + + " mnebtdrrcd = source.mnebtdrrcd, " + + " mnebtdrhtm = source.mnebtdrhtm, " + + " avftd = source.avftd, " + + " avftdrcd = source.avftdrcd, " + + " mxfltddr = source.mxfltddr, " + + " mxfltddrrcd = source.mxfltddrrcd, " + + " mxfltddrhtm = source.mxfltddrhtm, " + + " mnfltddr = source.mnfltddr, " + + " mnfltddrrcd = source.mnfltddrrcd, " + + " mnfltddrhtm = source.mnfltddrhtm, " + + " avebbdr = source.avebbdr, " + + " avedrc = source.avedrc, " + + " mxebtddr = source.mxebtddr, " + + " mxebtddrrcd = source.mxebtddrrcd, " + + " mxebtddrhtm = source.mxebtddrhtm, " + + " mnebtddr = source.mnebtddr, " + + " mnebtddrrcd = source.mnebtddrrcd, " + + " mnebtddrhtm = source.mnebtddrhtm, " + + " hravtdz = source.hravtdz, " + + " hravtdzrcd = source.hravtdzrcd, " + + " avtdr = source.avtdr, " + + " avtdrrcd = source.avtdrrcd, " + + " avtddr = source.avtddr, " + + " avtddrrcd = source.avtddrrcd " + + "WHEN NOT MATCHED THEN " + + " INSERT (stcd, yr, mth, avhtdz, avhtdzrcd, hthtdz, hthtdzrcd, hthtdzotm, " + + " lthtdz, lthtdzrcd, lthtdzotm, avltdz, avltdzrcd, htltdz, htltdzrcd, " + + " htltdzotm, ltltdz, ltltdzrcd, ltltdzotm, avftdr, avftdrrcd, mxfltdr, " + + " mxfltdrrcd, mxfltdrhtm, mnfltdr, mnfltdrrcd, mnfltdrhtm, aver, avebbrrcd, " + + " mxebtdr, mxebtdrrcd, mxebtdrhtm, mnebtdr, mnebtdrrcd, mnebtdrhtm, avftd, " + + " avftdrcd, mxfltddr, mxfltddrrcd, mxfltddrhtm, mnfltddr, mnfltddrrcd, " + + " mnfltddrhtm, avebbdr, avedrc, mxebtddr, mxebtddrrcd, mxebtddrhtm, " + + " mnebtddr, mnebtddrrcd, mnebtddrhtm, hravtdz, hravtdzrcd, avtdr, avtdrrcd, " + + " avtddr, avtddrrcd) " + + " VALUES (source.stcd, source.yr, source.mth, source.avhtdz, source.avhtdzrcd, " + + " source.hthtdz, source.hthtdzrcd, source.hthtdzotm, source.lthtdz, " + + " source.lthtdzrcd, source.lthtdzotm, source.avltdz, source.avltdzrcd, " + + " source.htltdz, source.htltdzrcd, source.htltdzotm, source.ltltdz, " + + " source.ltltdzrcd, source.ltltdzotm, source.avftdr, source.avftdrrcd, " + + " source.mxfltdr, source.mxfltdrrcd, source.mxfltdrhtm, source.mnfltdr, " + + " source.mnfltdrrcd, source.mnfltdrhtm, source.aver, source.avebbrrcd, " + + " source.mxebtdr, source.mxebtdrrcd, source.mxebtdrhtm, source.mnebtdr, " + + " source.mnebtdrrcd, source.mnebtdrhtm, source.avftd, source.avftdrcd, " + + " source.mxfltddr, source.mxfltddrrcd, source.mxfltddrhtm, source.mnfltddr, " + + " source.mnfltddrrcd, source.mnfltddrhtm, source.avebbdr, source.avedrc, " + + " source.mxebtddr, source.mxebtddrrcd, source.mxebtddrhtm, source.mnebtddr, " + + " source.mnebtddrrcd, source.mnebtddrhtm, source.hravtdz, source.hravtdzrcd, " + + " source.avtdr, source.avtdrrcd, source.avtddr, source.avtddrrcd);"; + + jdbcTemplate.batchUpdate(sql, hyMtzEList, 50, (ps, hyMttdzE) -> { + ps.setString(1, hyMttdzE.getStcd()); + ps.setInt(2, hyMttdzE.getYr()); + ps.setInt(3, hyMttdzE.getMth()); + ps.setBigDecimal(4, hyMttdzE.getAvhtdz()); + ps.setString(5, hyMttdzE.getAvhtdzrcd()); + ps.setBigDecimal(6, hyMttdzE.getHthtdz()); + ps.setString(7, hyMttdzE.getHthtdzrcd()); + if (hyMttdzE.getHthtdzotm() == null) { + ps.setTimestamp(8, null); + } else { + ps.setTimestamp(8, new Timestamp(hyMttdzE.getHthtdzotm().getTime())); + } + ps.setBigDecimal(9, hyMttdzE.getLthtdz()); + ps.setString(10, hyMttdzE.getLthtdzrcd()); + if (hyMttdzE.getLthtdzotm() == null) { + ps.setTimestamp(11, null); + } else { + ps.setTimestamp(11, new Timestamp(hyMttdzE.getLthtdzotm().getTime())); + } + ps.setBigDecimal(12, hyMttdzE.getAvltdz()); + ps.setString(13, hyMttdzE.getAvltdzrcd()); + ps.setBigDecimal(14, hyMttdzE.getHtltdz()); + ps.setString(15, hyMttdzE.getHtltdzrcd()); + if (hyMttdzE.getHtltdzotm() == null) { + ps.setTimestamp(16, null); + } else { + ps.setTimestamp(16, new Timestamp(hyMttdzE.getHtltdzotm().getTime())); + } + ps.setBigDecimal(17, hyMttdzE.getLtltdz()); + ps.setString(18, hyMttdzE.getLtltdzrcd()); + if (hyMttdzE.getLtltdzotm() == null) { + ps.setTimestamp(19, null); + } else { + ps.setTimestamp(19, new Timestamp(hyMttdzE.getLtltdzotm().getTime())); + } + ps.setBigDecimal(20, hyMttdzE.getAvftdr()); + ps.setString(21, hyMttdzE.getAvftdrrcd()); + ps.setBigDecimal(22, hyMttdzE.getMxfltdr()); + ps.setString(23, hyMttdzE.getMxfltdrrcd()); + if (hyMttdzE.getMxfltdrhtm() == null) { + ps.setTimestamp(24, null); + } else { + ps.setTimestamp(24, new Timestamp(hyMttdzE.getMxfltdrhtm().getTime())); + } + ps.setBigDecimal(25, hyMttdzE.getMnfltdr()); + ps.setString(26, hyMttdzE.getMnfltdrrcd()); + if (hyMttdzE.getMnfltdrhtm() == null) { + ps.setTimestamp(27, null); + } else { + ps.setTimestamp(27, new Timestamp(hyMttdzE.getMnfltdrhtm().getTime())); + } + ps.setBigDecimal(28, hyMttdzE.getAver()); + ps.setString(29, hyMttdzE.getAverbbrrcd()); + ps.setBigDecimal(30, hyMttdzE.getMxebtdr()); + ps.setString(31, hyMttdzE.getMxebtdrrcd()); + if (hyMttdzE.getMxebtdrht() == null) { + ps.setTimestamp(32, null); + } else { + ps.setTimestamp(32, new Timestamp(hyMttdzE.getMxebtdrht().getTime())); + } + ps.setBigDecimal(33, hyMttdzE.getMnebtdr()); + ps.setString(34, hyMttdzE.getMnebtdrrcd()); + if (hyMttdzE.getMnebtdrhtm() == null) { + ps.setTimestamp(35, null); + } else { + ps.setTimestamp(35, new Timestamp(hyMttdzE.getMnebtdrhtm().getTime())); + } + ps.setInt(36, hyMttdzE.getAvftd()); + ps.setString(37, hyMttdzE.getAvftdrcd()); + ps.setInt(38, hyMttdzE.getMxfltddr()); + ps.setString(39, hyMttdzE.getMxfltddrrcd()); + if (hyMttdzE.getMxfltddrhtm() == null) { + ps.setTimestamp(40, null); + } else { + ps.setTimestamp(40, new Timestamp(hyMttdzE.getMxfltddrhtm().getTime())); + } + ps.setInt(41, hyMttdzE.getMnfltddr()); + ps.setString(42, hyMttdzE.getMnfltddrrcd()); + if (hyMttdzE.getMnfltddrhtm() == null) { + ps.setTimestamp(43, null); + } else { + ps.setTimestamp(43, new Timestamp(hyMttdzE.getMnfltddrhtm().getTime())); + } + ps.setInt(44, hyMttdzE.getAvebbdr()); + ps.setString(45, hyMttdzE.getAvedrc()); + ps.setInt(46, hyMttdzE.getMxebtddr()); + ps.setString(47, hyMttdzE.getMxebtddrrcd()); + if (hyMttdzE.getMxebtddrhtm() == null) { + ps.setTimestamp(48, null); + } else { + ps.setTimestamp(48, new Timestamp(hyMttdzE.getMxebtddrhtm().getTime())); + } + ps.setInt(49, hyMttdzE.getMnbtddr()); + ps.setString(50, hyMttdzE.getMnebtddrrcd()); + if (hyMttdzE.getMnebtddrhtm() == null) { + ps.setTimestamp(51, null); + } else { + ps.setTimestamp(51, new Timestamp(hyMttdzE.getMnebtddrhtm().getTime())); + } + ps.setBigDecimal(52, hyMttdzE.getHravtdz()); + ps.setString(53, hyMttdzE.getHravtdzrcd()); + ps.setBigDecimal(54, hyMttdzE.getAvtdr()); + ps.setString(55, hyMttdzE.getAvtdrrcd()); + ps.setInt(56, hyMttdzE.getAvtddr()); + ps.setString(57, hyMttdzE.getAvtddrrcd()); + }); + }else { + for (String s : stcdsList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("591"); + removeFzTableId.add(fzTableId); + } + } + } else if (tableName.equals(SWTableEnum.YEAR_TIDE.value())) { + List hyYrtdzFList = hyYrtdzFService.list(Wrappers.lambdaQuery(HyYrtdzF.class) + .between(HyYrtdzF::getYr, startYear, endYear) + .in(HyYrtdzF::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyYrtdzFList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (" + + "?,?,?,?,?,?,?,?,?,?," + // 1-10 + "?,?,?,?,?,?,?,?,?,?," + // 11-20 + "?,?,?,?,?,?,?,?,?,?," + // 21-30 + "?,?,?,?,?,?,?,?,?,?," + // 31-40 + "?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,? " + // 41-49 (共49个占位符) + ")) " + + "AS source (" + + "stcd, yr, avhtdz, avhtdzrcd, hthtdz, hthtdzrcd, hthtdzotm, " + //7 + "lthtdz, lthtdzrcd, lthtdzotm, avltdz, avltdzrcd, htltdz, htltdzrcd, htltdzotm, " + //8 + "ltltdz, ltltdzrcd, ltltdzotm, avftdr, avftdrrcd, mxfltdr, mxfltdrrcd, mxfltdrhtm, " + //8 + "mnfltdr, mnfltdrrcd, mnfltdrhtm, aver, avebbrrcd, mxebtdr, mxebtdrrcd, " + //7 + "mxebtdrhtm, mnebtdr, mnebtdrrcd, mnebtdrhtm, avftd, avftdrcd, mxfltddr, " + //7 + "mxfltddrrcd, mxfltddrhtm, mnfltddr, mnfltddrrcd, mnfltddrhtm, avebbdr, " + //6 + "avedrc, mxebtddr, mxebtddrrcd, mxebtddrhtm, mnebtddr, mnebtddrrcd, " + //6 + "mnebtddrhtm, hravtdz, hravtdzrcd, avtdr, avtdrrcd, avtddr, avtddrrcd) " + //7 + "ON target.stcd = source.stcd " + + " AND target.yr = source.yr " + // 主键改为(stcd, yr) + "WHEN MATCHED THEN " + + " UPDATE SET " + + " avhtdz = source.avhtdz, " + + " avhtdzrcd = source.avhtdzrcd, " + + " hthtdz = source.hthtdz, " + + " hthtdzrcd = source.hthtdzrcd, " + + " hthtdzotm = source.hthtdzotm, " + + " lthtdz = source.lthtdz, " + + " lthtdzrcd = source.lthtdzrcd, " + + " lthtdzotm = source.lthtdzotm, " + + " avltdz = source.avltdz, " + + " avltdzrcd = source.avltdzrcd, " + + " htltdz = source.htltdz, " + + " htltdzrcd = source.htltdzrcd, " + + " htltdzotm = source.htltdzotm, " + + " ltltdz = source.ltltdz, " + + " ltltdzrcd = source.ltltdzrcd, " + + " ltltdzotm = source.ltltdzotm, " + + " avftdr = source.avftdr, " + + " avftdrrcd = source.avftdrrcd, " + + " mxfltdr = source.mxfltdr, " + + " mxfltdrrcd = source.mxfltdrrcd, " + + " mxfltdrhtm = source.mxfltdrhtm, " + + " mnfltdr = source.mnfltdr, " + + " mnfltdrrcd = source.mnfltdrrcd, " + + " mnfltdrhtm = source.mnfltdrhtm, " + + " aver = source.aver, " + + " avebbrrcd = source.avebbrrcd, " + + " mxebtdr = source.mxebtdr, " + + " mxebtdrrcd = source.mxebtdrrcd, " + + " mxebtdrhtm = source.mxebtdrhtm, " + + " mnebtdr = source.mnebtdr, " + + " mnebtdrrcd = source.mnebtdrrcd, " + + " mnebtdrhtm = source.mnebtdrhtm, " + + " avftd = source.avftd, " + + " avftdrcd = source.avftdrcd, " + + " mxfltddr = source.mxfltddr, " + + " mxfltddrrcd = source.mxfltddrrcd, " + + " mxfltddrhtm = source.mxfltddrhtm, " + + " mnfltddr = source.mnfltddr, " + + " mnfltddrrcd = source.mnfltddrrcd, " + + " mnfltddrhtm = source.mnfltddrhtm, " + + " avebbdr = source.avebbdr, " + + " avedrc = source.avedrc, " + + " mxebtddr = source.mxebtddr, " + + " mxebtddrrcd = source.mxebtddrrcd, " + + " mxebtddrhtm = source.mxebtddrhtm, " + + " mnebtddr = source.mnebtddr, " + + " mnebtddrrcd = source.mnebtddrrcd, " + + " mnebtddrhtm = source.mnebtddrhtm, " + + " hravtdz = source.hravtdz, " + + " hravtdzrcd = source.hravtdzrcd, " + + " avtdr = source.avtdr, " + + " avtdrrcd = source.avtdrrcd, " + + " avtddr = source.avtddr, " + + " avtddrrcd = source.avtddrrcd " + + "WHEN NOT MATCHED THEN " + + " INSERT (" + + " stcd, yr, avhtdz, avhtdzrcd, hthtdz, hthtdzrcd, hthtdzotm, " + + " lthtdz, lthtdzrcd, lthtdzotm, avltdz, avltdzrcd, htltdz, htltdzrcd, htltdzotm, " + + " ltltdz, ltltdzrcd, ltltdzotm, avftdr, avftdrrcd, mxfltdr, mxfltdrrcd, mxfltdrhtm, " + + " mnfltdr, mnfltdrrcd, mnfltdrhtm, aver, avebbrrcd, mxebtdr, mxebtdrrcd, " + + " mxebtdrhtm, mnebtdr, mnebtdrrcd, mnebtdrhtm, avftd, avftdrcd, mxfltddr, " + + " mxfltddrrcd, mxfltddrhtm, mnfltddr, mnfltddrrcd, mnfltddrhtm, avebbdr, " + + " avedrc, mxebtddr, mxebtddrrcd, mxebtddrhtm, mnebtddr, mnebtddrrcd, " + + " mnebtddrhtm, hravtdz, hravtdzrcd, avtdr, avtdrrcd, avtddr, avtddrrcd" + + " ) VALUES (" + + " source.stcd, source.yr, source.avhtdz, source.avhtdzrcd, source.hthtdz, " + + " source.hthtdzrcd, source.hthtdzotm, source.lthtdz, source.lthtdzrcd, " + + " source.lthtdzotm, source.avltdz, source.avltdzrcd, source.htltdz, " + + " source.htltdzrcd, source.htltdzotm, source.ltltdz, source.ltltdzrcd, " + + " source.ltltdzotm, source.avftdr, source.avftdrrcd, source.mxfltdr, " + + " source.mxfltdrrcd, source.mxfltdrhtm, source.mnfltdr, source.mnfltdrrcd, " + + " source.mnfltdrhtm, source.aver, source.avebbrrcd, source.mxebtdr, " + + " source.mxebtdrrcd, source.mxebtdrhtm, source.mnebtdr, source.mnebtdrrcd, " + + " source.mnebtdrhtm, source.avftd, source.avftdrcd, source.mxfltddr, " + + " source.mxfltddrrcd, source.mxfltddrhtm, source.mnfltddr, source.mnfltddrrcd, " + + " source.mnfltddrhtm, source.avebbdr, source.avedrc, source.mxebtddr, " + + " source.mxebtddrrcd, source.mxebtddrhtm, source.mnebtddr, source.mnebtddrrcd, " + + " source.mnebtddrhtm, source.hravtdz, source.hravtdzrcd, source.avtdr, " + + " source.avtdrrcd, source.avtddr, source.avtddrrcd" + + " );"; + + jdbcTemplate.batchUpdate(sql, hyYrtdzFList, 50, (ps, hyYrtdzF) -> { + ps.setString(1, hyYrtdzF.getStcd()); + ps.setInt(2, hyYrtdzF.getYr()); + ps.setBigDecimal(3, hyYrtdzF.getAvhtdz()); + ps.setString(4, hyYrtdzF.getAvhtdzrcd()); + ps.setBigDecimal(5, hyYrtdzF.getHthtdz()); + ps.setString(6, hyYrtdzF.getHthtdzrcd()); + if (hyYrtdzF.getHthtdzotm() == null) { + ps.setTimestamp(7, null); + } else { + ps.setTimestamp(7, new Timestamp(hyYrtdzF.getHthtdzotm().getTime())); + } + ps.setBigDecimal(8, hyYrtdzF.getLthtdz()); + ps.setString(9, hyYrtdzF.getLthtdzrcd()); + if (hyYrtdzF.getLthtdzotm() == null) { + ps.setTimestamp(10, null); + } else { + ps.setTimestamp(10, new Timestamp(hyYrtdzF.getLthtdzotm().getTime())); + } + ps.setBigDecimal(11, hyYrtdzF.getAvltdz()); + ps.setString(12, hyYrtdzF.getAvltdzrcd()); + ps.setBigDecimal(13, hyYrtdzF.getHtltdz()); + ps.setString(14, hyYrtdzF.getHtltdzrcd()); + if (hyYrtdzF.getHtltdzotm() == null) { + ps.setTimestamp(15, null); + } else { + ps.setTimestamp(15, new Timestamp(hyYrtdzF.getHtltdzotm().getTime())); + } + ps.setBigDecimal(16, hyYrtdzF.getLtltdz()); + ps.setString(17, hyYrtdzF.getLtltdzrcd()); + if (hyYrtdzF.getLtltdzotm() == null) { + ps.setTimestamp(18, null); + } else { + ps.setTimestamp(18, new Timestamp(hyYrtdzF.getLtltdzotm().getTime())); + } + ps.setBigDecimal(19, hyYrtdzF.getAvftdr()); + ps.setString(20, hyYrtdzF.getAvftdrrcd()); + ps.setBigDecimal(21, hyYrtdzF.getMxfltdr()); + ps.setString(22, hyYrtdzF.getMxfltdrrcd()); + if (hyYrtdzF.getMxfltdrhtm() == null) { + ps.setTimestamp(23, null); + } else { + ps.setTimestamp(23, new Timestamp(hyYrtdzF.getMxfltdrhtm().getTime())); + } + ps.setBigDecimal(24, hyYrtdzF.getMnfltdr()); + ps.setString(25, hyYrtdzF.getMnfltdrrcd()); + if (hyYrtdzF.getMnfltdrhtm() == null) { + ps.setTimestamp(26, null); + } else { + ps.setTimestamp(26, new Timestamp(hyYrtdzF.getMnfltdrhtm().getTime())); + } + ps.setBigDecimal(27, hyYrtdzF.getAver()); + ps.setString(28, hyYrtdzF.getAverbbrrcd()); + ps.setBigDecimal(29, hyYrtdzF.getMxebtdr()); + ps.setString(30, hyYrtdzF.getMxebtdrrcd()); + if (hyYrtdzF.getMxebtdrht() == null) { + ps.setTimestamp(31, null); + } else { + ps.setTimestamp(31, new Timestamp(hyYrtdzF.getMxebtdrht().getTime())); + } + ps.setBigDecimal(32, hyYrtdzF.getMnebtdr()); + ps.setString(33, hyYrtdzF.getMnebtdrrcd()); + if (hyYrtdzF.getMnebtdrhtm() == null) { + ps.setTimestamp(34, null); + } else { + ps.setTimestamp(34, new Timestamp(hyYrtdzF.getMnebtdrhtm().getTime())); + } + ps.setInt(35, hyYrtdzF.getAvftd()); + ps.setString(36, hyYrtdzF.getAvftdrcd()); + ps.setInt(37, hyYrtdzF.getMxfltddr()); + ps.setString(38, hyYrtdzF.getMxfltddrrcd()); + if (hyYrtdzF.getMxfltddrhtm() == null) { + ps.setTimestamp(39, null); + } else { + ps.setTimestamp(39, new Timestamp(hyYrtdzF.getMxfltddrhtm().getTime())); + } + ps.setInt(40, hyYrtdzF.getMnfltddr()); + ps.setString(41, hyYrtdzF.getMnfltddrrcd()); + if (hyYrtdzF.getMnfltddrhtm() == null) { + ps.setTimestamp(42, null); + } else { + ps.setTimestamp(42, new Timestamp(hyYrtdzF.getMnfltddrhtm().getTime())); + } + ps.setInt(43, hyYrtdzF.getAvebbdr()); + ps.setString(44, hyYrtdzF.getAvedrc()); + ps.setInt(45, hyYrtdzF.getMxebtddr()); + ps.setString(46, hyYrtdzF.getMxebtddrrcd()); + if (hyYrtdzF.getMxebtddrhtm() == null) { + ps.setTimestamp(47, null); + } else { + ps.setTimestamp(47, new Timestamp(hyYrtdzF.getMxebtddrhtm().getTime())); + } + ps.setInt(48, hyYrtdzF.getMnbtddr()); + ps.setString(49, hyYrtdzF.getMnebtddrrcd()); + if (hyYrtdzF.getMnebtddrhtm() == null) { + ps.setTimestamp(50, null); + } else { + ps.setTimestamp(50, new Timestamp(hyYrtdzF.getMnebtddrhtm().getTime())); + } + ps.setBigDecimal(51, hyYrtdzF.getHravtdz()); + ps.setString(52, hyYrtdzF.getHravtdzrcd()); + ps.setBigDecimal(53, hyYrtdzF.getAvtdr()); + ps.setString(54, hyYrtdzF.getAvtdrrcd()); + ps.setInt(55, hyYrtdzF.getAvtddr()); + ps.setString(56, hyYrtdzF.getAvtddrrcd()); + }); + } + } else if (tableName.equals(SWTableEnum.DAY_Q.value())) { + List hyDqCList = hyDqCService.list(Wrappers.lambdaQuery(HyDqC.class) + .between(HyDqC::getDt, startTimeDay, endTimeDay) + .in(HyDqC::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyDqCList)) { + List stcdList = hyDqCList.stream().map(HyDqC::getStcd).distinct().collect(Collectors.toList()); + Set stcdSet = new HashSet<>(stcdList); // 将小集合转为HashSet + List missingList = stcdsList.stream() + .filter(stcd -> !stcdSet.contains(stcd)) // 过滤未出现在stcdList中的元素 + .collect(Collectors.toList()); + for (String s : missingList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("351"); + removeFzTableId.add(fzTableId); + } + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?)) AS source (stcd,dt,avq,avqrcd) " + + "ON target.stcd = source.stcd AND target.dt = source.dt " + + "WHEN MATCHED THEN " + + " UPDATE SET avq = source.avq, avqrcd = source.avqrcd " + + "WHEN NOT MATCHED THEN " + + " INSERT (stcd, dt, avq, avqrcd) VALUES (source.stcd, source.dt, source.avq, source.avqrcd);"; + jdbcTemplate.batchUpdate(sql, hyDqCList, 50, (ps, hyDqC) -> { + ps.setString(1, hyDqC.getStcd()); + ps.setDate(2, new java.sql.Date(hyDqC.getDt().getTime())); + ps.setBigDecimal(3, hyDqC.getAvq()); + ps.setString(4, hyDqC.getAvqrcd()); + }); + }else { + for (String s : stcdsList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("351"); + removeFzTableId.add(fzTableId); + } + } + } else if (tableName.equals(SWTableEnum.MONTH_Q.value())) { + QueryWrapper queryWrapper = new QueryWrapper<>(); + queryWrapper.and(wrapper -> { + if (startYear.equals(endYear)) { + // 同一年：直接范围查询 + wrapper.apply("(yr = {0} AND mth BETWEEN {1} AND {2})", startYear, "01", "12"); + } else { + // 跨年：组合三段条件 + wrapper.apply("(yr = {0} AND mth >= {1})", startYear, "01"); // 起始年（1月至今） + for (int year = Integer.parseInt(startYear) + 1; year < Integer.parseInt(endYear); year++) { + wrapper.or().apply("yr = {0}", year); // 中间整年 + } + wrapper.or().apply("(yr = {0} AND mth <= {1})", endYear, "12"); // 结束年（1-12月） + } + }); + queryWrapper.in("stcd", stcdsList); + List hyMtqEList = hyMtqEService.list(queryWrapper); + if (ObjectUtils.isNotEmpty(hyMtqEList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?,?,?,?,?,?,?,?)) AS source (stcd,yr,mth,avq,avqrcd,mxq,mxqrcd,mxqdt,mnq,mnqrcd,mnqdt) " + + "ON target.stcd = source.stcd AND target.yr = source.yr AND target.mth = source.mth " + + "WHEN MATCHED THEN " + + " UPDATE SET avq = source.avq, avqrcd = source.avqrcd, mxq = source.mxq, mxqrcd = source.mxqrcd, " + + " mxqdt = source.mxqdt, mnq = source.mnq, mnqrcd = source.mnqrcd, mnqdt = source.mnqdt " + + "WHEN NOT MATCHED THEN " + + " INSERT (stcd, yr, mth, avq, avqrcd, mxq, mxqrcd, mxqdt, mnq, mnqrcd, mnqdt) " + + " VALUES (source.stcd, source.yr, source.mth, source.avq, source.avqrcd, source.mxq, source.mxqrcd, " + + " source.mxqdt, source.mnq, source.mnqrcd, source.mnqdt);"; + jdbcTemplate.batchUpdate(sql, hyMtqEList, 50, (ps, hyMtqE) -> { + ps.setString(1, hyMtqE.getStcd()); + ps.setInt(2, hyMtqE.getYr()); + ps.setInt(3, hyMtqE.getMth()); + ps.setBigDecimal(4, hyMtqE.getAvq()); + ps.setString(5, hyMtqE.getAvqrcd()); + ps.setBigDecimal(6, hyMtqE.getMxq()); + ps.setString(7, hyMtqE.getMxqrcd()); + if (hyMtqE.getMxqdt() == null) { + ps.setTimestamp(8, null); + } else { + ps.setTimestamp(8, new Timestamp(hyMtqE.getMxqdt().getTime())); + } + ps.setBigDecimal(9, hyMtqE.getMnq()); + ps.setString(10, hyMtqE.getMnqrcd()); + if (hyMtqE.getMnqdt() == null) { + ps.setTimestamp(11, null); + } else { + ps.setTimestamp(11, new Timestamp(hyMtqE.getMnqdt().getTime())); + } + }); + } + } else if (tableName.equals(SWTableEnum.YEAR_Q.value())) { + List hyYrqFList = hyYrqFService.list(Wrappers.lambdaQuery(HyYrqF.class) + .between(HyYrqF::getYr, startYear, endYear) + .in(HyYrqF::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyYrqFList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?,?,?,?,?,?,?,?,?,?,?)) AS source (stcd,yr,avq,avqrcd,mxq,mxqrcd,mxqdt,mnq,mnqrcd,mnqdt,rw,rwrcd,rm,rd) " + + "ON target.stcd = source.stcd AND target.yr = source.yr " + + "WHEN MATCHED THEN " + + " UPDATE SET avq = source.avq, avqrcd = source.avqrcd, mxq = source.mxq, mxqrcd = source.mxqrcd, " + + " mxqdt = source.mxqdt, mnq = source.mnq, mnqrcd = source.mnqrcd, mnqdt = source.mnqdt, " + + " rw = source.rw, rwrcd = source.rwrcd, rm = source.rm, rd = source.rd " + + "WHEN NOT MATCHED THEN " + + " INSERT (stcd, yr, avq, avqrcd, mxq, mxqrcd, mxqdt, mnq, mnqrcd, mnqdt, rw, rwrcd, rm, rd) " + + " VALUES (source.stcd, source.yr, source.avq, source.avqrcd, source.mxq, source.mxqrcd, " + + " source.mxqdt, source.mnq, source.mnqrcd, source.mnqdt, source.rw, source.rwrcd, " + + " source.rm, source.rd);"; + jdbcTemplate.batchUpdate(sql, hyYrqFList, 50, (ps, hyYrqF) -> { + ps.setString(1, hyYrqF.getStcd()); + ps.setInt(2, hyYrqF.getYr()); + ps.setBigDecimal(3, hyYrqF.getAvq()); + ps.setString(4, hyYrqF.getAvqrcd()); + ps.setBigDecimal(5, hyYrqF.getMxq()); + ps.setString(6, hyYrqF.getMxqrcd()); + if (hyYrqF.getMxqdt() == null) { + ps.setTimestamp(7, null); + } else { + ps.setTimestamp(7, new Timestamp(hyYrqF.getMxqdt().getTime())); + } + ps.setBigDecimal(8, hyYrqF.getMnq()); + ps.setString(9, hyYrqF.getMnqrcd()); + if (hyYrqF.getMnqdt() == null) { + ps.setTimestamp(10, null); + } else { + ps.setTimestamp(10, new Timestamp(hyYrqF.getMnqdt().getTime())); + } + ps.setBigDecimal(11, hyYrqF.getRw()); + ps.setString(12, hyYrqF.getRwrcd()); + ps.setBigDecimal(13, hyYrqF.getRm()); + ps.setBigDecimal(14, hyYrqF.getRd()); + }); + } + } else if (tableName.equals(SWTableEnum.DAY_MXFW.value())) { + List hyImxfwFList = hyImxfwFService.list(Wrappers.lambdaQuery(HyImxfwF.class) + .between(HyImxfwF::getYr, startYear, endYear) + .in(HyImxfwF::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyImxfwFList)) { + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?,?,?)) AS source (stcd,yr,bgdt,mxwdr,mxw,mxwrc) " + + "ON target.stcd = source.stcd AND target.yr = source.yr AND target.mxwdr = source.mxwdr " + + "WHEN MATCHED THEN " + + " UPDATE SET bgdt = source.bgdt, mxw = source.mxw, mxwrc = source.mxwrc " + + "WHEN NOT MATCHED THEN " + + " INSERT (stcd, yr, bgdt, mxwdr, mxw, mxwrc) " + + " VALUES (source.stcd, source.yr, source.bgdt, source.mxwdr, source.mxw, source.mxwrc);"; + jdbcTemplate.batchUpdate(sql, hyImxfwFList, 50, (ps, hyImxfwF) -> { + ps.setString(1, hyImxfwF.getStcd()); + ps.setInt(2, hyImxfwF.getYr()); + ps.setDate(3, new java.sql.Date(hyImxfwF.getBgdt().getTime())); + ps.setString(4, hyImxfwF.getMxwdr()); + ps.setBigDecimal(5, hyImxfwF.getMxw()); + ps.setString(6, hyImxfwF.getMxwrc()); + }); + } + } else if (tableName.equals(SWTableEnum.DP_WSFHEX.value())) { + List hyWsfhexBList = hyWsfhexBService.list(Wrappers.lambdaQuery(HyWsfhexB.class) + .between(HyWsfhexB::getTm, startTimeDay, endTimeDay) + .in(HyWsfhexB::getStcd, stcdsList)); + if (ObjectUtils.isNotEmpty(hyWsfhexBList)) { + List stcdList = hyWsfhexBList.stream().map(HyWsfhexB::getStcd).distinct().collect(Collectors.toList()); + Set stcdSet = new HashSet<>(stcdList); // 将小集合转为HashSet + List missingList = stcdsList.stream() + .filter(stcd -> !stcdSet.contains(stcd)) // 过滤未出现在stcdList中的元素 + .collect(Collectors.toList()); + for (String s : missingList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("202"); + removeFzTableId.add(fzTableId); + } + String sql = "MERGE INTO " + tableName + " AS target " + + "USING (VALUES (?, ?, ?, ?,?,?,?,?)) AS source (stcd,tm,upz,upzrcd,dwz,dwzrcd,q,s) " + + "ON target.stcd = source.stcd AND target.tm = source.tm " + + "WHEN MATCHED THEN " + + " UPDATE SET upz = source.upz, upzrcd = source.upzrcd, dwz = source.dwz, dwzrcd = source.dwzrcd, " + + " q = source.q, s = source.s " + + "WHEN NOT MATCHED THEN " + + " INSERT (stcd, tm, upz, upzrcd, dwz, dwzrcd, q, s) " + + " VALUES (source.stcd, source.tm, source.upz, source.upzrcd, source.dwz, source.dwzrcd, source.q, source.s);"; + jdbcTemplate.batchUpdate(sql, hyWsfhexBList, 50, (ps, hyWsfhexB) -> { + ps.setString(1, hyWsfhexB.getStcd()); + ps.setTimestamp(2, new Timestamp(hyWsfhexB.getTm().getTime())); + ps.setBigDecimal(3, hyWsfhexB.getUpz()); + ps.setString(4, hyWsfhexB.getUpzrcd()); + ps.setBigDecimal(5, hyWsfhexB.getDwz()); + ps.setString(6, hyWsfhexB.getDwzrcd()); + ps.setBigDecimal(7, hyWsfhexB.getQ()); + ps.setBigDecimal(8, hyWsfhexB.getS()); + }); + }else { + for (String s : stcdsList) { + FzTableId fzTableId = new FzTableId(); + fzTableId.setStcd(s); + fzTableId.setRtno("202"); + removeFzTableId.add(fzTableId); + } + } + } + } + + // 将 removeFzTableId 转为 HashSet 提升查询效率 + Set removeSet = new HashSet<>(removeFzTableId); + fzTableIds.removeIf(tableId -> + removeSet.stream().anyMatch(fz -> + fz.getStcd().equals(tableId.getStcd()) && + fz.getRtno().equals(tableId.getRtno()) + )); + // 开始批量合并插入 + String sql0 = "MERGE INTO FZ_TABLE_ID AS target " + + "USING (VALUES (?, ?, ?, ?)) AS source (STCD, YR, RTNO, YN) " + + "ON target.STCD = source.STCD AND target.YR = source.YR AND target.RTNO = source.RTNO AND target.YN = source.YN " + + "WHEN NOT MATCHED THEN INSERT (STCD, YR, RTNO, YN) VALUES (source.STCD, source.YR, source.RTNO, source.YN);"; + + jdbcTemplate.batchUpdate(sql0, fzTableIds, 50, (ps, item) -> { + ps.setString(1, item.getStcd()); + ps.setInt(2, item.getYr()); + ps.setString(3, item.getRtno()); + ps.setString(4, item.getYn()); + }); + } + + public static List getYearRange(int startYear, int endYear) { + List years = new ArrayList<>(); + for (int year = startYear; year <= endYear; year++) { + years.add(year); + } + return years; } @Override @DataSource(DataSourceType.SHARDING) - public R testSqlServer() { - List list = this.list().subList(0,100); - return R.ok().put("data",list); + public List> testSqlServer() { + return this.baseMapper.testSqlServer(); + } + + @Override + public R exportSoftToDate(FormDataRo formDataRo) { + Long userId = SecurityUtils.getUserId(); + Date date = new Date(); + // 定义格式 + SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm"); + String filename = sdf.format(date) + "-数据导出到云库"; + + YcExportTask ycExportTask = new YcExportTask(); + ycExportTask.setFilename(filename); + ycExportTask.setUserId(userId); + ycExportTask.setStartTime(date); + ycExportTask.setStatus(0); + ycExportTaskService.save(ycExportTask); + CompletableFuture.runAsync(() -> { + try { + exportData(formDataRo); + ycExportTask.setStatus(2); + } catch (Exception e) { + ycExportTask.setStatus(4); + log.error(e.getMessage()); + R.error("数据导出失败"); + } finally { + ycExportTask.setEndTime(new Date()); + ycExportTaskService.updateById(ycExportTask); + } + }, importThreadPool); + return R.ok("任务已提交"); } - private R taskAndExport(String tableName,String startTime, String endTime, String stcd, String stnm, Long userId) { - String startNewTime=""; - String endNewTime=""; - if (ObjectUtils.isNotEmpty(startTime) ){ - startNewTime=startTime.substring(0,10); + private void exportData(FormDataRo formDataRo) { + String startTime = formDataRo.getStartTime(); + String endTime = formDataRo.getEndTime(); + + + String[] dateDay = getDateDay(startTime, endTime); + String startTimeDay = dateDay[0]; + String endTimeDay = dateDay[1]; + + + String[] splitStartTime = startTime.split("-"); + String startYear = splitStartTime[0]; + String startMth = splitStartTime[1]; + String[] splitEndTime = endTime.split("-"); + String endYear = splitEndTime[0]; + String endMth = splitEndTime[1]; + + String tableIds = formDataRo.getIds(); + String stcds = formDataRo.getStcds(); + List ids = Pattern.compile(",") + .splitAsStream(tableIds) + .collect(Collectors.toList()); + + List stcdsList = Pattern.compile(",") + .splitAsStream(stcds) + .collect(Collectors.toList()); + + List ycShdpInfos = this.baseMapper.getYcShdpInfoByTableId(ids); + List tableNames = ycShdpInfos.stream().map(YcShdpInfo::getTableName).distinct().collect(Collectors.toList()); + + javax.sql.DataSource sqlServerDataSource = SqlServerDataSourceUtil.createDataSource(formDataRo); + JdbcTemplate jdbcTemplate = new JdbcTemplate(sqlServerDataSource); + + for (String tableName : tableNames) { + if (tableName.equals(SWTableEnum.HY_STSC.value())) { + String sql = "select * from " + tableName + " " + + "where stcd in (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") "; + List hyStscAS = jdbcTemplate.query(sql, new HyStscARowMapper()); + List jhDayDataList = hyStscAS.stream().map(i -> { + JHDayData jhDayData = new JHDayData(); + BeanUtils.copyProperties(i, jhDayData); + return jhDayData; + }).collect(Collectors.toList()); + ycExportTaskService.updateOrInsertDataToMysql(jhDayDataList, "stsc"); + } else if (tableName.equals(SWTableEnum.DAY_RAIN.value())) { + String sql = "select * from " + tableName + " " + + "where stcd in (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "and dt between '" + startTimeDay + "' and '" + endTimeDay + "'"; + List hyDqCList = jdbcTemplate.query(sql, new HyDpCRowMapper()); + timeTasksMapper.insertOrUpdateHyDpc(hyDqCList, SWTableEnum.DAY_RAIN.value()); + } else if (tableName.equals(SWTableEnum.MONTH_RAIN.value())) { + StringBuilder sql = new StringBuilder(); + sql.append("SELECT * FROM ").append(tableName) + .append(" WHERE stcd IN (") + .append(String.join(",", Collections.nCopies(stcdsList.size(), "?"))) // 生成 ?,?,? + .append(") AND ("); + if (startYear.equals(endYear)) { + sql.append("yr = ? AND mth BETWEEN ? AND ?"); + } else { + sql.append("(yr = ? AND mth >= ?) OR (yr BETWEEN ? AND ?) OR (yr = ? AND mth <= ?)"); + } + sql.append(")"); + List params = new ArrayList<>(); + params.addAll(stcdsList); + if (startYear.equals(endYear)) { + params.add(startYear); + params.add("01"); + params.add("12"); + } else { + params.add(startYear); + params.add("01"); + params.add(String.valueOf(Integer.parseInt(startYear) + 1)); + params.add(String.valueOf(Integer.parseInt(endYear) - 1)); + params.add(endYear); + params.add("12"); + } + List hyMtpEList = jdbcTemplate.query( + sql.toString(), + new HyMtpERowMapper(), + params.toArray() + ); + + timeTasksMapper.insertOrUpdateHyMtpEList(hyMtpEList, SWTableEnum.MONTH_RAIN.value()); + }else if (tableName.equals(SWTableEnum.YEAR_RAIN.value())) { + String stcdList = stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.joining(",")); + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + stcdList + ") AND yr BETWEEN ? AND ?"; + List hyYrpFList = jdbcTemplate.query(sql, new HyYrpFRowMapper(),startYear, endYear); + timeTasksMapper.insertOrUpdateHyYrpFList(hyYrpFList, SWTableEnum.YEAR_RAIN.value()); + }else if (tableName.equals(SWTableEnum.HY_DMXP_F.value())){ + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "AND yr BETWEEN ? AND ?"; + List hyDmxpFList = jdbcTemplate.query(sql, new HyDmxpFRowMapper(), startYear, endYear); + timeTasksMapper.insertOrUpdateHyDmxpF(hyDmxpFList, SWTableEnum.HY_DMXP_F.value()); + }else if (tableName.equals(SWTableEnum.DP_MMXP.value())){ + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "AND yr BETWEEN ? AND ?"; + List hyMmxpBList = jdbcTemplate.query(sql, new HyMmxpFRowMapper(), startYear, endYear); + timeTasksMapper.insertOrUpdateHyMmxpF(hyMmxpBList, SWTableEnum.DP_MMXP.value()); + }else if (tableName.equals(SWTableEnum.DP_HMXP.value())){ + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "AND yr BETWEEN ? AND ?"; + List hyHmxpBList = jdbcTemplate.query(sql, new HyHmxpFRowMapper(), startYear, endYear); + timeTasksMapper.insertOrUpdateHyHmxpF(hyHmxpBList, SWTableEnum.DP_HMXP.value()); + }else if (tableName.equals(SWTableEnum.DP_HOUR.value())){ + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "AND bgtm BETWEEN ? AND ?"; + List hyPrexBList = jdbcTemplate.query(sql, new HyPrexBRowMapper(), startTimeDay, endTimeDay); + timeTasksMapper.insertOrUpdateHyPrexBList(hyPrexBList, SWTableEnum.DP_HOUR.value()); + }else if (tableName.equals(SWTableEnum.DAY_DZC.value())){ + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "AND dt BETWEEN ? AND ?"; + List hyDzCList = jdbcTemplate.query(sql, new HyDzCRowMapper(), startTimeDay, endTimeDay); + timeTasksMapper.insertOrUpdateHyDzC(hyDzCList, SWTableEnum.DAY_DZC.value()); + }else if (tableName.equals(SWTableEnum.MONTH_RIVER.value())){ + StringBuilder sql = new StringBuilder(); + sql.append("SELECT * FROM ").append(tableName) + .append(" WHERE stcd IN (") + .append(String.join(",", Collections.nCopies(stcdsList.size(), "?"))) // 生成 ?,?,? + .append(") AND ("); + if (startYear.equals(endYear)) { + sql.append("yr = ? AND mth BETWEEN ? AND ?"); + } else { + sql.append("(yr = ? AND mth >= ?) OR (yr BETWEEN ? AND ?) OR (yr = ? AND mth <= ?)"); + } + sql.append(")"); + List params = new ArrayList<>(); + params.addAll(stcdsList); + if (startYear.equals(endYear)) { + params.add(startYear); + params.add("01"); + params.add("12"); + } else { + params.add(startYear); + params.add("01"); + params.add(String.valueOf(Integer.parseInt(startYear) + 1)); + params.add(String.valueOf(Integer.parseInt(endYear) - 1)); + params.add(endYear); + params.add("12"); + } + List hyMtzEList = jdbcTemplate.query( + sql.toString(), + new HyMtzERowMapper(), + params.toArray() + ); + + timeTasksMapper.insertOrUpdateHyMtzE(hyMtzEList, SWTableEnum.MONTH_RIVER.value()); + }else if (tableName.equals(SWTableEnum.YEAR_RIVER.value())){ + String stcdList = stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.joining(",")); + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + stcdList + ") AND yr BETWEEN ? AND ?"; + List hyYrzFList = jdbcTemplate.query(sql, new HyYrzFRowMapper(), startYear, endYear); + timeTasksMapper.insertOrUpdateHyYrzFList(hyYrzFList, SWTableEnum.YEAR_RIVER.value()); + }else if (tableName.equals(SWTableEnum.HY_WFDZ_F.value())){ + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "AND yr BETWEEN ? AND ?"; + List hyWfdzFList = jdbcTemplate.query(sql, new HyWfdzFRowMapper(), startYear, endYear); + timeTasksMapper.insertOrUpdateHyWfdzF(hyWfdzFList, SWTableEnum.HY_WFDZ_F.value()); + }else if (tableName.equals(SWTableEnum.DP_HLTDZ.value())){ + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "AND tm BETWEEN ? AND ?"; + List hyHltdzFList = jdbcTemplate.query(sql, new HyHltdzBRowMapper(), startTimeDay, endTimeDay); + timeTasksMapper.insertOrUpdateHyHltdzB(hyHltdzFList, SWTableEnum.DP_HLTDZ.value()); + }else if (tableName.equals(SWTableEnum.MONTH_MTTDZ.value())){ + StringBuilder sql = new StringBuilder(); + sql.append("SELECT * FROM ").append(tableName) + .append(" WHERE stcd IN (") + .append(String.join(",", Collections.nCopies(stcdsList.size(), "?"))) // 生成 ?,?,? + .append(") AND ("); + if (startYear.equals(endYear)) { + sql.append("yr = ? AND mth BETWEEN ? AND ?"); + } else { + sql.append("(yr = ? AND mth >= ?) OR (yr BETWEEN ? AND ?) OR (yr = ? AND mth <= ?)"); + } + sql.append(")"); + List params = new ArrayList<>(); + params.addAll(stcdsList); + if (startYear.equals(endYear)) { + params.add(startYear); + params.add("01"); + params.add("12"); + } else { + params.add(startYear); + params.add("01"); + params.add(String.valueOf(Integer.parseInt(startYear) + 1)); + params.add(String.valueOf(Integer.parseInt(endYear) - 1)); + params.add(endYear); + params.add("12"); + } + List hyMtzEList = jdbcTemplate.query( + sql.toString(), + new HyMttdzERowMapper(), + params.toArray() + ); + timeTasksMapper.insertOrUpdateHyMttdzEList(hyMtzEList, SWTableEnum.DP_HLTDZ.value()); + }else if (tableName.equals(SWTableEnum.YEAR_TIDE.value())){ + String stcdList = stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.joining(",")); + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + stcdList + ") AND yr BETWEEN ? AND ?"; + List hyYrtdzFList = jdbcTemplate.query(sql, new HyYrtdzFRowMapper(), startYear, endYear); + timeTasksMapper.insertOrUpdateHyYrtdzFList(hyYrtdzFList, SWTableEnum.YEAR_TIDE.value()); + }else if (tableName.equals(SWTableEnum.DAY_Q.value())){ + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "AND dt BETWEEN ? AND ?"; + List hyDqCList = jdbcTemplate.query(sql, new HyDqCRowMapper(), startTimeDay, endTimeDay); + timeTasksMapper.insertOrUpdateHyDqc(hyDqCList, SWTableEnum.DAY_Q.value()); + }else if (tableName.equals(SWTableEnum.MONTH_Q.value())){ + StringBuilder sql = new StringBuilder(); + sql.append("SELECT * FROM ").append(tableName) + .append(" WHERE stcd IN (") + .append(String.join(",", Collections.nCopies(stcdsList.size(), "?"))) // 生成 ?,?,? + .append(") AND ("); + if (startYear.equals(endYear)) { + sql.append("yr = ? AND mth BETWEEN ? AND ?"); + } else { + sql.append("(yr = ? AND mth >= ?) OR (yr BETWEEN ? AND ?) OR (yr = ? AND mth <= ?)"); + } + sql.append(")"); + List params = new ArrayList<>(); + params.addAll(stcdsList); + if (startYear.equals(endYear)) { + params.add(startYear); + params.add("01"); + params.add("12"); + } else { + params.add(startYear); + params.add("01"); + params.add(String.valueOf(Integer.parseInt(startYear) + 1)); + params.add(String.valueOf(Integer.parseInt(endYear) - 1)); + params.add(endYear); + params.add("12"); + } + List hyMtqEList = jdbcTemplate.query( + sql.toString(), + new HyMtqERowMapper(), + params.toArray() + ); + timeTasksMapper.insertOrUpdateHyMtqE(hyMtqEList, SWTableEnum.MONTH_Q.value()); + }else if (tableName.equals(SWTableEnum.YEAR_Q.value())) { + String stcdList = stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.joining(",")); + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + stcdList + ") AND yr BETWEEN ? AND ?"; + List hyYrqFList = jdbcTemplate.query(sql, new HyYrqFRowMapper(), startYear, endYear); + timeTasksMapper.insertOrUpdateHyYrqFList(hyYrqFList, SWTableEnum.YEAR_Q.value()); + }else if (tableName.equals(SWTableEnum.DAY_MXFW.value())){ + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "AND yr BETWEEN ? AND ?"; + List hyImxfwFList = jdbcTemplate.query(sql, new HyImxfwFRowMapper(), startYear, endYear); + timeTasksMapper.insertOrUpdateHyImxfwF(hyImxfwFList, SWTableEnum.DAY_MXFW.value()); + }else if (tableName.equals(SWTableEnum.DP_WSFHEX.value())){ + String sql = "SELECT * FROM " + tableName + + " WHERE stcd IN (" + String.join(",", stcdsList.stream().map(s -> "'" + s + "'").collect(Collectors.toList())) + ") " + + "AND tm BETWEEN ? AND ?"; + List hyWsfhexBList = jdbcTemplate.query(sql, new HyWsfhexBRowMapper(), startTimeDay, endTimeDay); + timeTasksMapper.insertOrUpdateHyWsfhexBList(hyWsfhexBList, SWTableEnum.DP_WSFHEX.value()); + } + } + } + + private static String[] getDateDay(String startTime, String endTime) { + DateTimeFormatter inputFormatter = DateTimeFormatter.ofPattern("yyyy-MM"); + DateTimeFormatter outputFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + + LocalDate startDate = LocalDate.parse(startTime + "-01", DateTimeFormatter.ISO_LOCAL_DATE); + String formattedStartTime = startDate.atStartOfDay().format(outputFormatter); + + LocalDate endDate = LocalDate.parse(endTime + "-01", DateTimeFormatter.ISO_LOCAL_DATE); + String formattedEndTime = endDate.atStartOfDay().format(outputFormatter); + return new String[]{formattedStartTime, formattedEndTime}; + } + + + private R taskAndExport(String tableName, String startTime, String endTime, String stcd, String stnm, Long userId) { + String startNewTime = ""; + String endNewTime = ""; + if (ObjectUtils.isNotEmpty(startTime)) { + startNewTime = startTime.substring(0, 10); } - if (ObjectUtils.isNotEmpty(endTime)){ - endNewTime=endTime.substring(0,10); + if (ObjectUtils.isNotEmpty(endTime)) { + endNewTime = endTime.substring(0, 10); } String filename = tableName + startNewTime + "-" + endNewTime; // 查询是否已存在相同条件且未完成的任务 @@ -212,9 +2465,9 @@ public class HyStscAServiceImpl extends ServiceImpl } YcExportTask ycExportTask = new YcExportTask(); String pathPeffix = RuoYiConfig.getExportPath() + - File.separator + userId + File.separator+ - DateUtils.parseDateToStr("yyyy-MM-dd",DateUtils.getNowDate()) + File.separator + - DateUtils.parseDateToStr("HH_mm",DateUtils.getNowDate())+File.separator; + File.separator + userId + File.separator + + DateUtils.parseDateToStr("yyyy-MM-dd", DateUtils.getNowDate()) + File.separator + + DateUtils.parseDateToStr("HH_mm", DateUtils.getNowDate()) + File.separator; ycExportTask.setFilename(filename); ycExportTask.setUserId(userId); ycExportTask.setStartTime(new Date()); @@ -337,11 +2590,6 @@ public class HyStscAServiceImpl extends ServiceImpl } - - - - - } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/impl/YcExportTaskServiceImpl.java b/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/impl/YcExportTaskServiceImpl.java index c6ba524..08a0930 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/impl/YcExportTaskServiceImpl.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/basic/service/impl/YcExportTaskServiceImpl.java @@ -3,22 +3,52 @@ package com.ruoyi.swlscx.basic.service.impl; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.ruoyi.common.annotation.DataSource; +import com.ruoyi.common.config.RuoYiConfig; import com.ruoyi.common.core.page.R; import com.ruoyi.common.enums.DataSourceType; import com.ruoyi.common.utils.Query; import com.ruoyi.common.utils.SecurityUtils; +import com.ruoyi.swlscx.basic.domain.po.HyStscA; import com.ruoyi.swlscx.basic.domain.po.YcExportTask; import com.ruoyi.swlscx.basic.mapper.YcExportTaskMapper; import com.ruoyi.swlscx.basic.service.YcExportTaskService; +import com.ruoyi.swlscx.common.constants.SystemConstants; import com.ruoyi.swlscx.common.utils.ExcelUtils; +import com.ruoyi.swlscx.synchronousData.dto.JHDayData; import lombok.extern.slf4j.Slf4j; +import org.springframework.beans.BeanUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.ApplicationContext; +import org.springframework.core.io.ByteArrayResource; +import org.springframework.http.HttpEntity; +import org.springframework.http.HttpHeaders; +import org.springframework.http.MediaType; +import org.springframework.http.ResponseEntity; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; +import org.springframework.util.LinkedMultiValueMap; +import org.springframework.util.MultiValueMap; +import org.springframework.web.client.RestTemplate; +import org.springframework.web.multipart.MultipartFile; import javax.servlet.http.HttpServletResponse; -import java.io.File; +import java.io.*; +import java.net.URL; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.nio.file.StandardCopyOption; +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; import java.util.List; import java.util.Map; +import java.util.stream.Collectors; +import java.util.zip.ZipEntry; +import java.util.zip.ZipInputStream; +import java.util.zip.ZipOutputStream; /** * @author 12974 @@ -31,6 +61,7 @@ public class YcExportTaskServiceImpl extends ServiceImpl> list=this.baseMapper.test(); - return R.ok().put("data",list); + List> list = this.baseMapper.test(); + return R.ok().put("data", list); + } + + + + + + + + @DataSource(DataSourceType.MASTER) + @Transactional(rollbackFor = Exception.class) + @Override + public void updateOrInsertDataToMysql(List jhDayDataList,String type) { + if (type.equals("stsc")){ + List dataList = jhDayDataList.stream().map(i -> { + HyStscA hyStscA = new HyStscA(); + BeanUtils.copyProperties(i, hyStscA); + return hyStscA; + }).collect(Collectors.toList()); + this.baseMapper.insertOrUpataData(dataList); + } + } + // 删除文件的方法 private boolean deleteFile(String fullPath) { File file = new File(fullPath); diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/common/constants/SystemConstants.java b/swlscx/src/main/java/com/ruoyi/swlscx/common/constants/SystemConstants.java index 0287402..5a025cd 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/common/constants/SystemConstants.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/common/constants/SystemConstants.java @@ -9,4 +9,10 @@ package com.ruoyi.swlscx.common.constants; public class SystemConstants { public static final String TIME_FORMAT="yyyy-MM-dd HH:mm:ss"; + + public static final String JDBC_URL="jdbc:sqlserver://192.168.16.232:1433;DatabaseName=hy_shdp;ncrypt=false;allowMultiQueries=true"; + + public static final String JDBC_USERNAME="sa"; + + public static final String JDBC_PASSWORD="admin"; } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/common/enums/SelectTableEnum.java b/swlscx/src/main/java/com/ruoyi/swlscx/common/enums/SelectTableEnum.java new file mode 100644 index 0000000..4ad25e4 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/common/enums/SelectTableEnum.java @@ -0,0 +1,84 @@ +package com.ruoyi.swlscx.common.enums; + +/** + * 水位最大最小值 + */ +public enum SelectTableEnum { + + DAY_RAIN("日降水", "DayRain"), + + + DAY_DCS("日平均含沙量表", "DayDcs"), + + DAY_DWE("日水面蒸发量表", "DayDwe"), + + DAY_DWT("日水温表", "DayDwt"), + DAY_ZSCS("逐时潮水位表", "DayZscs"), + + DAY_Q("日流量表", "DayQ"), + + DAY_DMXP("日时段最大降水表", "YearDmxp"), + + DAY_MXFW("时段最大洪量表", "YearImxfw"), + + DAY_DZ("日平均水位表", "DayDz"), + + DP_FDHEEX("洪水水文要素摘录表", "DpFdheex"), + DP_PREX("降水量摘录表", "DayPrex"), + + DP_RVFHEX("水库洪水水文要素摘录表", "DpRvfhex"), + DP_WSFHEX("水闸洪水水文要素摘录表", "DpWsfhex"), + DP_HLTDZ("逐潮高低潮位表", "DpHltdz"), + + DP_HMXP("小时时段最大降水量表", "YearHmxp"), + DP_MMXP("分钟时段最大降水量表", "YearMmxp"), + + MONTH_MTCS("月含沙量表", "MthMtcs"), + + MONTH_RAIN("月降水量表", "MthRain"), + + MONTH_MTQS( "月输沙率表", "MthMtqs"), + MONTH_MTTDZ( "月潮位表", "MthMttdz"), + + MONTH_MTWE("月水面蒸发量表", "MthMtwe"), + MONTH_MTWT("月水温表", "MthMtwt"), + + MONTH_Q("月流量表", "MthQ"), + MONTH_MTZ("月水位表", "MthMtz"), + DP_OBQ("实测流量表", "dp_obq_r"), + + + + DP_XSMSRS("实测大断面流量表", "dp_xsmsrs_g"), + + YEAR_YRCS("年含沙量表", "YearYrcs"), + YEAR_YRQS("年输沙率表", "YearYrqs"), + YEAR_YRWE("年水面蒸发量表", "YearYrwe"), + + YEAR_Q("年流量表", "YearYrq"), + + YEAR_RAIN("年降水表", "YearRain"), + YEAR_TIDE("年潮位表", "YearYrtdz"), + YEAR_YRWT("年水温表", "YearYrwt"), + + YEAR_YRZ("年水位表", "YearYrz"); + + + + + private final String desc; + private final String value; + + private SelectTableEnum(String desc, String value) { + this.desc = desc; + this.value = value; + } + + public String desc() { + return desc; + } + + public String value() { + return value; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/CommonUtils.java b/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/CommonUtils.java index 7a4100e..9fc9e6d 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/CommonUtils.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/CommonUtils.java @@ -5,8 +5,8 @@ import com.ruoyi.swlscx.common.PageParams; import org.apache.commons.lang3.StringUtils; import java.math.BigDecimal; -import java.util.HashMap; -import java.util.Map; +import java.util.*; +import java.util.stream.Collectors; /** * @Author al @@ -21,7 +21,14 @@ public class CommonUtils { map.put("startTime", startTime); map.put("endTime", endTime); map.put("stnm", stnm); - map.put("stcd", stcd); + if (stcd.contains("all")) { + stcd=""; + } + + List filteredList = Arrays.stream(stcd.split(",")) + .filter(s -> s != null && !s.trim().isEmpty()) + .collect(Collectors.toList()); + map.put("stcd", filteredList.isEmpty() ? null : filteredList); map.put("page", Convert.toStr(pageParams.getPageNum())); map.put("limit", Convert.toStr(pageParams.getPageSize())); return map; @@ -42,7 +49,17 @@ public class CommonUtils { map.put("endYear", Convert.toInt(endYear)); map.put("endTme", endTime); map.put("stnm", stnm); - map.put("stcd", stcd); + List filteredList = Collections.emptyList(); + if (stcd != null) { + if (stcd.contains("all")) { + stcd = ""; + } + filteredList = Arrays.stream(stcd.split(",")) + .filter(s -> s != null && !s.trim().isEmpty()) + .map(String::trim) + .collect(Collectors.toList()); + } + map.put("stcd", filteredList.isEmpty() ? null : filteredList); map.put("page", Convert.toStr(pageParams.getPageNum())); map.put("limit", Convert.toStr(pageParams.getPageSize())); return map; diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/ExcelUtils.java b/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/ExcelUtils.java index 8433c94..66a9bf3 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/ExcelUtils.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/ExcelUtils.java @@ -328,7 +328,6 @@ public class ExcelUtils { public static void downLoadExcel(HttpServletResponse response, YcExportTask t) { Long userId = SecurityUtils.getUserId(); String fullPath = t.getFilepath()+t.getFilename() + ".xls"; - log.info("fullPath{}",fullPath); File file = new File(fullPath); if (!file.exists()) { throw new RuntimeException("该文件不存在"); diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/SqlServerDataSourceUtil.java b/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/SqlServerDataSourceUtil.java new file mode 100644 index 0000000..7d6c3f8 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/common/utils/SqlServerDataSourceUtil.java @@ -0,0 +1,48 @@ +package com.ruoyi.swlscx.common.utils; +import com.alibaba.druid.pool.DruidDataSource; +import com.ruoyi.swlscx.basic.domain.ro.FormDataRo; + +import javax.sql.DataSource; + +public class SqlServerDataSourceUtil { + public static DataSource createDataSource(FormDataRo formDataRo) { +// formDataRo.setDataBase("hy_shdp"); +// formDataRo.setUserName("sa"); +// formDataRo.setPassword("admin"); +// formDataRo.setSqlseverIp("192.168.16.232"); + DruidDataSource dataSource = new DruidDataSource(); + // 基本连接配置 + dataSource.setDriverClassName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); + dataSource.setUrl(String.format( + "jdbc:sqlserver://%s:1433;databaseName=%s;encrypt=false;", + formDataRo.getSqlseverIp(), + formDataRo.getDataBase() + )); + dataSource.setUsername(formDataRo.getUserName()); + dataSource.setPassword(formDataRo.getPassword()); + + // 连接池优化配置（根据实际需求调整） + dataSource.setInitialSize(5); // 初始连接数 + dataSource.setMinIdle(5); // 最小空闲连接 + dataSource.setMaxActive(20); // 最大活跃连接 + dataSource.setMaxWait(60000); // 获取连接超时时间（毫秒） + dataSource.setTimeBetweenEvictionRunsMillis(60000); // 检测间隔 + dataSource.setMinEvictableIdleTimeMillis(300000); // 连接空闲超时 + dataSource.setValidationQuery("SELECT 1"); // 连接有效性检测SQL + dataSource.setTestWhileIdle(true); // 空闲时检测连接 + dataSource.setTestOnBorrow(false); // 借出连接时不检测 + dataSource.setTestOnReturn(false); // 归还连接时不检测 + + // 其他安全配置 + dataSource.setPoolPreparedStatements(true); // 缓存PreparedStatement + dataSource.setMaxPoolPreparedStatementPerConnectionSize(20); // 每个连接的PS缓存数 + + try { + dataSource.init(); // 初始化连接池 + } catch (Exception e) { + throw new RuntimeException("Druid数据源初始化失败", e); + } + + return dataSource; + } +} \ No newline at end of file diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/controller/DayExportController.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/controller/DayExportController.java index fdc3471..ebef11a 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/day/controller/DayExportController.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/controller/DayExportController.java @@ -33,6 +33,7 @@ public class DayExportController { private final HyDwtCService hyDwtCService; + private final HyZscsBService hyZscsBService; /** @@ -109,4 +110,16 @@ public class DayExportController { } + /** + * 导出逐时潮水位表 + */ + @PostMapping("/dayZscs") + public R exportDayZscs(HttpServletResponse response, + @RequestParam String startTime, + @RequestParam String endTime, + @RequestParam String stcd, + @RequestParam String stnm) { + return hyZscsBService.exportDayZscs(response, startTime, endTime, stcd, stnm); + } + } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/controller/DayTableController.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/controller/DayTableController.java index ff693ac..bd83e57 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/day/controller/DayTableController.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/controller/DayTableController.java @@ -1,5 +1,4 @@ package com.ruoyi.swlscx.day.controller; - import com.baomidou.mybatisplus.core.metadata.IPage; import com.ruoyi.common.core.page.R; import com.ruoyi.swlscx.common.PageParams; @@ -11,15 +10,6 @@ import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RequestParam; import org.springframework.web.bind.annotation.RestController; - -import javax.servlet.http.HttpServletResponse; - -/** - * @Author al - * @Date 2024/10/17 15:16 - * @Description: TODO - * @Version - */ @RestController @RequestMapping("/day") @RequiredArgsConstructor @@ -38,6 +28,7 @@ public class DayTableController { private final HyDwtCService hyDwtCService; + private final HyZscsBService hyZscsBService; /** * 获取日降雨量表数据 */ @@ -124,4 +115,19 @@ public class DayTableController { return R.ok().put("data", hyDwtCVoIPage.getRecords()).put("count", hyDwtCVoIPage.getTotal()); } + + /**查询逐时潮水表数据**/ + @GetMapping("/getDayZscsList") + public R getDayZscsList(@RequestParam("pageNum") Integer pageNum, + @RequestParam("pageSize") Integer pageSize, + @RequestParam("startTime") String startTime, + @RequestParam("endTime") String endTime, + @RequestParam("stcd") String stcd, + @RequestParam("stnm") String stnm) { + PageParams pageParams = new PageParams(pageNum.longValue(), pageSize.longValue()); + IPage hyZscsBVoIPage = hyZscsBService.selectHyZscsBDataByPageAndInfo(pageParams, startTime, endTime, stcd, stnm); + return R.ok().put("data", hyZscsBVoIPage.getRecords()).put("count", hyZscsBVoIPage.getTotal()); + } + + } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/domain/bo/HyZscsBBo.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/domain/bo/HyZscsBBo.java new file mode 100644 index 0000000..e7b6653 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/domain/bo/HyZscsBBo.java @@ -0,0 +1,32 @@ +package com.ruoyi.swlscx.day.domain.bo; + +import com.baomidou.mybatisplus.annotation.TableField; +import lombok.Data; + +import java.io.Serializable; +import java.math.BigDecimal; +import java.util.Date; + +/** + * @Author al + * @Date 2025/5/10 22:10 + * @Description: TODO + * @Version + */ +@Data +public class HyZscsBBo implements Serializable { + + private String stcd; + + private String stnm; + + private String tm; + private String tdr; + private String tdz; + + private String tdzrcd; + + @TableField(exist = false) + private static final long serialVersionUID = 1L; + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/domain/po/HyZscsB.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/domain/po/HyZscsB.java new file mode 100644 index 0000000..e82b5f1 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/domain/po/HyZscsB.java @@ -0,0 +1,33 @@ +package com.ruoyi.swlscx.day.domain.po; + +import com.baomidou.mybatisplus.annotation.TableField; +import lombok.Data; + +import java.io.Serializable; +import java.math.BigDecimal; +import java.util.Date; + +/** + * @Author al + * @Date 2025/5/10 22:10 + * @Description: TODO + * @Version + */ +@Data +public class HyZscsB implements Serializable { + + private String stcd; + + private String stnm; + + private Date tm; + private String tdr; + private Long tdz; + + private String tdzrcd; + + @TableField(exist = false) + private static final long serialVersionUID = 1L; + + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/domain/vo/HyZscsBVo.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/domain/vo/HyZscsBVo.java new file mode 100644 index 0000000..eb961b1 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/domain/vo/HyZscsBVo.java @@ -0,0 +1,32 @@ +package com.ruoyi.swlscx.day.domain.vo; + +import com.baomidou.mybatisplus.annotation.TableField; +import lombok.Data; + +import java.io.Serializable; +import java.util.Date; + +/** + * @Author al + * @Date 2025/5/10 22:10 + * @Description: TODO + * @Version + */ +@Data +public class HyZscsBVo implements Serializable { + + private String stcd; + + private String stnm; + + private Date tm; + private String tdr; + private Long tdz; + + private String tdzrcd; + + @TableField(exist = false) + private static final long serialVersionUID = 1L; + + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/mapper/HyZscsBMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/mapper/HyZscsBMapper.java new file mode 100644 index 0000000..1e666c5 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/mapper/HyZscsBMapper.java @@ -0,0 +1,30 @@ +package com.ruoyi.swlscx.day.mapper; + +import com.baomidou.mybatisplus.core.mapper.BaseMapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.plugins.pagination.Page; +import com.ruoyi.swlscx.day.domain.po.HyDpC; +import com.ruoyi.swlscx.day.domain.po.HyZscsB; +import com.ruoyi.swlscx.day.domain.vo.HyDpCVo; +import com.ruoyi.swlscx.day.domain.vo.HyZscsBVo; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; + +import java.util.List; +import java.util.Map; + +/** +* @author 12974 +* @description 针对表【hy_dp_c(日降水表)】的数据库操作Mapper +* @createDate 2024-10-15 17:40:46 +* @Entity com.ruoyi.swlscx.day.domain.po.HyDpC +*/ +@Mapper +public interface HyZscsBMapper extends BaseMapper { + + IPage selectHyZscsBDataByPageAndInfo(Page page,@Param("map") Map map); +} + + + + diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyDpCService.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyDpCService.java index a3384ed..d3a8317 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyDpCService.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyDpCService.java @@ -9,6 +9,7 @@ import com.ruoyi.swlscx.day.domain.vo.HyDpCVo; import org.springframework.web.multipart.MultipartFile; import javax.servlet.http.HttpServletResponse; +import java.util.List; /** * @author 12974 @@ -28,6 +29,9 @@ public interface HyDpCService extends IService { */ IPage selectHyDpCDataByPageAndInfo(PageParams pageParams, String startTime, String endTime, String stcd, String stnm); + + + /** * 导出日降雨量表数据 */ diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyDwtCService.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyDwtCService.java index e0f7a97..2344ee9 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyDwtCService.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyDwtCService.java @@ -34,4 +34,6 @@ public interface HyDwtCService extends IService { R exportDayWaterTemperature(HttpServletResponse response, String startTime, String endTime, String stcd, String stnm); R importDateTosoft(String startTime, String endTime); + + } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyZscsBService.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyZscsBService.java new file mode 100644 index 0000000..e20b0d0 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/service/HyZscsBService.java @@ -0,0 +1,39 @@ +package com.ruoyi.swlscx.day.service; + +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.service.IService; +import com.ruoyi.common.core.page.R; +import com.ruoyi.swlscx.common.PageParams; +import com.ruoyi.swlscx.day.domain.po.HyZscsB; +import com.ruoyi.swlscx.day.domain.vo.HyDpCVo; +import com.ruoyi.swlscx.day.domain.vo.HyZscsBVo; +import org.springframework.web.multipart.MultipartFile; + +import javax.servlet.http.HttpServletResponse; + +/** +* @author 12974 +* @description 针对表【hy_dp_c(日降水表)】的数据库操作Service +* @createDate 2024-10-15 17:40:46 +*/ +public interface HyZscsBService extends IService { + + + /** + * 导入逐时潮水位表数据 + */ + void importHyZscsBData(MultipartFile file); + + /** + * 查询逐时潮水位表数据 + */ + IPage selectHyZscsBDataByPageAndInfo(PageParams pageParams, String startTime, String endTime, String stcd, String stnm); + + R exportDayZscs(HttpServletResponse response, String startTime, String endTime, String stcd, String stnm); + + /** + * 导出逐时潮水位表数据 + */ +// R exportHyDpCData(HttpServletResponse response,String startTime, String endTime, String stcd, String stnm); + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/service/impl/HyDpCServiceImpl.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/service/impl/HyDpCServiceImpl.java index 57dff22..c4d1479 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/day/service/impl/HyDpCServiceImpl.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/service/impl/HyDpCServiceImpl.java @@ -112,9 +112,9 @@ public class HyDpCServiceImpl extends ServiceImpl return this.baseMapper.selectHyDpCDataByPageAndInfo(new Query().getPage(map), map); } + @Override public R exportHyDpCData(HttpServletResponse response,String startTime, String endTime, String stcd, String stnm) { - Long userId = SecurityUtils.getUserId(); String tableName = "日降水表"; return taskAndExport(tableName,startTime, endTime, stcd, stnm, userId); diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/day/service/impl/HyZscsBServiceImpl.java b/swlscx/src/main/java/com/ruoyi/swlscx/day/service/impl/HyZscsBServiceImpl.java new file mode 100644 index 0000000..22cd258 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/day/service/impl/HyZscsBServiceImpl.java @@ -0,0 +1,226 @@ +package com.ruoyi.swlscx.day.service.impl; + +import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper; +import com.baomidou.mybatisplus.core.metadata.IPage; +import com.baomidou.mybatisplus.extension.service.IService; +import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; +import com.ruoyi.common.config.RuoYiConfig; +import com.ruoyi.common.core.page.R; +import com.ruoyi.common.core.text.Convert; +import com.ruoyi.common.utils.DateUtils; +import com.ruoyi.common.utils.SecurityUtils; +import com.ruoyi.swlscx.basic.domain.po.HyStscA; +import com.ruoyi.swlscx.basic.domain.po.YcExportTask; +import com.ruoyi.swlscx.basic.service.YcExportTaskService; +import com.ruoyi.swlscx.common.PageParams; +import com.ruoyi.swlscx.common.constants.SystemConstants; +import com.ruoyi.swlscx.common.utils.CommonUtils; +import com.ruoyi.swlscx.common.utils.ExcelUtils; +import com.ruoyi.swlscx.common.utils.Query; +import com.ruoyi.swlscx.day.domain.bo.HyDpCBo; +import com.ruoyi.swlscx.day.domain.bo.HyZscsBBo; +import com.ruoyi.swlscx.day.domain.po.HyDpC; +import com.ruoyi.swlscx.day.domain.po.HyDweC; +import com.ruoyi.swlscx.day.domain.po.HyZscsB; +import com.ruoyi.swlscx.day.domain.vo.HyDpCVo; +import com.ruoyi.swlscx.day.domain.vo.HyZscsBVo; +import com.ruoyi.swlscx.day.mapper.HyDweCMapper; +import com.ruoyi.swlscx.day.mapper.HyZscsBMapper; +import com.ruoyi.swlscx.day.service.HyDweCService; +import com.ruoyi.swlscx.day.service.HyZscsBService; +import org.apache.commons.lang3.ObjectUtils; +import org.apache.poi.ss.usermodel.CellStyle; +import org.apache.poi.ss.usermodel.Row; +import org.apache.poi.ss.usermodel.Sheet; +import org.springframework.beans.BeanUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.context.ApplicationContext; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; +import org.springframework.web.multipart.MultipartFile; + +import javax.annotation.Resource; +import javax.servlet.http.HttpServletResponse; +import java.io.File; +import java.util.Date; +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.stream.Collectors; + +/** +* @author 12974 +* @description 针对表【hy_dp_c(日降水表)】的数据库操作Service +* @createDate 2024-10-15 17:40:46 +*/ +@Service +public class HyZscsBServiceImpl extends ServiceImpl + implements HyZscsBService { + + + /** + * 导入逐时潮水位表数据 + * @param file + */ + @Override + @Transactional(rollbackFor = Exception.class) + public void importHyZscsBData(MultipartFile file) { + try { + List hyDpCBos = ExcelUtils.readExcel(file.getInputStream(), HyZscsBBo.class, 2); + List hyDpCList = hyDpCBos.stream().map(i -> { + HyZscsB hyDpC = new HyZscsB(); + BeanUtils.copyProperties(i, hyDpC); + hyDpC.setTm(DateUtils.parseDate(i.getTm())); + hyDpC.setTdz(Convert.toLong(i.getTdz())); + return hyDpC; + }).collect(Collectors.toList()); + //重临时表中把数据刷过去 + this.saveBatch(hyDpCList); + } catch (Exception e) { + e.printStackTrace(); + } + } + + @Override + public IPage selectHyZscsBDataByPageAndInfo(PageParams pageParams, String startTime, String endTime, String stcd, String stnm) { + System.out.println("stcd ->"+stcd); + Map map = CommonUtils.getYearAndDayDataMap(pageParams, startTime, endTime, stcd, stnm); + return this.baseMapper.selectHyZscsBDataByPageAndInfo(new Query().getPage(map), map); + } + + @Override + public R exportDayZscs(HttpServletResponse response, String startTime, String endTime, String stcd, String stnm) { + Long userId = SecurityUtils.getUserId(); + String tableName = "逐时潮水位表"; + return taskAndExport(tableName,startTime, endTime, stcd, stnm, userId); + } + + @Resource + private ThreadPoolExecutor importThreadPool; + + @Resource + private ThreadPoolExecutor labelThreadPool; + + @Autowired + private ApplicationContext context; + + @Resource + private YcExportTaskService ycExportTaskService; + + private R taskAndExport(String tableName,String startTime, String endTime, String stcd, String stnm, Long userId) { + String startNewTime=""; + String endNewTime=""; + if (ObjectUtils.isNotEmpty(startTime) ){ + startNewTime=startTime.substring(0,10); + } + if (ObjectUtils.isNotEmpty(endTime)){ + endNewTime=endTime.substring(0,10); + } + String filename = tableName + startNewTime + "-" + endNewTime; + // 查询是否已存在相同条件且未完成的任务 + List ongoingTasks = ycExportTaskService.list( + new QueryWrapper() + .eq("user_id", userId) + .eq("filename", filename) + .eq("status", 0) // 状态为0表示任务未完成 + ); + + if (!ongoingTasks.isEmpty()) { + return R.error("当前任务正在下载中，请稍后重试"); + } + + YcExportTask ycExportTask = new YcExportTask(); + String pathPeffix = RuoYiConfig.getExportPath() + + File.separator + userId + File.separator+ + DateUtils.parseDateToStr("yyyy-MM-dd",DateUtils.getNowDate()) + File.separator + + DateUtils.parseDateToStr("HH_mm",DateUtils.getNowDate())+File.separator; + ycExportTask.setFilename(filename); + ycExportTask.setUserId(userId); + ycExportTask.setStartTime(new Date()); + ycExportTask.setStatus(0); + ycExportTask.setFilepath(pathPeffix); + ycExportTaskService.save(ycExportTask); + CompletableFuture.runAsync(() -> { + try { + File dest = new File(pathPeffix); + if (!dest.exists()) { + dest.mkdirs(); + } + String fullPath = pathPeffix + filename; + exportBlackData(fullPath, startTime, endTime, stcd, stnm); + + ycExportTask.setStatus(1); + ycExportTask.setEndTime(new Date()); + ycExportTaskService.updateById(ycExportTask); + } catch (Exception e) { + log.error(e.getMessage(), e); + R.error("任务下载失败"); + } + }, labelThreadPool); + return R.ok("任务已提交，请稍后下载"); + } + + + private void exportBlackData(String tableName, String startTime, String endTime, String stcd, String stnm) { + Map rainMap = CommonUtils.getYearAndDayDataMap(new PageParams(0L, 1000000000L), startTime, endTime, stcd, stnm); + ExcelUtils.excelBackExport2("dayDscs.xls", tableName, (Sheet sheet, CellStyle style) -> + dataModel1(rainMap, sheet, style)); + } + + public int dataModel1(Map map, Sheet sheet, CellStyle style) { + // 批量查询数据 + IPage hyZscsBVoIPage = this.baseMapper.selectHyZscsBDataByPageAndInfo(new Query().getPage(map), map); + + List records = hyZscsBVoIPage.getRecords(); + // 定义当前sheet的行号 + int rowIndex = 2; // 从第二行开始写入数据 + // 定义全局序号 + int globalIndex = 1; // 从1开始 + + // 定义当前sheet的编号 + int sheetIndex = 1; + + // 最大行数限制 + int maxRowsPerSheet = 65536; // 对于 .xls 文件，最大行数为 65536 + int batchSize = 1000; // 每次批量处理1000行，减少逐行写入的开销 + + // 复制表头到新sheet的逻辑 + ExcelUtils.copyHeader(sheet, style); + + // 批量处理数据 + for (int i = 0; i < records.size(); i += batchSize) { + // 处理一批数据 + int toIndex = Math.min(i + batchSize, records.size()); + List batchList = records.subList(i, toIndex); + + // 批量写入数据 + for (HyZscsBVo vo : batchList) { + // 如果当前行数达到最大行数，创建新sheet + if (rowIndex >= maxRowsPerSheet) { + sheetIndex++; + sheet = sheet.getWorkbook().createSheet("逐时潮水位表" + sheetIndex); + rowIndex = 2; // 重置行号 + // 复制表头到新sheet + ExcelUtils.copyHeader(sheet, style); + } + + // 创建新行并写入数据 + Row row = ExcelUtils.createRow(sheet, rowIndex); + + // 使用 globalIndex 作为序号 + ExcelUtils.formatCell(row, 0, String.valueOf(globalIndex), style); + ExcelUtils.formatCell(row, 1, vo.getStcd() != null ? vo.getStcd() : "", style); + ExcelUtils.formatCell(row, 2, vo.getStnm() != null ? vo.getStnm() : "", style); + ExcelUtils.formatCell(row, 3, vo.getTm() != null ? DateUtils.parseDateToStr(SystemConstants.TIME_FORMAT,vo.getTm()) : "", style); + ExcelUtils.formatCell(row, 4, vo.getTdr() != null ? vo.getTdr() : "", style); + ExcelUtils.formatCell(row, 5, vo.getTdz() != null ? vo.getTdz().toString() : "", style); + ExcelUtils.formatCell(row, 6, vo.getTdzrcd() != null ? vo.getTdzrcd() : "", style); + // 增加行号和全局序号 + rowIndex++; + globalIndex++; + } + } + return 0; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/excerpt/controller/ExcerptImportController.java b/swlscx/src/main/java/com/ruoyi/swlscx/excerpt/controller/ExcerptImportController.java index 583fb45..de42511 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/excerpt/controller/ExcerptImportController.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/excerpt/controller/ExcerptImportController.java @@ -47,8 +47,8 @@ public class ExcerptImportController { *导入降雨量摘录表 */ @PostMapping("/importRainExcerpt") - public R importRainExcerpt(String startTime, String endTime){ - return hyPrexBService.importDateTosoft(startTime, endTime); + public void importRainExcerpt(String startTime, String endTime){ + hyPrexBService.importDateTosoft(startTime, endTime); } diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/controller/TimeTasksController.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/controller/TimeTasksController.java new file mode 100644 index 0000000..5fd74b3 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/controller/TimeTasksController.java @@ -0,0 +1,271 @@ +package com.ruoyi.swlscx.synchronousData.controller;//package com.ruoyi.zxzb.synchronousData.controller; + +import com.ruoyi.common.core.page.R; +import com.ruoyi.swlscx.basic.service.YcExportTaskService; +import com.ruoyi.swlscx.synchronousData.dto.JHDayData; +import com.ruoyi.swlscx.synchronousData.service.TimeTasksService; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.web.bind.annotation.RequestBody; +import org.springframework.web.bind.annotation.RequestHeader; +import org.springframework.web.bind.annotation.RequestMapping; +import org.springframework.web.bind.annotation.RestController; + +import java.util.List; +import java.util.concurrent.CompletableFuture; + + +@RestController +@RequestMapping("/api") +public class TimeTasksController { + + @Autowired + private YcExportTaskService ycExportTaskService; + + @Autowired + private TimeTasksService timeTasksService; + + + @RequestMapping("/importSqlserverToMysql") + public R importSqlserverToMysql(@RequestBody List jhDayDataList, @RequestHeader("X-Type")String type) { + ycExportTaskService.updateOrInsertDataToMysql(jhDayDataList,type); + return R.ok(); + } + + + @RequestMapping("/test") + public R getTest1(){ + timeTasksService.setYcStaions(); + // 2. 异步执行 getDpJhQData() + CompletableFuture future1 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getDayDzcData(); + return 1; + } catch (Exception e) { return -1; } + }); + + // 2. 异步执行 getDpJhQData() + CompletableFuture future2 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getMonthMttdzData(); + return 1; + } catch (Exception e) { return -1; } + }); + + CompletableFuture future4 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getDayRainData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future5 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getDayQData(); + return 1; + } catch (Exception e) { return -1; } + }); + + CompletableFuture future6 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getDayDqsData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future7 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getDayDcsData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future8 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getDayDweData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future9 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getDayDwtData(); + return 1; + } catch (Exception e) { return -1; } + }); + return R.ok("测试成功"); + } + + + @RequestMapping("/test2") + public R getTest2(){ + timeTasksService.setYcStaions(); + + + // 2. 异步执行 getDpJhQData() + CompletableFuture future2 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getDayDmxpData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future3 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getDayImxfwData(); + return 1; + } catch (Exception e) { return -1; } + }); + + CompletableFuture future4 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getFdheexData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future5 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getHltdzData(); + return 1; + } catch (Exception e) { return -1; } + }); + + CompletableFuture future6 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getHmxpData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future7 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getMmxpData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future8 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getMtcsData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future9 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getMonthRainData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future10 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getMonthQData(); + return 1; + } catch (Exception e) { return -1; } + }); + return R.ok("测试成功"); + } + + + @RequestMapping("/test3") + public R getTest3(){ + timeTasksService.setYcStaions(); + // 2. 异步执行 getDpJhQData() + CompletableFuture future1 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getMonthMtqsData(); + return 1; + } catch (Exception e) { return -1; } + }); + + + // 2. 异步执行 getDpJhQData() + CompletableFuture future2 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getMonthMtweData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future3 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getMonthMtwtData(); + return 1; + } catch (Exception e) { return -1; } + }); + + CompletableFuture future4 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getMonthRiverData(); + return 1; + } catch (Exception e) { return -1; } + }); + + CompletableFuture future7 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getHourRainData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future8 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getWsfhexData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future9 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getRvfhexData(); + return 1; + } catch (Exception e) { return -1; } + }); + return R.ok("测试成功"); + } + + + @RequestMapping("/test4") + public R getTest4(){ + timeTasksService.setYcStaions(); + // 2. 异步执行 getDpJhQData() + CompletableFuture future1 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getYrcsData(); + return 1; + } catch (Exception e) { return -1; } + }); + + + // 2. 异步执行 getDpJhQData() + CompletableFuture future2 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getYearQData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future3 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getYearRainData(); + return 1; + } catch (Exception e) { return -1; } + }); + + CompletableFuture future4 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getYearTideData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future5 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getYearMtweData(); + return 1; + } catch (Exception e) { return -1; } + }); + + CompletableFuture future6 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getYearWtData(); + return 1; + } catch (Exception e) { return -1; } + }); + CompletableFuture future7 = CompletableFuture.supplyAsync(() -> { + try { + timeTasksService.getYearYrzData(); + return 1; + } catch (Exception e) { return -1; } + }); + return R.ok("测试成功"); + } + + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/JHDayData.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/JHDayData.java new file mode 100644 index 0000000..d80c14c --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/JHDayData.java @@ -0,0 +1,860 @@ +package com.ruoyi.swlscx.synchronousData.dto; + +import com.alibaba.excel.annotation.ExcelProperty; +import com.alibaba.excel.annotation.format.DateTimeFormat; +import com.baomidou.mybatisplus.annotation.FieldStrategy; +import com.baomidou.mybatisplus.annotation.TableField; +import com.baomidou.mybatisplus.annotation.TableId; +import lombok.Data; + +import java.math.BigDecimal; +import java.util.Date; + +/** + * @Author al + * @Date 2025/5/14 16:09 + * @Description: TODO + * @Version + */ +@Data +public class JHDayData { + + + private String stnm; + + private String stct; + + private String bshncd; + + private String hnnm; + + private String rvnm; + + private String obitmcd; + + private String addvcd; + + private String wrrgcd; + + private Integer esstyr; + + private Integer esstmth; + + private Integer wdstyr; + + private Integer wdstmth; + + private BigDecimal drar; + + private String flto; + + private BigDecimal dstrvm; + + private String fdtmnm; + + private String admag; + + private String admnst; + + private String stlc; + + private BigDecimal lgtd; + + private BigDecimal lttd; + + private String stgrd; + + private String frgrd; + + + /** + * 站码 + */ + private String stcd; + + /** + * 日期 + */ + private String dt; + + /** + * 降水量(毫米) + */ + private BigDecimal p; + + /** + * 降水量注解码 + */ + private String prcd; + + private BigDecimal avq; + + /** + * 平均流量注解码 + */ + private String avqrcd; + + /** + * 泥沙类型 + */ + private String sdtp; + + + /** + * 平均输沙率(千克每秒) + */ + private BigDecimal avqs; + + /** + * 平均输沙率注解码 + */ + private String avqsrcd; + + + + /** + * 平均含沙量(千克每立方米) + */ + private BigDecimal avcs; + + /** + * 平均含沙量注解码 + */ + private String avcsrcd; + + + /** + * 最大降水量时段长 + */ + private String mxpdr; + + /** + * 年 + */ + private String yr; + + /** + * 起始日期 + */ + private String bgdt; + + /** + * 最大降水量 + */ + private BigDecimal mxp; + + /** + * 最大降水量注解码 + */ + private String mxprc; + + /** + * 蒸发器型式 + */ + private String eetp; + + /** + * 水面蒸发量(毫米) + */ + private BigDecimal wsfe; + + /** + * 水面蒸发量注解码 + */ + private String wsfercd; + + + /** + * 水温 + */ + private BigDecimal wtmp; + + /** + * 水温注解码 + */ + private String wtmprcd; + + /** + * 平均水位(米) + */ + private BigDecimal avz; + + /** + * 平均水位注解码 + */ + private String avzrcd; + + /** + * 最大洪量时段长 + */ + private String mxwdr; + + + + /** + * 最大洪量 + */ + private BigDecimal mxw; + + /** + * 最大洪量注解码 + */ + private String mxwrc; + + /** + * 时间 + */ + private String tm; + + /** + * 水位 + */ + private BigDecimal z; + + /** + * 水位注解码 + + */ + private String zrcd; + + /** + * 流量 + */ + private BigDecimal q; + + /** + * 含沙量 + */ + private BigDecimal s; + + + + /** + * 潮别 + */ + private String tdtp; + + /** + * 潮位 + */ + private BigDecimal tdz; + + /** + * 潮位注解码 + */ + private String tdzrcd; + + /** + * 潮差 + */ + private BigDecimal tdrng; + + /** + * 历时 + */ + private String dr; + + /** + * 备注 + */ + private String nt; + + + + /** + * 起时间 + */ + private String bgtm; + + + /** + * 月 + */ + private String mth; + + + /** + * 最大含沙量(千克每立方米) + */ + private BigDecimal mxs; + + /** + * 最大含沙量注解码 + */ + private String mxsrcd; + + /** + * 最大含沙量日期 + */ + private String mxsdt; + + /** + * 最小含沙量(千克每立方米) + */ + private BigDecimal mns; + + /** + * 最小含沙量注解码 + */ + private String mnsrcd; + + /** + * 最小含沙量日期 + */ + private String mnsdt; + + + /** + * 降水日数 + */ + private String pdynum; + + /** + * 降水日数注解码 + */ + private String pdynumrcd; + + /** + * 最大降水量(毫米) + */ + private BigDecimal mxdyp; + + /** + * 最大降水量注解码 + */ + private String mxdyprcd; + + /** + * 最大日降水量出现日期 + */ + private String mxdypodt; + + + /** + * 最高流量 + */ + private BigDecimal mxq; + + /** + * 最高流量注解码 + */ + private String mxqrcd; + + /** + * 最高流量日期 + */ + private String mxqdt; + + /** + * 最小流量 + */ + private BigDecimal mnq; + + /** + * 最小流量注解码 + */ + private String mnqrcd; + + /** + * 最小流量日期 + */ + private String mnqdt; + + /** + * 最大日平均沙率(千克每秒) + */ + private BigDecimal mxdyqs; + + /** + * 最大日平均沙率注解码 + */ + private String mxdyqsrcd; + + /** + * 最大日平均沙率出现日期 + */ + private String mxdyqsodt; + + + + + /** + * 最大日水面蒸发量 + */ + private BigDecimal mxdye; + + /** + * 最大日水面蒸发量注解码 + */ + private String mxdyercd; + + /** + * 最小日水面蒸发量 + */ + private BigDecimal mndye; + + /** + * 最小日水面蒸发量注解码 + */ + private String mndyercd; + + /** + * 平均水温(摄氏度) + */ + private BigDecimal avwtmp; + + /** + * 平均水温注解码 + */ + private String avwtmprcd; + + /** + * 最高水温(摄氏度) + */ + private BigDecimal mxwtmp; + + /** + * 最高水温注解码 + */ + private String mxwtmprcd; + + /** + * 最高水温日期 + */ + private String mxwtmpdt; + + /** + * 最低水温(摄氏度) + */ + private BigDecimal mnwtmp; + + /** + * 最低水温注解码 + */ + private String mnwtmprcd; + + /** + * 最低水温日期 + */ + private String mnwtmpdt; + + + /** + * 最高水位 + */ + private BigDecimal htz; + + /** + * 最高水位注解码 + */ + private String htzrcd; + + /** + * 最高水位日期 + */ + private String htzdt; + + /** + * 最低水位 + */ + private BigDecimal mnz; + + /** + * 最低水位注解码 + */ + private String mnzrcd; + + /** + * 最低水位日期 + */ + private String mnzdt; + + + /** + * 止时间 + */ + private String endtm; + + + /** + * 坝上水位 + */ + private BigDecimal dambhdz; + + /** + * 坝上水位注解码 + */ + private String dambhdzrcd; + + + /** + * 蓄水量 + */ + private BigDecimal w; + + + + /** + * 闸上水位 + */ + private BigDecimal upz; + + /** + * 闸上水位注解码 + */ + private String upzrcd; + + /** + * 闸下水位 + */ + private BigDecimal dwz; + + /** + * 闸下水位注解码 + */ + private String dwzrcd; + + + /** + * 径流量(万立方米) + */ + private BigDecimal rw; + + /** + * 径流量注解码 + */ + private String rwrcd; + + /** + * 径流模数(立方分米每秒平方千米) + */ + private BigDecimal rm; + + /** + * 径流深(毫米) + */ + private BigDecimal rd; + + + + /** + * 终霜日期 + */ + private String frdsdt; + + /** + * 初霜日期 + */ + private String frapdt; + + /** + * 终雪日期 + */ + private String sndsdt; + + /** + * 初雪日期 + */ + private String snapdt; + + + /** + * 平均高潮潮位 + */ + private BigDecimal avhtdz; + + /** + * 平均高潮潮位注解码 + */ + private String avhtdzrcd; + + /** + * 最高高潮位 + */ + private BigDecimal hthtdz; + + /** + * 最高高潮位注解码 + */ + private String hthtdzrcd; + + /** + * 最高高潮位出现时间 + */ + private String hthtdzotm; + + /** + * 最低高潮位 + */ + private BigDecimal lthtdz; + + /** + * 最低高潮位注解码 + */ + private String lthtdzrcd; + + /** + * 最低高潮位出现时间 + */ + private String lthtdzotm; + + /** + * 平均低潮潮位 + */ + private BigDecimal avltdz; + + /** + * 平均低潮潮位注解码 + */ + private String avltdzrcd; + + /** + * 最高低潮位 + */ + private BigDecimal htltdz; + + /** + * 最高低潮位注解码 + */ + private String htltdzrcd; + + /** + * 最高低潮潮位出现时间 + */ + private String htltdzotm; + + /** + * 最低低潮位 + */ + private BigDecimal ltltdz; + + /** + * 最低低潮潮位注解码 + */ + private String ltltdzrcd; + + /** + * 最低地潮位出现时间 + */ + private String ltltdzotm; + + /** + * 平均涨潮潮差 + */ + private BigDecimal avftdr; + + /** + * 平均涨潮潮差注解码 + */ + private String avftdrrcd; + + /** + * 最大涨潮潮差 + */ + private BigDecimal mxfltdr; + + /** + * 最大涨潮潮差注解码 + */ + private String mxfltdrrcd; + + /** + * 最大涨潮潮差（高潮）时间 + */ + private String mxfltdrhtm; + + /** + * 最小潮潮差 + */ + private BigDecimal mnfltdr; + + /** + * 最小涨潮潮差注解码 + */ + private String mnfltdrrcd; + + /** + * 最小涨潮潮差（高潮）时间 + */ + private String mnfltdrhtm; + + /** + * 平均涨潮潮差 + */ + private BigDecimal aver; + + /** + * 平均涨潮潮差注解码 + */ + private String averbbrrcd; + + /** + * 最大落潮潮差 + */ + private BigDecimal mxebtdr; + + /** + * 最大落潮潮差注解码 + */ + private String mxebtdrrcd; + + /** + * 最大落潮潮差(高潮)时间 + */ + private String mxebtdrht; + + /** + * 最小落潮潮差 + */ + private BigDecimal mnebtdr; + + /** + * 最小落潮潮差注解码 + */ + private String mnebtdrrcd; + + /** + * 最小落潮潮差（高潮）时间 + */ + private String mnebtdrhtm; + + /** + * 平均涨潮历时 + */ + private String avftd; + + /** + * 平均涨潮历时注解码 + */ + private String avftdrcd; + + /** + * 最长涨潮历时 + */ + private String mxfltddr; + + /** + * 最长涨潮历时注解码 + */ + private String mxfltddrrcd; + + /** + * 最长涨潮历时（高潮）时间 + */ + private String mxfltddrhtm; + + /** + * 最短涨潮历时 + */ + private String mnfltddr; + + /** + * 最短涨潮历时注解码 + */ + private String mnfltddrrcd; + + /** + * 最短涨潮历时（高潮）时间 + */ + private String mnfltddrhtm; + + /** + * 平均落潮历时 + */ + private String avebbdr; + + /** + * 平均落潮历时注解码 + */ + private String avedrc; + + /** + * 最长落潮历时 + */ + private Integer mxebtddr; + + /** + * 最长落潮历时注解码 + */ + private String mxebtddrrcd; + + /** + * 最长落潮历时（高潮）时间 + */ + private String mxebtddrhtm; + + /** + * 最短落潮历时 + */ + private String mnbtddr; + + /** + * 最短落潮历时注解码 + */ + private String mnebtddrrcd; + + /** + * 最短落潮历时（高潮）时间 + */ + private String mnebtddrhtm; + + /** + * 逐时平均潮位 + */ + private BigDecimal hravtdz; + + /** + * 逐时平均潮位注解码 + */ + private String hravtdzrcd; + + /** + * 平均潮差 + */ + private BigDecimal avtdr; + + /** + * 平均潮差注解码 + */ + private String avtdrrcd; + + /** + * 平均历时 + */ + private String avtddr; + + /** + * 平均历时注解码 + */ + private String avtddrrcd; + + + /** + * 最大日水面蒸发量出现日期 + */ + private String mxdyeodt; + + + /** + * 最小日水面蒸发量出现日期 + */ + private String mndyeodt; + + /** + * 终冰日期 + */ + private String idsdt; + + /** + * 初冰日期 + */ + private String icapd; + + /** + * 蒸发场位置特征 + */ + private String eslcch; + + + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/SWDayData.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/SWDayData.java new file mode 100644 index 0000000..ec6a9bd --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/SWDayData.java @@ -0,0 +1,25 @@ +package com.ruoyi.swlscx.synchronousData.dto; + +import lombok.Data; + +import java.math.BigDecimal; + +/** + * @Author al + * @Date 2025/5/14 16:09 + * @Description: TODO + * @Version + */ +@Data +public class SWDayData { + + private String stnmId; + + private String tm; + + private BigDecimal value; + + private String sign; + + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/SWMonthData.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/SWMonthData.java new file mode 100644 index 0000000..54c7946 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/dto/SWMonthData.java @@ -0,0 +1,25 @@ +package com.ruoyi.swlscx.synchronousData.dto; + +import lombok.Data; + +import java.math.BigDecimal; + +/** + * @Author al + * @Date 2025/5/14 16:09 + * @Description: TODO + * @Version + */ +@Data +public class SWMonthData { + + private String stnmId; + + private String tm; + + private BigDecimal value; + + private String sign; + + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/enums/JhhkTableEnum.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/enums/JhhkTableEnum.java new file mode 100644 index 0000000..e2e4910 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/enums/JhhkTableEnum.java @@ -0,0 +1,81 @@ +package com.ruoyi.swlscx.synchronousData.enums; + +/** + * 水位最大最小值 + */ +public enum JhhkTableEnum { + + DAY_RAIN("日降水", "dp_dp_c"), + + DAY_DQS("日平均输沙率表", "dp_dqs_c"), + + DAY_DCS("日平均含沙量表", "dp_dcs_c"), + + DAY_DWE("日水面蒸发量表", "dp_dwe_c"), + + DAY_DWT("日水温表", "dp_dwt_c"), + + DAY_DMXP("日时段最大降水表", "dp_dmxp_f"), + + DAY_MXFW("时段最大洪量表", "dp_imxfw_f"), + + DAY_DZ("日平均水位表", "dp_dz_c"), + + DP_FDHEEX("洪水水文要素摘录表", "dp_fdheex_b"), + DP_HLTDZ("逐潮高低潮位表", "dp_hltdz_b"), + + DP_HMXP("小时时段最大降水量表", "dp_hmxp_f"), + DP_MMXP("分钟时段最大降水量表", "dp_mmxp_f"), + + MONTH_MTCS("月含沙量表", "dp_mtcs_e"), + + MONTH_RAIN("月降水量表", "dp_mtp_e"), + + MONTH_MTQS( "月输沙率表", "dp_mtqs_e"), + MONTH_MTTDZ( "月潮位表", "dp_mttdz_e"), + + MONTH_MTWE("月水面蒸发量表", "dp_mtwe_e"), + MONTH_MTWT("月水温表", "dp_mtwt_e"), + + MONTH_Q("月流量表", "dp_mtq_e"), + MONTH_MTZ("月水位表", "dp_mtz_e"), + DP_OBQ("实测流量表", "dp_obq_r"), + + DP_PREX("降水量摘录表", "dp_prex_b"), + + DP_RVFHEX("水库洪水水文要素摘录表", "dp_rvfhex_b"), + + DP_WSFHEX("水闸洪水水文要素摘录表", "dp_wsfhex_b"), + + DP_XSMSRS("实测大断面流量表", "dp_xsmsrs_g"), + + YEAR_YRCS("年含沙量表", "dp_yrcs_f"), + + YEAR_YRWE("年水面蒸发量表", "dp_yrwe_f"), + + YEAR_Q("年流量表", "dp_yrq_f"), + + YEAR_RAIN("年降水表", "dp_yrp_f"), + YEAR_TIDE("年潮位表", "dp_yrtdz_f"), + YEAR_YRWT("年水温表", "dp_yrwt_f"), + + YEAR_YRZ("年水位表", "dp_yrz_f"), + + DAY_Q("日平均流量", "dp_dq_c"); +//DAY_Q("日平均流量", "yc_rpt_hy_dq_c"); + private final String desc; + private final String value; + + private JhhkTableEnum(String desc, String value) { + this.desc = desc; + this.value = value; + } + + public String desc() { + return desc; + } + + public String value() { + return value; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/enums/SWTableEnum.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/enums/SWTableEnum.java new file mode 100644 index 0000000..069c91f --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/enums/SWTableEnum.java @@ -0,0 +1,94 @@ +package com.ruoyi.swlscx.synchronousData.enums; + +/** + * 水位最大最小值 + */ +public enum SWTableEnum { + HY_STSC("测站一览表", "hy_stsc_a"), + DAY_RAIN("日降水表", "hy_dp_c"), + + DAY_Q("日平均流量表", "hy_dq_c"), + + DAY_DQS("日平均输沙率表","hy_dqs_c"), + + DAY_DCS("日平均含沙量表", "hy_dcs_f"), + DAY_DWE("日水面蒸发量表", "hy_dwe_c"), + + DAY_DWT("日水温表", "hy_dwt_c"), + + DAY_DZC("日平均水位表", "hy_dz_c"), + + DAY_MXFW("时段最大洪量表", "hy_imxfw_f"), + + HY_DMXP_F("日时段最大降水表", "hy_dmxp_f"), + + + HY_WFDZ_F("保证率水位表", "hy_wfdz_f"), + + DP_FDHEEX("洪水水文要素摘录表", "hy_fdheex_b"), + + DP_HLTDZ("逐潮高低潮位表", "hy_hltdz_b"), + + DP_HMXP("小时时段最大降水量表", "hy_hmxp_f"), + + DP_MMXP("分钟时段最大降水量表", "hy_mmxp_f"), + + DP_HOUR("降水量摘录表", "hy_prex_b"), + + MONTH_MTCS("月含沙量表", "hy_mtcs_e"), + + MONTH_RAIN( "月降水量表", "hy_mtp_e"), + + MONTH_Q("月平均流量表", "hy_mtq_e"), + + MONTH_MTQS( "月输沙率表", "hy_mtqs_e"), + + MONTH_MTTDZ( "月潮位表", "hy_mttdz_e"), + + MONTH_MTWE("月水面蒸发量表", "hy_mtwe_e"), + + MONTH_MTWT("月水温表", "hy_mtwt_e"), + + MONTH_RIVER("月水位表", "hy_mtz_e"), + MONTH_RSVR("月水库水位表", "yc_rpt_rsvr_month"), + DP_OBQ("实测流量表", "yc_rpt_hy_obq_g"), + + + DP_RVFHEX("水库洪水水文要素摘录表", "hy_rvfhex_b"), + + + DP_WSFHEX("水闸洪水水文要素摘录表", "hy_wsfhex_b"), + DP_XSMSRS("实测大断面流量表", "yc_rpt_hy_xsmsrs_g"), + YEAR_YRCS("年含沙量表", "hy_yrcs_f"), + YEAR_Q("年流量表", "hy_yrq_f"), + YEAR_RAIN("年降水量表", "hy_yrp_f"), + + YEAR_TIDE("年潮位表", "hy_yrtdz_f"), + + YEAR_RIVER("年水位表", "hy_yrz_f"), + + YEAR_RSVR("年水库水位表", "yc_rpt_rsvr_year"), + + YEAR_YRWT("年水温表", "hy_yrwt_f"), + + + YEAR_YRWE("年水面蒸发量表", "hy_yrwe_f"); + + + + private final String desc; + private final String value; + + private SWTableEnum(String desc, String value) { + this.desc = desc; + this.value = value; + } + + public String desc() { + return desc; + } + + public String value() { + return value; + } +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/mapper/TimeTasksMapper.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/mapper/TimeTasksMapper.java new file mode 100644 index 0000000..4fd4b69 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/mapper/TimeTasksMapper.java @@ -0,0 +1,151 @@ +package com.ruoyi.swlscx.synchronousData.mapper; + +import com.ruoyi.swlscx.basic.domain.po.HyWfdzF; +import com.ruoyi.swlscx.day.domain.po.*; +import com.ruoyi.swlscx.excerpt.domain.po.*; +import com.ruoyi.swlscx.month.domain.po.*; +import com.ruoyi.swlscx.synchronousData.dto.JHDayData; +import com.ruoyi.swlscx.synchronousData.dto.SWDayData; +import com.ruoyi.swlscx.synchronousData.dto.SWMonthData; +import com.ruoyi.swlscx.year.domain.po.*; +import org.apache.ibatis.annotations.Mapper; +import org.apache.ibatis.annotations.Param; + +import java.util.List; + +/** + * @Author al + * @Date 2025/5/14 15:01 + * @Description: TODO + * @Version + */ +@Mapper +public interface TimeTasksMapper { + + + List getDayData(@Param("stcd")String stcd, @Param("startTime") String startTime, @Param("endTime") String endTime, @Param("tableName") String tableName); + + List getDataByDgdt(@Param("stcd")String stcd,@Param("startTime") String startTime, @Param("endTime") String endTime, @Param("tableName") String tableName); + + List getDataByTm(@Param("stcd")String stcd,@Param("startTime") String startTime, @Param("endTime") String endTime, @Param("tableName") String tableName); + + List getDataByBgtm(@Param("stcd")String stcd,@Param("startTime") String startTime, @Param("endTime") String endTime, @Param("tableName") String tableName); + + List getDataByYr(@Param("stcd") String stcd, @Param("year") String year, @Param("tableName") String tableName); + + void insertOrUpdateHyDpc(@Param("list") List ycRptHyDpcList, @Param("tableName") String tableName); + + void insertOrUpdateHyDqc(@Param("list") List hyDqCList, @Param("tableName") String tableName); + + void insertOrUpdateHyDqsC(@Param("list") List hyDqsCList, @Param("tableName") String tableName); + + void insertOrUpdateHyDcsF(@Param("list") List hyDcsFList, @Param("tableName") String tableName); + + void insertOrUpdateHyDmxpF(@Param("list") List hyDmxpFList, @Param("tableName") String tableName); + + void insertOrUpdateHyDweC(@Param("list") List hyDweCList, @Param("tableName") String tableName); + + void insertOrUpdateHyDwtC(@Param("list") List hyDwtCList,@Param("tableName") String tableName); + + void insertOrUpdateHyDzC(@Param("list") List hyDzCList, @Param("tableName") String tableName); + + void insertOrUpdateHyImxfwF(@Param("list") List hyImxfwFList, @Param("tableName") String tableName); + + void insertOrUpdateHyFdheexB(@Param("list") List hyFdheexBList, @Param("tableName") String tableName); + + void insertOrUpdateHyHltdzB(@Param("list") List hyHltdzBList, @Param("tableName") String tableName); + + void insertOrUpdateHyHmxpF(@Param("list") List hyHmxpFList, @Param("tableName") String tableName); + + void insertOrUpdateHyMmxpF(@Param("list") List hyMmxpFList, @Param("tableName") String tableName); + + void insertOrUpdateHyMtcsE(@Param("list") List hyMtcsEList, @Param("tableName") String tableName); + + void insertOrUpdateHyMtpEList(@Param("list") List hyMtpEList, @Param("tableName") String tableName); + + void insertOrUpdateHyMtqE(@Param("list") List hyMtqEList, @Param("tableName") String tableName); + + void insertOrUpdateHyMtqsEList(@Param("list") List hyMtqsEList, @Param("tableName") String tableName); + + void insertOrUpdateHyMtweE(@Param("list") List hyMtweEList, @Param("tableName") String tableName); + + void insertOrUpdateHyMtwtE(@Param("list") List hyMtwtEList, @Param("tableName") String tableName); + + void insertOrUpdateHyMtzE(@Param("list") List hyMtzEList, @Param("tableName") String tableName); + + void insertOrUpdateHyPrexBList(@Param("list") List hyPrexBList, @Param("tableName") String tableName); + + void insertOrUpdateHyRvfhexBList(@Param("list") List hyRvfhexBList, @Param("tableName") String tableName); + + void insertOrUpdateHyWsfhexBList(@Param("list") List hyWsfhexBList, @Param("tableName") String tableName); + + void insertOrUpdateHyYrcsFList(@Param("list") List hyYrcsFList, @Param("tableName") String tableName); + + void insertOrUpdateHyYrqFList(@Param("list") List hyYrqFList, @Param("tableName") String tableName); + + void insertOrUpdateHyYrpFList(@Param("list") List hyYrpFList, @Param("tableName") String tableName); + + void insertOrUpdateHyYrtdzFList(@Param("list") List hyYrtdzFList,@Param("tableName") String tableName); + + void insertOrUpdateHyYrweFList(@Param("list") List hyYrweFList, @Param("tableName") String tableName); + + void insertOrUpdateHyYrwtFList(@Param("list") List hyYrwtFList, @Param("tableName") String tableName); + + void insertOrUpdateHyYrzFList(@Param("list") List hyYrzFList, @Param("tableName") String tableName); + + void insertOrUpdateHyMttdzEList(@Param("list") List hyMttdzEList,@Param("tableName") String tableName); + + void insertOrUpdateHyWfdzF(@Param("list") List hyWfdzFList,@Param("tableName") String value); +// +// void deleteAll(@Param("tableName") String tableName); +// +// void insertOrUpdate(@Param("list") List swDayDataList, @Param("tableName") String tableName); +// +// void insertOrUpdateHyDqs(@Param("list") List ycRptHyDqsList,@Param("tableName") String tableName); +// +// void insertOrUpdateHyDcs(@Param("list") List ycRptHyDcsList,@Param("tableName") String tableName); +// +// void insertOrUpdateHyDwe(@Param("list") List ycRptHyDweList, @Param("tableName") String tableName); +// +// void insertOrUpdateHyDwt(@Param("list") List ycRptHyDwtList, @Param("tableName") String tableName); +// + +// +// void insertOrUpdateArchCharRain(@Param("list") List archCharRainList,@Param("tableName") String tableName); +// +// void insertOrUpdateImxfw(@Param("list") List ycRptImxfwList, @Param("tableName") String tableName); +// +// +// void insertOrUpdateFdheex(@Param("list") List ycRptFdheexList, @Param("tableName") String tableName); +// +// void insertOrUpdateTideHour(@Param("list") List ycRptTideHourList, @Param("tableName") String tableName); +// + +// +// +// void insertOrUpdateHyMtcs(@Param("list") List ycRptHyMtcsList, @Param("tableName") String tableName); +// +// void insertOrUpdateMonthData(@Param("list") List swMonthData, @Param("tableName") String tableName); +// +// void insertOrUpdateMtqsData(@Param("list") List ycRptHyMtqsList, @Param("tableName") String tableName); +// +// void insertOrUpdateHyMtwe(@Param("list") List ycRptHyMtweList, @Param("tableName") String tableName); +// +// void insertOrUpdateHyMtwt(@Param("list") List ycRptHyMtwtList,@Param("tableName") String tableName); +// +// void insertOrUpdateDpObq(@Param("list") List ycRptDpObqRS, @Param("tableName") String tableName); +// +// void insertOrUpdateHyRvfhexB(@Param("list") List ycRptHyRvfhexBList, @Param("tableName") String tableName); +// +// void insertOrUpdateHyWsfhexB(@Param("list") List ycRptHyWsfhexBList, @Param("tableName") String tableName); +// +// List getDataByObdt(@Param("stcd")String stcd,@Param("startTime") String startTime, @Param("endTime") String endTime, @Param("tableName") String tableName); +// +// void insertOrUpdateXsmsrs(@Param("list") List ycRptXsmsrsGS, @Param("tableName") String tableName); +// +// void insertOrUpdateHyYrcsF(@Param("list") List ycRptHyYrcsList, @Param("tableName") String tableName); +// +// void insertOrUpdateYrweData(@Param("list") List ycRptHyYrweList, @Param("tableName") String tableName); +// +// void insertOrUpdateYrwtData(@Param("list") List ycRptHyYrwtList, @Param("tableName") String tableName); +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/GetDateService.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/GetDateService.java new file mode 100644 index 0000000..39c31f4 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/GetDateService.java @@ -0,0 +1,15 @@ +package com.ruoyi.swlscx.synchronousData.service; + +import java.util.List; + +/** + * @Author al + * @Date 2025/5/14 14:49 + * @Description: TODO + * @Version + */ +public interface GetDateService { + + void insertRainData(List stcds,String tableName); + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/TimeTasksService.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/TimeTasksService.java new file mode 100644 index 0000000..4df723f --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/TimeTasksService.java @@ -0,0 +1,83 @@ +package com.ruoyi.swlscx.synchronousData.service; + +/** + * @Author al + * @Date 2025/5/14 14:49 + * @Description: TODO + * @Version + */ +public interface TimeTasksService { + + void getDayRainData(); + + void getDayQData(); + + void getDayDqsData(); +// + void getDayDcsData(); + + void getDayDweData(); + + void getDayDwtData(); + + void getDayDzcData(); +// +// void getDayRsverData(); + + void getDayDmxpData(); +// + void getDayImxfwData(); + + void getFdheexData(); + + void getHltdzData(); + + void getHmxpData(); + + void getMmxpData(); + + void getMtcsData(); + + void getMonthRainData(); + + void getMonthQData(); + + void getMonthMtqsData(); + + void getMonthMtweData(); + + void getMonthMtwtData(); + + void getMonthRiverData(); +// +// void getMonthRsvrData(); +// +// void getObqData(); + + void getHourRainData(); + + void getWsfhexData(); + + void getRvfhexData(); + + + void getYrcsData(); + + void getYearQData(); + + void getYearRainData(); + + void getYearTideData(); + + void getYearMtweData(); + + void getYearWtData(); + + void getYearYrzData(); +// +// void getYearRsvrData(); +// + + void getMonthMttdzData(); + void setYcStaions(); +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/impl/GetDateServiceImpl.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/impl/GetDateServiceImpl.java new file mode 100644 index 0000000..c812f63 --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/impl/GetDateServiceImpl.java @@ -0,0 +1,210 @@ +package com.ruoyi.swlscx.synchronousData.service.impl; + +import com.alibaba.fastjson.JSON; +import com.ruoyi.common.annotation.DataSource; +import com.ruoyi.common.enums.DataSourceType; +import com.ruoyi.swlscx.day.domain.po.*; +import com.ruoyi.swlscx.excerpt.domain.po.*; +import com.ruoyi.swlscx.month.domain.po.*; +import com.ruoyi.swlscx.synchronousData.dto.SWDayData; +import com.ruoyi.swlscx.synchronousData.dto.SWMonthData; +import com.ruoyi.swlscx.synchronousData.enums.SWTableEnum; +import com.ruoyi.swlscx.synchronousData.mapper.TimeTasksMapper; +import com.ruoyi.swlscx.synchronousData.service.GetDateService; +import com.ruoyi.swlscx.year.domain.po.*; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.data.redis.core.StringRedisTemplate; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; + +/** + * @Author al + * @Date 2025/5/14 14:49 + * @Description: TODO + * @Version + */ +@Service +public class GetDateServiceImpl implements GetDateService { + + + @Autowired + private TimeTasksMapper timeTasksMapper; + + @Autowired + private StringRedisTemplate stringRedisTemplate; + + /** + * 处理雨量数据 + */ + @Transactional(rollbackFor = Exception.class) + @Override + @DataSource(DataSourceType.MASTER) + public void insertRainData(List stcds,String tableName) { + for (String stcd : stcds) { + if (tableName.equals(SWTableEnum.DAY_RAIN.value())) { + //从redis中查数据 + List ycRptHyDpcList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyDpC.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyDpc(ycRptHyDpcList, tableName); + }else if (tableName.equals(SWTableEnum.DAY_Q.value())) { + //从redis中查数据 + List hyDqCList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyDqC.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyDqc(hyDqCList, tableName); + } else if (tableName.equals(SWTableEnum.DAY_DQS.value())) { + //从redis中查数据 + List hyDqsCList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyDqsC.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyDqsC(hyDqsCList, tableName); + }else if (tableName.equals(SWTableEnum.DAY_DCS.value())) { + //从redis中查数据 + List hyDcsFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyDcsF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyDcsF(hyDcsFList, tableName); + }else if (tableName.equals(SWTableEnum.HY_DMXP_F.value())) { + //从redis中查数据 + List hyDmxpFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyDmxpF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyDmxpF(hyDmxpFList, tableName); + }else if (tableName.equals(SWTableEnum.DAY_DWE.value())) { + //从redis中查数据 + List hyDweCList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyDweC.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyDweC(hyDweCList, tableName); + }else if (tableName.equals(SWTableEnum.DAY_DWT.value())) { + //从redis中查数据 + List hyDwtCList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyDwtC.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyDwtC(hyDwtCList, tableName); + }else if (tableName.equals(SWTableEnum.DAY_DZC.value())) { + //从redis中查数据 + List hyDzCList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyDzC.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyDzC(hyDzCList, tableName); + }else if (tableName.equals(SWTableEnum.DAY_MXFW.value())) { + //从redis中查数据 + List hyImxfwFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyImxfwF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyImxfwF(hyImxfwFList, tableName); + }else if (tableName.equals(SWTableEnum.DP_FDHEEX.value())) { + //从redis中查数据 + List hyFdheexBList= JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyFdheexB.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyFdheexB(hyFdheexBList, tableName); + }else if (tableName.equals(SWTableEnum.DP_HLTDZ.value())) { + //从redis中查数据 + List hyHltdzBList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyHltdzB.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyHltdzB(hyHltdzBList, tableName); + }else if (tableName.equals(SWTableEnum.DP_HMXP.value())) { + //从redis中查数据 + List hyHmxpFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyHmxpF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyHmxpF(hyHmxpFList, tableName); + }else if (tableName.equals(SWTableEnum.DP_MMXP.value())) { + //从redis中查数据 + List hyMmxpFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyMmxpF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyMmxpF(hyMmxpFList, tableName); + }else if (tableName.equals(SWTableEnum.MONTH_MTCS.value())) { + //从redis中查数据 + List hyMtcsEList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyMtcsE.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyMtcsE(hyMtcsEList, tableName); + }else if (tableName.equals(SWTableEnum.MONTH_RAIN.value())) { + //从redis中查数据 + List hyMtpEList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyMtpE.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyMtpEList(hyMtpEList, tableName); + }else if (tableName.equals(SWTableEnum.MONTH_Q.value())) { + //从redis中查数据 + List hyMtqEList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyMtqE.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyMtqE(hyMtqEList, tableName); + }else if (tableName.equals(SWTableEnum.MONTH_MTQS.value())) { + //从redis中查数据 + List hyMtqsEList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyMtqsE.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyMtqsEList(hyMtqsEList, tableName); + }else if (tableName.equals(SWTableEnum.MONTH_MTWE.value())) { + //从redis中查数据 + List hyMtweEList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyMtweE.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyMtweE(hyMtweEList, tableName); + }else if (tableName.equals(SWTableEnum.MONTH_MTWT.value())) { + //从redis中查数据 + List hyMtwtEList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyMtwtE.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyMtwtE(hyMtwtEList, tableName); + }else if (tableName.equals(SWTableEnum.MONTH_RIVER.value())) { + //从redis中查数据 + List hyMtzEList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyMtzE.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyMtzE(hyMtzEList, tableName); + }else if (tableName.equals(SWTableEnum.DP_HOUR.value())) { + //从redis中查数据 + List hyPrexBList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyPrexB.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyPrexBList(hyPrexBList, tableName); + }else if (tableName.equals(SWTableEnum.DP_RVFHEX.value())) { + //从redis中查数据 + List hyRvfhexBList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyRvfhexB.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyRvfhexBList(hyRvfhexBList, tableName); + }else if (tableName.equals(SWTableEnum.DP_WSFHEX.value())) { + //从redis中查数据 + List hyWsfhexBList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyWsfhexB.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyWsfhexBList(hyWsfhexBList, tableName); + }else if (tableName.equals(SWTableEnum.YEAR_YRCS.value())) { + //从redis中查数据 + List hyYrcsFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyYrcsF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyYrcsFList(hyYrcsFList, tableName); + }else if (tableName.equals(SWTableEnum.YEAR_Q.value())) { + //从redis中查数据 + List hyYrqFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyYrqF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyYrqFList(hyYrqFList, tableName); + }else if (tableName.equals(SWTableEnum.YEAR_RAIN.value())) { + //从redis中查数据 + List hyYrpFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyYrpF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyYrpFList(hyYrpFList, tableName); + }else if (tableName.equals(SWTableEnum.YEAR_TIDE.value())) { + //从redis中查数据 + List hyYrtdzFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyYrtdzF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyYrtdzFList(hyYrtdzFList, tableName); + }else if (tableName.equals(SWTableEnum.YEAR_YRWE.value())) { + //从redis中查数据 + List hyYrweFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyYrweF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyYrweFList(hyYrweFList, tableName); + }else if (tableName.equals(SWTableEnum.YEAR_YRWT.value())) { + //从redis中查数据 + List hyYrwtFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyYrwtF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyYrwtFList(hyYrwtFList, tableName); + }else if (tableName.equals(SWTableEnum.YEAR_RIVER.value())) { + //从redis中查数据 + List hyYrzFList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyYrzF.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyYrzFList(hyYrzFList, tableName); + }else if (tableName.equals(SWTableEnum.MONTH_MTTDZ.value())) { + //从redis中查数据 + List hyMttdzEList = JSON.parseArray(stringRedisTemplate.opsForValue().get(stcd), HyMttdzE.class); + //更新新增操作 + timeTasksMapper.insertOrUpdateHyMttdzEList(hyMttdzEList, tableName); + } + + } + //清除redis缓存 + for (String stcd : stcds) { + stringRedisTemplate.delete(stcd); + } + } + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/impl/TimeTasksServiceImpl.java b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/impl/TimeTasksServiceImpl.java new file mode 100644 index 0000000..07f65bd --- /dev/null +++ b/swlscx/src/main/java/com/ruoyi/swlscx/synchronousData/service/impl/TimeTasksServiceImpl.java @@ -0,0 +1,1347 @@ +package com.ruoyi.swlscx.synchronousData.service.impl; + +import com.alibaba.fastjson.JSON; +import com.ruoyi.common.annotation.DataSource; +import com.ruoyi.common.core.text.Convert; +import com.ruoyi.common.enums.DataSourceType; +import com.ruoyi.common.utils.DateUtils; +import com.ruoyi.swlscx.basic.domain.po.HyStscA; +import com.ruoyi.swlscx.basic.service.HyStscAService; +import com.ruoyi.swlscx.day.domain.po.*; +import com.ruoyi.swlscx.excerpt.domain.po.*; +import com.ruoyi.swlscx.month.domain.po.*; +import com.ruoyi.swlscx.synchronousData.dto.JHDayData; +import com.ruoyi.swlscx.synchronousData.enums.JhhkTableEnum; +import com.ruoyi.swlscx.synchronousData.enums.SWTableEnum; +import com.ruoyi.swlscx.synchronousData.mapper.TimeTasksMapper; +import com.ruoyi.swlscx.synchronousData.service.GetDateService; +import com.ruoyi.swlscx.synchronousData.service.TimeTasksService; +import com.ruoyi.swlscx.year.domain.po.*; +import org.springframework.beans.BeanUtils; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.data.redis.core.StringRedisTemplate; +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Service; + +import java.time.LocalDateTime; +import java.time.Year; +import java.time.format.DateTimeFormatter; +import java.util.ArrayList; +import java.util.List; +import java.util.concurrent.TimeUnit; + +/** + * @Author al + * @Date 2025/5/14 14:49 + * @Description: TODO + * @Version + */ +@Service +public class TimeTasksServiceImpl implements TimeTasksService { + + @Autowired + private TimeTasksMapper timeTasksMapper; +// + @Autowired + private HyStscAService hyStscAService; +// + + @Autowired + private GetDateService getDateService; + + @Autowired + private StringRedisTemplate stringRedisTemplate; + + + + + + /** + * 获取江河湖库日雨量数据 + */ + @Override + @Scheduled(cron = "0 10 0 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getDayRainData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DAY_RAIN.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDayData(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyDpCList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyDpC hyDpC = new HyDpC(); + hyDpC.setStcd(jhDayData.getStcd()); + hyDpC.setDt(DateUtils.parseDate(jhDayData.getDt())); + hyDpC.setP(jhDayData.getP()); + hyDpCList.add(hyDpC); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyDpCList); + stringRedisTemplate.opsForValue().set("dayRain:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("dayRain:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.DAY_RAIN.value()); + } + + + /** + * 获取江河湖库日平均流量表 + */ + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 20 0 18 * ?") + @Override + public void getDayQData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DAY_Q.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDayData(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyDqCList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyDqC hyDqC = new HyDqC(); + hyDqC.setStcd(jhDayData.getStcd()); + hyDqC.setDt(DateUtils.parseDate(jhDayData.getDt())); + hyDqC.setAvq(jhDayData.getAvq()); + hyDqC.setAvqrcd(jhDayData.getAvqrcd()); + hyDqCList.add(hyDqC); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyDqCList); + stringRedisTemplate.opsForValue().set("dayQ:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("dayQ:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.DAY_Q.value()); + } + + /** + * 获取江河湖库日平均输沙率表 + */ + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 30 0 18 * ?") + @Override + public void getDayDqsData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DAY_DQS.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDayData(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyDqsCList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyDqsC hyDqsC = new HyDqsC(); + hyDqsC.setStcd(jhDayData.getStcd()); + hyDqsC.setDt(DateUtils.parseDate(jhDayData.getDt())); + hyDqsC.setSdtp(jhDayData.getSdtp()); + hyDqsC.setAvqs(jhDayData.getAvqs()); + hyDqsC.setAvqsrcd(jhDayData.getAvqsrcd()); + hyDqsCList.add(hyDqsC); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyDqsCList); + stringRedisTemplate.opsForValue().set("dayDqs:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("dayDqs:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.DAY_DQS.value()); + } + + + /** + * 获取江河湖库日平均含沙量表 + */ + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 40 0 18 * ?") + @Override + public void getDayDcsData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DAY_DCS.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDayData(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyDcsFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyDcsF hyDcsF = new HyDcsF(); + hyDcsF.setStcd(jhDayData.getStcd()); + hyDcsF.setDt(DateUtils.parseDate(jhDayData.getDt())); + hyDcsF.setAvcs(jhDayData.getAvcs()); + hyDcsF.setAvcsrcd(jhDayData.getAvcsrcd()); + hyDcsFList.add(hyDcsF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyDcsFList); + stringRedisTemplate.opsForValue().set("dayDcs:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("dayDcs:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.DAY_DCS.value()); + } + + + + /** + * 获取江河湖库日时段最大降水表 + */ + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 50 0 18 * ?") + @Override + public void getDayDmxpData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DAY_DMXP.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByDgdt(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyDmxpFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyDmxpF hyDmxpF = new HyDmxpF(); + hyDmxpF.setStcd(jhDayData.getStcd()); + hyDmxpF.setBgdt(DateUtils.parseDate(jhDayData.getBgdt())); + hyDmxpF.setYr(Convert.toInt(jhDayData.getYr())); + hyDmxpF.setMxpdr(Convert.toInt(jhDayData.getMxpdr())); + hyDmxpF.setMxp(jhDayData.getMxp()); + hyDmxpF.setMxprc(jhDayData.getMxprc()); + hyDmxpFList.add(hyDmxpF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyDmxpFList); + stringRedisTemplate.opsForValue().set("DayDmxp:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("DayDmxp:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.HY_DMXP_F.value()); + } + + + /** + * 获取江河湖库日水面蒸发量表 + */ + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 0 1 18 * ?") // 每月19号01:00执行 + @Override + public void getDayDweData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DAY_DWE.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDayData(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List ycRptHyDwes = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyDweC hyDweC = new HyDweC(); + hyDweC.setStcd(jhDayData.getStcd()); + hyDweC.setDt(DateUtils.parseDate(jhDayData.getDt())); + hyDweC.setEetp(jhDayData.getEetp()); + hyDweC.setWsfe(jhDayData.getWsfe()); + hyDweC.setWsfercd(jhDayData.getWsfercd()); + ycRptHyDwes.add(hyDweC); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(ycRptHyDwes); + stringRedisTemplate.opsForValue().set("dayDwe:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("dayDwe:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.DAY_DWE.value()); + } + + + /** + * 获取江河湖库日水温表 + */ + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 10 1 18 * ?") + @Override + public void getDayDwtData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DAY_DWT.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDayData(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List ycRptHyDwts = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyDwtC hyDwtC = new HyDwtC(); + hyDwtC.setStcd(jhDayData.getStcd()); + hyDwtC.setDt(DateUtils.parseDate(jhDayData.getDt())); + hyDwtC.setWtmp(jhDayData.getWtmp()); + hyDwtC.setWtmprcd(jhDayData.getWtmprcd()); + ycRptHyDwts.add(hyDwtC); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(ycRptHyDwts); + stringRedisTemplate.opsForValue().set("dayDwt:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("dayDwt:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.DAY_DWT.value()); + } + + + /** + * 获取江河湖库日平均水位表 + */ + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 20 1 18 * ?") + @Override + public void getDayDzcData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DAY_DZ.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDayData(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyDzCList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyDzC hyDzC = new HyDzC(); + hyDzC.setStcd(jhDayData.getStcd()); + hyDzC.setDt(DateUtils.parseDate(jhDayData.getDt())); + hyDzC.setAvz(jhDayData.getAvz()); + hyDzC.setAvzrcd(jhDayData.getAvzrcd()); + hyDzCList.add(hyDzC); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyDzCList); + stringRedisTemplate.opsForValue().set("dayDzc:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("dayDzc:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.DAY_DZC.value()); + } + + + /** + * 获取江河湖库时段最大洪量表 + */ + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 30 1 18 * ?") + @Override + public void getDayImxfwData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DAY_MXFW.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByDgdt(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyImxfwFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyImxfwF hyImxfwF = new HyImxfwF(); + hyImxfwF.setStcd(jhDayData.getStcd()); + hyImxfwF.setBgdt(DateUtils.parseDate(jhDayData.getBgdt())); + hyImxfwF.setYr(Convert.toInt(jhDayData.getYr())); + hyImxfwF.setMxw(jhDayData.getMxw()); + hyImxfwF.setMxwrc(jhDayData.getMxwrc()); + hyImxfwF.setMxwdr(jhDayData.getMxwdr()); + hyImxfwFList.add(hyImxfwF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyImxfwFList); + stringRedisTemplate.opsForValue().set("dayImxfw:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("dayImxfw:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.DAY_MXFW.value());} + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 40 1 18 * ?") + @Override + public void getFdheexData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DP_FDHEEX.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByTm(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyFdheexBList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyFdheexB hyFdheexB = new HyFdheexB(); + hyFdheexB.setStcd(jhDayData.getStcd()); + hyFdheexB.setTm(DateUtils.parseDate(jhDayData.getTm())); + hyFdheexB.setZ(jhDayData.getZ()); + hyFdheexB.setZrcd(jhDayData.getZrcd()); + hyFdheexB.setQ(jhDayData.getQ()); + hyFdheexB.setS(jhDayData.getS()); + hyFdheexBList.add(hyFdheexB); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyFdheexBList); + stringRedisTemplate.opsForValue().set("DpFdheex:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("DpFdheex:"+ycStation.getStcd()); + }getDateService.insertRainData(stcds, SWTableEnum.DP_FDHEEX.value());} + + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 50 1 18 * ?") + @Override + public void getHltdzData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DP_HLTDZ.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByTm(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue;} + List hyHltdzBList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyHltdzB hyHltdzB = new HyHltdzB(); + hyHltdzB.setStcd(jhDayData.getStcd()); + hyHltdzB.setTm(DateUtils.parseDate(jhDayData.getTm())); + hyHltdzB.setTdtp(jhDayData.getTdtp()); + hyHltdzB.setTdz(jhDayData.getTdz()); + hyHltdzB.setTdzrcd(jhDayData.getTdzrcd()); + hyHltdzB.setTdrng(jhDayData.getTdrng()); + hyHltdzB.setDr(jhDayData.getDr()); + hyHltdzB.setNt(jhDayData.getNt()); + hyHltdzBList.add(hyHltdzB);} + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyHltdzBList); + stringRedisTemplate.opsForValue().set("HyHltdzB:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS);stcds.add("HyHltdzB:"+ycStation.getStcd());} + getDateService.insertRainData(stcds, SWTableEnum.DP_HLTDZ.value());} + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 0 2 18 * ?") @Override + public void getHmxpData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DP_HMXP.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByBgtm(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) {continue;} + //匹配数据 + List archCharRains = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyHmxpF hyHmxpF = new HyHmxpF(); + hyHmxpF.setStcd(jhDayData.getStcd()); + hyHmxpF.setBgtm(DateUtils.parseDate(jhDayData.getBgtm())); + hyHmxpF.setYr(Convert.toInt(jhDayData.getYr())); + hyHmxpF.setMxpdr(Convert.toInt(jhDayData.getMxpdr())); + hyHmxpF.setMxp(jhDayData.getMxp()); + hyHmxpF.setMxprc(jhDayData.getMxprc()); + archCharRains.add(hyHmxpF);} + //插入数据到redis中 + String jsonData = JSON.toJSONString(archCharRains); + stringRedisTemplate.opsForValue().set("DpHmxp:"+ycStation.getStcd(), jsonData, 12, TimeUnit.HOURS); + stcds.add("DpHmxp:"+ycStation.getStcd());} + getDateService.insertRainData(stcds, SWTableEnum.DP_HMXP.value());} + + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 10 2 18 * ?") + @Override + public void getMmxpData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DP_MMXP.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByBgtm(ycStation.getStcd(), startTime, endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyMmxpFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyMmxpF hyMmxpF = new HyMmxpF(); + hyMmxpF.setStcd(jhDayData.getStcd()); + hyMmxpF.setMxpdr(Convert.toInt(jhDayData.getMxpdr())); + hyMmxpF.setYr(Convert.toInt(jhDayData.getYr())); + hyMmxpF.setBgdt(DateUtils.parseDate(jhDayData.getBgtm())); + hyMmxpF.setMxp(jhDayData.getMxp()); + hyMmxpF.setMxprc(jhDayData.getMxprc()); + hyMmxpFList.add(hyMmxpF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyMmxpFList); + stringRedisTemplate.opsForValue().set("DpMmxp:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("DpMmxp:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.DP_MMXP.value()); + } + + + /** + * 获取江河湖库月含沙量表 + */ + @DataSource(DataSourceType.SLAVE) + @Scheduled(cron = "0 20 2 18 * ?") + @Override + public void getMtcsData() { + List ycStations = getYcStations(); + String tableName = JhhkTableEnum.MONTH_MTCS.value(); + String year = getNowYear(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyMtcsEList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyMtcsE hyMtcsE = new HyMtcsE(); + hyMtcsE.setStcd(jhDayData.getStcd()); + hyMtcsE.setYr(Convert.toInt(jhDayData.getYr())); + hyMtcsE.setMth(Convert.toInt(jhDayData.getMth())); + hyMtcsE.setAvcs(jhDayData.getAvcs()); + hyMtcsE.setAvcsrcd(jhDayData.getAvcsrcd()); + hyMtcsE.setMxs(jhDayData.getMxs()); + hyMtcsE.setMxsrcd(jhDayData.getMxsrcd()); + hyMtcsE.setMxsdt(DateUtils.parseDate(jhDayData.getMxsdt())); + hyMtcsE.setMns(jhDayData.getMns()); + hyMtcsE.setMnsrcd(jhDayData.getMnsrcd()); + hyMtcsE.setMnsdt(DateUtils.parseDate(jhDayData.getMnsdt())); + hyMtcsEList.add(hyMtcsE); + } + + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyMtcsEList); + stringRedisTemplate.opsForValue().set("MthMtcs:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("MthMtcs:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds, SWTableEnum.MONTH_MTCS.value()); + } + + + /** + * 获取江河湖库月降水表数据 + */ + @Override + @Scheduled(cron = "0 30 2 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getMonthRainData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.MONTH_RAIN.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyMtpEList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyMtpE hyMtpE = new HyMtpE(); + hyMtpE.setStcd(jhDayData.getStcd()); + hyMtpE.setYr(Convert.toInt(jhDayData.getYr())); + hyMtpE.setMth(Convert.toInt(jhDayData.getMth())); + hyMtpE.setP(jhDayData.getP()); + hyMtpE.setPrcd(jhDayData.getPrcd()); + hyMtpE.setPdynum(jhDayData.getPdynum()); + hyMtpE.setMxdyp(jhDayData.getMxdyp()); + hyMtpE.setMxdyprcd(jhDayData.getMxdyprcd()); + hyMtpE.setMxdypodt(DateUtils.parseDate(jhDayData.getMxdypodt())); + hyMtpEList.add(hyMtpE); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyMtpEList); + stringRedisTemplate.opsForValue().set("MonthRain:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("MonthRain:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.MONTH_RAIN.value()); + } + + + /** + * 获取江河湖库月流量表数据 + */ + @Override + @Scheduled(cron = "0 40 2 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getMonthQData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.MONTH_Q.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyMtqEList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyMtqE hyMtqE = new HyMtqE(); + hyMtqE.setStcd(jhDayData.getStcd()); + hyMtqE.setYr(Convert.toInt(jhDayData.getYr())); + hyMtqE.setMth(Convert.toInt(jhDayData.getMth())); + hyMtqE.setAvq(jhDayData.getAvq()); + hyMtqE.setAvqrcd(jhDayData.getAvqrcd()); + hyMtqE.setMxq(jhDayData.getMxq()); + hyMtqE.setMxqrcd(jhDayData.getMxqrcd()); + hyMtqE.setMxqdt(DateUtils.parseDate(jhDayData.getMxqdt())); + hyMtqE.setMnq(jhDayData.getMnq()); + hyMtqE.setMnqrcd(jhDayData.getMnqrcd()); + hyMtqE.setMnqdt(DateUtils.parseDate(jhDayData.getMnqdt())); + hyMtqEList.add(hyMtqE); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyMtqEList); + stringRedisTemplate.opsForValue().set("MonthQ:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("MonthQ:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.MONTH_Q.value()); + } + + + /** + * 获取江河湖库月输沙率表 + */ + @Override + @Scheduled(cron = "0 50 2 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getMonthMtqsData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.MONTH_MTQS.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyMtqsEList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyMtqsE hyMtqsE = new HyMtqsE(); + hyMtqsE.setStcd(jhDayData.getStcd()); + hyMtqsE.setSdtp(jhDayData.getSdtp()); + hyMtqsE.setYr(Convert.toInt(jhDayData.getYr())); + hyMtqsE.setMth(Convert.toInt(jhDayData.getMth())); + hyMtqsE.setAvqs(jhDayData.getAvqs()); + hyMtqsE.setAvqsrcd(jhDayData.getAvqsrcd()); + hyMtqsE.setMxdyqs(jhDayData.getMxdyqs()); + hyMtqsE.setMxdyqsrcd(jhDayData.getMxdyqsrcd()); + hyMtqsE.setMxdyqsodt(DateUtils.parseDate(jhDayData.getMxdyqsodt())); + hyMtqsEList.add(hyMtqsE); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyMtqsEList); + stringRedisTemplate.opsForValue().set("MonthMtqs:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("MonthMtqs:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.MONTH_MTQS.value()); + } + + + /** + * 获取江河湖库月潮位表 + */ + @Override + @Scheduled(cron = "0 0 3 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getMonthMttdzData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.MONTH_MTTDZ.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyMttdzEList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyMttdzE hyMttdzE = new HyMttdzE(); + BeanUtils.copyProperties(jhDayData, hyMttdzE); + hyMttdzE.setYr(Convert.toInt(jhDayData.getYr())); + hyMttdzE.setMth(Convert.toInt(jhDayData.getMth())); + hyMttdzE.setAvhtdz(Convert.toBigDecimal(jhDayData.getAvhtdz())); + hyMttdzE.setHthtdz(Convert.toBigDecimal(jhDayData.getHthtdz())); + hyMttdzE.setHthtdzotm(DateUtils.parseDate(jhDayData.getHthtdzotm())); + hyMttdzE.setLthtdz(Convert.toBigDecimal(jhDayData.getLthtdz())); + hyMttdzE.setLthtdzotm(DateUtils.parseDate(jhDayData.getLthtdzotm())); + hyMttdzE.setAvltdz(Convert.toBigDecimal(jhDayData.getAvltdz())); + hyMttdzE.setHtltdz(Convert.toBigDecimal(jhDayData.getHtltdz())); + hyMttdzE.setHtltdzotm(DateUtils.parseDate(jhDayData.getHtltdzotm())); + hyMttdzE.setLtltdz(Convert.toBigDecimal(jhDayData.getLtltdz())); + hyMttdzE.setLtltdzotm(DateUtils.parseDate(jhDayData.getLtltdzotm())); + hyMttdzE.setAvftdr(Convert.toBigDecimal(jhDayData.getAvftdr())); + hyMttdzE.setMxfltdr(Convert.toBigDecimal(jhDayData.getMxfltdr())); + hyMttdzE.setMxfltdrhtm(DateUtils.parseDate(jhDayData.getMxfltdrhtm())); + hyMttdzE.setMnfltdr(Convert.toBigDecimal(jhDayData.getMnfltdr())); + hyMttdzE.setMnfltdrhtm(DateUtils.parseDate(jhDayData.getMnfltdrhtm())); + hyMttdzE.setAver(Convert.toBigDecimal(jhDayData.getAver())); + hyMttdzE.setMxebtdr(Convert.toBigDecimal(jhDayData.getMxebtdr())); + hyMttdzE.setMxebtdrht(DateUtils.parseDate(jhDayData.getMxebtdrht())); + hyMttdzE.setMnebtdr(Convert.toBigDecimal(jhDayData.getMnebtdr())); + hyMttdzE.setMnebtdrhtm(DateUtils.parseDate(jhDayData.getMnebtdrhtm())); + hyMttdzE.setAvftd(Convert.toInt(jhDayData.getAvftd())); + hyMttdzE.setMxfltddr(Convert.toInt(jhDayData.getMxfltddr())); + hyMttdzE.setMxfltddrhtm(DateUtils.parseDate(jhDayData.getMxfltddrhtm())); + hyMttdzE.setMnfltddr(Convert.toInt(jhDayData.getMnfltddr())); + hyMttdzE.setMnfltddrhtm(DateUtils.parseDate(jhDayData.getMnfltddrhtm())); + hyMttdzE.setAvebbdr(Convert.toInt(jhDayData.getAvebbdr())); + hyMttdzE.setMxebtddr(Convert.toInt(jhDayData.getMxebtddr())); + hyMttdzE.setMxebtddrhtm(DateUtils.parseDate(jhDayData.getMxebtddrhtm())); + hyMttdzE.setMnbtddr(Convert.toInt(jhDayData.getMnbtddr())); + hyMttdzE.setMnebtddrhtm(DateUtils.parseDate(jhDayData.getMnebtddrhtm())); + hyMttdzE.setHravtdz(Convert.toBigDecimal(jhDayData.getHravtdz())); + hyMttdzE.setAvtdr(Convert.toBigDecimal(jhDayData.getAvtdr())); + hyMttdzE.setAvtddr(Convert.toInt(jhDayData.getAvtddr())); + hyMttdzEList.add(hyMttdzE); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyMttdzEList); + stringRedisTemplate.opsForValue().set("MonthMtqs:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("MonthMtqs:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.MONTH_MTTDZ.value()); + } + + + /** + * 获取江河湖库月水面蒸发量表 + */ + @Override + @Scheduled(cron = "0 10 3 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getMonthMtweData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.MONTH_MTWE.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyMtweEList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyMtweE hyMtweE = new HyMtweE(); + hyMtweE.setStcd(jhDayData.getStcd()); + hyMtweE.setEetp(jhDayData.getEetp()); + hyMtweE.setYr(Convert.toInt(jhDayData.getYr())); + hyMtweE.setMth(Convert.toInt(jhDayData.getMth())); + hyMtweE.setWsfe(jhDayData.getWsfe()); + hyMtweE.setWsfercd(jhDayData.getWsfercd()); + hyMtweE.setMxdye(jhDayData.getMxdye()); + hyMtweE.setMxdyercd(jhDayData.getMxdyercd()); + hyMtweE.setMndye(jhDayData.getMndye()); + hyMtweE.setMndyercd(jhDayData.getMndyercd()); + + hyMtweEList.add(hyMtweE); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyMtweEList); + stringRedisTemplate.opsForValue().set("MonthMtwe:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("MonthMtwe:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.MONTH_MTWE.value()); + } + + + /** + * 获取江河湖库月水温表 + */ + @Override + @Scheduled(cron = "0 20 3 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getMonthMtwtData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.MONTH_MTWT.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyMtwtEList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyMtwtE hyMtwtE = new HyMtwtE(); + hyMtwtE.setStcd(jhDayData.getStcd()); + hyMtwtE.setYr(Convert.toInt(jhDayData.getYr())); + hyMtwtE.setMth(Convert.toInt(jhDayData.getMth())); + hyMtwtE.setAvwtmp(jhDayData.getAvwtmp()); + hyMtwtE.setAvwtmprcd(jhDayData.getAvwtmprcd()); + hyMtwtE.setMxwtmp(jhDayData.getMxwtmp()); + hyMtwtE.setMxwtmprcd(jhDayData.getMxwtmprcd()); + hyMtwtE.setMxwtmpdt(DateUtils.parseDate(jhDayData.getMxwtmpdt())); + hyMtwtE.setMnwtmp(jhDayData.getMnwtmp()); + hyMtwtE.setMnwtmprcd(jhDayData.getMnwtmprcd()); + hyMtwtE.setMnwtmpdt(DateUtils.parseDate(jhDayData.getMnwtmpdt())); + hyMtwtEList.add(hyMtwtE); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyMtwtEList); + stringRedisTemplate.opsForValue().set("MonthMtwt:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("MonthMtwt:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.MONTH_MTWT.value()); + } + + /** + * 获取江河湖库月河道水位表 + */ + @Override + @Scheduled(cron = "0 30 3 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getMonthRiverData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.MONTH_MTZ.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyMtzEList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyMtzE hyMtzE = new HyMtzE(); + hyMtzE.setStcd(jhDayData.getStcd()); + hyMtzE.setYr(Convert.toInt(jhDayData.getYr())); + hyMtzE.setMth(Convert.toInt(jhDayData.getMth())); + hyMtzE.setAvz(jhDayData.getAvz()); + hyMtzE.setAvzrcd(jhDayData.getAvzrcd()); + hyMtzE.setHtz(jhDayData.getHtz()); + hyMtzE.setHtzrcd(jhDayData.getHtzrcd()); + hyMtzE.setHtzdt(DateUtils.parseDate(jhDayData.getHtzdt())); + hyMtzE.setMnz(jhDayData.getMnz()); + hyMtzE.setMnzrcd(jhDayData.getMnzrcd()); + hyMtzE.setMnzdt(DateUtils.parseDate(jhDayData.getMnzdt())); + hyMtzEList.add(hyMtzE); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyMtzEList); + stringRedisTemplate.opsForValue().set("MonthRiver:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("MonthRiver:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.MONTH_RIVER.value()); + } + + + + + /** + * 获取江河湖库降水量摘录表 + */ + @Override + @Scheduled(cron = "0 40 3 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getHourRainData() { + List ycStations = getYcStations(); + String tableName = JhhkTableEnum.DP_PREX.value(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByBgtm(ycStation.getStcd(), startTime,endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyPrexBList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyPrexB hyPrexB = new HyPrexB(); + hyPrexB.setStcd(jhDayData.getStcd()); + hyPrexB.setBgtm(DateUtils.parseDate(jhDayData.getBgtm())); + hyPrexB.setEndtm(DateUtils.parseDate(jhDayData.getEndtm())); + hyPrexB.setP(jhDayData.getP()); + hyPrexB.setPrcd(jhDayData.getPrcd()); + hyPrexBList.add(hyPrexB); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyPrexBList); + stringRedisTemplate.opsForValue().set("HourRain:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("HourRain:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.DP_HOUR.value()); + } + + + /** + * 获取江河湖库水库洪水水位要素摘录表 + */ + @Override + @Scheduled(cron = "0 50 3 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getRvfhexData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DP_RVFHEX.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByTm(ycStation.getStcd(), startTime,endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyRvfhexBList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyRvfhexB hyRvfhexB = new HyRvfhexB(); + BeanUtils.copyProperties(jhDayData, hyRvfhexB); + hyRvfhexB.setTm(DateUtils.parseDate(jhDayData.getTm())); + hyRvfhexBList.add(hyRvfhexB); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyRvfhexBList); + stringRedisTemplate.opsForValue().set("DpRvfhex:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("DpRvfhex:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.DP_RVFHEX.value()); + } + + + + /** + * 获取江河湖库水闸洪水水文要素摘录表 + */ + @Override + @Scheduled(cron = "0 0 4 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getWsfhexData() { + List ycStations = getYcStations(); + String[] startAndEndTime = getStartAndEndTime(); + String startTime = startAndEndTime[1]; + String endTime = startAndEndTime[0]; + String tableName = JhhkTableEnum.DP_WSFHEX.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByTm(ycStation.getStcd(), startTime,endTime, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyWsfhexBList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyWsfhexB hyWsfhexB = new HyWsfhexB(); + BeanUtils.copyProperties(jhDayData, hyWsfhexB); + hyWsfhexB.setTm(DateUtils.parseDate(jhDayData.getTm())); + hyWsfhexBList.add(hyWsfhexB); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyWsfhexBList); + stringRedisTemplate.opsForValue().set("DpWsfhex:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("DpWsfhex:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.DP_WSFHEX.value()); + } + + + + + + /** + * 获取江河湖库年含沙量表 + */ + @Override + @Scheduled(cron = "0 10 4 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getYrcsData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.YEAR_YRCS.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyYrcsFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyYrcsF hyYrcsF = new HyYrcsF(); + BeanUtils.copyProperties(jhDayData, hyYrcsF); + hyYrcsF.setYr(Convert.toInt(jhDayData.getYr())); + hyYrcsF.setMxsdt(DateUtils.parseDate(jhDayData.getMxsdt())); + hyYrcsF.setMnsdt(DateUtils.parseDate(jhDayData.getMnsdt())); + hyYrcsFList.add(hyYrcsF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyYrcsFList); + stringRedisTemplate.opsForValue().set("YearYrcs:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("YearYrcs:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.YEAR_YRCS.value()); + } + + + /** + * 获取江河湖库年流量表 + */ + @Override + @Scheduled(cron = "0 20 4 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getYearQData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.YEAR_Q.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyYrqFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyYrqF hyYrqF = new HyYrqF(); + BeanUtils.copyProperties(jhDayData, hyYrqF); + hyYrqF.setYr(Convert.toInt(jhDayData.getYr())); + hyYrqF.setMxqdt(DateUtils.parseDate(jhDayData.getMxqdt())); + hyYrqF.setMnqdt(DateUtils.parseDate(jhDayData.getMnqdt())); + hyYrqFList.add(hyYrqF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyYrqFList); + stringRedisTemplate.opsForValue().set("YearQ:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("YearQ:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.YEAR_Q.value()); + } + + + + /** + * 获取江河湖库年降水表 + */ + @Override + @Scheduled(cron = "0 30 4 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getYearRainData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.YEAR_RAIN.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyYrpFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyYrpF hyYrpF = new HyYrpF(); + BeanUtils.copyProperties(jhDayData, hyYrpF); + hyYrpF.setYr(Convert.toInt(jhDayData.getYr())); + hyYrpF.setFrdsdt(DateUtils.parseDate(jhDayData.getFrdsdt())); + hyYrpF.setFrapdt(DateUtils.parseDate(jhDayData.getFrapdt())); + hyYrpF.setSndsdt(DateUtils.parseDate(jhDayData.getSndsdt())); + hyYrpF.setSnapdt(DateUtils.parseDate(jhDayData.getSnapdt())); + hyYrpFList.add(hyYrpF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyYrpFList); + stringRedisTemplate.opsForValue().set("YearRain:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("YearRain:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.YEAR_RAIN.value()); + } + + + /** + * 获取江河湖库年潮位表 + */ + @Override + @Scheduled(cron = "0 40 4 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getYearTideData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.YEAR_TIDE.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyYrtdzFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyYrtdzF hyYrtdzF = new HyYrtdzF(); + BeanUtils.copyProperties(jhDayData, hyYrtdzF); + hyYrtdzF.setYr(Convert.toInt(jhDayData.getYr())); + hyYrtdzF.setAvhtdz(Convert.toBigDecimal(jhDayData.getAvhtdz())); + hyYrtdzF.setHthtdz(Convert.toBigDecimal(jhDayData.getHthtdz())); + hyYrtdzF.setHthtdzotm(DateUtils.parseDate(jhDayData.getHthtdzotm())); + hyYrtdzF.setLthtdz(Convert.toBigDecimal(jhDayData.getLthtdz())); + hyYrtdzF.setLthtdzotm(DateUtils.parseDate(jhDayData.getLthtdzotm())); + hyYrtdzF.setAvltdz(Convert.toBigDecimal(jhDayData.getAvltdz())); + hyYrtdzF.setHtltdz(Convert.toBigDecimal(jhDayData.getHtltdz())); + hyYrtdzF.setHtltdzotm(DateUtils.parseDate(jhDayData.getHtltdzotm())); + hyYrtdzF.setLtltdz(Convert.toBigDecimal(jhDayData.getLtltdz())); + hyYrtdzF.setLtltdzotm(DateUtils.parseDate(jhDayData.getLtltdzotm())); + hyYrtdzF.setAvftdr(Convert.toBigDecimal(jhDayData.getAvftdr())); + hyYrtdzF.setMxfltdr(Convert.toBigDecimal(jhDayData.getMxfltdr())); + hyYrtdzF.setMxfltdrhtm(DateUtils.parseDate(jhDayData.getMxfltdrhtm())); + hyYrtdzF.setMnfltdr(Convert.toBigDecimal(jhDayData.getMnfltdr())); + hyYrtdzF.setMnfltdrhtm(DateUtils.parseDate(jhDayData.getMnfltdrhtm())); + hyYrtdzF.setAver(Convert.toBigDecimal(jhDayData.getAver())); + hyYrtdzF.setMxebtdr(Convert.toBigDecimal(jhDayData.getMxebtdr())); + hyYrtdzF.setMxebtdrht(DateUtils.parseDate(jhDayData.getMxebtdrht())); + hyYrtdzF.setMnebtdr(Convert.toBigDecimal(jhDayData.getMnebtdr())); + hyYrtdzF.setMnebtdrhtm(DateUtils.parseDate(jhDayData.getMnebtdrhtm())); + hyYrtdzF.setAvftd(Convert.toInt(jhDayData.getAvftd())); + hyYrtdzF.setMxfltddr(Convert.toInt(jhDayData.getMxfltddr())); + hyYrtdzF.setMxfltddrhtm(DateUtils.parseDate(jhDayData.getMxfltddrhtm())); + hyYrtdzF.setMnfltddr(Convert.toInt(jhDayData.getMnfltddr())); + hyYrtdzF.setMnfltddrhtm(DateUtils.parseDate(jhDayData.getMnfltddrhtm().split("\\.")[0])); + hyYrtdzF.setAvebbdr(Convert.toInt(jhDayData.getAvebbdr())); + hyYrtdzF.setMxebtddr(Convert.toInt(jhDayData.getMxebtddr())); + hyYrtdzF.setMxebtddrhtm(DateUtils.parseDate(jhDayData.getMxebtddrhtm())); + hyYrtdzF.setMnbtddr(Convert.toInt(jhDayData.getMnbtddr())); + hyYrtdzF.setMnebtddrhtm(DateUtils.parseDate(jhDayData.getMnebtddrhtm())); + hyYrtdzF.setHravtdz(Convert.toBigDecimal(jhDayData.getHravtdz())); + hyYrtdzF.setAvtdr(Convert.toBigDecimal(jhDayData.getAvtdr())); + hyYrtdzF.setAvtddr(Convert.toInt(jhDayData.getAvtddr())); + hyYrtdzFList.add(hyYrtdzF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyYrtdzFList); + stringRedisTemplate.opsForValue().set("YearTide:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("YearTide:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.YEAR_TIDE.value()); + } + + + /** + * 获取江河湖库年水面蒸发量表 + */ + @Override + @Scheduled(cron = "0 50 4 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getYearMtweData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.YEAR_YRWE.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyYrweFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyYrweF hyYrweF = new HyYrweF(); + BeanUtils.copyProperties(jhDayData, hyYrweF); + hyYrweF.setYr(Convert.toInt(jhDayData.getYr())); + hyYrweF.setWsfe(Convert.toBigDecimal(jhDayData.getWsfe())); + hyYrweF.setMxdye(Convert.toBigDecimal(jhDayData.getMxdye())); + hyYrweF.setMxdyeodt(DateUtils.parseDate(jhDayData.getMxdyeodt())); + hyYrweF.setMndye(Convert.toBigDecimal(jhDayData.getMndye())); + hyYrweF.setMndyeodt(DateUtils.parseDate(jhDayData.getMndyeodt())); + hyYrweF.setIdsdt(DateUtils.parseDate(jhDayData.getIdsdt())); + hyYrweF.setIcapd(DateUtils.parseDate(jhDayData.getIcapd())); + hyYrweFList.add(hyYrweF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyYrweFList); + stringRedisTemplate.opsForValue().set("YearWe:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("YearWe:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.YEAR_YRWE.value()); + } + + + /** + * 获取江河湖库年水温表 + */ + @Override + @Scheduled(cron = "0 0 5 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getYearWtData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.YEAR_YRWT.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyYrwtFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyYrwtF hyYrwtF = new HyYrwtF(); + BeanUtils.copyProperties(jhDayData, hyYrwtF); + hyYrwtF.setYr(Convert.toInt(jhDayData.getYr())); + hyYrwtF.setAvwtmp(Convert.toBigDecimal(jhDayData.getAvwtmp())); + hyYrwtF.setMxwtmp(Convert.toBigDecimal(jhDayData.getMxwtmp())); + hyYrwtF.setMnwtmp(Convert.toBigDecimal(jhDayData.getMnwtmp())); + hyYrwtF.setMnwtmpdt(DateUtils.parseDate(jhDayData.getMnwtmpdt())); + hyYrwtFList.add(hyYrwtF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyYrwtFList); + stringRedisTemplate.opsForValue().set("YearWt:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("YearWt:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.YEAR_YRWT.value()); + } + + + /** + * 获取江河湖库河道年水位表 + */ + @Override + @Scheduled(cron = "0 10 5 18 * ?") + @DataSource(DataSourceType.SLAVE) + public void getYearYrzData() { + List ycStations = getYcStations(); + String year = getNowYear(); + String tableName = JhhkTableEnum.YEAR_YRZ.value(); + List stcds = new ArrayList<>(); + for (HyStscA ycStation : ycStations) { + List jhDayDataList = timeTasksMapper.getDataByYr(ycStation.getStcd(), year, tableName); + if (jhDayDataList == null || jhDayDataList.isEmpty()) { + continue; + } + //匹配数据 + List hyYrzFList = new ArrayList<>(); + for (JHDayData jhDayData : jhDayDataList) { + HyYrzF hyYrzF = new HyYrzF(); + BeanUtils.copyProperties(jhDayData, hyYrzF); + hyYrzF.setYr(Convert.toInt(jhDayData.getYr())); + hyYrzF.setAvz(Convert.toBigDecimal(jhDayData.getAvz())); + hyYrzF.setHtz(Convert.toBigDecimal(jhDayData.getHtz())); + hyYrzF.setHtzdt(DateUtils.parseDate(jhDayData.getHtzdt())); + hyYrzF.setMnz(Convert.toBigDecimal(jhDayData.getMnz())); + hyYrzF.setMnzdt(DateUtils.parseDate(jhDayData.getMnzdt())); + hyYrzFList.add(hyYrzF); + } + //插入数据到redis中 + String jsonData = JSON.toJSONString(hyYrzFList); + stringRedisTemplate.opsForValue().set("YearRiver:"+ycStation.getStcd(), jsonData, 12, + TimeUnit.HOURS); + stcds.add("YearRiver:"+ycStation.getStcd()); + } + getDateService.insertRainData(stcds,SWTableEnum.YEAR_RIVER.value()); + } + + private static String getNowYear() { + return Convert.toStr(Year.now().getValue()); + } + + private List getYcStations() { + String ycStaionList = stringRedisTemplate.opsForValue().get("ycStation"); + return JSON.parseArray(ycStaionList, HyStscA.class); + } + + @Scheduled(cron = "0 0 23 * * ?") + @DataSource(DataSourceType.MASTER) + @Override + public void setYcStaions() { + stringRedisTemplate.delete("ycStation"); + + List ycStations = hyStscAService.list(); + //插入数据到redis中 + String jsonData = JSON.toJSONString(ycStations); + stringRedisTemplate.opsForValue().set("ycStation", jsonData); + } + + private static String[] getStartAndEndTime() { + DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + LocalDateTime endDate = LocalDateTime.now() + .withHour(0) + .withMinute(0) + .withSecond(0); + + LocalDateTime startDate = endDate.minusMonths(6); + return new String[]{ + endDate.format(formatter), // endTime + startDate.format(formatter) // startTime + }; + } + + +} diff --git a/swlscx/src/main/java/com/ruoyi/swlscx/year/service/HyYrzFService.java b/swlscx/src/main/java/com/ruoyi/swlscx/year/service/HyYrzFService.java index 691d72f..35a3ae9 100644 --- a/swlscx/src/main/java/com/ruoyi/swlscx/year/service/HyYrzFService.java +++ b/swlscx/src/main/java/com/ruoyi/swlscx/year/service/HyYrzFService.java @@ -1,11 +1,13 @@ package com.ruoyi.swlscx.year.service; +import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.metadata.IPage; import com.baomidou.mybatisplus.extension.service.IService; import com.ruoyi.common.core.page.R; import com.ruoyi.swlscx.common.PageParams; import com.ruoyi.swlscx.year.domain.po.HyYrzF; import com.ruoyi.swlscx.year.domain.vo.HyYrzFVo; +import io.lettuce.core.ScanIterator; import org.springframework.web.multipart.MultipartFile; import javax.servlet.http.HttpServletResponse; @@ -32,4 +34,5 @@ public interface HyYrzFService extends IService { R exportYearWaterLeverList(HttpServletResponse response, String startTime, String endTime, String stcd, String stnm); R importDateTosoft(String startTime, String endTime); + } diff --git a/swlscx/src/main/resources/mapper/basic/HyStscAMapper.xml b/swlscx/src/main/resources/mapper/basic/HyStscAMapper.xml index 4acde65..ed1c620 100644 --- a/swlscx/src/main/resources/mapper/basic/HyStscAMapper.xml +++ b/swlscx/src/main/resources/mapper/basic/HyStscAMapper.xml @@ -58,55 +58,157 @@ and hme.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + order by hme.esstyr - - TRUNCATE TABLE hy_stsc_a_temp; + + TRUNCATE TABLE hy_stsc_a; + + insert into hy_stsc_a ( + stcd, stnm, stct, bshncd, hnnm, rvnm, obitmcd, addvcd, wrrgcd, + esstyr, esstmth, wdstyr, wdstmth, drar, flto, dstrvm, fdtmnm, + admag, admnst, stlc, lgtd, lttd, stgrd, frgrd, nt + ) values + ( + #{item.stcd}, #{item.stnm}, #{item.stct}, #{item.bshncd}, #{item.hnnm}, #{item.rvnm}, + #{item.obitmcd}, #{item.addvcd}, #{item.wrrgcd}, #{item.esstyr}, #{item.esstmth}, + #{item.wdstyr}, #{item.wdstmth}, #{item.drar}, #{item.flto}, #{item.dstrvm}, + #{item.fdtmnm}, #{item.admag}, #{item.admnst}, #{item.stlc}, #{item.lgtd}, + #{item.lttd}, #{item.stgrd}, #{item.frgrd}, #{item.nt} + ) + + + + + - MERGE INTO hy_stsc_a AS a - USING hy_stsc_a_temp AS temp - ON (a.stcd = temp.stcd) + MERGE INTO hy_stsc_a WITH (HOLDLOCK) AS a + USING ( + SELECT + + SELECT + #{item.stcd} AS stcd, + #{item.stnm} AS stnm, + #{item.stct} AS stct, + #{item.bshncd} AS bshncd, + #{item.hnnm} AS hnnm, + #{item.rvnm} AS rvnm, + #{item.obitmcd} AS obitmcd, + #{item.addvcd} AS addvcd, + #{item.wrrgcd} AS wrrgcd, + #{item.esstyr} AS esstyr, + #{item.esstmth} AS esstmth, + #{item.wdstyr} AS wdstyr, + #{item.wdstmth} AS wdstmth, + #{item.drar} AS drar, + #{item.flto} AS flto, + #{item.dstrvm} AS dstrvm, + #{item.fdtmnm} AS fdtmnm, + #{item.admag} AS admag, + #{item.admnst} AS admnst, + #{item.stlc} AS stlc, + #{item.lgtd} AS lgtd, + #{item.lttd} AS lttd, + #{item.stgrd} AS stgrd, + #{item.frgrd} AS frgrd, + #{item.nt} AS nt + + FROM (VALUES (0)) AS dummy(col) + ) AS temp ON (a.stcd = temp.stcd) WHEN MATCHED THEN UPDATE SET - a.stnm = temp.stnm, - a.stct = temp.stct, - a.bshncd = temp.bshncd, - a.hnnm = temp.hnnm, - a.rvnm = temp.rvnm, - a.obitmcd = temp.obitmcd, - a.addvcd = temp.addvcd, - a.wrrgcd = temp.wrrgcd, - a.esstyr = temp.esstyr, - a.esstmth = temp.esstmth, - a.wdstyr = temp.wdstyr, - a.wdstmth = temp.wdstmth, - a.drar = temp.drar, - a.flto = temp.flto, - a.dstrvm = temp.dstrvm, - a.fdtmnm = temp.fdtmnm, - a.admag = temp.admag, - a.admnst = temp.admnst, - a.stlc = temp.stlc, - a.lgtd = temp.lgtd, - a.lttd = temp.lttd, - a.stgrd = temp.stgrd, - a.frgrd = temp.frgrd, - a.nt = temp.nt - WHEN NOT MATCHED THEN - INSERT (stcd, stnm, stct, bshncd, hnnm, rvnm, obitmcd, addvcd, wrrgcd, esstyr, esstmth, wdstyr, wdstmth, drar, flto, dstrvm, fdtmnm, admag, admnst, stlc, lgtd, lttd, stgrd, frgrd, nt) - VALUES - (temp.stcd, temp.stnm, temp.stct, temp.bshncd, temp.hnnm, temp.rvnm, temp.obitmcd, temp.addvcd, temp.wrrgcd, temp.esstyr, temp.esstmth, temp.wdstyr, temp.wdstmth, temp.drar, temp.flto, temp.dstrvm, temp.fdtmnm, temp.admag, temp.admnst, temp.stlc, temp.lgtd, temp.lttd, temp.stgrd, temp.frgrd, temp.nt); + a.stnm = temp.stnm, + a.stct = temp.stct, + a.bshncd = temp.bshncd, + a.hnnm = temp.hnnm, + a.rvnm = temp.rvnm, + a.obitmcd = temp.obitmcd, + a.addvcd = temp.addvcd, + a.wrrgcd = temp.wrrgcd, + a.esstyr = temp.esstyr, + a.esstmth = temp.esstmth, + a.wdstyr = temp.wdstyr, + a.wdstmth = temp.wdstmth, + a.drar = temp.drar, + a.flto = temp.flto, + a.dstrvm = temp.dstrvm, + a.fdtmnm = temp.fdtmnm, + a.admag = temp.admag, + a.admnst = temp.admnst, + a.stlc = temp.stlc, + a.lgtd = temp.lgtd, + a.lttd = temp.lttd, + a.stgrd = temp.stgrd, + a.frgrd = temp.frgrd, + a.nt = temp.nt + WHEN NOT MATCHED BY TARGET THEN + INSERT ( + stcd, stnm, stct, bshncd, hnnm, rvnm, obitmcd, addvcd, wrrgcd, + esstyr, esstmth, wdstyr, wdstmth, drar, flto, dstrvm, fdtmnm, + admag, admnst, stlc, lgtd, lttd, stgrd, frgrd, nt + ) VALUES ( + temp.stcd, temp.stnm, temp.stct, temp.bshncd, temp.hnnm, temp.rvnm, + temp.obitmcd, temp.addvcd, temp.wrrgcd, temp.esstyr, temp.esstmth, + temp.wdstyr, temp.wdstmth, temp.drar, temp.flto, temp.dstrvm, temp.fdtmnm, + temp.admag, temp.admnst, temp.stlc, temp.lgtd, temp.lttd, temp.stgrd, + temp.frgrd, temp.nt + ) + + + + + + + + + diff --git a/swlscx/src/main/resources/mapper/basic/YcExportTaskMapper.xml b/swlscx/src/main/resources/mapper/basic/YcExportTaskMapper.xml index b8073b9..97f5078 100644 --- a/swlscx/src/main/resources/mapper/basic/YcExportTaskMapper.xml +++ b/swlscx/src/main/resources/mapper/basic/YcExportTaskMapper.xml @@ -16,4 +16,53 @@ + + + + + INSERT INTO hy_stsc_a ( + stcd, stnm, stct, bshncd, hnnm, rvnm, obitmcd, + addvcd, wrrgcd, esstyr, esstmth, wdstyr, wdstmth, + drar, flto, dstrvm, fdtmnm, admag, admnst, stlc, + lgtd, lttd, stgrd, frgrd, nt + ) + VALUES + + ( + #{item.stcd}, #{item.stnm}, #{item.stct}, #{item.bshncd}, + #{item.hnnm}, #{item.rvnm}, #{item.obitmcd}, #{item.addvcd}, + #{item.wrrgcd}, #{item.esstyr}, #{item.esstmth}, #{item.wdstyr}, + #{item.wdstmth}, #{item.drar}, #{item.flto}, #{item.dstrvm}, + #{item.fdtmnm}, #{item.admag}, #{item.admnst}, #{item.stlc}, + #{item.lgtd}, #{item.lttd}, #{item.stgrd}, #{item.frgrd}, #{item.nt} + ) + + ON DUPLICATE KEY UPDATE + stnm = VALUES(stnm), + stct = VALUES(stct), + bshncd = VALUES(bshncd), + hnnm = VALUES(hnnm), + rvnm = VALUES(rvnm), + obitmcd = VALUES(obitmcd), + addvcd = VALUES(addvcd), + wrrgcd = VALUES(wrrgcd), + esstyr = VALUES(esstyr), + esstmth = VALUES(esstmth), + wdstyr = VALUES(wdstyr), + wdstmth = VALUES(wdstmth), + drar = VALUES(drar), + flto = VALUES(flto), + dstrvm = VALUES(dstrvm), + fdtmnm = VALUES(fdtmnm), + admag = VALUES(admag), + admnst = VALUES(admnst), + stlc = VALUES(stlc), + lgtd = VALUES(lgtd), + lttd = VALUES(lttd), + stgrd = VALUES(stgrd), + frgrd = VALUES(frgrd), + nt = VALUES(nt) + diff --git a/swlscx/src/main/resources/mapper/day/HyDcsFMapper.xml b/swlscx/src/main/resources/mapper/day/HyDcsFMapper.xml index cdd5add..7495b51 100644 --- a/swlscx/src/main/resources/mapper/day/HyDcsFMapper.xml +++ b/swlscx/src/main/resources/mapper/day/HyDcsFMapper.xml @@ -44,8 +44,11 @@ and hme.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.dt >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/day/HyDpCMapper.xml b/swlscx/src/main/resources/mapper/day/HyDpCMapper.xml index 917c504..ea76a02 100644 --- a/swlscx/src/main/resources/mapper/day/HyDpCMapper.xml +++ b/swlscx/src/main/resources/mapper/day/HyDpCMapper.xml @@ -50,8 +50,10 @@ and hme.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.dt >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/day/HyDqCMapper.xml b/swlscx/src/main/resources/mapper/day/HyDqCMapper.xml index 0ce0e75..0f0d79c 100644 --- a/swlscx/src/main/resources/mapper/day/HyDqCMapper.xml +++ b/swlscx/src/main/resources/mapper/day/HyDqCMapper.xml @@ -47,8 +47,10 @@ and hme.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.dt >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/day/HyDweCMapper.xml b/swlscx/src/main/resources/mapper/day/HyDweCMapper.xml index 8116bde..ad6cfd0 100644 --- a/swlscx/src/main/resources/mapper/day/HyDweCMapper.xml +++ b/swlscx/src/main/resources/mapper/day/HyDweCMapper.xml @@ -53,8 +53,10 @@ and hme.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.dt >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/day/HyDwtCMapper.xml b/swlscx/src/main/resources/mapper/day/HyDwtCMapper.xml index 5574c3b..44a3db0 100644 --- a/swlscx/src/main/resources/mapper/day/HyDwtCMapper.xml +++ b/swlscx/src/main/resources/mapper/day/HyDwtCMapper.xml @@ -16,8 +16,11 @@ and hme.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.dt >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/day/HyDzCMapper.xml b/swlscx/src/main/resources/mapper/day/HyDzCMapper.xml index 8e3e177..ae3ff57 100644 --- a/swlscx/src/main/resources/mapper/day/HyDzCMapper.xml +++ b/swlscx/src/main/resources/mapper/day/HyDzCMapper.xml @@ -48,8 +48,10 @@ and hme.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.dt >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/day/HyZscsBMapper.xml b/swlscx/src/main/resources/mapper/day/HyZscsBMapper.xml new file mode 100644 index 0000000..f6bccb1 --- /dev/null +++ b/swlscx/src/main/resources/mapper/day/HyZscsBMapper.xml @@ -0,0 +1,38 @@ + + + + + + + diff --git a/swlscx/src/main/resources/mapper/excerpt/HyFdheexBMapper.xml b/swlscx/src/main/resources/mapper/excerpt/HyFdheexBMapper.xml index 7aea700..3661130 100644 --- a/swlscx/src/main/resources/mapper/excerpt/HyFdheexBMapper.xml +++ b/swlscx/src/main/resources/mapper/excerpt/HyFdheexBMapper.xml @@ -53,8 +53,11 @@ and hme.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.tm >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/excerpt/HyPrexBMapper.xml b/swlscx/src/main/resources/mapper/excerpt/HyPrexBMapper.xml index f03997b..0096584 100644 --- a/swlscx/src/main/resources/mapper/excerpt/HyPrexBMapper.xml +++ b/swlscx/src/main/resources/mapper/excerpt/HyPrexBMapper.xml @@ -49,8 +49,11 @@ and hme.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.bgtm >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/excerpt/HyRvfhexBMapper.xml b/swlscx/src/main/resources/mapper/excerpt/HyRvfhexBMapper.xml index 289a68b..4e38220 100644 --- a/swlscx/src/main/resources/mapper/excerpt/HyRvfhexBMapper.xml +++ b/swlscx/src/main/resources/mapper/excerpt/HyRvfhexBMapper.xml @@ -60,8 +60,11 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.tm >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/excerpt/HyWsfhexBMapper.xml b/swlscx/src/main/resources/mapper/excerpt/HyWsfhexBMapper.xml index 5b9640c..96e3017 100644 --- a/swlscx/src/main/resources/mapper/excerpt/HyWsfhexBMapper.xml +++ b/swlscx/src/main/resources/mapper/excerpt/HyWsfhexBMapper.xml @@ -21,8 +21,11 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.tm >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/month/HyMtcsEMapper.xml b/swlscx/src/main/resources/mapper/month/HyMtcsEMapper.xml index f3e61d3..3bf9e57 100644 --- a/swlscx/src/main/resources/mapper/month/HyMtcsEMapper.xml +++ b/swlscx/src/main/resources/mapper/month/HyMtcsEMapper.xml @@ -18,18 +18,15 @@ left join hy_stsc_a hsa on hme.stcd = hsa.stcd - + and hme.stcd in - + #{stcd} and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') - and hme.yr >= #{map.startYear} diff --git a/swlscx/src/main/resources/mapper/month/HyMtpEMapper.xml b/swlscx/src/main/resources/mapper/month/HyMtpEMapper.xml index c41f2e4..5d0ffe4 100644 --- a/swlscx/src/main/resources/mapper/month/HyMtpEMapper.xml +++ b/swlscx/src/main/resources/mapper/month/HyMtpEMapper.xml @@ -9,14 +9,10 @@ left join hy_stsc_a hsa on hme.stcd = hsa.stcd - - and hme.stcd in - - #{stcd} - - - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hsa.stnm like concat('%',#{map.stnm},'%') diff --git a/swlscx/src/main/resources/mapper/month/HyMtqEMapper.xml b/swlscx/src/main/resources/mapper/month/HyMtqEMapper.xml index dcd3529..be92e71 100644 --- a/swlscx/src/main/resources/mapper/month/HyMtqEMapper.xml +++ b/swlscx/src/main/resources/mapper/month/HyMtqEMapper.xml @@ -29,8 +29,11 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.yr >= #{map.startYear} diff --git a/swlscx/src/main/resources/mapper/month/HyMtqsEMapper.xml b/swlscx/src/main/resources/mapper/month/HyMtqsEMapper.xml index 2b92b9d..449df8e 100644 --- a/swlscx/src/main/resources/mapper/month/HyMtqsEMapper.xml +++ b/swlscx/src/main/resources/mapper/month/HyMtqsEMapper.xml @@ -29,14 +29,10 @@ left join hy_stsc_a hsa on hme.stcd = hsa.stcd - - and hme.stcd in - - #{stcd} - - - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hsa.stnm like concat('%',#{map.stnm},'%') diff --git a/swlscx/src/main/resources/mapper/month/HyMttdzEMapper.xml b/swlscx/src/main/resources/mapper/month/HyMttdzEMapper.xml index 94cd8ce..df537b0 100644 --- a/swlscx/src/main/resources/mapper/month/HyMttdzEMapper.xml +++ b/swlscx/src/main/resources/mapper/month/HyMttdzEMapper.xml @@ -92,17 +92,13 @@ left join hy_stsc_a hsa on hme.stcd = hsa.stcd - - and hme.stcd in - - #{stcd} - - and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.yr >= #{map.startYear} diff --git a/swlscx/src/main/resources/mapper/month/HyMtweEMapper.xml b/swlscx/src/main/resources/mapper/month/HyMtweEMapper.xml index 0deda7a..7943c76 100644 --- a/swlscx/src/main/resources/mapper/month/HyMtweEMapper.xml +++ b/swlscx/src/main/resources/mapper/month/HyMtweEMapper.xml @@ -30,15 +30,12 @@ left join hy_stsc_a hsa on hme.stcd = hsa.stcd - + and hme.stcd in - + #{stcd} - - and hme.stcd like concat('%',#{map.stcd},'%') - and hsa.stnm like concat('%',#{map.stnm},'%') diff --git a/swlscx/src/main/resources/mapper/month/HyMtwtEMapper.xml b/swlscx/src/main/resources/mapper/month/HyMtwtEMapper.xml index a437f32..f19b925 100644 --- a/swlscx/src/main/resources/mapper/month/HyMtwtEMapper.xml +++ b/swlscx/src/main/resources/mapper/month/HyMtwtEMapper.xml @@ -30,8 +30,11 @@ left join hy_stsc_a hsa on hme.stcd = hsa.stcd - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hsa.stnm like concat('%',#{map.stnm},'%') diff --git a/swlscx/src/main/resources/mapper/month/HyMtzEMapper.xml b/swlscx/src/main/resources/mapper/month/HyMtzEMapper.xml index bcae9d5..684afb4 100644 --- a/swlscx/src/main/resources/mapper/month/HyMtzEMapper.xml +++ b/swlscx/src/main/resources/mapper/month/HyMtzEMapper.xml @@ -21,17 +21,13 @@ left join hy_stsc_a hsa on hme.stcd = hsa.stcd - - and hme.stcd in - - #{stcd} - - and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.yr >= #{map.startYear} diff --git a/swlscx/src/main/resources/mapper/synchronousData/TimeTasksMapper.xml b/swlscx/src/main/resources/mapper/synchronousData/TimeTasksMapper.xml new file mode 100644 index 0000000..a3b46bd --- /dev/null +++ b/swlscx/src/main/resources/mapper/synchronousData/TimeTasksMapper.xml @@ -0,0 +1,1037 @@ + + + + + + + + + + + + + + + INSERT INTO ${tableName} (stcd, dt, p, prcd) + VALUES + + ( + #{item.stcd}, + #{item.dt}, + #{item.p}, + #{item.prcd} + ) + + ON DUPLICATE KEY UPDATE + p = VALUES(p), + prcd = VALUES(prcd) + + + + INSERT INTO ${tableName} (stcd, dt, avq, avqrcd) + VALUES + + ( + #{item.stcd}, + #{item.dt}, + #{item.avq}, + #{item.avqrcd} + ) + + ON DUPLICATE KEY UPDATE + avq = VALUES(avq), + avq = VALUES(avq) + + + + INSERT INTO ${tableName} (stcd,sdtp, dt, avqs, avqsrcd) + VALUES + + ( + #{item.stcd}, + #{item.sdtp}, + #{item.dt}, + #{item.avqs}, + #{item.avqsrcd} + ) + + ON DUPLICATE KEY UPDATE + avqs = VALUES(avqs), + avqsrcd = VALUES(avqsrcd) + + + + INSERT INTO ${tableName} (stcd, dt, avcs, avcsrcd) + VALUES + + ( + #{item.stcd}, + #{item.dt}, + #{item.avcs}, + #{item.avcsrcd} + ) + + ON DUPLICATE KEY UPDATE + avcs = VALUES(avcs), + avcsrcd = VALUES(avcsrcd) + + + + INSERT INTO ${tableName} (stcd, yr, bgdt, mxpdr,mxp,mxprc) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.bgdt}, + #{item.mxpdr}, + #{item.mxp}, + #{item.mxprc} + ) + + ON DUPLICATE KEY UPDATE + bgdt = VALUES(bgdt), + mxp = VALUES(mxp), + mxprc = VALUES(mxprc) + + + + INSERT INTO ${tableName} (stcd, dt, eetp, wsfe,wsfercd) + VALUES + + ( + #{item.stcd}, + #{item.dt}, + #{item.eetp}, + #{item.wsfe}, + #{item.wsfercd} + ) + + ON DUPLICATE KEY UPDATE + wsfe = VALUES(wsfe), + wsfercd = VALUES(wsfercd) + + + + + INSERT INTO ${tableName} (stcd, dt, wtmp, wtmprcd) + VALUES + + ( + #{item.stcd}, + #{item.dt}, + #{item.wtmp}, + #{item.wtmprcd} + ) + + ON DUPLICATE KEY UPDATE + wtmp = VALUES(wtmp), + wtmprcd = VALUES(wtmprcd) + + + + + INSERT INTO ${tableName} (stcd, dt, avz, avzrcd) + VALUES + + ( + #{item.stcd}, + #{item.dt}, + #{item.avz}, + #{item.avzrcd} + ) + + ON DUPLICATE KEY UPDATE + avz = VALUES(avz), + avzrcd = VALUES(avzrcd) + + + + + INSERT INTO ${tableName} (stcd, yr, bgdt, mxwdr,mxw,mxwrc) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.bgdt}, + #{item.mxwdr}, + #{item.mxw}, + #{item.mxwrc} + ) + + ON DUPLICATE KEY UPDATE + bgdt = VALUES(bgdt), + mxw = VALUES(mxw), + mxwrc = VALUES(mxwrc) + + + + + INSERT INTO ${tableName} (stcd, tm, z, zrcd,q,s) + VALUES + + ( + #{item.stcd}, + #{item.tm}, + #{item.z}, + #{item.zrcd}, + #{item.q}, + #{item.s} + ) + + ON DUPLICATE KEY UPDATE + z = VALUES(z), + zrcd = VALUES(zrcd), + q = VALUES(q), + s = VALUES(s) + + + + INSERT INTO ${tableName} (stcd, tm, tdtp, tdz,tdzrcd,tdrng,dr,nt) + VALUES + + ( + #{item.stcd}, + #{item.tm}, + #{item.tdtp}, + #{item.tdz}, + #{item.tdzrcd}, + #{item.tdrng}, + #{item.dr}, + #{item.nt} + ) + + ON DUPLICATE KEY UPDATE + tdtp = VALUES(tdtp), + tdz = VALUES(tdz), + tdzrcd = VALUES(tdzrcd), + tdrng = VALUES(tdrng), + dr = VALUES(dr), + nt = VALUES(nt) + + + + + INSERT INTO ${tableName} (stcd, yr, bgtm, mxpdr,mxp,mxprc) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.bgtm}, + #{item.mxpdr}, + #{item.mxp}, + #{item.mxprc} + ) + + ON DUPLICATE KEY UPDATE + bgtm = VALUES(bgtm), + mxp = VALUES(mxp), + mxprc = VALUES(mxprc) + + + + + + INSERT INTO ${tableName} (stcd, yr, bgdt, mxpdr,mxp,mxprc) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.bgdt}, + #{item.mxpdr}, + #{item.mxp}, + #{item.mxprc} + ) + + ON DUPLICATE KEY UPDATE + bgdt = VALUES(bgdt), + mxp = VALUES(mxp), + mxprc = VALUES(mxprc) + + + + + + INSERT INTO ${tableName} (stcd, yr, mth, avcs,avcsrcd,mxs,mxsrcd,mxsdt,mns,mnsrcd,mnsdt) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.mth}, + #{item.avcs}, + #{item.avcsrcd}, + #{item.mxs}, + #{item.mxsrcd}, + #{item.mxsdt}, + #{item.mns}, + #{item.mnsrcd}, + #{item.mnsdt} + ) + + ON DUPLICATE KEY UPDATE + avcs = VALUES(avcs), + avcsrcd = VALUES(avcsrcd), + mxs = VALUES(mxs), + mxsrcd = VALUES(mxsrcd), + mxsdt = VALUES(mxsdt), + mns = VALUES(mns), + mnsrcd = VALUES(mnsrcd), + mnsdt = VALUES(mnsdt) + + + + + + INSERT INTO ${tableName} (stcd, yr, mth, p,prcd,pdynum,pdynumrcd,mxdyp,mxdyprcd,mxdypodt) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.mth}, + #{item.p}, + #{item.prcd}, + #{item.pdynum}, + #{item.pdynumrcd}, + #{item.mxdyp}, + #{item.mxdyprcd}, + #{item.mxdypodt} + ) + + ON DUPLICATE KEY UPDATE + p = VALUES(p), + prcd = VALUES(prcd), + pdynum = VALUES(pdynum), + pdynumrcd = VALUES(pdynumrcd), + mxdyp = VALUES(mxdyp), + mxdyprcd = VALUES(mxdyprcd), + mxdypodt = VALUES(mxdypodt) + + + + + INSERT INTO ${tableName} (stcd, yr, mth, avq,avqrcd,mxq,mxqrcd,mxqdt,mnq,mnqrcd,mnqdt) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.mth}, + #{item.avq}, + #{item.avqrcd}, + #{item.mxq}, + #{item.mxqrcd}, + #{item.mxqdt}, + #{item.mnq}, + #{item.mnqrcd}, + #{item.mnqdt} + ) + + ON DUPLICATE KEY UPDATE + avq = VALUES(avq), + avqrcd = VALUES(avqrcd), + mxq = VALUES(mxq), + mxqrcd = VALUES(mxqrcd), + mxqdt = VALUES(mxqdt), + mnq = VALUES(mnq), + mnqrcd = VALUES(mnqrcd), + mnqdt = VALUES(mnqdt) + + + + + INSERT INTO ${tableName} (stcd, sdtp, yr,mth, avqs,avqsrcd,mxdyqs,mxdyqsrcd,mxdyqsodt) + VALUES + + ( + #{item.stcd}, + #{item.sdtp}, + #{item.yr}, + #{item.mth}, + #{item.avqs}, + #{item.avqsrcd}, + #{item.mxdyqs}, + #{item.mxdyqsrcd}, + #{item.mxdyqsodt} + ) + + ON DUPLICATE KEY UPDATE + avqs = VALUES(avqs), + avqsrcd = VALUES(avqsrcd), + mxdyqs = VALUES(mxdyqs), + mxdyqsrcd = VALUES(mxdyqsrcd), + mxdyqsodt = VALUES(mxdyqsodt) + + + + INSERT INTO ${tableName} (stcd, eetp, yr,mth, wsfe,wsfercd ,mxdye,mxdyercd,mndye,mndyercd) + VALUES + + ( + #{item.stcd}, + #{item.eetp}, + #{item.yr}, + #{item.mth}, + #{item.wsfe}, + #{item.wsfercd}, + #{item.mxdye}, + #{item.mxdyercd}, + #{item.mndye}, + #{item.mndyercd} + ) + + ON DUPLICATE KEY UPDATE + wsfe = VALUES(wsfe), + wsfercd = VALUES(wsfercd), + mxdye = VALUES(mxdye), + mxdyercd = VALUES(mxdyercd), + mndye = VALUES(mndye), + mndyercd = VALUES(mndyercd) + + + + + INSERT INTO ${tableName} (stcd, yr,mth, avwtmp,avwtmprcd ,mxwtmp,mxwtmprcd,mxwtmpdt,mnwtmp,mnwtmprcd,mnwtmpdt) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.mth}, + #{item.avwtmp}, + #{item.avwtmprcd}, + #{item.mxwtmp}, + #{item.mxwtmprcd}, + #{item.mxwtmpdt}, + #{item.mnwtmp}, + #{item.mnwtmprcd}, + #{item.mnwtmpdt} + ) + + ON DUPLICATE KEY UPDATE + avwtmp = VALUES(avwtmp), + avwtmprcd = VALUES(avwtmprcd), + mxwtmp = VALUES(mxwtmp), + mxwtmprcd = VALUES(mxwtmprcd), + mxwtmpdt = VALUES(mxwtmpdt), + mnwtmp = VALUES(mnwtmp), + mnwtmprcd = VALUES(mnwtmprcd), + mnwtmpdt = VALUES(mnwtmpdt) + + + + + INSERT INTO ${tableName} (stcd, yr,mth, avz,avzrcd ,htz,htzrcd,htzdt,mnz,mnzrcd,mnzdt) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.mth}, + #{item.avz}, + #{item.avzrcd}, + #{item.htz}, + #{item.htzrcd}, + #{item.htzdt}, + #{item.mnz}, + #{item.mnzrcd}, + #{item.mnzdt} + ) + + ON DUPLICATE KEY UPDATE + avz = VALUES(avz), + avzrcd = VALUES(avzrcd), + htz = VALUES(htz), + htzrcd = VALUES(htzrcd), + htzdt = VALUES(htzdt), + mnz = VALUES(mnz), + mnzrcd = VALUES(mnzrcd), + mnzdt = VALUES(mnzdt) + + + + + INSERT INTO ${tableName} (stcd, bgtm,endtm, p,prcd ) + VALUES + + ( + #{item.stcd}, + #{item.bgtm}, + #{item.endtm}, + #{item.p}, + #{item.prcd} + ) + + ON DUPLICATE KEY UPDATE + endtm = VALUES(endtm), + p = VALUES(p), + prcd = VALUES(prcd) + + + + INSERT INTO ${tableName} (stcd, tm,dambhdz, dambhdzrcd,q,s,w,nt ) + VALUES + + ( + #{item.stcd}, + #{item.tm}, + #{item.dambhdz}, + #{item.dambhdzrcd}, + #{item.q}, + #{item.s}, + #{item.w}, + #{item.nt} + ) + + ON DUPLICATE KEY UPDATE + dambhdz = VALUES(dambhdz), + dambhdzrcd = VALUES(dambhdzrcd), + q = VALUES(q), + s = VALUES(s), + w = VALUES(w), + nt = VALUES(nt) + + + + + INSERT INTO ${tableName} (stcd, tm,upz, upzrcd,dwz,dwzrcd,q,s ) + VALUES + + ( + #{item.stcd}, + #{item.tm}, + #{item.upz}, + #{item.upzrcd}, + #{item.dwz}, + #{item.dwzrcd}, + #{item.q}, + #{item.s} + ) + + ON DUPLICATE KEY UPDATE + upz = VALUES(upz), + upzrcd = VALUES(upzrcd), + dwz = VALUES(dwz), + dwzrcd = VALUES(dwzrcd), + q = VALUES(q), + s = VALUES(s) + + + + + INSERT INTO ${tableName} (stcd, yr, avcs, avcsrcd, mxs, mxsrcd, mxsdt, mns, mnsrcd, mnsdt ) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.avcs}, + #{item.avcsrcd}, + #{item.mxs}, + #{item.mxsrcd}, + #{item.mxsdt}, + #{item.mns}, + #{item.mnsrcd}, + #{item.mnsdt} + ) + + ON DUPLICATE KEY UPDATE + avcs = VALUES(avcs), + avcsrcd = VALUES(avcsrcd), + mxs = VALUES(mxs), + mxsrcd = VALUES(mxsrcd), + mxsdt = VALUES(mxsdt), + mns = VALUES(mns), + mnsrcd = VALUES(mnsrcd), + mnsdt = VALUES(mnsdt) + + + + + INSERT INTO ${tableName} (stcd, yr, avq, avqrcd, mxq, mxqrcd, mxqdt, mnq, mnqrcd, mnqdt, + rw, rwrcd, rm, rd) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.avq}, + #{item.avqrcd}, + #{item.mxq}, + #{item.mxqrcd}, + #{item.mxqdt}, + #{item.mnq}, + #{item.mnqrcd}, + #{item.mnqdt}, + #{item.rw}, + #{item.rwrcd}, + #{item.rm}, + #{item.rd} + ) + + ON DUPLICATE KEY UPDATE + avq = VALUES(avq), + avqrcd = VALUES(avqrcd), + mxq = VALUES(mxq), + mxqrcd = VALUES(mxqrcd), + mxqdt = VALUES(mxqdt), + mnq = VALUES(mnq), + mnqrcd = VALUES(mnqrcd), + mnqdt = VALUES(mnqdt), + rw = VALUES(rw), + rwrcd = VALUES(rwrcd), + rm = VALUES(rm), + rd = VALUES(rd) + + + + + INSERT INTO ${tableName} (stcd, yr, p, prcd,pdynum,pdynumrcd,frdsdt,frapdt,sndsdt,snapdt) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.p}, + #{item.prcd}, + #{item.pdynum}, + #{item.pdynumrcd}, + #{item.frdsdt}, + #{item.frapdt}, + #{item.sndsdt}, + #{item.snapdt} + ) + + ON DUPLICATE KEY UPDATE + p = VALUES(p), + prcd = VALUES(prcd), + pdynum = VALUES(pdynum), + pdynumrcd = VALUES(pdynumrcd), + frdsdt = VALUES(frdsdt), + frapdt = VALUES(frapdt), + sndsdt = VALUES(sndsdt), + snapdt = VALUES(snapdt) + + + + + INSERT INTO ${tableName} ( stcd, yr, avhtdz, avhtdzrcd, hthtdz, hthtdzrcd, hthtdzotm, + lthtdz, lthtdzrcd, lthtdzotm, avltdz, avltdzrcd, htltdz, htltdzrcd, + htltdzotm, ltltdz, ltltdzrcd, ltltdzotm, avftdr, avftdrrcd, mxfltdr, + mxfltdrrcd, mxfltdrhtm, mnfltdr, mnfltdrrcd, mnfltdrhtm, aver, + averbbrrcd, mxebtdr, mxebtdrrcd, mxebtdrht, mnebtdr, mnebtdrrcd, + mnebtdrhtm, avftd, avftdrcd, mxfltddr, mxfltddrrcd, mxfltddrhtm, + mnfltddr, mnfltddrrcd, mnfltddrhtm, avebbdr, avedrc, mxebtddr, + mxebtddrrcd, mxebtddrhtm, mnbtddr, mnebtddrrcd, mnebtddrhtm, + hravtdz, hravtdzrcd, avtdr, avtdrrcd, avtddr, avtddrrcd + ) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.avhtdz}, + #{item.avhtdzrcd}, + #{item.hthtdz}, + #{item.hthtdzrcd}, + #{item.hthtdzotm}, + #{item.lthtdz}, + #{item.lthtdzrcd}, + #{item.lthtdzotm}, + #{item.avltdz}, + #{item.avltdzrcd}, + #{item.htltdz}, + + #{item.htltdzrcd}, + #{item.htltdzotm}, + #{item.ltltdz}, + #{item.ltltdzrcd}, + #{item.ltltdzotm}, + #{item.avftdr}, + + #{item.avftdrrcd}, + #{item.mxfltdr}, + #{item.mxfltdrrcd}, + #{item.mxfltdrhtm}, + #{item.mnfltdr}, + #{item.mnfltdrrcd}, + #{item.mnfltdrhtm}, + #{item.aver}, + #{item.averbbrrcd}, + #{item.mxebtdr}, + #{item.mxebtdrrcd}, + #{item.mxebtdrht}, + #{item.mnebtdr}, + #{item.mnebtdrrcd}, + #{item.mnebtdrhtm}, + + #{item.avftd}, + #{item.avftdrcd}, + #{item.mxfltddr}, + #{item.mxfltddrrcd}, + #{item.mxfltddrhtm}, + #{item.mnfltddr}, + #{item.mnfltddrrcd}, + #{item.mnfltddrhtm}, + #{item.avebbdr}, + #{item.avedrc}, + #{item.mxebtddr}, + #{item.mxebtddrrcd}, + #{item.mxebtddrhtm}, + #{item.mnbtddr}, + #{item.mnebtddrrcd}, + #{item.mnebtddrhtm}, + #{item.hravtdz}, + #{item.hravtdzrcd}, + #{item.avtdr}, + #{item.avtdrrcd}, + #{item.avtddr}, + #{item.avtddrrcd} + + + ) + + ON DUPLICATE KEY UPDATE + avhtdz = VALUES(avhtdz), + avhtdzrcd = VALUES(avhtdzrcd), + hthtdz = VALUES(hthtdz), + hthtdzrcd = VALUES(hthtdzrcd), + hthtdzotm = VALUES(hthtdzotm), + lthtdz = VALUES(lthtdz), + lthtdzrcd = VALUES(lthtdzrcd), + lthtdzotm = VALUES(lthtdzotm), + avltdz = VALUES(avltdz), + avltdzrcd = VALUES(avltdzrcd), + htltdz = VALUES(htltdz), + htltdzrcd = VALUES(htltdzrcd), + htltdzotm = VALUES(htltdzotm), + ltltdz = VALUES(ltltdz), + ltltdzrcd = VALUES(ltltdzrcd), + ltltdzotm = VALUES(ltltdzotm), + avftdr = VALUES(avftdr), + avftdrrcd = VALUES(avftdrrcd), + mxfltdr = VALUES(mxfltdr), + mxfltdrrcd = VALUES(mxfltdrrcd), + mxfltdrhtm = VALUES(mxfltdrhtm), + mnfltdr = VALUES(mnfltdr), + mnfltdrrcd = VALUES(mnfltdrrcd), + mnfltdrhtm = VALUES(mnfltdrhtm), + aver = VALUES(aver), + averbbrrcd = VALUES(averbbrrcd), + mxebtdr = VALUES(mxebtdr), + mxebtdrrcd = VALUES(mxebtdrrcd), + mxebtdrht = VALUES(mxebtdrht), + mnebtdr = VALUES(mnebtdr), + mnebtdrrcd = VALUES(mnebtdrrcd), + mnebtdrhtm = VALUES(mnebtdrhtm), + avftd = VALUES(avftd), + avftdrcd = VALUES(avftdrcd), + mxfltddr = VALUES(mxfltddr), + mxfltddrrcd = VALUES(mxfltddrrcd), + mxfltddrhtm = VALUES(mxfltddrhtm), + mnfltddr = VALUES(mnfltddr), + mnfltddrrcd = VALUES(mnfltddrrcd), + mnfltddrhtm = VALUES(mnfltddrhtm), + avebbdr = VALUES(avebbdr), + avedrc = VALUES(avedrc), + mxebtddr = VALUES(mxebtddr), + mxebtddrrcd = VALUES(mxebtddrrcd), + mxebtddrhtm = VALUES(mxebtddrhtm), + mnbtddr = VALUES(mnbtddr), + mnebtddrrcd = VALUES(mnebtddrrcd), + mnebtddrhtm = VALUES(mnebtddrhtm), + hravtdz = VALUES(hravtdz), + hravtdzrcd = VALUES(hravtdzrcd), + avtdr = VALUES(avtdr), + avtdrrcd = VALUES(avtdrrcd), + avtddr = VALUES(avtddr), + avtddrrcd = VALUES(avtddrrcd) + + + + + + + INSERT INTO ${tableName} (stcd, + eetp, + yr, + wsfe, + wsfercd, + mxdye, + mxdyercd, + mxdyeodt, + mndye, + mndyercd, + mndyeodt, + idsdt, + icapd, + eslcch, + nt + ) + VALUES + + ( + #{item.stcd}, + #{item.eetp}, + #{item.yr}, + #{item.wsfe}, + #{item.wsfercd}, + #{item.mxdye}, + #{item.mxdyercd}, + #{item.mxdyeodt}, + #{item.mndye}, + #{item.mndyercd}, + #{item.mndyeodt}, + #{item.idsdt}, + #{item.icapd}, + #{item.eslcch}, + #{item.nt} + ) + + ON DUPLICATE KEY UPDATE + wsfe = VALUES(wsfe), + wsfercd = VALUES(wsfercd), + mxdye = VALUES(mxdye), + mxdyercd = VALUES(mxdyercd), + mxdyeodt = VALUES(mxdyeodt), + mndye = VALUES(mndye), + mndyercd = VALUES(mndyercd), + mndyeodt = VALUES(mndyeodt), + idsdt = VALUES(idsdt), + icapd = VALUES(icapd), + eslcch = VALUES(eslcch), + nt = VALUES(nt) + + + + + INSERT INTO ${tableName} (stcd, yr, avwtmp, avwtmprcd, mxwtmp, mxwtmprcd, mxwtmpdt, mnwtmp, mnwtmprcd, mnwtmpdt ) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.avwtmp}, + #{item.avwtmprcd}, + #{item.mxwtmp}, + #{item.mxwtmprcd}, + #{item.mxwtmpdt}, + #{item.mnwtmp}, + #{item.mnwtmprcd}, + #{item.mnwtmpdt} + ) + + ON DUPLICATE KEY UPDATE + avwtmp = VALUES(avwtmp), + avwtmprcd = VALUES(avwtmprcd), + mxwtmp = VALUES(mxwtmp), + mxwtmprcd = VALUES(mxwtmprcd), + mxwtmpdt = VALUES(mxwtmpdt), + mnwtmp = VALUES(mnwtmp), + mnwtmprcd = VALUES(mnwtmprcd), + mnwtmpdt = VALUES(mnwtmpdt) + + + + + INSERT INTO ${tableName} (stcd, yr, avz, avzrcd, htz, htzrcd, htzdt, mnz, mnzrcd, mnzdt ) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.avz}, + #{item.avzrcd}, + #{item.htz}, + #{item.htzrcd}, + #{item.htzdt}, + #{item.mnz}, + #{item.mnzrcd}, + #{item.mnzdt} + ) + + ON DUPLICATE KEY UPDATE + avz = VALUES(avz), + avzrcd = VALUES(avzrcd), + htz = VALUES(htz), + htzrcd = VALUES(htzrcd), + htzdt = VALUES(htzdt), + mnz = VALUES(mnz), + mnzrcd = VALUES(mnzrcd), + mnzdt = VALUES(mnzdt) + + + + + insert into ${tableName} (stcd, yr, wf, rfz, rzrcd) values + (#{item.stcd}, #{item.yr}, #{item.wf}, #{item.rfz}, #{item.rzrcd}) + + ON DUPLICATE KEY UPDATE + wf = VALUES(wf), + rfz = VALUES(rfz), + rzrcd = VALUES(rzrcd) + + + + + INSERT INTO ${tableName} ( stcd, yr,mth, avhtdz, avhtdzrcd, hthtdz, hthtdzrcd, hthtdzotm, + lthtdz, lthtdzrcd, lthtdzotm, avltdz, avltdzrcd, htltdz, htltdzrcd, + htltdzotm, ltltdz, ltltdzrcd, ltltdzotm, avftdr, avftdrrcd, mxfltdr, + mxfltdrrcd, mxfltdrhtm, mnfltdr, mnfltdrrcd, mnfltdrhtm, aver, + averbbrrcd, mxebtdr, mxebtdrrcd, mxebtdrht, mnebtdr, mnebtdrrcd, + mnebtdrhtm, avftd, avftdrcd, mxfltddr, mxfltddrrcd, mxfltddrhtm, + mnfltddr, mnfltddrrcd, mnfltddrhtm, avebbdr, avedrc, mxebtddr, + mxebtddrrcd, mxebtddrhtm, mnbtddr, mnebtddrrcd, mnebtddrhtm, + hravtdz, hravtdzrcd, avtdr, avtdrrcd, avtddr, avtddrrcd + ) + VALUES + + ( + #{item.stcd}, + #{item.yr}, + #{item.mth}, + #{item.avhtdz}, + #{item.avhtdzrcd}, + #{item.hthtdz}, + #{item.hthtdzrcd}, + #{item.hthtdzotm}, + #{item.lthtdz}, + #{item.lthtdzrcd}, + #{item.lthtdzotm}, + #{item.avltdz}, + #{item.avltdzrcd}, + #{item.htltdz}, + + #{item.htltdzrcd}, + #{item.htltdzotm}, + #{item.ltltdz}, + #{item.ltltdzrcd}, + #{item.ltltdzotm}, + #{item.avftdr}, + + #{item.avftdrrcd}, + #{item.mxfltdr}, + #{item.mxfltdrrcd}, + #{item.mxfltdrhtm}, + #{item.mnfltdr}, + #{item.mnfltdrrcd}, + #{item.mnfltdrhtm}, + #{item.aver}, + #{item.averbbrrcd}, + #{item.mxebtdr}, + #{item.mxebtdrrcd}, + #{item.mxebtdrht}, + #{item.mnebtdr}, + #{item.mnebtdrrcd}, + #{item.mnebtdrhtm}, + + #{item.avftd}, + #{item.avftdrcd}, + #{item.mxfltddr}, + #{item.mxfltddrrcd}, + #{item.mxfltddrhtm}, + #{item.mnfltddr}, + #{item.mnfltddrrcd}, + #{item.mnfltddrhtm}, + #{item.avebbdr}, + #{item.avedrc}, + #{item.mxebtddr}, + #{item.mxebtddrrcd}, + #{item.mxebtddrhtm}, + #{item.mnbtddr}, + #{item.mnebtddrrcd}, + #{item.mnebtddrhtm}, + #{item.hravtdz}, + #{item.hravtdzrcd}, + #{item.avtdr}, + #{item.avtdrrcd}, + #{item.avtddr}, + #{item.avtddrrcd} + + + ) + + ON DUPLICATE KEY UPDATE + avhtdz = VALUES(avhtdz), + avhtdzrcd = VALUES(avhtdzrcd), + hthtdz = VALUES(hthtdz), + hthtdzrcd = VALUES(hthtdzrcd), + hthtdzotm = VALUES(hthtdzotm), + lthtdz = VALUES(lthtdz), + lthtdzrcd = VALUES(lthtdzrcd), + lthtdzotm = VALUES(lthtdzotm), + avltdz = VALUES(avltdz), + avltdzrcd = VALUES(avltdzrcd), + htltdz = VALUES(htltdz), + htltdzrcd = VALUES(htltdzrcd), + htltdzotm = VALUES(htltdzotm), + ltltdz = VALUES(ltltdz), + ltltdzrcd = VALUES(ltltdzrcd), + ltltdzotm = VALUES(ltltdzotm), + avftdr = VALUES(avftdr), + avftdrrcd = VALUES(avftdrrcd), + mxfltdr = VALUES(mxfltdr), + mxfltdrrcd = VALUES(mxfltdrrcd), + mxfltdrhtm = VALUES(mxfltdrhtm), + mnfltdr = VALUES(mnfltdr), + mnfltdrrcd = VALUES(mnfltdrrcd), + mnfltdrhtm = VALUES(mnfltdrhtm), + aver = VALUES(aver), + averbbrrcd = VALUES(averbbrrcd), + mxebtdr = VALUES(mxebtdr), + mxebtdrrcd = VALUES(mxebtdrrcd), + mxebtdrht = VALUES(mxebtdrht), + mnebtdr = VALUES(mnebtdr), + mnebtdrrcd = VALUES(mnebtdrrcd), + mnebtdrhtm = VALUES(mnebtdrhtm), + avftd = VALUES(avftd), + avftdrcd = VALUES(avftdrcd), + mxfltddr = VALUES(mxfltddr), + mxfltddrrcd = VALUES(mxfltddrrcd), + mxfltddrhtm = VALUES(mxfltddrhtm), + mnfltddr = VALUES(mnfltddr), + mnfltddrrcd = VALUES(mnfltddrrcd), + mnfltddrhtm = VALUES(mnfltddrhtm), + avebbdr = VALUES(avebbdr), + avedrc = VALUES(avedrc), + mxebtddr = VALUES(mxebtddr), + mxebtddrrcd = VALUES(mxebtddrrcd), + mxebtddrhtm = VALUES(mxebtddrhtm), + mnbtddr = VALUES(mnbtddr), + mnebtddrrcd = VALUES(mnebtddrrcd), + mnebtddrhtm = VALUES(mnebtddrhtm), + hravtdz = VALUES(hravtdz), + hravtdzrcd = VALUES(hravtdzrcd), + avtdr = VALUES(avtdr), + avtdrrcd = VALUES(avtdrrcd), + avtddr = VALUES(avtddr), + avtddrrcd = VALUES(avtddrrcd) + + + + + diff --git a/swlscx/src/main/resources/mapper/year/HyDmxpFMapper.xml b/swlscx/src/main/resources/mapper/year/HyDmxpFMapper.xml index 01bedc9..5548da1 100644 --- a/swlscx/src/main/resources/mapper/year/HyDmxpFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyDmxpFMapper.xml @@ -14,8 +14,11 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyHmxpFMapper.xml b/swlscx/src/main/resources/mapper/year/HyHmxpFMapper.xml index 6bea113..78b01bd 100644 --- a/swlscx/src/main/resources/mapper/year/HyHmxpFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyHmxpFMapper.xml @@ -22,8 +22,11 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyImxfwFMapper.xml b/swlscx/src/main/resources/mapper/year/HyImxfwFMapper.xml index 40a8bfb..d6743c3 100644 --- a/swlscx/src/main/resources/mapper/year/HyImxfwFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyImxfwFMapper.xml @@ -14,8 +14,11 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyMmxpFMapper.xml b/swlscx/src/main/resources/mapper/year/HyMmxpFMapper.xml index 32edb86..dd49400 100644 --- a/swlscx/src/main/resources/mapper/year/HyMmxpFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyMmxpFMapper.xml @@ -22,8 +22,11 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyYrcsFMapper.xml b/swlscx/src/main/resources/mapper/year/HyYrcsFMapper.xml index 4035e14..d1d5d8b 100644 --- a/swlscx/src/main/resources/mapper/year/HyYrcsFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyYrcsFMapper.xml @@ -15,8 +15,10 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyYrpFMapper.xml b/swlscx/src/main/resources/mapper/year/HyYrpFMapper.xml index 2644456..4855023 100644 --- a/swlscx/src/main/resources/mapper/year/HyYrpFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyYrpFMapper.xml @@ -82,8 +82,11 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyYrqFMapper.xml b/swlscx/src/main/resources/mapper/year/HyYrqFMapper.xml index 01386bf..96fcc62 100644 --- a/swlscx/src/main/resources/mapper/year/HyYrqFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyYrqFMapper.xml @@ -27,8 +27,10 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyYrqsFMapper.xml b/swlscx/src/main/resources/mapper/year/HyYrqsFMapper.xml index d5fe4a9..8cd1bbf 100644 --- a/swlscx/src/main/resources/mapper/year/HyYrqsFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyYrqsFMapper.xml @@ -28,8 +28,10 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyYrtdzFMapper.xml b/swlscx/src/main/resources/mapper/year/HyYrtdzFMapper.xml index cb84299..4749531 100644 --- a/swlscx/src/main/resources/mapper/year/HyYrtdzFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyYrtdzFMapper.xml @@ -12,8 +12,11 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyYrweFMapper.xml b/swlscx/src/main/resources/mapper/year/HyYrweFMapper.xml index 54c44a2..6de709e 100644 --- a/swlscx/src/main/resources/mapper/year/HyYrweFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyYrweFMapper.xml @@ -28,8 +28,10 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyYrwtFMapper.xml b/swlscx/src/main/resources/mapper/year/HyYrwtFMapper.xml index 29074e3..ff26250 100644 --- a/swlscx/src/main/resources/mapper/year/HyYrwtFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyYrwtFMapper.xml @@ -23,8 +23,10 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.yr >= #{map.startTime} diff --git a/swlscx/src/main/resources/mapper/year/HyYrzFMapper.xml b/swlscx/src/main/resources/mapper/year/HyYrzFMapper.xml index 7d6c658..1cff47e 100644 --- a/swlscx/src/main/resources/mapper/year/HyYrzFMapper.xml +++ b/swlscx/src/main/resources/mapper/year/HyYrzFMapper.xml @@ -22,8 +22,10 @@ and hsa.stnm like concat('%',#{map.stnm},'%') - - and hme.stcd like concat('%',#{map.stcd},'%') + + and hme.stcd in + #{stcd} + and hme.yr >= #{map.startTime}