edb_info.go 43 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267
  1. package data
  2. import (
  3. "errors"
  4. "eta/eta_chart_lib/models"
  5. "eta/eta_chart_lib/models/data_manage"
  6. "eta/eta_chart_lib/services/alarm_msg"
  7. "eta/eta_chart_lib/utils"
  8. "fmt"
  9. "sort"
  10. "time"
  11. )
  12. // EdbInfoRefreshAllFromBaseBak
  13. // @author Roc
  14. // @datetime 2022-09-16 11:04:44
  15. // @description 全部刷新指标(切换到edb_lib服务),将原有的单个指标刷新,调整为批量多个指标刷新
  16. // DeprecatedTime 2023-10-23 09:38:19废弃
  17. // Deprecated
  18. func EdbInfoRefreshAllFromBaseBak(edbInfoIdList []int, refreshAll bool) (err error, errmsg string) {
  19. defer func() {
  20. if err != nil {
  21. fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg)
  22. go alarm_msg.SendAlarmMsg("EdbInfoRefreshFromBaseV2,Err"+err.Error()+";errMsg:"+errmsg, 3)
  23. //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers)
  24. }
  25. }()
  26. // 获取关联的基础指标
  27. newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr, err, errmsg := getRefreshEdbInfoListByIds(edbInfoIdList)
  28. if err != nil {
  29. return
  30. }
  31. var startDate string
  32. for _, bv := range newBaseEdbInfoArr {
  33. //source := bv.Source
  34. //edbInfoId := bv.EdbInfoId
  35. //edbCode := bv.EdbCode
  36. if bv.StartDate == "0000-00-00" {
  37. continue
  38. }
  39. //开始时间
  40. startDate = ``
  41. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  42. sTime, tmpErr := time.Parse(utils.FormatDate, bv.StartDate)
  43. if tmpErr != nil {
  44. err = tmpErr
  45. errmsg = err.Error()
  46. return
  47. }
  48. startDate = sTime.Format(utils.FormatDate)
  49. } else {
  50. sTime, tmpErr := time.Parse(utils.FormatDate, bv.EndDate)
  51. if tmpErr != nil {
  52. err = tmpErr
  53. errmsg = err.Error()
  54. return
  55. }
  56. frequency := bv.Frequency
  57. var limitDay int
  58. switch frequency {
  59. case "日度":
  60. limitDay = utils.DATA_REFRESH
  61. case "周度":
  62. limitDay = utils.DATA_REFRESH * 7
  63. case "月度":
  64. limitDay = utils.DATA_REFRESH * 30
  65. case "季度":
  66. limitDay = utils.DATA_REFRESH * 90
  67. case "年度":
  68. limitDay = utils.DATA_REFRESH * 365
  69. default:
  70. limitDay = utils.DATA_REFRESH
  71. }
  72. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  73. }
  74. result, tmpErr := RefreshEdbData(bv.EdbInfoId, bv.Source, bv.SubSource, bv.EdbCode, startDate)
  75. if tmpErr != nil {
  76. err = tmpErr
  77. fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err", time.Now())
  78. errmsg = "RefreshBaseEdbData Err:" + tmpErr.Error()
  79. return
  80. }
  81. if result.Ret != 200 {
  82. fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  83. errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  84. err = fmt.Errorf("刷新失败, err:", errmsg)
  85. return
  86. }
  87. //maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
  88. //if err != nil {
  89. // if err.Error() == utils.ErrNoRow() { //找不到数据,那么就进入到下一条数据做处理
  90. // continue
  91. // }
  92. // return err
  93. //}
  94. //if maxAndMinItem != nil {
  95. // err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
  96. // if err != nil {
  97. // return err
  98. // }
  99. //}
  100. fmt.Println("end newBaseEdbInfoArr:", bv, time.Now())
  101. }
  102. //刷新相关普通计算指标
  103. for _, v := range calculateArr {
  104. edbInfo := newCalculateMap[v]
  105. if edbInfo == nil {
  106. return
  107. }
  108. startDate = edbInfo.StartDate
  109. source := edbInfo.Source
  110. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  111. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  112. } else {
  113. if source == utils.DATA_SOURCE_CALCULATE {
  114. startDate = ``
  115. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  116. startDate = edbInfo.StartDate
  117. } else {
  118. sTime, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
  119. if tmpErr != nil {
  120. err = tmpErr
  121. errmsg = tmpErr.Error()
  122. return
  123. }
  124. frequency := edbInfo.Frequency
  125. var limitDay int
  126. switch frequency {
  127. case "日度":
  128. limitDay = utils.DATA_REFRESH
  129. case "周度":
  130. limitDay = utils.DATA_REFRESH * 7
  131. case "月度":
  132. limitDay = utils.DATA_REFRESH * 30
  133. case "季度":
  134. limitDay = utils.DATA_REFRESH * 90
  135. case "年度":
  136. limitDay = utils.DATA_REFRESH * 365
  137. default:
  138. limitDay = utils.DATA_REFRESH
  139. }
  140. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  141. }
  142. }
  143. }
  144. result, tmpErr := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  145. if tmpErr != nil {
  146. err = tmpErr
  147. fmt.Println(v, "RefreshEdbCalculateData err", time.Now())
  148. errmsg = "RefreshEdbCalculateData Err:" + tmpErr.Error()
  149. return
  150. }
  151. if result.Ret != 200 {
  152. fmt.Println(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  153. errmsg = fmt.Sprint(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  154. err = fmt.Errorf("刷新失败")
  155. return
  156. }
  157. }
  158. //刷新相关预测计算指标
  159. for _, v := range predictCalculateArr {
  160. edbInfo := newPredictCalculateMap[v]
  161. if edbInfo == nil {
  162. return
  163. }
  164. startDate = edbInfo.StartDate
  165. source := edbInfo.Source
  166. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  167. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  168. } else {
  169. if source == utils.DATA_SOURCE_PREDICT_CALCULATE {
  170. startDate = ``
  171. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  172. startDate = edbInfo.StartDate
  173. } else {
  174. sTime, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
  175. if tmpErr != nil {
  176. err = tmpErr
  177. errmsg = tmpErr.Error()
  178. return
  179. }
  180. frequency := edbInfo.Frequency
  181. var limitDay int
  182. switch frequency {
  183. case "日度":
  184. limitDay = utils.DATA_REFRESH
  185. case "周度":
  186. limitDay = utils.DATA_REFRESH * 7
  187. case "月度":
  188. limitDay = utils.DATA_REFRESH * 30
  189. case "季度":
  190. limitDay = utils.DATA_REFRESH * 90
  191. case "年度":
  192. limitDay = utils.DATA_REFRESH * 365
  193. default:
  194. limitDay = utils.DATA_REFRESH
  195. }
  196. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  197. }
  198. }
  199. }
  200. result, tmpErr := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  201. if tmpErr != nil {
  202. err = tmpErr
  203. fmt.Println(v, "RefreshPredictEdbCalculateData err", time.Now())
  204. errmsg = "RefreshPredictEdbCalculateData Err:" + tmpErr.Error()
  205. return
  206. }
  207. if result.Ret != 200 {
  208. fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  209. errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  210. err = fmt.Errorf("刷新失败")
  211. return
  212. }
  213. }
  214. // 4、更新动态环差值
  215. {
  216. predictEdbInfoIdList := make([]int, 0)
  217. for _, v := range newBasePredictEdbInfoArr {
  218. predictEdbInfoIdList = append(predictEdbInfoIdList, v.EdbInfoId)
  219. }
  220. fmt.Println("predictEdbConfCalculateMappingDetailList:", predictEdbInfoIdList)
  221. predictEdbConfCalculateMappingDetailList, tmpErr := data_manage.GetPredictEdbConfCalculateMappingDetailListByEdbInfoId(predictEdbInfoIdList)
  222. if tmpErr != nil {
  223. err = tmpErr
  224. errmsg = fmt.Sprint("更新动态环差值时,获取数据失败:" + err.Error())
  225. return
  226. }
  227. for _, bv := range predictEdbConfCalculateMappingDetailList {
  228. result, tmpErr := RefreshEdbData(bv.EdbInfoId, utils.DATA_SOURCE_PREDICT, utils.DATA_SUB_SOURCE_EDB, bv.EdbCode, "")
  229. if tmpErr != nil {
  230. err = tmpErr
  231. fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err", time.Now())
  232. errmsg = "RefreshBasePredictEdbData Err:" + err.Error()
  233. return
  234. }
  235. if result.Ret != 200 {
  236. fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  237. errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  238. err = errors.New("刷新失败:" + errmsg)
  239. return
  240. }
  241. fmt.Println("end predictEdbConfCalculateMappingDetailList:", bv, time.Now())
  242. }
  243. }
  244. //5、刷新相关预测计算指标
  245. for _, v := range predictCalculateArr {
  246. edbInfo := newPredictCalculateMap[v]
  247. if edbInfo == nil {
  248. return
  249. }
  250. startDate = edbInfo.StartDate
  251. source := edbInfo.Source
  252. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  253. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  254. } else {
  255. if source == utils.DATA_SOURCE_PREDICT_CALCULATE {
  256. startDate = ``
  257. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  258. startDate = edbInfo.StartDate
  259. } else {
  260. sTime, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
  261. if tmpErr != nil {
  262. err = tmpErr
  263. errmsg = tmpErr.Error()
  264. return
  265. }
  266. frequency := edbInfo.Frequency
  267. var limitDay int
  268. switch frequency {
  269. case "日度":
  270. limitDay = utils.DATA_REFRESH
  271. case "周度":
  272. limitDay = utils.DATA_REFRESH * 7
  273. case "月度":
  274. limitDay = utils.DATA_REFRESH * 30
  275. case "季度":
  276. limitDay = utils.DATA_REFRESH * 90
  277. case "年度":
  278. limitDay = utils.DATA_REFRESH * 365
  279. default:
  280. limitDay = utils.DATA_REFRESH
  281. }
  282. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  283. }
  284. }
  285. }
  286. result, tmpErr := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  287. if tmpErr != nil {
  288. err = tmpErr
  289. fmt.Println(v, "RefreshPredictEdbCalculateData err", time.Now())
  290. errmsg = "RefreshPredictEdbCalculateData Err:" + tmpErr.Error()
  291. return
  292. }
  293. if result.Ret != 200 {
  294. fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  295. errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  296. err = fmt.Errorf("刷新失败")
  297. return
  298. }
  299. }
  300. return
  301. }
  302. // getRefreshEdbInfoList 获取待更新的指标(普通基础指标、普通运算指标,预测运算指标)
  303. func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) {
  304. calculateList, err := data_manage.GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList)
  305. if err != nil && err.Error() != utils.ErrNoRow() {
  306. err = errors.New("GetEdbInfoAllCalculate Err:" + err.Error())
  307. return
  308. }
  309. // 获取指标信息
  310. edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
  311. if err != nil {
  312. err = errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error())
  313. return
  314. }
  315. baseEdbInfoArr := make([]*data_manage.EdbInfo, 0) // 基础普通指标
  316. calculateInfoArr := make([]*data_manage.EdbInfo, 0) //基础运算指标
  317. basePredictEdbInfoArr := make([]*data_manage.EdbInfo, 0) // 预测普通指标
  318. predictCalculateInfoArr := make([]*data_manage.EdbInfo, 0) //预测运算指标
  319. for _, baseEdbInfo := range edbInfoList {
  320. if baseEdbInfo.EdbInfoType == 0 { //普通指标
  321. switch baseEdbInfo.EdbType {
  322. case 1: //基础指标
  323. baseEdbInfoArr = append(baseEdbInfoArr, baseEdbInfo)
  324. case 2: //计算指标
  325. calculateList = append(calculateList, baseEdbInfo)
  326. }
  327. } else { //预测指标
  328. switch baseEdbInfo.EdbType {
  329. case 1: //基础指标
  330. basePredictEdbInfoArr = append(basePredictEdbInfoArr, baseEdbInfo)
  331. case 2: //计算指标
  332. predictCalculateInfoArr = append(predictCalculateInfoArr, baseEdbInfo)
  333. }
  334. }
  335. }
  336. // 计算指标
  337. for _, v := range calculateList {
  338. getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  339. if tmpErr != nil {
  340. err = tmpErr
  341. fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
  342. errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
  343. return
  344. }
  345. for _, tmpEdbInfo := range getBaseEdbInfoArr {
  346. switch tmpEdbInfo.EdbInfoType {
  347. case 0: //普通基础指标
  348. baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
  349. case 1: //预测基础指标
  350. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  351. }
  352. }
  353. for _, tmpEdbInfo := range getCalculateInfoArr {
  354. switch tmpEdbInfo.EdbInfoType {
  355. case 0: //普通运算指标
  356. calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
  357. case 1: //预测运算指标
  358. //predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  359. if tmpEdbInfo.EdbType == 1 { //预测普通指标
  360. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  361. } else {
  362. predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  363. }
  364. }
  365. }
  366. switch v.EdbInfoType {
  367. case 0: //普通运算指标
  368. calculateInfoArr = append(calculateInfoArr, v)
  369. case 1: //预测运算指标
  370. if v.EdbType == 1 { //预测普通指标
  371. basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
  372. } else {
  373. predictCalculateInfoArr = append(predictCalculateInfoArr, v)
  374. }
  375. }
  376. }
  377. // 预测计算指标
  378. for _, v := range predictCalculateInfoArr {
  379. getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  380. if tmpErr != nil {
  381. err = tmpErr
  382. fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
  383. errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
  384. return
  385. }
  386. for _, tmpEdbInfo := range getBaseEdbInfoArr {
  387. switch tmpEdbInfo.EdbInfoType {
  388. case 0: //普通基础指标
  389. baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
  390. case 1: //预测基础指标
  391. if tmpEdbInfo.EdbType == 1 { //预测普通指标
  392. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  393. } else {
  394. predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  395. }
  396. //basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  397. }
  398. }
  399. for _, tmpEdbInfo := range getCalculateInfoArr {
  400. switch tmpEdbInfo.EdbInfoType {
  401. case 0: //普通运算指标
  402. calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
  403. case 1: //预测运算指标
  404. if tmpEdbInfo.EdbType == 1 { //预测普通指标
  405. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  406. } else {
  407. predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  408. }
  409. //predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  410. }
  411. }
  412. switch v.EdbInfoType {
  413. case 0: //普通运算指标
  414. calculateInfoArr = append(calculateInfoArr, v)
  415. case 1: //预测运算指标
  416. if v.EdbType == 1 { //预测普通指标
  417. basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
  418. } else {
  419. predictCalculateInfoArr = append(predictCalculateInfoArr, v)
  420. }
  421. }
  422. }
  423. // 第一次的计算指标map
  424. newCalculateMap = make(map[int]*data_manage.EdbInfo)
  425. for _, v := range calculateInfoArr {
  426. if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
  427. calculateArr = append(calculateArr, v.EdbInfoId)
  428. }
  429. newCalculateMap[v.EdbInfoId] = v
  430. }
  431. // 基础预测指标
  432. if len(basePredictEdbInfoArr) > 0 {
  433. basePredictEdbInfoIdList := make([]int, 0)
  434. for _, v := range basePredictEdbInfoArr {
  435. basePredictEdbInfoIdList = append(basePredictEdbInfoIdList, v.EdbInfoId)
  436. }
  437. baseEdbInfoList, tmpErr := data_manage.GetPredictEdbInfoAllCalculate(basePredictEdbInfoIdList)
  438. if tmpErr != nil {
  439. err = tmpErr
  440. return
  441. }
  442. tmpCalculateList := make([]*data_manage.EdbInfo, 0)
  443. for _, v := range baseEdbInfoList {
  444. switch v.EdbType {
  445. case 1:
  446. baseEdbInfoArr = append(baseEdbInfoArr, v)
  447. case 2:
  448. // 如果不在第一次里面,那么在第二次 刷新预测指标的时候 需要加进去
  449. if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
  450. tmpCalculateList = append(tmpCalculateList, v)
  451. }
  452. }
  453. }
  454. // 这里是查询预测指标用到的 普通计算指标
  455. for _, v := range tmpCalculateList {
  456. getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  457. if tmpErr != nil {
  458. err = tmpErr
  459. fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
  460. errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
  461. return
  462. }
  463. // 基础指标
  464. for _, tmpEdbInfo := range getBaseEdbInfoArr {
  465. switch tmpEdbInfo.EdbInfoType {
  466. case 0: //普通基础指标
  467. baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
  468. case 1: //预测基础指标
  469. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  470. }
  471. }
  472. // 计算指标
  473. for _, tmpEdbInfo := range getCalculateInfoArr {
  474. switch tmpEdbInfo.EdbInfoType {
  475. case 0: //普通运算指标
  476. calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
  477. case 1: //预测运算指标
  478. if tmpEdbInfo.EdbType == 1 { //预测普通指标
  479. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  480. } else {
  481. predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  482. }
  483. }
  484. }
  485. switch v.EdbInfoType {
  486. case 0: //普通运算指标
  487. calculateInfoArr = append(calculateInfoArr, v)
  488. case 1: //预测运算指标
  489. if v.EdbType == 1 { //预测普通指标
  490. basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
  491. } else {
  492. predictCalculateInfoArr = append(predictCalculateInfoArr, v)
  493. }
  494. }
  495. }
  496. // 第二次计算指标的map
  497. for _, v := range calculateInfoArr {
  498. if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
  499. calculateArr = append(calculateArr, v.EdbInfoId)
  500. }
  501. newCalculateMap[v.EdbInfoId] = v
  502. }
  503. }
  504. // 普通基础指标去重
  505. newBaseEdbInfoArr = make([]*data_manage.EdbInfo, 0)
  506. baseMap := make(map[int]int)
  507. for _, v := range baseEdbInfoArr {
  508. if _, ok := baseMap[v.EdbInfoId]; !ok {
  509. newBaseEdbInfoArr = append(newBaseEdbInfoArr, v)
  510. }
  511. baseMap[v.EdbInfoId] = v.EdbInfoId
  512. }
  513. // 普通计算指标的id
  514. sort.Ints(calculateArr)
  515. // 普通预测指标去重
  516. newBasePredictEdbInfoArr = make([]*data_manage.EdbInfo, 0)
  517. basePredictMap := make(map[int]int)
  518. for _, v := range basePredictEdbInfoArr {
  519. if _, ok := basePredictMap[v.EdbInfoId]; !ok {
  520. newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, v)
  521. }
  522. basePredictMap[v.EdbInfoId] = v.EdbInfoId
  523. }
  524. // 预测计算指标去重
  525. newPredictCalculateMap = make(map[int]*data_manage.EdbInfo)
  526. for _, v := range predictCalculateInfoArr {
  527. if _, ok := newPredictCalculateMap[v.EdbInfoId]; !ok {
  528. predictCalculateArr = append(predictCalculateArr, v.EdbInfoId)
  529. }
  530. newPredictCalculateMap[v.EdbInfoId] = v
  531. }
  532. // 预测计算指标的id
  533. sort.Ints(predictCalculateArr)
  534. return
  535. }
  536. // GetEdbSourceByEdbInfoIdList 获取关联指标的来源
  537. func GetEdbSourceByEdbInfoIdList(chartEdbInfoMappingList []*models.ChartEdbInfoMapping) (sourceNameList, sourceNameEnList []string) {
  538. sourceNameList = make([]string, 0)
  539. sourceNameEnList = make([]string, 0)
  540. sourceMap := make(map[int]string)
  541. for _, v := range chartEdbInfoMappingList {
  542. // 指标类型:1:基础指标,2:计算指标
  543. if v.EdbType == 2 || v.EdbInfoCategoryType == 1 {
  544. //sourceMap[0] = "弘则研究"
  545. baseEdbInfoArr, _, _ := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  546. for _, baseEdbInfo := range baseEdbInfoArr {
  547. if baseEdbInfo.EdbInfoType == 0 { //普通指标才参与,预测指标不参与
  548. sourceMap[baseEdbInfo.Source] = baseEdbInfo.SourceName
  549. }
  550. }
  551. } else {
  552. sourceMap[v.Source] = v.SourceName
  553. }
  554. }
  555. for source, sourceName := range sourceMap {
  556. if utils.InArrayByInt([]int{utils.DATA_SOURCE_MANUAL}, source) {
  557. continue
  558. }
  559. sourceNameList = append(sourceNameList, sourceName)
  560. sourceNameEn, ok := utils.DataSourceEnMap[source]
  561. if !ok {
  562. sourceNameEn = sourceName
  563. }
  564. sourceNameEnList = append(sourceNameEnList, sourceNameEn)
  565. }
  566. //sourceNameList = append(sourceNameList, utils.ChartDefaultNameCn)
  567. //sourceNameEnList = append(sourceNameEnList, utils.ChartDefaultNameEn)
  568. // 图表来源
  569. conf, e := models.GetBusinessConf()
  570. if e != nil {
  571. return
  572. }
  573. if conf[models.BusinessConfCompanyName] != "" {
  574. sourceNameList = append(sourceNameList, conf[models.BusinessConfCompanyName])
  575. sourceNameEnList = append(sourceNameEnList, conf[models.BusinessConfCompanyName])
  576. }
  577. return
  578. }
  579. // edbInfoRefreshAll
  580. //
  581. // @Description: 指标刷新服务
  582. // @author: Roc
  583. // @datetime2023-10-23 11:04:30
  584. // @param refreshAll bool
  585. // @param newBaseEdbInfoArr []*data_manage.EdbInfo
  586. // @param newBasePredictEdbInfoArr []*data_manage.EdbInfo
  587. // @param newCalculateMap map[int]*data_manage.EdbInfo
  588. // @param newPredictCalculateMap map[int]*data_manage.EdbInfo
  589. // @param calculateArr []int
  590. // @param predictCalculateArr []int
  591. // @return err error
  592. // @return errmsg string
  593. func edbInfoRefreshAll(refreshAll bool, newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) (err error, errmsg string) {
  594. defer func() {
  595. if err != nil {
  596. fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg)
  597. go alarm_msg.SendAlarmMsg("EdbInfoRefreshFromBaseV2,Err"+err.Error()+";errMsg:"+errmsg, 3)
  598. //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers)
  599. }
  600. }()
  601. var startDate string
  602. for _, bv := range newBaseEdbInfoArr {
  603. //source := bv.Source
  604. //edbInfoId := bv.EdbInfoId
  605. //edbCode := bv.EdbCode
  606. if bv.StartDate == "0000-00-00" {
  607. continue
  608. }
  609. //开始时间
  610. startDate = ``
  611. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  612. sTime, tmpErr := time.Parse(utils.FormatDate, bv.StartDate)
  613. if tmpErr != nil {
  614. err = tmpErr
  615. errmsg = err.Error()
  616. return
  617. }
  618. startDate = sTime.Format(utils.FormatDate)
  619. } else {
  620. sTime, tmpErr := time.Parse(utils.FormatDate, bv.EndDate)
  621. if tmpErr != nil {
  622. err = tmpErr
  623. errmsg = err.Error()
  624. return
  625. }
  626. frequency := bv.Frequency
  627. var limitDay int
  628. switch frequency {
  629. case "日度":
  630. limitDay = utils.DATA_REFRESH
  631. case "周度":
  632. limitDay = utils.DATA_REFRESH * 7
  633. case "月度":
  634. limitDay = utils.DATA_REFRESH * 30
  635. case "季度":
  636. limitDay = utils.DATA_REFRESH * 90
  637. case "年度":
  638. limitDay = utils.DATA_REFRESH * 365
  639. default:
  640. limitDay = utils.DATA_REFRESH
  641. }
  642. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  643. }
  644. result, tmpErr := RefreshEdbData(bv.EdbInfoId, bv.Source, bv.SubSource, bv.EdbCode, startDate)
  645. if tmpErr != nil {
  646. err = tmpErr
  647. fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err", time.Now())
  648. errmsg = "RefreshBaseEdbData Err:" + tmpErr.Error()
  649. return
  650. }
  651. if result.Ret != 200 {
  652. fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  653. errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  654. err = fmt.Errorf("刷新失败, err:", errmsg)
  655. return
  656. }
  657. //maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
  658. //if err != nil {
  659. // if err.Error() == utils.ErrNoRow() { //找不到数据,那么就进入到下一条数据做处理
  660. // continue
  661. // }
  662. // return err
  663. //}
  664. //if maxAndMinItem != nil {
  665. // err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
  666. // if err != nil {
  667. // return err
  668. // }
  669. //}
  670. fmt.Println("end newBaseEdbInfoArr:", bv, time.Now())
  671. }
  672. //刷新相关普通计算指标
  673. for _, v := range calculateArr {
  674. edbInfo := newCalculateMap[v]
  675. if edbInfo == nil {
  676. return
  677. }
  678. startDate = edbInfo.StartDate
  679. source := edbInfo.Source
  680. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  681. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  682. } else {
  683. if source == utils.DATA_SOURCE_CALCULATE {
  684. startDate = ``
  685. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  686. startDate = edbInfo.StartDate
  687. } else {
  688. sTime, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
  689. if tmpErr != nil {
  690. err = tmpErr
  691. errmsg = tmpErr.Error()
  692. return
  693. }
  694. frequency := edbInfo.Frequency
  695. var limitDay int
  696. switch frequency {
  697. case "日度":
  698. limitDay = utils.DATA_REFRESH
  699. case "周度":
  700. limitDay = utils.DATA_REFRESH * 7
  701. case "月度":
  702. limitDay = utils.DATA_REFRESH * 30
  703. case "季度":
  704. limitDay = utils.DATA_REFRESH * 90
  705. case "年度":
  706. limitDay = utils.DATA_REFRESH * 365
  707. default:
  708. limitDay = utils.DATA_REFRESH
  709. }
  710. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  711. }
  712. }
  713. }
  714. result, tmpErr := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  715. if tmpErr != nil {
  716. err = tmpErr
  717. fmt.Println(v, "RefreshEdbCalculateData err", time.Now())
  718. errmsg = "RefreshEdbCalculateData Err:" + tmpErr.Error()
  719. return
  720. }
  721. if result.Ret != 200 {
  722. fmt.Println(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  723. errmsg = fmt.Sprint(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  724. err = fmt.Errorf("刷新失败")
  725. return
  726. }
  727. }
  728. //刷新相关预测计算指标
  729. for _, v := range predictCalculateArr {
  730. edbInfo := newPredictCalculateMap[v]
  731. if edbInfo == nil {
  732. return
  733. }
  734. startDate = edbInfo.StartDate
  735. source := edbInfo.Source
  736. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  737. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  738. } else {
  739. if source == utils.DATA_SOURCE_PREDICT_CALCULATE {
  740. startDate = ``
  741. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  742. startDate = edbInfo.StartDate
  743. } else {
  744. sTime, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
  745. if tmpErr != nil {
  746. err = tmpErr
  747. errmsg = tmpErr.Error()
  748. return
  749. }
  750. frequency := edbInfo.Frequency
  751. var limitDay int
  752. switch frequency {
  753. case "日度":
  754. limitDay = utils.DATA_REFRESH
  755. case "周度":
  756. limitDay = utils.DATA_REFRESH * 7
  757. case "月度":
  758. limitDay = utils.DATA_REFRESH * 30
  759. case "季度":
  760. limitDay = utils.DATA_REFRESH * 90
  761. case "年度":
  762. limitDay = utils.DATA_REFRESH * 365
  763. default:
  764. limitDay = utils.DATA_REFRESH
  765. }
  766. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  767. }
  768. }
  769. }
  770. result, tmpErr := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  771. if tmpErr != nil {
  772. err = tmpErr
  773. fmt.Println(v, "RefreshPredictEdbCalculateData err", time.Now())
  774. errmsg = "RefreshPredictEdbCalculateData Err:" + tmpErr.Error()
  775. return
  776. }
  777. if result.Ret != 200 {
  778. fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  779. errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  780. err = fmt.Errorf("刷新失败")
  781. return
  782. }
  783. }
  784. // 4、更新动态环差值
  785. {
  786. predictEdbInfoIdList := make([]int, 0)
  787. for _, v := range newBasePredictEdbInfoArr {
  788. predictEdbInfoIdList = append(predictEdbInfoIdList, v.EdbInfoId)
  789. }
  790. fmt.Println("predictEdbConfCalculateMappingDetailList:", predictEdbInfoIdList)
  791. predictEdbConfCalculateMappingDetailList, tmpErr := data_manage.GetPredictEdbConfCalculateMappingDetailListByEdbInfoId(predictEdbInfoIdList)
  792. if tmpErr != nil {
  793. err = tmpErr
  794. errmsg = fmt.Sprint("更新动态环差值时,获取数据失败:" + err.Error())
  795. return
  796. }
  797. for _, bv := range predictEdbConfCalculateMappingDetailList {
  798. result, tmpErr := RefreshEdbData(bv.EdbInfoId, utils.DATA_SOURCE_PREDICT, utils.DATA_SUB_SOURCE_EDB, bv.EdbCode, "")
  799. if tmpErr != nil {
  800. err = tmpErr
  801. fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err", time.Now())
  802. errmsg = "RefreshBasePredictEdbData Err:" + err.Error()
  803. return
  804. }
  805. if result.Ret != 200 {
  806. fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  807. errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  808. err = errors.New("刷新失败:" + errmsg)
  809. return
  810. }
  811. fmt.Println("end predictEdbConfCalculateMappingDetailList:", bv, time.Now())
  812. }
  813. }
  814. //5、刷新相关预测计算指标
  815. for _, v := range predictCalculateArr {
  816. edbInfo := newPredictCalculateMap[v]
  817. if edbInfo == nil {
  818. return
  819. }
  820. startDate = edbInfo.StartDate
  821. source := edbInfo.Source
  822. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  823. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  824. } else {
  825. if source == utils.DATA_SOURCE_PREDICT_CALCULATE {
  826. startDate = ``
  827. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  828. startDate = edbInfo.StartDate
  829. } else {
  830. sTime, tmpErr := time.Parse(utils.FormatDate, edbInfo.EndDate)
  831. if tmpErr != nil {
  832. err = tmpErr
  833. errmsg = tmpErr.Error()
  834. return
  835. }
  836. frequency := edbInfo.Frequency
  837. var limitDay int
  838. switch frequency {
  839. case "日度":
  840. limitDay = utils.DATA_REFRESH
  841. case "周度":
  842. limitDay = utils.DATA_REFRESH * 7
  843. case "月度":
  844. limitDay = utils.DATA_REFRESH * 30
  845. case "季度":
  846. limitDay = utils.DATA_REFRESH * 90
  847. case "年度":
  848. limitDay = utils.DATA_REFRESH * 365
  849. default:
  850. limitDay = utils.DATA_REFRESH
  851. }
  852. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  853. }
  854. }
  855. }
  856. result, tmpErr := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  857. if tmpErr != nil {
  858. err = tmpErr
  859. fmt.Println(v, "RefreshPredictEdbCalculateData err", time.Now())
  860. errmsg = "RefreshPredictEdbCalculateData Err:" + tmpErr.Error()
  861. return
  862. }
  863. if result.Ret != 200 {
  864. fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  865. errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  866. err = fmt.Errorf("刷新失败")
  867. return
  868. }
  869. }
  870. return
  871. }
  872. // EdbInfoRefreshAllFromBaseV3
  873. //
  874. // @Description: 全部刷新指标(切换到edb_lib服务)
  875. // @author: Roc
  876. // @datetime2023-10-23 09:57:55
  877. // @param edbInfoIdList []int
  878. // @param refreshAll bool
  879. // @param isSync bool
  880. // @return err error
  881. // @return isAsync bool
  882. func EdbInfoRefreshAllFromBase(edbInfoIdList []int, refreshAll bool) (err error, errMsg string) {
  883. defer func() {
  884. if err != nil {
  885. fmt.Println("EdbInfoRefreshAllFromBaseV3 Err:" + err.Error() + ";errMsg:" + errMsg)
  886. go alarm_msg.SendAlarmMsg("EdbInfoRefreshAllFromBaseV3,Err"+err.Error()+";errMsg:"+errMsg, 3)
  887. }
  888. }()
  889. traceEdbInfoList, err := TraceEdbInfoByEdbInfoIdList(edbInfoIdList)
  890. if err != nil {
  891. return
  892. }
  893. // existEdbInfoIdMap 已经处理了的指标id map
  894. existEdbInfoIdMap := make(map[int]int)
  895. // 基础指标
  896. newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
  897. newBasePredictEdbInfoArr := make([]*data_manage.EdbInfo, 0)
  898. newBaseMap := make(map[int]*data_manage.EdbInfo)
  899. newPredictBaseMap := make(map[int]*data_manage.EdbInfo)
  900. // 计算指标
  901. newCalculateMap := make(map[int]*data_manage.EdbInfo)
  902. newPredictCalculateMap := make(map[int]*data_manage.EdbInfo)
  903. calculateArr := make([]int, 0)
  904. predictCalculateArr := make([]int, 0)
  905. // 获取关联指标
  906. for _, traceEdbInfo := range traceEdbInfoList {
  907. tmpBaseEdbInfoArr, tmpBasePredictEdbInfoArr, tmpCalculateMap, tmpPredictCalculateMap, _, _ := getRefreshEdbInfoListByTraceEdbInfo(traceEdbInfo, existEdbInfoIdMap)
  908. // 普通基础指标
  909. for _, edbInfo := range tmpBaseEdbInfoArr {
  910. if _, ok := newBaseMap[edbInfo.EdbInfoId]; !ok {
  911. if edbInfo.NoUpdate == 1 {
  912. continue
  913. }
  914. newBaseMap[edbInfo.EdbInfoId] = edbInfo
  915. newBaseEdbInfoArr = append(newBaseEdbInfoArr, edbInfo)
  916. }
  917. }
  918. // 预测基础指标
  919. for _, edbInfo := range tmpBasePredictEdbInfoArr {
  920. if _, ok := newPredictBaseMap[edbInfo.EdbInfoId]; !ok {
  921. newPredictBaseMap[edbInfo.EdbInfoId] = edbInfo
  922. newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, edbInfo)
  923. }
  924. }
  925. // 普通计算指标
  926. for _, edbInfo := range tmpCalculateMap {
  927. if _, ok := newCalculateMap[edbInfo.EdbInfoId]; !ok {
  928. if edbInfo.NoUpdate == 1 {
  929. continue
  930. }
  931. newCalculateMap[edbInfo.EdbInfoId] = edbInfo
  932. calculateArr = append(calculateArr, edbInfo.EdbInfoId)
  933. }
  934. }
  935. // 预测计算指标
  936. for _, edbInfo := range tmpPredictCalculateMap {
  937. if _, ok := newPredictCalculateMap[edbInfo.EdbInfoId]; !ok {
  938. newPredictCalculateMap[edbInfo.EdbInfoId] = edbInfo
  939. predictCalculateArr = append(predictCalculateArr, edbInfo.EdbInfoId)
  940. }
  941. }
  942. }
  943. // 普通计算指标的id
  944. sort.Ints(calculateArr)
  945. // 预测计算指标的id
  946. sort.Ints(predictCalculateArr)
  947. // 需要刷新的指标数量
  948. totalEdbInfo := len(newBaseEdbInfoArr) + len(calculateArr) + len(predictCalculateArr) + len(newBasePredictEdbInfoArr)
  949. if totalEdbInfo == 0 {
  950. return
  951. }
  952. //if totalEdbInfo <= 20{
  953. // err,errMsg = edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
  954. //} else {
  955. // go edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
  956. //}
  957. err, errMsg = edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
  958. return
  959. }
  960. // getRefreshEdbInfoListByTraceEdbInfo
  961. //
  962. // @Description: 根据溯源获取关联指标(去掉重复指标id)
  963. // @author: Roc
  964. // @datetime2023-10-23 11:22:50
  965. // @param traceEdbInfo data_manage.TraceEdbInfoResp
  966. // @param existEdbInfoIdMap map[int]int
  967. // @return newBaseEdbInfoArr []*data_manage.EdbInfo
  968. // @return newBasePredictEdbInfoArr []*data_manage.EdbInfo
  969. // @return newCalculateMap map[int]*data_manage.EdbInfo
  970. // @return newPredictCalculateMap map[int]*data_manage.EdbInfo
  971. // @return calculateArr []int
  972. // @return predictCalculateArr []int
  973. func getRefreshEdbInfoListByTraceEdbInfo(traceEdbInfo data_manage.TraceEdbInfoResp, existEdbInfoIdMap map[int]int) (newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) {
  974. newBaseEdbInfoArr = make([]*data_manage.EdbInfo, 0)
  975. newBasePredictEdbInfoArr = make([]*data_manage.EdbInfo, 0)
  976. newCalculateMap = make(map[int]*data_manage.EdbInfo)
  977. newPredictCalculateMap = make(map[int]*data_manage.EdbInfo)
  978. calculateArr = make([]int, 0)
  979. predictCalculateArr = make([]int, 0)
  980. _, ok := existEdbInfoIdMap[traceEdbInfo.EdbInfoId]
  981. if ok {
  982. return
  983. }
  984. existEdbInfoIdMap[traceEdbInfo.EdbInfoId] = traceEdbInfo.EdbInfoId
  985. switch traceEdbInfo.EdbInfoType {
  986. //0-普通指标; 1-预测指标
  987. case 0: // 0-普通指标
  988. if traceEdbInfo.EdbType == 1 { //1-基础指标
  989. newBaseEdbInfoArr = append(newBaseEdbInfoArr, traceEdbInfo.EdbInfo)
  990. } else if traceEdbInfo.EdbType == 2 { //2-计算指标
  991. newCalculateMap[traceEdbInfo.EdbInfoId] = traceEdbInfo.EdbInfo
  992. calculateArr = append(calculateArr, traceEdbInfo.EdbInfoId)
  993. }
  994. case 1: // 1-预测指标
  995. if traceEdbInfo.EdbType == 1 { //1-基础指标
  996. newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, traceEdbInfo.EdbInfo)
  997. } else if traceEdbInfo.EdbType == 2 { //2-计算指标
  998. newPredictCalculateMap[traceEdbInfo.EdbInfoId] = traceEdbInfo.EdbInfo
  999. predictCalculateArr = append(predictCalculateArr, traceEdbInfo.EdbInfoId)
  1000. }
  1001. }
  1002. if traceEdbInfo.Child != nil && len(traceEdbInfo.Child) > 0 {
  1003. for _, v := range traceEdbInfo.Child {
  1004. tmpBaseEdbInfoArr, tmpPredictEdbInfoArr, tmpCalculateMap, tmpPredictCalculateMap, tmpCalculateArr, tmpPredictCalculateArr := getRefreshEdbInfoListByTraceEdbInfo(v, existEdbInfoIdMap)
  1005. newBaseEdbInfoArr = append(newBaseEdbInfoArr, tmpBaseEdbInfoArr...)
  1006. newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, tmpPredictEdbInfoArr...)
  1007. for k, tmpEdbInfo := range tmpCalculateMap {
  1008. newCalculateMap[k] = tmpEdbInfo
  1009. }
  1010. for k, tmpEdbInfo := range tmpPredictCalculateMap {
  1011. newPredictCalculateMap[k] = tmpEdbInfo
  1012. }
  1013. calculateArr = append(calculateArr, tmpCalculateArr...)
  1014. predictCalculateArr = append(predictCalculateArr, tmpPredictCalculateArr...)
  1015. }
  1016. }
  1017. return
  1018. }
  1019. // TraceEdbInfoByEdbInfoIdList
  1020. //
  1021. // @Description: 根据指标id列表返回指标追溯的列表
  1022. // @author: Roc
  1023. // @datetime2023-10-23 11:22:21
  1024. // @param edbInfoIdList []int
  1025. // @return traceEdbInfoList []data_manage.TraceEdbInfoResp
  1026. // @return err error
  1027. func TraceEdbInfoByEdbInfoIdList(edbInfoIdList []int) (traceEdbInfoList []data_manage.TraceEdbInfoResp, err error) {
  1028. traceEdbInfoList = make([]data_manage.TraceEdbInfoResp, 0)
  1029. edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
  1030. if err != nil {
  1031. return
  1032. }
  1033. edbInfoRuleMap := make(map[int]string, 0)
  1034. edbMappingMap := make(map[int][]*data_manage.EdbInfoCalculateMappingInfo)
  1035. findIdMap := make(map[int]int)
  1036. existMap := make(map[int]data_manage.TraceEdbInfoResp)
  1037. for _, edbInfo := range edbInfoList {
  1038. findIdMap[edbInfo.EdbInfoId] = edbInfo.EdbInfoId
  1039. //edbInfoRuleMap[edbInfoId] = getEdbRuleTitle(edbInfo)
  1040. traceEdbInfo := data_manage.TraceEdbInfoResp{
  1041. //EdbInfoId: edbInfo.EdbInfoId,
  1042. EdbInfoId: edbInfo.EdbInfoId,
  1043. EdbInfoType: edbInfo.EdbInfoType,
  1044. EdbName: edbInfo.EdbName,
  1045. EdbType: edbInfo.EdbType,
  1046. //Source: edbInfo.Source,
  1047. UniqueCode: edbInfo.UniqueCode,
  1048. ClassifyId: edbInfo.ClassifyId,
  1049. EdbInfo: edbInfo,
  1050. }
  1051. traceEdbInfo.Child, err = traceEdbInfoByEdbInfoId(edbInfo.EdbInfoId, traceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
  1052. traceEdbInfoList = append(traceEdbInfoList, traceEdbInfo)
  1053. }
  1054. //findEdbInfoIdList := make([]int, 0)
  1055. //for _, v := range findIdMap {
  1056. // findEdbInfoIdList = append(findEdbInfoIdList, v)
  1057. //}
  1058. //findEdbInfoList, err := data_manage.GetEdbInfoByIdList(findEdbInfoIdList)
  1059. //if err != nil {
  1060. // return
  1061. //}
  1062. //edbInfoMap := make(map[int]*data_manage.EdbInfo)
  1063. //for _, tmpEdbInfo := range findEdbInfoList {
  1064. // edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo
  1065. //}
  1066. //for k, traceEdbInfo := range traceEdbInfoList {
  1067. // traceEdbInfoList[k], err = handleTraceEdbInfo(traceEdbInfo, 0, edbInfoMap, edbMappingMap)
  1068. //}
  1069. return
  1070. }
  1071. // traceEdbInfoByEdbInfoId
  1072. //
  1073. // @Description: 指标追溯
  1074. // @author: Roc
  1075. // @datetime2023-10-23 11:21:54
  1076. // @param edbInfoId int
  1077. // @param traceEdbInfo data_manage.TraceEdbInfoResp
  1078. // @param edbInfoRuleMap map[int]string
  1079. // @param findIdMap map[int]int
  1080. // @param existMap map[int]data_manage.TraceEdbInfoResp
  1081. // @param edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo
  1082. // @return child []data_manage.TraceEdbInfoResp
  1083. // @return err error
  1084. func traceEdbInfoByEdbInfoId(edbInfoId int, traceEdbInfo data_manage.TraceEdbInfoResp, edbInfoRuleMap map[int]string, findIdMap map[int]int, existMap map[int]data_manage.TraceEdbInfoResp, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (child []data_manage.TraceEdbInfoResp, err error) {
  1085. traceEdbInfo, ok := existMap[edbInfoId]
  1086. if ok {
  1087. return
  1088. }
  1089. child = make([]data_manage.TraceEdbInfoResp, 0)
  1090. edbInfoMappingList, e := data_manage.GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId)
  1091. if e != nil {
  1092. err = fmt.Errorf("GetEdbInfoCalculateMappingListByEdbInfoId err: %s", e.Error())
  1093. return
  1094. }
  1095. // 指标信息map
  1096. edbInfoMap := make(map[int]*data_manage.EdbInfo)
  1097. if len(edbInfoMappingList) > 0 {
  1098. fromEdbInfoIdList := make([]int, 0)
  1099. for _, v := range edbInfoMappingList {
  1100. fromEdbInfoIdList = append(fromEdbInfoIdList, v.FromEdbInfoId)
  1101. }
  1102. edbInfoList, tmpErr := data_manage.GetEdbInfoByIdList(fromEdbInfoIdList)
  1103. if tmpErr != nil {
  1104. err = fmt.Errorf("traceEdbInfoByEdbInfoId GetEdbInfoByIdList err: %s", tmpErr.Error())
  1105. return
  1106. }
  1107. for _, v := range edbInfoList {
  1108. edbInfoMap[v.EdbInfoId] = v
  1109. }
  1110. }
  1111. edbMappingMap[edbInfoId] = edbInfoMappingList
  1112. for _, v := range edbInfoMappingList {
  1113. tmpEdbInfoId := v.FromEdbInfoId
  1114. tmpTraceEdbInfo := data_manage.TraceEdbInfoResp{
  1115. EdbInfoId: tmpEdbInfoId,
  1116. EdbInfoType: v.FromEdbInfoType,
  1117. EdbType: v.FromEdbType,
  1118. UniqueCode: v.FromUniqueCode,
  1119. ClassifyId: v.FromClassifyId,
  1120. EdbInfo: edbInfoMap[v.FromEdbInfoId],
  1121. }
  1122. // 计算指标/预测指标继续溯源
  1123. if edbInfoId != v.FromEdbInfoId && (v.FromEdbType == 2 || v.FromEdbInfoType == 1) {
  1124. // 查过了就不查了
  1125. if _, ok2 := findIdMap[tmpEdbInfoId]; !ok2 {
  1126. tmpTraceEdbInfo.Child, e = traceEdbInfoByEdbInfoId(tmpEdbInfoId, tmpTraceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
  1127. if e != nil {
  1128. err = fmt.Errorf("traceEdbInfoByEdbInfoId err: %s", e.Error())
  1129. return
  1130. }
  1131. }
  1132. }
  1133. child = append(child, tmpTraceEdbInfo)
  1134. findIdMap[tmpEdbInfoId] = tmpEdbInfoId
  1135. }
  1136. existMap[edbInfoId] = traceEdbInfo
  1137. return
  1138. }
  1139. // GetEdbSourceByEdbInfoIdListForExcel 获取关联指标的来源
  1140. func GetEdbSourceByEdbInfoIdListForExcel(edbInfoIdList []int) (sourceNameList, sourceNameEnList []string, err error) {
  1141. sourceNameList = make([]string, 0)
  1142. sourceNameEnList = make([]string, 0)
  1143. sourceMap := make(map[int]string)
  1144. edbInfoList, tmpErr := data_manage.GetEdbInfoByIdList(edbInfoIdList)
  1145. if tmpErr != nil {
  1146. err = tmpErr
  1147. return
  1148. }
  1149. for _, v := range edbInfoList {
  1150. // 指标类型:1:基础指标,2:计算指标
  1151. if v.EdbType == 2 {
  1152. //sourceMap[0] = "弘则研究"
  1153. baseEdbInfoArr, _, _ := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  1154. for _, baseEdbInfo := range baseEdbInfoArr {
  1155. if baseEdbInfo.EdbInfoType == 0 { //普通指标才参与,预测指标不参与
  1156. sourceMap[baseEdbInfo.Source] = baseEdbInfo.SourceName
  1157. }
  1158. }
  1159. } else {
  1160. sourceMap[v.Source] = v.SourceName
  1161. }
  1162. }
  1163. for source, sourceName := range sourceMap {
  1164. if utils.InArrayByInt([]int{utils.DATA_SOURCE_MANUAL, utils.DATA_SOURCE_MYSTEEL_CHEMICAL}, source) {
  1165. continue
  1166. }
  1167. sourceNameList = append(sourceNameList, sourceName)
  1168. sourceNameEn, ok := utils.DataSourceEnMap[source]
  1169. if !ok {
  1170. sourceNameEn = sourceName
  1171. }
  1172. sourceNameEnList = append(sourceNameEnList, sourceNameEn)
  1173. }
  1174. //sourceNameList = append(sourceNameList, utils.ChartDefaultNameCn)
  1175. //sourceNameEnList = append(sourceNameEnList, utils.ChartDefaultNameEn)
  1176. // 图表来源
  1177. conf, e := models.GetBusinessConf()
  1178. if e != nil {
  1179. return
  1180. }
  1181. if conf[models.BusinessConfCompanyName] != "" {
  1182. sourceNameList = append(sourceNameList, conf[models.BusinessConfCompanyName])
  1183. sourceNameEnList = append(sourceNameEnList, conf[models.BusinessConfCompanyName])
  1184. }
  1185. return
  1186. }