edb_info.go 105 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117
  1. package data
  2. import (
  3. "encoding/json"
  4. "errors"
  5. "eta/eta_api/models"
  6. "eta/eta_api/models/data_manage"
  7. "eta/eta_api/models/system"
  8. "eta/eta_api/services/alarm_msg"
  9. "eta/eta_api/services/elastic"
  10. "eta/eta_api/utils"
  11. "fmt"
  12. "sort"
  13. "strconv"
  14. "strings"
  15. "time"
  16. )
  17. // EdbInfoRefreshAllFromBaseV2 全部刷新指标(切换到edb_lib服务)
  18. func EdbInfoRefreshAllFromBaseV2(edbInfoId int, refreshAll bool) (err error, isAsync bool) {
  19. var errmsg string
  20. defer func() {
  21. if err != nil {
  22. fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg)
  23. go alarm_msg.SendAlarmMsg("EdbInfoRefreshFromBaseV2,Err"+err.Error()+";errMsg:"+errmsg, 3)
  24. //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers)
  25. }
  26. }()
  27. err, isAsync = EdbInfoRefreshAllFromBaseV3([]int{edbInfoId}, refreshAll, false)
  28. return
  29. }
  30. // EdbInfoRefreshAllFromBaseV3Bak 全部刷新指标(切换到edb_lib服务)
  31. // @author Roc
  32. // @datetime 2022-09-16 11:04:44
  33. // @description 将原有的单个指标刷新,调整为批量多个指标刷新
  34. // DeprecatedTime 2023-10-23 09:38:19废弃
  35. // Deprecated
  36. func EdbInfoRefreshAllFromBaseV3Bak(edbInfoIdList []int, refreshAll, isSync bool) (err error, isAsync bool) {
  37. var errmsg string
  38. defer func() {
  39. if err != nil {
  40. fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg)
  41. go alarm_msg.SendAlarmMsg("EdbInfoRefreshFromBaseV2,Err"+err.Error()+";errMsg:"+errmsg, 3)
  42. //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers)
  43. }
  44. }()
  45. // 获取关联的基础指标
  46. newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr, err, errmsg := getRefreshEdbInfoListByIds(edbInfoIdList)
  47. if err != nil {
  48. return
  49. }
  50. // 需要刷新的指标数量
  51. totalEdbInfo := len(newBaseEdbInfoArr) + len(calculateArr) + len(predictCalculateArr)
  52. if totalEdbInfo <= 20 || isSync {
  53. err = edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
  54. } else {
  55. isAsync = true
  56. go edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
  57. }
  58. return
  59. }
  60. // EdbInfoRefreshAllFromBaseV3
  61. //
  62. // @Description: 全部刷新指标(切换到edb_lib服务)
  63. // @author: Roc
  64. // @datetime2023-10-23 09:57:55
  65. // @param edbInfoIdList []int
  66. // @param refreshAll bool
  67. // @param isSync bool
  68. // @return err error
  69. // @return isAsync bool
  70. func EdbInfoRefreshAllFromBaseV3(edbInfoIdList []int, refreshAll, isSync bool) (err error, isAsync bool) {
  71. var errmsg string
  72. defer func() {
  73. if err != nil {
  74. fmt.Println("EdbInfoRefreshAllFromBaseV3 Err:" + err.Error() + ";errmsg:" + errmsg)
  75. go alarm_msg.SendAlarmMsg("EdbInfoRefreshAllFromBaseV3,Err"+err.Error()+";errMsg:"+errmsg, 3)
  76. }
  77. }()
  78. traceEdbInfoList, err := TraceEdbInfoByEdbInfoIdList(edbInfoIdList)
  79. if err != nil {
  80. return
  81. }
  82. // existEdbInfoIdMap 已经处理了的指标id map
  83. existEdbInfoIdMap := make(map[int]int)
  84. // 基础指标
  85. newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
  86. newBasePredictEdbInfoArr := make([]*data_manage.EdbInfo, 0)
  87. newBaseMap := make(map[int]*data_manage.EdbInfo)
  88. newPredictBaseMap := make(map[int]*data_manage.EdbInfo)
  89. // 计算指标
  90. newCalculateMap := make(map[int]*data_manage.EdbInfo)
  91. newPredictCalculateMap := make(map[int]*data_manage.EdbInfo)
  92. calculateArr := make([]int, 0)
  93. predictCalculateArr := make([]int, 0)
  94. // 获取关联指标
  95. for _, traceEdbInfo := range traceEdbInfoList {
  96. tmpBaseEdbInfoArr, tmpBasePredictEdbInfoArr, tmpCalculateMap, tmpPredictCalculateMap, _, _ := getRefreshEdbInfoListByTraceEdbInfo(traceEdbInfo, existEdbInfoIdMap)
  97. // 普通基础指标
  98. for _, edbInfo := range tmpBaseEdbInfoArr {
  99. if _, ok := newBaseMap[edbInfo.EdbInfoId]; !ok {
  100. newBaseMap[edbInfo.EdbInfoId] = edbInfo
  101. newBaseEdbInfoArr = append(newBaseEdbInfoArr, edbInfo)
  102. }
  103. }
  104. // 预测基础指标
  105. for _, edbInfo := range tmpBasePredictEdbInfoArr {
  106. if _, ok := newPredictBaseMap[edbInfo.EdbInfoId]; !ok {
  107. newPredictBaseMap[edbInfo.EdbInfoId] = edbInfo
  108. newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, edbInfo)
  109. }
  110. }
  111. // 普通计算指标
  112. for _, edbInfo := range tmpCalculateMap {
  113. if _, ok := newCalculateMap[edbInfo.EdbInfoId]; !ok {
  114. newCalculateMap[edbInfo.EdbInfoId] = edbInfo
  115. calculateArr = append(calculateArr, edbInfo.EdbInfoId)
  116. }
  117. }
  118. // 预测计算指标
  119. for _, edbInfo := range tmpPredictCalculateMap {
  120. if _, ok := newPredictCalculateMap[edbInfo.EdbInfoId]; !ok {
  121. newPredictCalculateMap[edbInfo.EdbInfoId] = edbInfo
  122. predictCalculateArr = append(predictCalculateArr, edbInfo.EdbInfoId)
  123. }
  124. }
  125. }
  126. // 普通计算指标的id
  127. sort.Ints(calculateArr)
  128. // 预测计算指标的id
  129. sort.Ints(predictCalculateArr)
  130. // 需要刷新的指标数量
  131. totalEdbInfo := len(newBaseEdbInfoArr) + len(calculateArr) + len(predictCalculateArr)
  132. if totalEdbInfo <= 20 || isSync {
  133. err = edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
  134. } else {
  135. isAsync = true
  136. go edbInfoRefreshAll(refreshAll, newBaseEdbInfoArr, newBasePredictEdbInfoArr, newCalculateMap, newPredictCalculateMap, calculateArr, predictCalculateArr)
  137. }
  138. return
  139. }
  140. // getRefreshEdbInfoListByTraceEdbInfo根据溯源获取关联指标
  141. 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) {
  142. newBaseEdbInfoArr = make([]*data_manage.EdbInfo, 0)
  143. newBasePredictEdbInfoArr = make([]*data_manage.EdbInfo, 0)
  144. newCalculateMap = make(map[int]*data_manage.EdbInfo)
  145. newPredictCalculateMap = make(map[int]*data_manage.EdbInfo)
  146. calculateArr = make([]int, 0)
  147. predictCalculateArr = make([]int, 0)
  148. _, ok := existEdbInfoIdMap[traceEdbInfo.EdbInfoId]
  149. if ok {
  150. return
  151. }
  152. existEdbInfoIdMap[traceEdbInfo.EdbInfoId] = traceEdbInfo.EdbInfoId
  153. switch traceEdbInfo.EdbInfoType {
  154. //0-普通指标; 1-预测指标
  155. case 0: // 0-普通指标
  156. if traceEdbInfo.EdbType == 1 { //1-基础指标
  157. newBaseEdbInfoArr = append(newBaseEdbInfoArr, traceEdbInfo.EdbInfo)
  158. } else if traceEdbInfo.EdbType == 2 { //2-计算指标
  159. newCalculateMap[traceEdbInfo.EdbInfoId] = traceEdbInfo.EdbInfo
  160. calculateArr = append(calculateArr, traceEdbInfo.EdbInfoId)
  161. }
  162. case 1: // 1-预测指标
  163. if traceEdbInfo.EdbType == 1 { //1-基础指标
  164. newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, traceEdbInfo.EdbInfo)
  165. } else if traceEdbInfo.EdbType == 2 { //2-计算指标
  166. newPredictCalculateMap[traceEdbInfo.EdbInfoId] = traceEdbInfo.EdbInfo
  167. predictCalculateArr = append(predictCalculateArr, traceEdbInfo.EdbInfoId)
  168. }
  169. }
  170. if traceEdbInfo.Child != nil && len(traceEdbInfo.Child) > 0 {
  171. for _, v := range traceEdbInfo.Child {
  172. tmpBaseEdbInfoArr, tmpPredictEdbInfoArr, tmpCalculateMap, tmpPredictCalculateMap, tmpCalculateArr, tmpPredictCalculateArr := getRefreshEdbInfoListByTraceEdbInfo(v, existEdbInfoIdMap)
  173. newBaseEdbInfoArr = append(newBaseEdbInfoArr, tmpBaseEdbInfoArr...)
  174. newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, tmpPredictEdbInfoArr...)
  175. for k, tmpEdbInfo := range tmpCalculateMap {
  176. newCalculateMap[k] = tmpEdbInfo
  177. }
  178. for k, tmpEdbInfo := range tmpPredictCalculateMap {
  179. newPredictCalculateMap[k] = tmpEdbInfo
  180. }
  181. calculateArr = append(calculateArr, tmpCalculateArr...)
  182. predictCalculateArr = append(predictCalculateArr, tmpPredictCalculateArr...)
  183. }
  184. }
  185. return
  186. }
  187. func edbInfoRefreshAll(refreshAll bool, newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int) (err error) {
  188. var errmsg string
  189. defer func() {
  190. if err != nil {
  191. fmt.Println("EdbInfoRefreshAllFromBaseV2 Err:" + err.Error() + ";errmsg:" + errmsg)
  192. go alarm_msg.SendAlarmMsg("EdbInfoRefreshFromBaseV2,Err"+err.Error()+";errMsg:"+errmsg, 3)
  193. //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers)
  194. }
  195. }()
  196. var startDate string
  197. for _, bv := range newBaseEdbInfoArr {
  198. //source := bv.Source
  199. //edbInfoId := bv.EdbInfoId
  200. //edbCode := bv.EdbCode
  201. if bv.StartDate == "0000-00-00" {
  202. continue
  203. }
  204. //开始时间
  205. startDate = ``
  206. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  207. sTime, err := time.Parse(utils.FormatDate, bv.StartDate)
  208. if err != nil {
  209. return err
  210. }
  211. startDate = sTime.Format(utils.FormatDate)
  212. } else {
  213. sTime, err := time.Parse(utils.FormatDate, bv.EndDate)
  214. if err != nil {
  215. return err
  216. }
  217. frequency := bv.Frequency
  218. var limitDay int
  219. switch frequency {
  220. case "日度":
  221. limitDay = utils.DATA_START_REFRESH_LIMIT
  222. case "周度":
  223. limitDay = utils.DATA_START_REFRESH_LIMIT * 7
  224. case "月度":
  225. limitDay = utils.DATA_START_REFRESH_LIMIT * 30
  226. case "季度":
  227. limitDay = utils.DATA_START_REFRESH_LIMIT * 90
  228. case "年度":
  229. limitDay = utils.DATA_START_REFRESH_LIMIT * 365
  230. default:
  231. limitDay = utils.DATA_START_REFRESH_LIMIT
  232. }
  233. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  234. }
  235. result, err := RefreshEdbData(bv.EdbInfoId, bv.Source, bv.EdbCode, startDate)
  236. if err != nil {
  237. fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err", time.Now())
  238. errmsg = "RefreshBaseEdbData Err:" + err.Error()
  239. return err
  240. }
  241. if result.Ret != 200 {
  242. fmt.Println(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  243. errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  244. return fmt.Errorf("刷新失败, err:", errmsg)
  245. }
  246. //maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
  247. //if err != nil {
  248. // if err.Error() == utils.ErrNoRow() { //找不到数据,那么就进入到下一条数据做处理
  249. // continue
  250. // }
  251. // return err
  252. //}
  253. //if maxAndMinItem != nil {
  254. // err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
  255. // if err != nil {
  256. // return err
  257. // }
  258. //}
  259. fmt.Println("end newBaseEdbInfoArr:", bv, time.Now())
  260. }
  261. //刷新相关普通计算指标
  262. for _, v := range calculateArr {
  263. edbInfo := newCalculateMap[v]
  264. if edbInfo == nil {
  265. return err
  266. }
  267. //计算指标就不用开始时间了吧,因为存在说开始时间变更的情况
  268. startDate = ``
  269. if !refreshAll { //如果不是全部更新,那么以指标的开始时间作为刷新
  270. startDate = edbInfo.StartDate
  271. source := edbInfo.Source
  272. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  273. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  274. } else {
  275. if source == utils.DATA_SOURCE_CALCULATE {
  276. sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
  277. if err != nil {
  278. return err
  279. }
  280. frequency := edbInfo.Frequency
  281. var limitDay int
  282. switch frequency {
  283. case "日度":
  284. limitDay = utils.DATA_START_REFRESH_LIMIT
  285. case "周度":
  286. limitDay = utils.DATA_START_REFRESH_LIMIT * 7
  287. case "月度":
  288. limitDay = utils.DATA_START_REFRESH_LIMIT * 30
  289. case "季度":
  290. limitDay = utils.DATA_START_REFRESH_LIMIT * 90
  291. case "年度":
  292. limitDay = utils.DATA_START_REFRESH_LIMIT * 365
  293. default:
  294. limitDay = utils.DATA_START_REFRESH_LIMIT
  295. }
  296. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  297. }
  298. }
  299. }
  300. result, err := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  301. if err != nil {
  302. fmt.Println(v, "RefreshEdbCalculateData err", time.Now())
  303. errmsg = "RefreshEdbCalculateData Err:" + err.Error()
  304. return err
  305. }
  306. if result.Ret != 200 {
  307. fmt.Println(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  308. errmsg = fmt.Sprint(v, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  309. return fmt.Errorf("刷新失败")
  310. }
  311. }
  312. //刷新相关预测计算指标
  313. for _, v := range predictCalculateArr {
  314. edbInfo := newPredictCalculateMap[v]
  315. if edbInfo == nil {
  316. return err
  317. }
  318. startDate = edbInfo.StartDate
  319. source := edbInfo.Source
  320. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  321. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  322. } else {
  323. if source == utils.DATA_SOURCE_PREDICT_CALCULATE {
  324. startDate = ``
  325. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  326. startDate = edbInfo.StartDate
  327. } else {
  328. sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
  329. if err != nil {
  330. return err
  331. }
  332. frequency := edbInfo.Frequency
  333. var limitDay int
  334. switch frequency {
  335. case "日度":
  336. limitDay = utils.DATA_START_REFRESH_LIMIT
  337. case "周度":
  338. limitDay = utils.DATA_START_REFRESH_LIMIT * 7
  339. case "月度":
  340. limitDay = utils.DATA_START_REFRESH_LIMIT * 30
  341. case "季度":
  342. limitDay = utils.DATA_START_REFRESH_LIMIT * 90
  343. case "年度":
  344. limitDay = utils.DATA_START_REFRESH_LIMIT * 365
  345. default:
  346. limitDay = utils.DATA_START_REFRESH_LIMIT
  347. }
  348. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  349. }
  350. }
  351. }
  352. result, err := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  353. if err != nil {
  354. fmt.Println(v, "RefreshEdbCalculateData err", time.Now())
  355. errmsg = "RefreshEdbCalculateData Err:" + err.Error()
  356. return err
  357. }
  358. if result.Ret != 200 {
  359. fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  360. errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  361. return fmt.Errorf("刷新失败")
  362. }
  363. }
  364. // 4、更新动态环差值
  365. {
  366. predictEdbInfoIdList := make([]int, 0)
  367. for _, v := range newBasePredictEdbInfoArr {
  368. predictEdbInfoIdList = append(predictEdbInfoIdList, v.EdbInfoId)
  369. }
  370. fmt.Println("predictEdbConfCalculateMappingDetailList:", predictEdbInfoIdList)
  371. predictEdbConfCalculateMappingDetailList, err := data_manage.GetPredictEdbConfCalculateMappingDetailListByEdbInfoId(predictEdbInfoIdList)
  372. if err != nil {
  373. errmsg = fmt.Sprint("更新动态环差值时,获取数据失败:" + err.Error())
  374. return fmt.Errorf("刷新失败, err:", errmsg)
  375. }
  376. for _, bv := range predictEdbConfCalculateMappingDetailList {
  377. result, err := RefreshEdbData(bv.EdbInfoId, utils.DATA_SOURCE_PREDICT, bv.EdbCode, "")
  378. if err != nil {
  379. fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err", time.Now())
  380. errmsg = "RefreshBasePredictEdbData Err:" + err.Error()
  381. return err
  382. }
  383. if result.Ret != 200 {
  384. fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  385. errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  386. return fmt.Errorf("刷新失败, err:%s", errmsg)
  387. }
  388. fmt.Println("end predictEdbConfCalculateMappingDetailList:", bv, time.Now())
  389. }
  390. }
  391. //5、再次刷新相关预测计算指标
  392. for _, v := range predictCalculateArr {
  393. edbInfo := newPredictCalculateMap[v]
  394. if edbInfo == nil {
  395. return err
  396. }
  397. startDate = edbInfo.StartDate
  398. source := edbInfo.Source
  399. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  400. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  401. } else {
  402. if source == utils.DATA_SOURCE_PREDICT_CALCULATE {
  403. startDate = ``
  404. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  405. startDate = edbInfo.StartDate
  406. } else {
  407. sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
  408. if err != nil {
  409. return err
  410. }
  411. frequency := edbInfo.Frequency
  412. var limitDay int
  413. switch frequency {
  414. case "日度":
  415. limitDay = utils.DATA_START_REFRESH_LIMIT
  416. case "周度":
  417. limitDay = utils.DATA_START_REFRESH_LIMIT * 7
  418. case "月度":
  419. limitDay = utils.DATA_START_REFRESH_LIMIT * 30
  420. case "季度":
  421. limitDay = utils.DATA_START_REFRESH_LIMIT * 90
  422. case "年度":
  423. limitDay = utils.DATA_START_REFRESH_LIMIT * 365
  424. default:
  425. limitDay = utils.DATA_START_REFRESH_LIMIT
  426. }
  427. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  428. }
  429. }
  430. }
  431. result, err := RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  432. if err != nil {
  433. fmt.Println(v, "RefreshEdbCalculateData err", time.Now())
  434. errmsg = "RefreshEdbCalculateData Err:" + err.Error()
  435. return err
  436. }
  437. if result.Ret != 200 {
  438. fmt.Println(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  439. errmsg = fmt.Sprint(v, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  440. return fmt.Errorf("刷新失败")
  441. }
  442. }
  443. return err
  444. }
  445. // EdbInfoRefresh 刷新单个指标,不会刷新关联指标
  446. func EdbInfoRefresh(edbInfo *data_manage.EdbInfoView, refreshAll bool) (err error) {
  447. var errmsg string
  448. defer func() {
  449. if err != nil {
  450. fmt.Println("EdbInfoRefresh Err:" + err.Error() + ";errmsg:" + errmsg)
  451. go alarm_msg.SendAlarmMsg("EdbInfoRefresh,Err"+err.Error()+";errMsg:"+errmsg, 3)
  452. //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers)
  453. }
  454. }()
  455. switch edbInfo.EdbInfoType {
  456. //指标类型,0:普通指标,1:预测指标
  457. case 0:
  458. if edbInfo.StartDate == "0000-00-00" {
  459. return
  460. }
  461. //开始时间
  462. startDate := ``
  463. if edbInfo.EdbType == 1 {
  464. // 基础指标
  465. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  466. sTime, err := time.Parse(utils.FormatDate, edbInfo.StartDate)
  467. if err != nil {
  468. return err
  469. }
  470. startDate = sTime.Format(utils.FormatDate)
  471. } else {
  472. sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
  473. if err != nil {
  474. return err
  475. }
  476. frequency := edbInfo.Frequency
  477. var limitDay int
  478. switch frequency {
  479. case "日度":
  480. limitDay = utils.DATA_START_REFRESH_LIMIT
  481. case "周度":
  482. limitDay = utils.DATA_START_REFRESH_LIMIT * 7
  483. case "月度":
  484. limitDay = utils.DATA_START_REFRESH_LIMIT * 30
  485. case "季度":
  486. limitDay = utils.DATA_START_REFRESH_LIMIT * 90
  487. case "年度":
  488. limitDay = utils.DATA_START_REFRESH_LIMIT * 365
  489. default:
  490. limitDay = utils.DATA_START_REFRESH_LIMIT
  491. }
  492. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  493. }
  494. result, err := RefreshEdbData(edbInfo.EdbInfoId, edbInfo.Source, edbInfo.EdbCode, startDate)
  495. if err != nil {
  496. fmt.Println(edbInfo.EdbInfoId, "RefreshBaseEdbData err", time.Now())
  497. errmsg = "RefreshBaseEdbData Err:" + err.Error()
  498. return err
  499. }
  500. if result.Ret != 200 {
  501. fmt.Println(edbInfo.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  502. errmsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshBaseEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  503. return fmt.Errorf("刷新失败, err:", errmsg)
  504. }
  505. } else { //计算指标
  506. //计算指标就不用开始时间了吧,因为存在说开始时间变更的情况
  507. if !refreshAll { //如果不是全部更新,那么以指标的开始时间作为刷新
  508. startDate = edbInfo.StartDate
  509. source := edbInfo.Source
  510. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  511. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  512. } else {
  513. if source == utils.DATA_SOURCE_CALCULATE {
  514. sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
  515. if err != nil {
  516. return err
  517. }
  518. frequency := edbInfo.Frequency
  519. var limitDay int
  520. switch frequency {
  521. case "日度":
  522. limitDay = utils.DATA_START_REFRESH_LIMIT
  523. case "周度":
  524. limitDay = utils.DATA_START_REFRESH_LIMIT * 7
  525. case "月度":
  526. limitDay = utils.DATA_START_REFRESH_LIMIT * 30
  527. case "季度":
  528. limitDay = utils.DATA_START_REFRESH_LIMIT * 90
  529. case "年度":
  530. limitDay = utils.DATA_START_REFRESH_LIMIT * 365
  531. default:
  532. limitDay = utils.DATA_START_REFRESH_LIMIT
  533. }
  534. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  535. }
  536. }
  537. }
  538. result, err := RefreshEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  539. if err != nil {
  540. fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err", time.Now())
  541. errmsg = "RefreshEdbCalculateData Err:" + err.Error()
  542. return err
  543. }
  544. if result.Ret != 200 {
  545. fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  546. errmsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  547. return fmt.Errorf("刷新失败")
  548. }
  549. }
  550. case 1:
  551. startDate := edbInfo.StartDate
  552. var result *models.BaseResponse
  553. if startDate == "" || startDate == "0000-00-00" { //如果没有开始日期,说明还没有计算出来数据,那么就往前面推40年吧(也意味着重新计算了)
  554. startDate = time.Now().AddDate(-40, 0, 0).Format(utils.FormatDate)
  555. } else {
  556. startDate = ``
  557. if refreshAll { //刷新所有数据,用开始时间作为起始日期去刷新
  558. startDate = edbInfo.StartDate
  559. } else {
  560. sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
  561. if err != nil {
  562. return err
  563. }
  564. frequency := edbInfo.Frequency
  565. var limitDay int
  566. switch frequency {
  567. case "日度":
  568. limitDay = utils.DATA_START_REFRESH_LIMIT
  569. case "周度":
  570. limitDay = utils.DATA_START_REFRESH_LIMIT * 7
  571. case "月度":
  572. limitDay = utils.DATA_START_REFRESH_LIMIT * 30
  573. case "季度":
  574. limitDay = utils.DATA_START_REFRESH_LIMIT * 90
  575. case "年度":
  576. limitDay = utils.DATA_START_REFRESH_LIMIT * 365
  577. default:
  578. limitDay = utils.DATA_START_REFRESH_LIMIT
  579. }
  580. startDate = sTime.AddDate(0, 0, -limitDay).Format(utils.FormatDate)
  581. }
  582. }
  583. if edbInfo.EdbType == 1 { //基础指标
  584. result, err = RefreshPredictEdbCalculateData(edbInfo.EdbInfoId, edbInfo.EdbCode, startDate)
  585. } else {
  586. // 预测计算指标
  587. // 4、更新动态环差值
  588. {
  589. predictEdbConfCalculateMappingDetailList, err := data_manage.GetPredictEdbConfCalculateMappingDetailListByEdbInfoId([]int{edbInfo.EdbInfoId})
  590. if err != nil {
  591. errmsg = fmt.Sprint("更新动态环差值时,获取数据失败:" + err.Error())
  592. return fmt.Errorf("刷新失败, err:", errmsg)
  593. }
  594. for _, bv := range predictEdbConfCalculateMappingDetailList {
  595. result, err := RefreshEdbData(bv.EdbInfoId, utils.DATA_SOURCE_PREDICT, bv.EdbCode, "")
  596. if err != nil {
  597. fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err", time.Now())
  598. errmsg = "RefreshBasePredictEdbData Err:" + err.Error()
  599. return err
  600. }
  601. if result.Ret != 200 {
  602. fmt.Println(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  603. errmsg = fmt.Sprint(bv.EdbInfoId, "RefreshBasePredictEdbData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  604. return fmt.Errorf("刷新失败, err:%s", errmsg)
  605. }
  606. fmt.Println("end predictEdbConfCalculateMappingDetailList:", bv, time.Now())
  607. }
  608. }
  609. }
  610. if err != nil {
  611. fmt.Println(edbInfo.EdbInfoId, "RefreshEdbCalculateData err", time.Now())
  612. errmsg = "RefreshEdbCalculateData Err:" + err.Error()
  613. return err
  614. }
  615. if result.Ret != 200 {
  616. fmt.Println(edbInfo.EdbInfoId, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  617. errmsg = fmt.Sprint(edbInfo.EdbInfoId, "RefreshPredictEdbCalculateData err;msg:", result.Msg, ";errMsg:", result.ErrMsg)
  618. return fmt.Errorf("刷新失败")
  619. }
  620. }
  621. return err
  622. }
  623. // AddEdbInfo 新增手工指标数据
  624. func AddEdbInfo(secName, unit, frequency, noticeTime, mobile string, classifyId, userId int) (err error) {
  625. tradeCode, err := models.GetMaxTradeCode()
  626. if err != nil {
  627. return
  628. }
  629. if tradeCode == "" {
  630. err = errors.New("最大编码为空")
  631. return
  632. }
  633. maxTradeCode, err := utils.GetMaxTradeCode(tradeCode)
  634. if err != nil {
  635. err = errors.New("获取编码信息失败,Err:" + err.Error())
  636. return
  637. }
  638. if maxTradeCode == "" {
  639. err = errors.New("编码为空,请联系技术")
  640. return
  641. }
  642. //判断指标名称是否为空
  643. if secName == "" {
  644. err = errors.New("指标名称不能为空")
  645. return
  646. }
  647. item, err := models.GetEdbinfoBySecName(secName)
  648. if err != nil && err.Error() != utils.ErrNoRow() {
  649. err = errors.New("获取信息失败,Err:" + err.Error())
  650. return
  651. }
  652. if item != nil {
  653. err = errors.New("指标名称已存在")
  654. return
  655. }
  656. // 先删除该指标编码的历史数据(避免上海删除指标时,没有删除该指标数据)
  657. _ = models.DeleteAllEdbData(maxTradeCode)
  658. // 再次新增指标
  659. err = models.AddEdbinfo(maxTradeCode, secName, unit, "手动", frequency, noticeTime, classifyId, userId)
  660. if err != nil {
  661. err = errors.New("新增失败,Err:" + err.Error())
  662. return
  663. }
  664. err = models.AddEdbinfoUser(maxTradeCode, mobile)
  665. return
  666. }
  667. //全部刷新指标
  668. //func EdbInfoRefreshAllFromBase(edbInfoId int) (err error) {
  669. // var errmsg string
  670. // defer func() {
  671. // if err != nil {
  672. // fmt.Println("EdbInfoRefreshAllFromBase Err:" + err.Error() + ";errmsg:" + errmsg)
  673. // go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"失败提醒", "EdbInfoRefreshFromBase:"+errmsg, utils.EmailSendToUsers)
  674. // }
  675. // }()
  676. //
  677. // calculateList, err := data_manage.GetEdbInfoAllCalculate(edbInfoId)
  678. // if err != nil && err.Error() != utils.ErrNoRow() {
  679. // return errors.New("GetEdbInfoAllCalculate Err:" + err.Error())
  680. // }
  681. // baseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
  682. // calculateInfoArr := make([]*data_manage.EdbInfo, 0)
  683. // baseEdbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
  684. // if err != nil {
  685. // return errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error())
  686. // }
  687. // baseEdbInfoArr = append(baseEdbInfoArr, baseEdbInfo)
  688. //
  689. // for _, v := range calculateList {
  690. // getBaseEdbInfoArr, getCalculateInfoArr, err := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  691. // if err != nil {
  692. // fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
  693. // errmsg = "获取需要刷新的指标失败:Err:" + err.Error()
  694. // return err
  695. // }
  696. // baseEdbInfoArr = append(baseEdbInfoArr, getBaseEdbInfoArr...)
  697. // calculateInfoArr = append(calculateInfoArr, getCalculateInfoArr...)
  698. // calculateInfoArr = append(calculateInfoArr, v)
  699. // }
  700. // //取重
  701. // newBaseEdbInfoArr := make([]*data_manage.EdbInfo, 0)
  702. // baseMap := make(map[int]int)
  703. // for _, v := range baseEdbInfoArr {
  704. // if _, ok := baseMap[v.EdbInfoId]; !ok {
  705. // newBaseEdbInfoArr = append(newBaseEdbInfoArr, v)
  706. // }
  707. // baseMap[v.EdbInfoId] = v.EdbInfoId
  708. // }
  709. //
  710. // var calculateArr []int
  711. // newCalculateMap := make(map[int]*data_manage.EdbInfo)
  712. // for _, v := range calculateInfoArr {
  713. // if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
  714. // calculateArr = append(calculateArr, v.EdbInfoId)
  715. // }
  716. // newCalculateMap[v.EdbInfoId] = v
  717. // }
  718. // sort.Ints(calculateArr)
  719. // var startDate string
  720. // for _, bv := range newBaseEdbInfoArr {
  721. // source := bv.Source
  722. // edbInfoId := bv.EdbInfoId
  723. // edbCode := bv.EdbCode
  724. //
  725. // sTime, err := time.Parse(utils.FormatDate, bv.StartDate)
  726. // if err != nil {
  727. // return err
  728. // }
  729. // startDate = sTime.Format(utils.FormatDate)
  730. //
  731. // if source == utils.DATA_SOURCE_THS {
  732. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
  733. // err = data_manage.RefreshAllEdbDataByThs(edbInfoId, source, edbCode, startDate, endDate)
  734. // if err != nil {
  735. // errmsg = "RefreshAllEdbDataByThs Err:" + err.Error()
  736. // }
  737. // } else if source == utils.DATA_SOURCE_WIND {
  738. // endDate := time.Now().Format(utils.FormatDate)
  739. // err = data_manage.RefreshAllEdbDataByWind(edbInfoId, source, edbCode, startDate, endDate)
  740. // if err != nil {
  741. // errmsg = "RefreshAllEdbDataByWind Err:" + err.Error()
  742. // }
  743. // } else if source == utils.DATA_SOURCE_PB {
  744. // startDate := sTime.Format(utils.FormatDateUnSpace)
  745. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDateUnSpace)
  746. // err = data_manage.RefreshAllEdbDataByPb(edbInfoId, source, edbCode, startDate, endDate)
  747. // if err != nil {
  748. // errmsg = "RefreshAllEdbDataByPb Err:" + err.Error()
  749. // }
  750. // } else if source == utils.DATA_SOURCE_MANUAL {
  751. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
  752. // err = data_manage.RefreshAllEdbDataByManual(edbInfoId, source, edbCode, startDate, endDate)
  753. // if err != nil {
  754. // errmsg = "RefreshAllEdbDataByManual Err:" + err.Error()
  755. // }
  756. // } else if source == utils.DATA_SOURCE_LZ {
  757. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
  758. // err = data_manage.RefreshAllEdbDataByLz(edbInfoId, source, edbCode, startDate, endDate)
  759. // if err != nil {
  760. // errmsg = "RefreshAllEdbDataByLz Err:" + err.Error()
  761. // }
  762. // } else if source == utils.DATA_SOURCE_YS {
  763. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
  764. // err = data_manage.RefreshAllEdbDataByYs(edbInfoId, source, edbCode, startDate, endDate)
  765. // if err != nil {
  766. // errmsg = "RefreshAllEdbDataByYs Err:" + err.Error()
  767. // }
  768. // } else if source == utils.DATA_SOURCE_GL {
  769. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
  770. // err = data_manage.RefreshAllEdbDataByGl(edbInfoId, source, edbCode, startDate, endDate)
  771. // if err != nil {
  772. // errmsg = "RefreshAllEdbDataByGl Err:" + err.Error()
  773. // }
  774. // } else if source == utils.DATA_SOURCE_ZZ {
  775. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
  776. // err = data_manage.RefreshAllEdbDataByZz(edbInfoId, source, edbCode, startDate, endDate)
  777. // if err != nil {
  778. // errmsg = "RefreshAllEdbDataByZz Err:" + err.Error()
  779. // }
  780. // } else if source == utils.DATA_SOURCE_DL {
  781. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
  782. // err = data_manage.RefreshAllEdbDataByDl(edbInfoId, source, edbCode, startDate, endDate)
  783. // if err != nil {
  784. // errmsg = "RefreshAllEdbDataByDl Err:" + err.Error()
  785. // }
  786. // } else if source == utils.DATA_SOURCE_SH {
  787. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
  788. // err = data_manage.RefreshAllEdbDataBySh(edbInfoId, source, edbCode, startDate, endDate)
  789. // if err != nil {
  790. // errmsg = "RefreshAllEdbDataBySh Err:" + err.Error()
  791. // }
  792. // } else if source == utils.DATA_SOURCE_CFFEX {
  793. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
  794. // err = data_manage.RefreshAllEdbDataByCffex(edbInfoId, source, edbCode, startDate, endDate)
  795. // if err != nil {
  796. // errmsg = "RefreshAllEdbDataByCffex Err:" + err.Error()
  797. // }
  798. // } else if source == utils.DATA_SOURCE_SHFE {
  799. // endDate := time.Now().AddDate(utils.DATA_END_DATE_LIMIT, 0, 0).Format(utils.FormatDate)
  800. // err = data_manage.RefreshAllEdbDataByShfe(edbInfoId, source, edbCode, startDate, endDate)
  801. // if err != nil {
  802. // errmsg = "RefreshAllEdbDataByShfe Err:" + err.Error()
  803. // }
  804. // }
  805. //
  806. // maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
  807. // if err != nil {
  808. // return err
  809. // }
  810. // if maxAndMinItem != nil {
  811. // err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
  812. // if err != nil {
  813. // return err
  814. // }
  815. // }
  816. // fmt.Println("end newBaseEdbInfoArr:", bv, time.Now())
  817. // }
  818. //
  819. // endDate := "" //计算指标不限制日期
  820. // //刷新相关计算指标
  821. // for _, v := range calculateArr {
  822. // edbInfo := newCalculateMap[v]
  823. // if edbInfo == nil {
  824. // return err
  825. // }
  826. // edbInfoId := edbInfo.EdbInfoId
  827. // source := edbInfo.Source
  828. // edbCode := edbInfo.EdbCode
  829. //
  830. // if source == utils.DATA_SOURCE_CALCULATE {
  831. // startDate = edbInfo.StartDate
  832. // sTime, err := time.Parse(utils.FormatDate, edbInfo.EndDate)
  833. // if err != nil {
  834. // return err
  835. // }
  836. // startDate = sTime.Format(utils.FormatDate)
  837. //
  838. // var edbInfoIdBytes []string
  839. // calculateMap, err := data_manage.GetEdbInfoCalculateDetail(edbInfoId, edbInfo.Source)
  840. // if err != nil {
  841. // errmsg = "GetEdbInfoCalculateDetail Err:" + err.Error()
  842. // return err
  843. // }
  844. // var formulaStr string
  845. // edbInfoList := make([]*data_manage.EdbInfo, 0)
  846. //
  847. // for _, v := range calculateMap {
  848. // formulaStr += v.FromTag + ","
  849. // edbInfoIdBytes = append(edbInfoIdBytes, v.FromTag)
  850. // edbInfo, _ := data_manage.GetEdbInfoById(v.FromEdbInfoId)
  851. // edbInfoList = append(edbInfoList, edbInfo)
  852. // }
  853. // err = data_manage.RefreshAllCalculate(edbInfoList, int(edbInfoId), source, edbInfo.EdbCode, edbInfo.CalculateFormula, startDate, endDate, edbInfoIdBytes)
  854. // if err != nil {
  855. // errmsg = "RefreshCalculate Err:" + err.Error()
  856. // return err
  857. // }
  858. // } else if source == utils.DATA_SOURCE_CALCULATE_LJZZY { //刷新累计值转月值
  859. // calculateLjzzy, err := data_manage.GetEdbInfoCalculateLjzzyDetail(edbInfoId)
  860. // if err != nil {
  861. // errmsg = "GetEdbInfoCalculateLjzzyDetail Err:" + err.Error()
  862. // return err
  863. // }
  864. // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateLjzzy.FromEdbInfoId)
  865. // if err != nil {
  866. // errmsg = "GetEdbInfoById Err:" + err.Error()
  867. // return err
  868. // }
  869. // startDate = edbInfo.StartDate
  870. // endDate = time.Now().Format(utils.FormatDate)
  871. // err = data_manage.RefreshAllCalculateLjzzy(edbInfoId, source, fromEdbInfo, calculateLjzzy.EdbCode, startDate, endDate)
  872. // if err != nil {
  873. // errmsg = "RefreshAllCalculateLjzzy Err:" + err.Error()
  874. // return err
  875. // }
  876. // } else if source == utils.DATA_SOURCE_CALCULATE_TBZ { //刷新同比值
  877. // calculateTbz, err := data_manage.GetEdbInfoCalculateTbzDetail(edbInfoId)
  878. // if err != nil {
  879. // errmsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
  880. // return err
  881. // }
  882. // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId)
  883. // if err != nil {
  884. // errmsg = "GetEdbInfoById Err:" + err.Error()
  885. // return err
  886. // }
  887. // startDate = edbInfo.StartDate
  888. // endDate = time.Now().Format(utils.FormatDate)
  889. // err = data_manage.RefreshAllCalculateTbz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
  890. // if err != nil {
  891. // errmsg = "RefreshAllCalculateTbz Err:" + err.Error()
  892. // return err
  893. // }
  894. // } else if source == utils.DATA_SOURCE_CALCULATE_TCZ { //同差值
  895. // calculateTcz, err := data_manage.GetEdbInfoCalculateTczDetail(edbInfoId)
  896. // if err != nil {
  897. // errmsg = "GetEdbInfoCalculateTczDetail Err:" + err.Error()
  898. // return err
  899. // }
  900. // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTcz.FromEdbInfoId)
  901. // if err != nil {
  902. // errmsg = "GetEdbInfoById Err:" + err.Error()
  903. // return err
  904. // }
  905. // startDate = edbInfo.StartDate
  906. // endDate = time.Now().Format(utils.FormatDate)
  907. // err = data_manage.RefreshAllCalculateTcz(edbInfoId, source, fromEdbInfo, calculateTcz.EdbCode, startDate, endDate)
  908. // if err != nil {
  909. // errmsg = "RefreshCalculateTcz Err:" + err.Error()
  910. // return err
  911. // }
  912. // } else if source == utils.DATA_SOURCE_CALCULATE_NSZYDPJJS { //N数值移动平均计算
  913. // calculateNszydpjjs, err := data_manage.GetEdbInfoCalculateNszydpjjsDetail(edbInfoId)
  914. // if err != nil {
  915. // errmsg = "GetEdbInfoCalculateNszydpjjsDetail Err:" + err.Error()
  916. // return err
  917. // }
  918. // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateNszydpjjs.FromEdbInfoId)
  919. // if err != nil {
  920. // errmsg = "GetEdbInfoById Err:" + err.Error()
  921. // return err
  922. // }
  923. // formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
  924. // startDate = edbInfo.StartDate
  925. // err = data_manage.RefreshAllCalculateNszydpjjs(edbInfoId, edbInfo.Source, formulaInt, fromEdbInfo, calculateNszydpjjs.EdbCode, startDate)
  926. // if err != nil {
  927. // errmsg = "RefreshCalculateNszydpjjs Err:" + err.Error()
  928. // return err
  929. // }
  930. // } else if source == utils.DATA_SOURCE_CALCULATE_HBZ { //刷新环比值
  931. // calculateTbz, err := data_manage.GetEdbInfoCalculateHbzDetail(edbInfoId)
  932. // if err != nil {
  933. // errmsg = "GetEdbInfoCalculateHbzDetail Err:" + err.Error()
  934. // return err
  935. // }
  936. // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId)
  937. // if err != nil {
  938. // errmsg = "GetEdbInfoById Err:" + err.Error()
  939. // return err
  940. // }
  941. // startDate = edbInfo.StartDate
  942. // endDate = time.Now().Format(utils.FormatDate)
  943. // formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
  944. // err = data_manage.RefreshAllCalculateHbz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, formulaInt)
  945. // if err != nil {
  946. // errmsg = "RefreshAllCalculateHbz Err:" + err.Error()
  947. // return err
  948. // }
  949. // } else if source == utils.DATA_SOURCE_CALCULATE_HCZ { //刷新环差值
  950. // calculateTbz, err := data_manage.GetEdbInfoCalculateHczDetail(edbInfoId)
  951. // if err != nil {
  952. // errmsg = "GetEdbInfoCalculateHczDetail Err:" + err.Error()
  953. // return err
  954. // }
  955. // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId)
  956. // if err != nil {
  957. // errmsg = "GetEdbInfoById Err:" + err.Error()
  958. // return err
  959. // }
  960. // startDate = edbInfo.StartDate
  961. // endDate = time.Now().Format(utils.FormatDate)
  962. // formulaInt, _ := strconv.Atoi(edbInfo.CalculateFormula)
  963. // err = data_manage.RefreshAllCalculateHcz(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate, formulaInt)
  964. // if err != nil {
  965. // errmsg = "RefreshAllCalculateHcz Err:" + err.Error()
  966. // return err
  967. // }
  968. // } else if source == utils.DATA_SOURCE_CALCULATE_BP { //刷新变频
  969. // calculateTbz, err := data_manage.GetEdbInfoCalculateBpDetail(edbInfoId)
  970. // if err != nil {
  971. // errmsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
  972. // return err
  973. // }
  974. // fromEdbInfo, err := data_manage.GetEdbInfoById(calculateTbz.FromEdbInfoId)
  975. // if err != nil {
  976. // errmsg = "GetEdbInfoById Err:" + err.Error()
  977. // return err
  978. // }
  979. // startDate = edbInfo.StartDate
  980. // endDate = time.Now().Format(utils.FormatDate)
  981. // err = data_manage.RefreshAllCalculateBp(edbInfoId, source, fromEdbInfo, calculateTbz.EdbCode, startDate, endDate)
  982. // if err != nil {
  983. // errmsg = "RefreshAllCalculateBp Err:" + err.Error()
  984. // return err
  985. // }
  986. //<<<<<<< HEAD
  987. // } else if source == utils.DATA_SOURCE_CALCULATE_TIME_SHIFT {
  988. // calculate, err := data_manage.GetEdbInfoCalculateMappingDetail(edbInfoId)
  989. // if err != nil {
  990. // errmsg = "GetEdbInfoCalculateTbzDetail Err:" + err.Error()
  991. // return err
  992. // }
  993. // fromEdbInfo, err := data_manage.GetEdbInfoById(calculate.FromEdbInfoId)
  994. // if err != nil {
  995. // errmsg = "GetEdbInfoById Err:" + err.Error()
  996. // return err
  997. // }
  998. // startDate = edbInfo.StartDate
  999. // endDate = time.Now().Format(utils.FormatDate)
  1000. // formulaInt, _ := strconv.Atoi(calculate.CalculateFormula)
  1001. // err = data_manage.RefreshAllCalculateTimeShift(edbInfoId, source, formulaInt, calculate.MoveType, fromEdbInfo, calculate.EdbCode, startDate, endDate, calculate.MoveFrequency)
  1002. // if err != nil {
  1003. // errmsg = "RefreshAllCalculateTimeShift Err:" + err.Error()
  1004. //=======
  1005. // } else if source == utils.DATA_SOURCE_CALCULATE_ZJPJ { //刷新直接拼接
  1006. // err = data_manage.RefreshAllCalculateZjpj(edbInfo)
  1007. // if err != nil {
  1008. // errmsg = "RefreshAllCalculateBp Err:" + err.Error()
  1009. //>>>>>>> 884fd669cc9e91923781680e1890a519c012d38e
  1010. // return err
  1011. // }
  1012. // }
  1013. //
  1014. // maxAndMinItem, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
  1015. // if err != nil {
  1016. // return err
  1017. // }
  1018. //
  1019. // if maxAndMinItem != nil {
  1020. // err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
  1021. // if err != nil {
  1022. // return err
  1023. // }
  1024. // }
  1025. // fmt.Println("end calculateArr:", v, time.Now())
  1026. // }
  1027. // return err
  1028. //}
  1029. //
  1030. //// AddEdbInfo 新增手工指标数据
  1031. //func AddEdbInfo(secName, unit, frequency, noticeTime, mobile string, classifyId, userId int) (err error) {
  1032. // tradeCode, err := models.GetMaxTradeCode()
  1033. // if err != nil {
  1034. // return
  1035. // }
  1036. //
  1037. // if tradeCode == "" {
  1038. // err = errors.New("最大编码为空")
  1039. // return
  1040. // }
  1041. // maxTradeCode, err := utils.GetMaxTradeCode(tradeCode)
  1042. // if err != nil {
  1043. // err = errors.New("获取编码信息失败,Err:" + err.Error())
  1044. // return
  1045. // }
  1046. // if maxTradeCode == "" {
  1047. // err = errors.New("编码为空,请联系技术")
  1048. // return
  1049. // }
  1050. // //判断指标名称是否为空
  1051. // if secName == "" {
  1052. // err = errors.New("指标名称不能为空")
  1053. // return
  1054. // }
  1055. // item, err := models.GetEdbinfoBySecName(secName)
  1056. // if err != nil && err.Error() != utils.ErrNoRow() {
  1057. // err = errors.New("获取信息失败,Err:" + err.Error())
  1058. // return
  1059. // }
  1060. // if item != nil {
  1061. // err = errors.New("指标名称已存在")
  1062. // return
  1063. // }
  1064. // err = models.AddEdbinfo(maxTradeCode, secName, unit, "手动", frequency, noticeTime, classifyId, userId)
  1065. // if err != nil {
  1066. // err = errors.New("新增失败,Err:" + err.Error())
  1067. // return
  1068. // }
  1069. // err = models.AddEdbinfoUser(maxTradeCode, mobile)
  1070. // return
  1071. //}
  1072. //
  1073. //
  1074. //
  1075. //
  1076. // AddOrEditAllEdbInfoToEs 修复ES中的指标
  1077. func AddOrEditAllEdbInfoToEs() {
  1078. //添加es
  1079. total, itemInfoList, _ := data_manage.GetEdbInfoFilterList("", []interface{}{}, 0, 100000)
  1080. for k, itemInfo := range itemInfoList {
  1081. elastic.EsAddOrEditEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(itemInfo.EdbInfoId), itemInfo)
  1082. fmt.Println("剩余", int(total)-k-1, "条数据")
  1083. }
  1084. }
  1085. // AddOrEditEdbInfoToEs 添加/修改ES中的指标
  1086. func AddOrEditEdbInfoToEs(edbInfoId int) {
  1087. //添加es
  1088. itemInfo, _ := data_manage.GetEdbInfoByCondition("AND edb_info_id=?", []interface{}{edbInfoId})
  1089. go elastic.EsAddOrEditEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(itemInfo.EdbInfoId), itemInfo)
  1090. }
  1091. // DeleteEdbInfoToEs 删除ES中的指标
  1092. func DeleteEdbInfoToEs(edbInfoId int) {
  1093. //添加es
  1094. go elastic.EsDeleteEdbInfoData(utils.DATA_INDEX_NAME, strconv.Itoa(edbInfoId))
  1095. }
  1096. // RefreshManualData 根据手工指标code刷新手工指标数据
  1097. func RefreshManualData(edbCode string) {
  1098. var err error
  1099. defer func() {
  1100. if err != nil {
  1101. go alarm_msg.SendAlarmMsg("导入手工数据后,根据手工指标code刷新手工指标数据失败提醒,Err"+err.Error(), 3)
  1102. //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"导入手工数据后,根据手工指标code刷新手工指标数据失败提醒", "errmsg:"+err.Error(), utils.EmailSendToUsers)
  1103. }
  1104. }()
  1105. edbInfo, err := data_manage.GetEdbInfoByEdbCode(utils.DATA_SOURCE_MANUAL, edbCode)
  1106. if err != nil {
  1107. if err.Error() == utils.ErrNoRow() {
  1108. err = nil
  1109. }
  1110. return
  1111. }
  1112. // 刷新指标库
  1113. err, _ = EdbInfoRefreshAllFromBaseV2(edbInfo.EdbInfoId, true)
  1114. return
  1115. }
  1116. // EdbInfoReplace 替换指标v2版本(更换时间:2022年01月05日15:33:42)
  1117. func EdbInfoReplace(oldEdbInfo, newEdbInfo *data_manage.EdbInfo, sysAdminId int, sysAdminRealName string) (replaceChartTotal, replaceCalculateTotal int, err error) {
  1118. defer func() {
  1119. if err != nil {
  1120. fmt.Println("ERR:", err.Error())
  1121. }
  1122. }()
  1123. mappingList, replaceChartTotal, replaceCalculateTotal, err := data_manage.ReplaceChartEdb(oldEdbInfo, newEdbInfo)
  1124. if err != nil {
  1125. return
  1126. }
  1127. //更新指标
  1128. err = replaceRelationEdbInfo(mappingList, oldEdbInfo, newEdbInfo, sysAdminId, sysAdminRealName)
  1129. return
  1130. }
  1131. // replaceRelationEdbInfo 刷新指标
  1132. func replaceRelationEdbInfo(mappingList []*data_manage.EdbInfoCalculateMapping, oldEdbInfo, newEdbInfo *data_manage.EdbInfo, sysAdminId int, sysAdminRealName string) (err error) {
  1133. errmsg := ``
  1134. defer func() {
  1135. if errmsg != "" {
  1136. fmt.Println("errmsg:" + errmsg)
  1137. }
  1138. if err != nil && errmsg != "" {
  1139. go alarm_msg.SendAlarmMsg("替换关联指标失败提醒,errmsg:"+errmsg, 3)
  1140. //go utils.SendEmail(utils.APPNAME+"【"+utils.RunMode+"】"+"替换指标失败提醒", "errmsg:"+errmsg, utils.EmailSendToUsers)
  1141. }
  1142. }()
  1143. //获取计算指标关联指标
  1144. allMappingList := make([]*data_manage.EdbInfoCalculateMapping, 0)
  1145. allMapping := make(map[int]int)
  1146. tmpMapping := make(map[int]int)
  1147. for _, v := range mappingList {
  1148. if _, ok := allMapping[v.EdbInfoId]; !ok {
  1149. allMappingList = append(allMappingList, v)
  1150. }
  1151. newList, _ := data_manage.GetAllCalculateV2(v.EdbInfoId, newEdbInfo.EdbInfoId, tmpMapping)
  1152. for _, nv := range newList {
  1153. if _, ok := allMapping[v.EdbInfoId]; !ok {
  1154. allMappingList = append(allMappingList, nv)
  1155. }
  1156. allMapping[v.EdbInfoId] = v.EdbInfoId
  1157. }
  1158. allMapping[v.EdbInfoId] = v.EdbInfoId
  1159. }
  1160. for mk, mv := range allMappingList { //原指标关联的所有计算指标
  1161. fmt.Println("mk/mv", mk, mv)
  1162. //重新计算计算指标
  1163. {
  1164. edbInfo, tmpErr := data_manage.GetEdbInfoById(mv.EdbInfoId) //计算指标
  1165. err = tmpErr
  1166. if err != nil {
  1167. if err.Error() == utils.ErrNoRow() {
  1168. errmsg = "计算指标已被删除"
  1169. } else {
  1170. errmsg = "获取计算指标失败:err:" + err.Error()
  1171. }
  1172. return
  1173. }
  1174. fromEdbInfoList, tmpErr := data_manage.GetEdbInfoCalculateDetail(mv.EdbInfoId, edbInfo.Source)
  1175. err = tmpErr
  1176. if err != nil {
  1177. errmsg = "获取计算指标失败:err:" + err.Error()
  1178. return
  1179. }
  1180. if len(fromEdbInfoList) <= 0 {
  1181. errmsg = "计算指标所依赖指标不存在"
  1182. err = fmt.Errorf("计算指标所依赖指标不存在")
  1183. return
  1184. }
  1185. fromEdbInfoItem := fromEdbInfoList[0]
  1186. if fromEdbInfoItem == nil {
  1187. return
  1188. }
  1189. fromEdbInfo, tmpErr := data_manage.GetEdbInfoById(fromEdbInfoItem.FromEdbInfoId)
  1190. err = tmpErr
  1191. if err != nil {
  1192. errmsg = "获取计算指标 来源指标失败:err:" + err.Error()
  1193. return
  1194. }
  1195. edbCode := edbInfo.EdbCode
  1196. //uniqueCode := edbInfo.UniqueCode
  1197. sourName := edbInfo.SourceName
  1198. source := edbInfo.Source
  1199. edbInfoId := edbInfo.EdbInfoId
  1200. req := &data_manage.EdbInfoCalculateBatchSaveReqByEdbLib{
  1201. AdminId: sysAdminId,
  1202. AdminName: sysAdminRealName,
  1203. EdbInfoId: edbInfoId,
  1204. EdbName: edbInfo.EdbName,
  1205. Frequency: edbInfo.Frequency,
  1206. Unit: edbInfo.Unit,
  1207. ClassifyId: edbInfo.ClassifyId,
  1208. Formula: edbInfo.CalculateFormula, //N数值移动平均计算、环比值、环差值
  1209. FromEdbInfoId: fromEdbInfoList[0].FromEdbInfoId,
  1210. Source: edbInfo.Source,
  1211. MoveType: edbInfo.MoveType,
  1212. MoveFrequency: edbInfo.MoveFrequency,
  1213. CalculateFormula: edbInfo.CalculateFormula,
  1214. EdbInfoIdArr: nil,
  1215. }
  1216. if source == utils.DATA_SOURCE_CALCULATE_ZJPJ {
  1217. edbInfoIdArr := make([]data_manage.EdbInfoFromTag, 0)
  1218. //A指标
  1219. aFromEdbInfoId := fromEdbInfoList[0].FromEdbInfoId
  1220. //找出需要替换的指标
  1221. {
  1222. for _, v := range fromEdbInfoList {
  1223. if v.FromTag == "A" {
  1224. if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
  1225. aFromEdbInfoId = newEdbInfo.EdbInfoId
  1226. } else {
  1227. aFromEdbInfoId = fromEdbInfoList[0].FromEdbInfoId
  1228. }
  1229. }
  1230. if v.FromTag == "B" {
  1231. if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
  1232. edbInfoIdArr = append(edbInfoIdArr, data_manage.EdbInfoFromTag{
  1233. EdbInfoId: newEdbInfo.EdbInfoId,
  1234. FromTag: v.FromTag,
  1235. })
  1236. } else {
  1237. edbInfoIdArr = append(edbInfoIdArr, data_manage.EdbInfoFromTag{
  1238. EdbInfoId: v.FromEdbInfoId,
  1239. FromTag: v.FromTag,
  1240. })
  1241. }
  1242. }
  1243. }
  1244. }
  1245. req.FromEdbInfoId = aFromEdbInfoId
  1246. req.EdbInfoIdArr = edbInfoIdArr
  1247. sourName = "直接拼接"
  1248. if len(req.EdbInfoIdArr) != 1 {
  1249. errmsg = "请传入拼接日期之后的指标"
  1250. err = fmt.Errorf("请传入拼接日期之后的指标")
  1251. return
  1252. }
  1253. secondEdbInfoReq := req.EdbInfoIdArr[0]
  1254. secondEdbInfo, tmpErr := data_manage.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
  1255. err = tmpErr
  1256. if err != nil {
  1257. errmsg = "获取拼接日期之后的指标信息失败:Err:" + err.Error()
  1258. err = fmt.Errorf("获取拼接日期之后的指标信息失败:Err:" + err.Error())
  1259. return
  1260. }
  1261. if fromEdbInfo.EdbInfoId == secondEdbInfo.EdbInfoId {
  1262. errmsg = "两个指标不允许为同一个"
  1263. err = fmt.Errorf("两个指标不允许为同一个")
  1264. return
  1265. }
  1266. } else if source == utils.DATA_SOURCE_CALCULATE_LJZTBPJ { //累计值同比拼接
  1267. edbInfoIdArr := make([]data_manage.EdbInfoFromTag, 0)
  1268. //A指标
  1269. aFromEdbInfoId := fromEdbInfoList[0].FromEdbInfoId
  1270. // 找出需要替换的指标
  1271. {
  1272. for _, v := range fromEdbInfoList {
  1273. if v.FromTag == "A" {
  1274. if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
  1275. aFromEdbInfoId = newEdbInfo.EdbInfoId
  1276. } else {
  1277. aFromEdbInfoId = fromEdbInfoList[0].FromEdbInfoId
  1278. }
  1279. }
  1280. if v.FromTag == "B" {
  1281. if v.FromEdbInfoId == oldEdbInfo.EdbInfoId {
  1282. edbInfoIdArr = append(edbInfoIdArr, data_manage.EdbInfoFromTag{
  1283. EdbInfoId: newEdbInfo.EdbInfoId,
  1284. FromTag: v.FromTag,
  1285. })
  1286. } else {
  1287. edbInfoIdArr = append(edbInfoIdArr, data_manage.EdbInfoFromTag{
  1288. EdbInfoId: v.FromEdbInfoId,
  1289. FromTag: v.FromTag,
  1290. })
  1291. }
  1292. }
  1293. }
  1294. }
  1295. req.FromEdbInfoId = aFromEdbInfoId
  1296. req.EdbInfoIdArr = edbInfoIdArr
  1297. sourName = "累计值同比拼接"
  1298. if fromEdbInfo.Frequency != "月度" {
  1299. errmsg = "累计值同比拼接,待拼接指标只能筛选月度指标"
  1300. err = fmt.Errorf("累计值同比拼接,待拼接指标只能筛选月度指标")
  1301. return
  1302. }
  1303. if len(req.EdbInfoIdArr) != 1 {
  1304. errmsg = "请传入同比值指标"
  1305. err = fmt.Errorf("请传入同比值指标")
  1306. return
  1307. }
  1308. secondEdbInfoReq := req.EdbInfoIdArr[0]
  1309. tbzEdbInfo, tmpErr := data_manage.GetEdbInfoById(secondEdbInfoReq.EdbInfoId)
  1310. err = tmpErr
  1311. if err != nil {
  1312. errmsg = "获取同比值指标信息失败:Err:" + err.Error()
  1313. err = fmt.Errorf("获取同比值指标信息失败:Err:" + err.Error())
  1314. return
  1315. }
  1316. if tbzEdbInfo.Source != utils.DATA_SOURCE_CALCULATE_TBZ {
  1317. errmsg = "指标必须是传入同比值指标类型"
  1318. err = fmt.Errorf("指标必须是传入同比值指标类型")
  1319. return
  1320. }
  1321. if tbzEdbInfo.Frequency != "月度" {
  1322. errmsg = "同比值指标只能筛选月度指标"
  1323. err = fmt.Errorf("同比值指标只能筛选月度指标")
  1324. return
  1325. }
  1326. if fromEdbInfo.EdbInfoId == tbzEdbInfo.EdbInfoId {
  1327. errmsg = "两个指标不允许为同一个"
  1328. err = fmt.Errorf("两个指标不允许为同一个")
  1329. return
  1330. }
  1331. } else {
  1332. errmsg = "无效计算方式,source:" + strconv.Itoa(source)
  1333. err = fmt.Errorf("无效计算方式,source:" + strconv.Itoa(source))
  1334. return
  1335. }
  1336. // 调用指标库去更新
  1337. reqJson, tmpErr := json.Marshal(req)
  1338. if tmpErr == nil {
  1339. respItem, tmpErr := EditEdbCalculateData(string(reqJson))
  1340. if err != nil {
  1341. err = tmpErr
  1342. return
  1343. }
  1344. if respItem.Ret != 200 {
  1345. err = errors.New("修改失败")
  1346. return
  1347. }
  1348. } else {
  1349. err = tmpErr
  1350. }
  1351. maxAndMinItem, tmpErr := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
  1352. err = tmpErr
  1353. if err != nil && err.Error() != utils.ErrNoRow() {
  1354. errmsg = "生成" + sourName + "失败,GetEdbInfoMaxAndMinInfo Err:" + err.Error()
  1355. err = fmt.Errorf("生成" + sourName + "失败,GetEdbInfoMaxAndMinInfo Err:" + err.Error())
  1356. return
  1357. }
  1358. if maxAndMinItem != nil {
  1359. err = data_manage.ModifyEdbInfoMaxAndMinInfo(edbInfoId, maxAndMinItem)
  1360. }
  1361. }
  1362. }
  1363. return
  1364. }
  1365. // 获取频度的英文版
  1366. func GetFrequencyEn(frequency string) (frequencyEn string) {
  1367. switch frequency {
  1368. case "日度":
  1369. frequencyEn = "day"
  1370. return
  1371. case "周度":
  1372. frequencyEn = "week"
  1373. return
  1374. case "旬度":
  1375. frequencyEn = "ten days"
  1376. return
  1377. case "月度":
  1378. frequencyEn = "month"
  1379. return
  1380. case "季度":
  1381. frequencyEn = "quarter"
  1382. return
  1383. case "年度":
  1384. frequencyEn = "year"
  1385. return
  1386. }
  1387. return
  1388. }
  1389. func GetLeadUnitEn(unit string) (unitEn string) {
  1390. switch unit {
  1391. case "天":
  1392. unitEn = "day"
  1393. return
  1394. case "周":
  1395. unitEn = "week"
  1396. return
  1397. case "月":
  1398. unitEn = "month"
  1399. return
  1400. case "季":
  1401. unitEn = "quarter"
  1402. return
  1403. case "年":
  1404. unitEn = "year"
  1405. return
  1406. }
  1407. return
  1408. }
  1409. // getRefreshEdbInfoList 获取待更新的指标(普通基础指标、普通运算指标,预测运算指标)
  1410. //func getRefreshEdbInfoList(edbInfoId int) (newBaseEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) {
  1411. // calculateList, err := data_manage.GetEdbInfoAllCalculate(edbInfoId)
  1412. // if err != nil && err.Error() != utils.ErrNoRow() {
  1413. // err = errors.New("GetEdbInfoAllCalculate Err:" + err.Error())
  1414. // return
  1415. // }
  1416. // // 获取指标信息
  1417. // baseEdbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
  1418. // if err != nil {
  1419. // err = errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error())
  1420. // return
  1421. // }
  1422. //
  1423. // baseEdbInfoArr := make([]*data_manage.EdbInfo, 0) // 基础普通指标
  1424. // calculateInfoArr := make([]*data_manage.EdbInfo, 0) //基础运算指标
  1425. // basePredictEdbInfoArr := make([]*data_manage.EdbInfo, 0) // 预测普通指标
  1426. // predictCalculateInfoArr := make([]*data_manage.EdbInfo, 0) //预测运算指标
  1427. //
  1428. // if baseEdbInfo.EdbInfoType == 0 { //普通指标
  1429. // switch baseEdbInfo.EdbType {
  1430. // case 1: //基础指标
  1431. // baseEdbInfoArr = append(baseEdbInfoArr, baseEdbInfo)
  1432. // case 2: //计算指标
  1433. // calculateList = append(calculateList, baseEdbInfo)
  1434. // }
  1435. // } else { //预测指标
  1436. // switch baseEdbInfo.EdbType {
  1437. // case 1: //基础指标
  1438. // basePredictEdbInfoArr = append(basePredictEdbInfoArr, baseEdbInfo)
  1439. // case 2: //计算指标
  1440. // predictCalculateInfoArr = append(predictCalculateInfoArr, baseEdbInfo)
  1441. // }
  1442. // }
  1443. //
  1444. // // 计算指标
  1445. // for _, v := range calculateList {
  1446. // getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  1447. // if tmpErr != nil {
  1448. // err = tmpErr
  1449. // fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
  1450. // errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
  1451. // return
  1452. // }
  1453. // for _, tmpEdbInfo := range getBaseEdbInfoArr {
  1454. // switch tmpEdbInfo.EdbInfoType {
  1455. // case 0: //普通基础指标
  1456. // baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
  1457. // case 1: //预测基础指标
  1458. // basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  1459. // }
  1460. // }
  1461. //
  1462. // for _, tmpEdbInfo := range getCalculateInfoArr {
  1463. // switch tmpEdbInfo.EdbInfoType {
  1464. // case 0: //普通运算指标
  1465. // calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
  1466. // case 1: //预测运算指标
  1467. // predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  1468. // }
  1469. // }
  1470. // switch v.EdbInfoType {
  1471. // case 0: //普通运算指标
  1472. // calculateInfoArr = append(calculateInfoArr, v)
  1473. // case 1: //预测运算指标
  1474. // predictCalculateInfoArr = append(predictCalculateInfoArr, v)
  1475. // }
  1476. // }
  1477. //
  1478. // // 预测计算指标
  1479. // for _, v := range predictCalculateInfoArr {
  1480. // getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  1481. // if tmpErr != nil {
  1482. // err = tmpErr
  1483. // fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
  1484. // errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
  1485. // return
  1486. // }
  1487. // for _, tmpEdbInfo := range getBaseEdbInfoArr {
  1488. // switch tmpEdbInfo.EdbInfoType {
  1489. // case 0: //普通基础指标
  1490. // baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
  1491. // case 1: //预测基础指标
  1492. // basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  1493. // }
  1494. // }
  1495. //
  1496. // for _, tmpEdbInfo := range getCalculateInfoArr {
  1497. // switch tmpEdbInfo.EdbInfoType {
  1498. // case 0: //普通运算指标
  1499. // calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
  1500. // case 1: //预测运算指标
  1501. // predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  1502. // }
  1503. // }
  1504. // switch v.EdbInfoType {
  1505. // case 0: //普通运算指标
  1506. // calculateInfoArr = append(calculateInfoArr, v)
  1507. // case 1: //预测运算指标
  1508. // predictCalculateInfoArr = append(predictCalculateInfoArr, v)
  1509. // }
  1510. // }
  1511. //
  1512. // // 第一次的计算指标map
  1513. // newCalculateMap = make(map[int]*data_manage.EdbInfo)
  1514. // for _, v := range calculateInfoArr {
  1515. // if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
  1516. // calculateArr = append(calculateArr, v.EdbInfoId)
  1517. // }
  1518. // newCalculateMap[v.EdbInfoId] = v
  1519. // }
  1520. //
  1521. // // 基础预测指标
  1522. // if len(basePredictEdbInfoArr) > 0 {
  1523. // basePredictEdbInfoIdList := make([]int, 0)
  1524. // for _, v := range basePredictEdbInfoArr {
  1525. // basePredictEdbInfoIdList = append(basePredictEdbInfoIdList, v.EdbInfoId)
  1526. // }
  1527. // baseEdbInfoList, tmpErr := data_manage.GetPredictEdbInfoAllCalculate(basePredictEdbInfoIdList)
  1528. // if tmpErr != nil {
  1529. // err = tmpErr
  1530. // return
  1531. // }
  1532. //
  1533. // tmpCalculateList := make([]*data_manage.EdbInfo, 0)
  1534. // for _, v := range baseEdbInfoList {
  1535. // switch v.EdbType {
  1536. // case 1:
  1537. // baseEdbInfoArr = append(baseEdbInfoArr, v)
  1538. // case 2:
  1539. // // 如果不在第一次里面,那么在第二次 刷新预测指标的时候 需要加进去
  1540. // if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
  1541. // tmpCalculateList = append(tmpCalculateList, v)
  1542. // }
  1543. // }
  1544. // }
  1545. //
  1546. // // 这里是查询预测指标用到的 普通计算指标
  1547. // for _, v := range tmpCalculateList {
  1548. // getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  1549. // if tmpErr != nil {
  1550. // err = tmpErr
  1551. // fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
  1552. // errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
  1553. // return
  1554. // }
  1555. //
  1556. // // 基础指标
  1557. // for _, tmpEdbInfo := range getBaseEdbInfoArr {
  1558. // switch tmpEdbInfo.EdbInfoType {
  1559. // case 0: //普通基础指标
  1560. // baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
  1561. // case 1: //预测基础指标
  1562. // basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  1563. // }
  1564. // }
  1565. //
  1566. // // 计算指标
  1567. // for _, tmpEdbInfo := range getCalculateInfoArr {
  1568. // switch tmpEdbInfo.EdbInfoType {
  1569. // case 0: //普通运算指标
  1570. // calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
  1571. // case 1: //预测运算指标
  1572. // predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  1573. // }
  1574. // }
  1575. // switch v.EdbInfoType {
  1576. // case 0: //普通运算指标
  1577. // calculateInfoArr = append(calculateInfoArr, v)
  1578. // case 1: //预测运算指标
  1579. // predictCalculateInfoArr = append(predictCalculateInfoArr, v)
  1580. // }
  1581. // }
  1582. //
  1583. // // 第二次计算指标的map
  1584. // for _, v := range calculateInfoArr {
  1585. // if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
  1586. // calculateArr = append(calculateArr, v.EdbInfoId)
  1587. // }
  1588. // newCalculateMap[v.EdbInfoId] = v
  1589. // }
  1590. // }
  1591. //
  1592. // // 普通基础指标去重
  1593. // newBaseEdbInfoArr = make([]*data_manage.EdbInfo, 0)
  1594. // baseMap := make(map[int]int)
  1595. // for _, v := range baseEdbInfoArr {
  1596. // if _, ok := baseMap[v.EdbInfoId]; !ok {
  1597. // newBaseEdbInfoArr = append(newBaseEdbInfoArr, v)
  1598. // }
  1599. // baseMap[v.EdbInfoId] = v.EdbInfoId
  1600. // }
  1601. //
  1602. // // 普通计算指标的id
  1603. // sort.Ints(calculateArr)
  1604. //
  1605. // // 预测计算指标去重
  1606. // newPredictCalculateMap = make(map[int]*data_manage.EdbInfo)
  1607. // for _, v := range predictCalculateInfoArr {
  1608. // if _, ok := newPredictCalculateMap[v.EdbInfoId]; !ok {
  1609. // predictCalculateArr = append(predictCalculateArr, v.EdbInfoId)
  1610. // }
  1611. // newPredictCalculateMap[v.EdbInfoId] = v
  1612. // }
  1613. // // 预测计算指标的id
  1614. // sort.Ints(predictCalculateArr)
  1615. //
  1616. // return
  1617. //}
  1618. // getRefreshEdbInfoList 获取待更新的指标(普通基础指标、普通运算指标,预测运算指标)
  1619. func getRefreshEdbInfoListByIds(edbInfoIdList []int) (newBaseEdbInfoArr, newBasePredictEdbInfoArr []*data_manage.EdbInfo, newCalculateMap, newPredictCalculateMap map[int]*data_manage.EdbInfo, calculateArr, predictCalculateArr []int, err error, errMsg string) {
  1620. calculateList, err := data_manage.GetEdbInfoAllCalculateByEdbInfoIdList(edbInfoIdList)
  1621. if err != nil && err.Error() != utils.ErrNoRow() {
  1622. err = errors.New("GetEdbInfoAllCalculate Err:" + err.Error())
  1623. return
  1624. }
  1625. // 获取指标信息
  1626. edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
  1627. if err != nil {
  1628. err = errors.New("GetEdbInfoAllCalGetEdbInfoByIdr:" + err.Error())
  1629. return
  1630. }
  1631. baseEdbInfoArr := make([]*data_manage.EdbInfo, 0) // 基础普通指标
  1632. calculateInfoArr := make([]*data_manage.EdbInfo, 0) //基础运算指标
  1633. basePredictEdbInfoArr := make([]*data_manage.EdbInfo, 0) // 预测普通指标
  1634. predictCalculateInfoArr := make([]*data_manage.EdbInfo, 0) //预测运算指标
  1635. for _, baseEdbInfo := range edbInfoList {
  1636. // 指标若停更, 则忽略掉
  1637. if baseEdbInfo.NoUpdate == 1 {
  1638. continue
  1639. }
  1640. if baseEdbInfo.EdbInfoType == 0 { //普通指标
  1641. switch baseEdbInfo.EdbType {
  1642. case 1: //基础指标
  1643. baseEdbInfoArr = append(baseEdbInfoArr, baseEdbInfo)
  1644. case 2: //计算指标
  1645. calculateList = append(calculateList, baseEdbInfo)
  1646. }
  1647. } else { //预测指标
  1648. switch baseEdbInfo.EdbType {
  1649. case 1: //基础指标
  1650. basePredictEdbInfoArr = append(basePredictEdbInfoArr, baseEdbInfo)
  1651. case 2: //计算指标
  1652. predictCalculateInfoArr = append(predictCalculateInfoArr, baseEdbInfo)
  1653. }
  1654. }
  1655. }
  1656. // 计算指标
  1657. for _, v := range calculateList {
  1658. getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  1659. if tmpErr != nil {
  1660. err = tmpErr
  1661. fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
  1662. errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
  1663. return
  1664. }
  1665. for _, tmpEdbInfo := range getBaseEdbInfoArr {
  1666. switch tmpEdbInfo.EdbInfoType {
  1667. case 0: //普通基础指标
  1668. baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
  1669. case 1: //预测基础指标
  1670. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  1671. }
  1672. }
  1673. for _, tmpEdbInfo := range getCalculateInfoArr {
  1674. switch tmpEdbInfo.EdbInfoType {
  1675. case 0: //普通运算指标
  1676. calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
  1677. case 1: //预测运算指标
  1678. //predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  1679. if tmpEdbInfo.EdbType == 1 { //预测普通指标
  1680. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  1681. } else {
  1682. predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  1683. }
  1684. }
  1685. }
  1686. switch v.EdbInfoType {
  1687. case 0: //普通运算指标
  1688. calculateInfoArr = append(calculateInfoArr, v)
  1689. case 1: //预测指标
  1690. if v.EdbType == 1 { //预测普通指标
  1691. basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
  1692. } else {
  1693. predictCalculateInfoArr = append(predictCalculateInfoArr, v)
  1694. }
  1695. }
  1696. }
  1697. // 预测计算指标
  1698. for _, v := range predictCalculateInfoArr {
  1699. getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  1700. if tmpErr != nil {
  1701. err = tmpErr
  1702. fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
  1703. errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
  1704. return
  1705. }
  1706. for _, tmpEdbInfo := range getBaseEdbInfoArr {
  1707. switch tmpEdbInfo.EdbInfoType {
  1708. case 0: //普通基础指标
  1709. baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
  1710. case 1: //预测基础指标
  1711. if tmpEdbInfo.EdbType == 1 { //预测普通指标
  1712. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  1713. } else {
  1714. predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  1715. }
  1716. //basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  1717. }
  1718. }
  1719. for _, tmpEdbInfo := range getCalculateInfoArr {
  1720. switch tmpEdbInfo.EdbInfoType {
  1721. case 0: //普通运算指标
  1722. calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
  1723. case 1: //预测运算指标
  1724. if tmpEdbInfo.EdbType == 1 { //预测普通指标
  1725. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  1726. } else {
  1727. predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  1728. }
  1729. //predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  1730. }
  1731. }
  1732. switch v.EdbInfoType {
  1733. case 0: //普通运算指标
  1734. calculateInfoArr = append(calculateInfoArr, v)
  1735. case 1: //预测指标
  1736. if v.EdbType == 1 { //预测普通指标
  1737. basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
  1738. } else {
  1739. predictCalculateInfoArr = append(predictCalculateInfoArr, v)
  1740. }
  1741. }
  1742. }
  1743. // 第一次的计算指标map
  1744. newCalculateMap = make(map[int]*data_manage.EdbInfo)
  1745. for _, v := range calculateInfoArr {
  1746. if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
  1747. calculateArr = append(calculateArr, v.EdbInfoId)
  1748. }
  1749. newCalculateMap[v.EdbInfoId] = v
  1750. }
  1751. // 基础预测指标
  1752. if len(basePredictEdbInfoArr) > 0 {
  1753. basePredictEdbInfoIdList := make([]int, 0)
  1754. for _, v := range basePredictEdbInfoArr {
  1755. basePredictEdbInfoIdList = append(basePredictEdbInfoIdList, v.EdbInfoId)
  1756. }
  1757. baseEdbInfoList, tmpErr := data_manage.GetPredictEdbInfoAllCalculate(basePredictEdbInfoIdList)
  1758. if tmpErr != nil {
  1759. err = tmpErr
  1760. return
  1761. }
  1762. tmpCalculateList := make([]*data_manage.EdbInfo, 0)
  1763. for _, v := range baseEdbInfoList {
  1764. switch v.EdbType {
  1765. case 1:
  1766. baseEdbInfoArr = append(baseEdbInfoArr, v)
  1767. case 2:
  1768. // 如果不在第一次里面,那么在第二次 刷新预测指标的时候 需要加进去
  1769. if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
  1770. tmpCalculateList = append(tmpCalculateList, v)
  1771. }
  1772. }
  1773. }
  1774. // 这里是查询预测指标用到的 普通计算指标
  1775. for _, v := range tmpCalculateList {
  1776. getBaseEdbInfoArr, getCalculateInfoArr, tmpErr := data_manage.GetRefreshEdbInfoFromBase(v.EdbInfoId, v.Source)
  1777. if tmpErr != nil {
  1778. err = tmpErr
  1779. fmt.Println("GetRefreshEdbInfoFromBase err:" + err.Error())
  1780. errMsg = "获取需要刷新的指标失败:Err:" + err.Error()
  1781. return
  1782. }
  1783. // 基础指标
  1784. for _, tmpEdbInfo := range getBaseEdbInfoArr {
  1785. switch tmpEdbInfo.EdbInfoType {
  1786. case 0: //普通基础指标
  1787. baseEdbInfoArr = append(baseEdbInfoArr, tmpEdbInfo)
  1788. case 1: //预测基础指标
  1789. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  1790. }
  1791. }
  1792. // 计算指标
  1793. for _, tmpEdbInfo := range getCalculateInfoArr {
  1794. switch tmpEdbInfo.EdbInfoType {
  1795. case 0: //普通运算指标
  1796. calculateInfoArr = append(calculateInfoArr, tmpEdbInfo)
  1797. case 1: //预测运算指标
  1798. if v.EdbType == 1 { //预测普通指标
  1799. basePredictEdbInfoArr = append(basePredictEdbInfoArr, tmpEdbInfo)
  1800. } else {
  1801. predictCalculateInfoArr = append(predictCalculateInfoArr, tmpEdbInfo)
  1802. }
  1803. }
  1804. }
  1805. switch v.EdbInfoType {
  1806. case 0: //普通运算指标
  1807. calculateInfoArr = append(calculateInfoArr, v)
  1808. case 1: //预测指标
  1809. if v.EdbType == 1 { //预测普通指标
  1810. basePredictEdbInfoArr = append(basePredictEdbInfoArr, v)
  1811. } else { //预测运算指标
  1812. predictCalculateInfoArr = append(predictCalculateInfoArr, v)
  1813. }
  1814. }
  1815. }
  1816. // 第二次计算指标的map
  1817. for _, v := range calculateInfoArr {
  1818. if _, ok := newCalculateMap[v.EdbInfoId]; !ok {
  1819. calculateArr = append(calculateArr, v.EdbInfoId)
  1820. }
  1821. newCalculateMap[v.EdbInfoId] = v
  1822. }
  1823. }
  1824. // 普通基础指标去重
  1825. newBaseEdbInfoArr = make([]*data_manage.EdbInfo, 0)
  1826. baseMap := make(map[int]int)
  1827. for _, v := range baseEdbInfoArr {
  1828. if _, ok := baseMap[v.EdbInfoId]; !ok {
  1829. newBaseEdbInfoArr = append(newBaseEdbInfoArr, v)
  1830. }
  1831. baseMap[v.EdbInfoId] = v.EdbInfoId
  1832. }
  1833. // 普通计算指标的id
  1834. sort.Ints(calculateArr)
  1835. // 普通预测指标去重
  1836. newBasePredictEdbInfoArr = make([]*data_manage.EdbInfo, 0)
  1837. basePredictMap := make(map[int]int)
  1838. for _, v := range basePredictEdbInfoArr {
  1839. if _, ok := basePredictMap[v.EdbInfoId]; !ok {
  1840. newBasePredictEdbInfoArr = append(newBasePredictEdbInfoArr, v)
  1841. }
  1842. basePredictMap[v.EdbInfoId] = v.EdbInfoId
  1843. }
  1844. // 预测计算指标去重
  1845. newPredictCalculateMap = make(map[int]*data_manage.EdbInfo)
  1846. for _, v := range predictCalculateInfoArr {
  1847. if _, ok := newPredictCalculateMap[v.EdbInfoId]; !ok {
  1848. predictCalculateArr = append(predictCalculateArr, v.EdbInfoId)
  1849. }
  1850. newPredictCalculateMap[v.EdbInfoId] = v
  1851. }
  1852. // 预测计算指标的id
  1853. sort.Ints(predictCalculateArr)
  1854. return
  1855. }
  1856. // GetMoveEdbChartList 获取待转移的指标/图表列表
  1857. // @param source 来源 :1:手工数据指标 2:钢联化工数据库 3:ETA指标库 4:ETA预测指标 5:图库
  1858. func GetMoveEdbChartList(source, userId int, keyword, classify string, startSize, pageSize int) (list []data_manage.MoveEdbChartList, total int, err error) {
  1859. var condition string
  1860. var pars []interface{}
  1861. switch source {
  1862. case 1: //手工数据指标
  1863. if keyword != "" {
  1864. condition += ` AND (a.SEC_NAME LIKE ? OR a.TRADE_CODE like ? ) `
  1865. pars = append(pars, `%`+keyword+`%`, `%`+keyword+`%`)
  1866. }
  1867. if userId > 0 {
  1868. condition += ` AND a.user_id = ? `
  1869. pars = append(pars, userId)
  1870. }
  1871. if classify != "" {
  1872. condition += ` AND a.classify_id IN (` + classify + `) `
  1873. }
  1874. total, err = models.GetEdbinfoListCount(condition, pars, "", 0)
  1875. if err != nil {
  1876. return
  1877. }
  1878. tmpList, tmpErr := models.GetEdbinfoList(condition, pars, startSize, pageSize, "", 0)
  1879. if tmpErr != nil {
  1880. err = tmpErr
  1881. return
  1882. }
  1883. if len(tmpList) > 0 {
  1884. adminIdList := make([]int, 0)
  1885. for _, v := range tmpList {
  1886. adminIdList = append(adminIdList, v.UserId)
  1887. }
  1888. adminList, tmpErr := system.GetAdminListByIdListWithoutEnable(adminIdList)
  1889. if tmpErr != nil {
  1890. err = tmpErr
  1891. return
  1892. }
  1893. adminMap := make(map[int]string)
  1894. for _, adminInfo := range adminList {
  1895. adminMap[adminInfo.AdminId] = adminInfo.RealName
  1896. }
  1897. for _, v := range tmpList {
  1898. list = append(list, data_manage.MoveEdbChartList{
  1899. DataId: v.TradeCode,
  1900. Code: v.TradeCode,
  1901. Name: v.SecName,
  1902. ClassifyName: v.ClassifyName,
  1903. CreateUserId: v.UserId,
  1904. CreateUserName: adminMap[v.UserId],
  1905. })
  1906. }
  1907. }
  1908. case 2: //钢联化工数据库
  1909. if keyword != `` {
  1910. condition += " AND (index_name like ? OR index_code like ? OR sys_user_real_name like ? ) "
  1911. pars = append(pars, "%"+keyword+"%", "%"+keyword+"%", "%"+keyword+"%")
  1912. }
  1913. if userId > 0 {
  1914. condition += ` AND sys_user_id = ? `
  1915. pars = append(pars, userId)
  1916. }
  1917. if classify != "" {
  1918. condition += ` AND base_from_mysteel_chemical_classify_id IN (` + classify + `) `
  1919. }
  1920. total, err = data_manage.GetMysteelChemicalIndexCount(condition, pars)
  1921. if err != nil {
  1922. return
  1923. }
  1924. tmpList, tmpErr := data_manage.GetMysteelChemicalIndexList(condition, pars, startSize, pageSize)
  1925. if tmpErr != nil {
  1926. err = tmpErr
  1927. return
  1928. }
  1929. for _, v := range tmpList {
  1930. list = append(list, data_manage.MoveEdbChartList{
  1931. DataId: strconv.Itoa(v.BaseFromMysteelChemicalIndexId),
  1932. Code: v.IndexCode,
  1933. Name: v.IndexName,
  1934. //ClassifyName: v.,
  1935. CreateUserId: v.SysUserId,
  1936. CreateUserName: v.SysUserRealName,
  1937. })
  1938. }
  1939. case 3, 4: //ETA指标库、ETA预测指标
  1940. if keyword != `` {
  1941. condition += " AND (edb_code like ? OR edb_name like ? OR sys_user_real_name like ? ) "
  1942. pars = append(pars, "%"+keyword+"%", "%"+keyword+"%", "%"+keyword+"%")
  1943. }
  1944. if userId > 0 {
  1945. condition += ` AND sys_user_id = ? `
  1946. pars = append(pars, userId)
  1947. }
  1948. if classify != "" {
  1949. condition += ` AND classify_id IN (` + classify + `) `
  1950. }
  1951. edbInfoType := 0 //ETA指标库
  1952. if source == 4 { //ETA预测指标
  1953. edbInfoType = 1
  1954. }
  1955. condition += ` AND edb_info_type = ? `
  1956. pars = append(pars, edbInfoType)
  1957. total, err = data_manage.GetEdbInfoByConditionCount(condition, pars)
  1958. if err != nil {
  1959. return
  1960. }
  1961. tmpList, tmpErr := data_manage.GetEdbInfoListByCondition(condition, pars, startSize, pageSize)
  1962. if tmpErr != nil {
  1963. err = tmpErr
  1964. return
  1965. }
  1966. for _, v := range tmpList {
  1967. list = append(list, data_manage.MoveEdbChartList{
  1968. DataId: strconv.Itoa(v.EdbInfoId),
  1969. Code: v.EdbCode,
  1970. Name: v.EdbName,
  1971. //ClassifyName: v.,
  1972. CreateUserId: v.SysUserId,
  1973. CreateUserName: v.SysUserRealName,
  1974. })
  1975. }
  1976. case 5: //图库
  1977. if keyword != `` {
  1978. condition += " AND (chart_name like ? OR sys_user_real_name like ? ) "
  1979. pars = append(pars, "%"+keyword+"%", "%"+keyword+"%")
  1980. }
  1981. if userId > 0 {
  1982. condition += ` AND sys_user_id = ? `
  1983. pars = append(pars, userId)
  1984. }
  1985. if classify != "" {
  1986. condition += ` AND chart_classify_id IN (` + classify + `) `
  1987. }
  1988. total, err = data_manage.GetChartInfoCountByCondition(condition, pars)
  1989. if err != nil {
  1990. return
  1991. }
  1992. tmpList, tmpErr := data_manage.GetChartInfoListByCondition(condition, pars, startSize, pageSize)
  1993. if tmpErr != nil {
  1994. err = tmpErr
  1995. return
  1996. }
  1997. // 获取所有的图表分类
  1998. firstClassifyList, tmpErr := data_manage.GetChartClassifyByParentId(0, 1)
  1999. if tmpErr != nil {
  2000. err = tmpErr
  2001. return
  2002. }
  2003. firstClassifyNameMap := make(map[int]string)
  2004. for _, v := range firstClassifyList {
  2005. firstClassifyNameMap[v.ChartClassifyId] = v.ChartClassifyName
  2006. }
  2007. secondClassList, tmpErr := data_manage.GetChartClassifyAll(1)
  2008. if tmpErr != nil {
  2009. err = tmpErr
  2010. return
  2011. }
  2012. secondClassifyNameMap := make(map[int]string)
  2013. for _, v := range secondClassList {
  2014. firstName := firstClassifyNameMap[v.ParentId]
  2015. if firstName != `` {
  2016. firstName = firstName + " / "
  2017. }
  2018. secondClassifyNameMap[v.ChartClassifyId] = firstName + v.ChartClassifyName
  2019. }
  2020. for _, v := range tmpList {
  2021. list = append(list, data_manage.MoveEdbChartList{
  2022. DataId: strconv.Itoa(v.ChartInfoId),
  2023. Name: v.ChartName,
  2024. ClassifyName: secondClassifyNameMap[v.ChartClassifyId],
  2025. CreateUserId: v.SysUserId,
  2026. CreateUserName: v.SysUserRealName,
  2027. })
  2028. }
  2029. default:
  2030. return
  2031. }
  2032. return
  2033. }
  2034. // MoveEdbChart 转移指标/图表创建人
  2035. // @param source 来源 :1:手工数据指标 2:钢联化工数据库 3:ETA指标库 4:ETA预测指标 5:图库
  2036. func MoveEdbChart(source, userId int, dataId []string) (err error, errMsg string) {
  2037. adminInfo, err := system.GetSysAdminById(userId)
  2038. if err != nil {
  2039. return
  2040. }
  2041. switch source {
  2042. case 1: //手工数据指标
  2043. tmpList, tmpErr := models.GetEdbinfoListByCodeListGroupByUserId(dataId)
  2044. if tmpErr != nil {
  2045. err = tmpErr
  2046. return
  2047. }
  2048. if len(tmpList) > 0 {
  2049. for _, v := range tmpList {
  2050. if v.UserId == userId {
  2051. errMsg = "新创建人不可和原创建人一致"
  2052. err = errors.New(errMsg)
  2053. return
  2054. }
  2055. }
  2056. // 修改创建人
  2057. err = models.ModifyEdbinfoUserIdByCodeList(dataId, userId)
  2058. }
  2059. case 2: //钢联化工数据库
  2060. tmpList, tmpErr := data_manage.GetMysteelChemicalIndexListGroupByUserId(dataId)
  2061. if tmpErr != nil {
  2062. err = tmpErr
  2063. return
  2064. }
  2065. if len(tmpList) > 0 {
  2066. for _, v := range tmpList {
  2067. if v.SysUserId == userId {
  2068. errMsg = "新创建人不可和原创建人一致"
  2069. err = errors.New(errMsg)
  2070. return
  2071. }
  2072. }
  2073. // 修改创建人
  2074. err = data_manage.ModifyMysteelChemicalIndexUserIdByCodeList(dataId, adminInfo.AdminId, adminInfo.RealName)
  2075. }
  2076. case 3, 4: //ETA指标库、ETA预测指标
  2077. tmpList, tmpErr := data_manage.GetEdbInfoListGroupByUserId(dataId)
  2078. if tmpErr != nil {
  2079. err = tmpErr
  2080. return
  2081. }
  2082. if len(tmpList) > 0 {
  2083. for _, v := range tmpList {
  2084. if v.SysUserId == userId {
  2085. errMsg = "新创建人不可和原创建人一致"
  2086. err = errors.New(errMsg)
  2087. return
  2088. }
  2089. }
  2090. // 修改创建人
  2091. err = data_manage.ModifyEdbInfoUserIdByCodeList(dataId, adminInfo.AdminId, adminInfo.RealName)
  2092. // 移除当前用户的不可操作权限
  2093. {
  2094. obj := data_manage.EdbInfoNoPermissionAdmin{}
  2095. for _, v := range dataId {
  2096. edbInfoId, _ := strconv.Atoi(v)
  2097. go obj.DeleteByEdbInfoIdAndAdminId(edbInfoId, adminInfo.AdminId)
  2098. }
  2099. }
  2100. }
  2101. case 5: //图库
  2102. tmpList, tmpErr := data_manage.GetChartInfoListGroupByUserId(dataId)
  2103. if tmpErr != nil {
  2104. err = tmpErr
  2105. return
  2106. }
  2107. if len(tmpList) > 0 {
  2108. for _, v := range tmpList {
  2109. if v.SysUserId == userId {
  2110. errMsg = "新创建人不可和原创建人一致"
  2111. err = errors.New(errMsg)
  2112. return
  2113. }
  2114. }
  2115. // 修改创建人
  2116. err = data_manage.ModifyChartInfoUserIdByCodeList(dataId, adminInfo.AdminId, adminInfo.RealName)
  2117. }
  2118. default:
  2119. return
  2120. }
  2121. return
  2122. }
  2123. func GetEdbChartClassifyList(source int) (resp data_manage.EdbChartClassifyResp, err error) {
  2124. switch source {
  2125. case 1: //手工数据指标
  2126. list, e := models.GetEdbdataClassify(0)
  2127. if e != nil {
  2128. err = e
  2129. return
  2130. }
  2131. for _, v := range list {
  2132. item := data_manage.EdbChartClassify{
  2133. ClassifyId: v.ClassifyId,
  2134. ClassifyName: v.ClassifyName,
  2135. ParentId: v.ParentId,
  2136. }
  2137. for _, v2 := range v.Child {
  2138. child := data_manage.EdbChartClassify{
  2139. ClassifyId: v2.ClassifyId,
  2140. ClassifyName: v2.ClassifyName,
  2141. ParentId: v2.ParentId,
  2142. }
  2143. item.Child = append(item.Child, &child)
  2144. }
  2145. resp.List = append(resp.List, &item)
  2146. }
  2147. case 2: //钢联化工数据库
  2148. rootList, e := data_manage.GetBaseFromMysteelChemicalClassifyByParentId(0)
  2149. if e != nil && e.Error() != utils.ErrNoRow() {
  2150. err = e
  2151. return
  2152. }
  2153. classifyAll, e := data_manage.GetAllBaseFromMysteelChemicalClassify()
  2154. if e != nil && e.Error() != utils.ErrNoRow() {
  2155. err = e
  2156. return
  2157. }
  2158. rootChildMap := make(map[int][]*data_manage.BaseFromMysteelChemicalClassifyItems)
  2159. for _, v := range classifyAll {
  2160. rootChildMap[v.ParentId] = append(rootChildMap[v.ParentId], v)
  2161. }
  2162. nodeAll := make([]*data_manage.BaseFromMysteelChemicalClassifyItems, 0)
  2163. for _, v := range rootList {
  2164. if existItems, ok := rootChildMap[v.BaseFromMysteelChemicalClassifyId]; ok {
  2165. v.Children = existItems
  2166. } else {
  2167. items := make([]*data_manage.BaseFromMysteelChemicalClassifyItems, 0)
  2168. v.Children = items
  2169. }
  2170. nodeAll = append(nodeAll, v)
  2171. }
  2172. for _, v := range nodeAll {
  2173. item := data_manage.EdbChartClassify{
  2174. ClassifyId: v.BaseFromMysteelChemicalClassifyId,
  2175. ClassifyName: v.ClassifyName,
  2176. ParentId: v.ParentId,
  2177. }
  2178. for _, v2 := range v.Children {
  2179. child := data_manage.EdbChartClassify{
  2180. ClassifyId: v2.BaseFromMysteelChemicalClassifyId,
  2181. ClassifyName: v2.ClassifyName,
  2182. ParentId: v2.ParentId,
  2183. }
  2184. item.Child = append(item.Child, &child)
  2185. }
  2186. resp.List = append(resp.List, &item)
  2187. }
  2188. case 3: //ETA指标库
  2189. //rootList, e := data_manage.GetEdbClassifyByParentId(0, 0)
  2190. //if e != nil && e.Error() != utils.ErrNoRow() {
  2191. // err = e
  2192. // return
  2193. //}
  2194. // 考虑到后面可以会迭代到10层, 这里直接用递归处理
  2195. classifyAll, e := data_manage.GetAllEdbClassifyByType(0)
  2196. if e != nil && e.Error() != utils.ErrNoRow() {
  2197. err = e
  2198. return
  2199. }
  2200. resp.List = GetEdbMenuTreeRecursive(classifyAll, 0)
  2201. //rootChildMap := make(map[int][]*data_manage.EdbClassifyItems)
  2202. //for _, v := range classifyAll {
  2203. // rootChildMap[v.ParentId] = append(rootChildMap[v.ParentId], v)
  2204. //}
  2205. //nodeAll := make([]*data_manage.EdbClassifyItems, 0)
  2206. //for _, v := range rootList {
  2207. // if existItems, ok := rootChildMap[v.ClassifyId]; ok {
  2208. // v.Children = existItems
  2209. // } else {
  2210. // items := make([]*data_manage.EdbClassifyItems, 0)
  2211. // v.Children = items
  2212. // }
  2213. // nodeAll = append(nodeAll, v)
  2214. //}
  2215. //
  2216. //for _, v := range nodeAll {
  2217. // item := data_manage.EdbChartClassify{
  2218. // ClassifyId: v.ClassifyId,
  2219. // ClassifyName: v.ClassifyName,
  2220. // ParentId: v.ParentId,
  2221. // }
  2222. // for _, v2 := range v.Children {
  2223. // child := data_manage.EdbChartClassify{
  2224. // ClassifyId: v2.ClassifyId,
  2225. // ClassifyName: v2.ClassifyName,
  2226. // ParentId: v2.ParentId,
  2227. // }
  2228. // item.Child = append(item.Child, &child)
  2229. // }
  2230. // resp.List = append(resp.List, &item)
  2231. //}
  2232. case 4: //ETA预测指标
  2233. // 考虑到后面可以会迭代到10层, 这里直接用递归
  2234. classifyAll, e := data_manage.GetAllEdbClassifyByType(1)
  2235. if e != nil && e.Error() != utils.ErrNoRow() {
  2236. err = e
  2237. return
  2238. }
  2239. resp.List = GetEdbMenuTreeRecursive(classifyAll, 0)
  2240. //rootList, e := data_manage.GetEdbClassifyByParentId(0, 1)
  2241. //if e != nil && e.Error() != utils.ErrNoRow() {
  2242. // err = e
  2243. // return
  2244. //}
  2245. //nodeAll := make([]*data_manage.EdbClassifyItems, 0)
  2246. //for _, v := range rootList {
  2247. // nodeAll = append(nodeAll, v)
  2248. //}
  2249. //
  2250. //for _, v := range nodeAll {
  2251. // item := data_manage.EdbChartClassify{
  2252. // ClassifyId: v.ClassifyId,
  2253. // ClassifyName: v.ClassifyName,
  2254. // ParentId: v.ParentId,
  2255. // }
  2256. // for _, v2 := range v.Children {
  2257. // child := data_manage.EdbChartClassify{
  2258. // ClassifyId: v2.ClassifyId,
  2259. // ClassifyName: v2.ClassifyName,
  2260. // ParentId: v2.ParentId,
  2261. // }
  2262. // item.Child = append(item.Child, &child)
  2263. // }
  2264. // resp.List = append(resp.List, &item)
  2265. //}
  2266. case 5: //图库
  2267. //判断是否存在缓存,如果存在缓存,那么直接从缓存中获取
  2268. //key := utils.CACHE_CHART_CLASSIFY
  2269. //if utils.Re == nil {
  2270. // if utils.Re == nil && utils.Rc.IsExist(key) {
  2271. // rep := new(data_manage.ChartClassifyListResp)
  2272. // if data, err1 := utils.Rc.RedisBytes(key); err1 == nil {
  2273. // e := json.Unmarshal(data, &rep)
  2274. // if e == nil && rep != nil {
  2275. // for _, v := range rep.AllNodes {
  2276. // item := data_manage.EdbChartClassify{
  2277. // ClassifyId: v.ChartClassifyId,
  2278. // ClassifyName: v.ChartClassifyName,
  2279. // ParentId: v.ParentId,
  2280. // }
  2281. // for _, v2 := range v.Children {
  2282. // child := data_manage.EdbChartClassify{
  2283. // ClassifyId: v2.ChartClassifyId,
  2284. // ClassifyName: v2.ChartClassifyName,
  2285. // ParentId: v2.ParentId,
  2286. // }
  2287. // item.Child = append(item.Child, &child)
  2288. // }
  2289. // resp.List = append(resp.List, &item)
  2290. // }
  2291. // fmt.Println("source redis")
  2292. // return
  2293. // }
  2294. // }
  2295. // }
  2296. //}
  2297. // 考虑到后面可以会迭代到10层, 这里直接用递归处理
  2298. classifyAll, e := data_manage.GetAllChartClassifyItemsBySource(1)
  2299. if e != nil && e.Error() != utils.ErrNoRow() {
  2300. err = e
  2301. return
  2302. }
  2303. resp.List = GetChartMenuTreeRecursive(classifyAll, 0)
  2304. //rootList, e := data_manage.GetChartClassifyByParentIdFromETA(0)
  2305. //if e != nil && e.Error() != utils.ErrNoRow() {
  2306. // err = e
  2307. // return
  2308. //}
  2309. //
  2310. //classifyAll, e := data_manage.GetChartClassifyAllFromETA()
  2311. //if e != nil && e.Error() != utils.ErrNoRow() {
  2312. // err = e
  2313. // return
  2314. //}
  2315. //
  2316. //rootChildMap := make(map[int][]*data_manage.ChartClassifyItems)
  2317. //for _, v := range classifyAll {
  2318. // rootChildMap[v.ParentId] = append(rootChildMap[v.ParentId], v)
  2319. //}
  2320. //nodeAll := make([]*data_manage.ChartClassifyItems, 0)
  2321. //for _, v := range rootList {
  2322. // if existItems, ok := rootChildMap[v.ChartClassifyId]; ok {
  2323. // v.Children = existItems
  2324. // } else {
  2325. // items := make([]*data_manage.ChartClassifyItems, 0)
  2326. // v.Children = items
  2327. // }
  2328. // nodeAll = append(nodeAll, v)
  2329. //}
  2330. //
  2331. //for _, v := range nodeAll {
  2332. // item := data_manage.EdbChartClassify{
  2333. // ClassifyId: v.ChartClassifyId,
  2334. // ClassifyName: v.ChartClassifyName,
  2335. // ParentId: v.ParentId,
  2336. // }
  2337. // for _, v2 := range v.Children {
  2338. // child := data_manage.EdbChartClassify{
  2339. // ClassifyId: v2.ChartClassifyId,
  2340. // ClassifyName: v2.ChartClassifyName,
  2341. // ParentId: v2.ParentId,
  2342. // }
  2343. // item.Child = append(item.Child, &child)
  2344. // }
  2345. // resp.List = append(resp.List, &item)
  2346. //}
  2347. // 将数据加入缓存
  2348. //if utils.Re == nil {
  2349. // utils.Rc.Delete(key)
  2350. //}
  2351. default:
  2352. return
  2353. }
  2354. return
  2355. }
  2356. // EdbInfoAdd 添加指标到指标库
  2357. func EdbInfoAdd(source, classifyId int, edbCode, edbName, frequency, unit, startDate, endDate string, sysUserId int, sysUserRealName string) (edbInfo *data_manage.EdbInfo, err error, errMsg string, isSendEmail bool) {
  2358. isSendEmail = true
  2359. //判断指标名称是否存在
  2360. var condition string
  2361. var pars []interface{}
  2362. //condition += " AND source=? "
  2363. //pars = append(pars, source)
  2364. condition += " AND edb_name=? "
  2365. pars = append(pars, edbName)
  2366. count, err := data_manage.GetEdbInfoCountByCondition(condition, pars)
  2367. if err != nil {
  2368. errMsg = "判断指标名称是否存在失败"
  2369. err = errors.New("判断指标名称是否存在失败,Err:" + err.Error())
  2370. return
  2371. }
  2372. if count > 0 {
  2373. errMsg = "指标名称已存在,请重新填写"
  2374. err = errors.New(errMsg)
  2375. isSendEmail = false
  2376. return
  2377. }
  2378. edbInfo = new(data_manage.EdbInfo)
  2379. edbInfo.Source = source
  2380. sourceNameMap := map[int]string{
  2381. utils.DATA_SOURCE_THS: "同花顺",
  2382. utils.DATA_SOURCE_WIND: "wind",
  2383. utils.DATA_SOURCE_PB: "彭博",
  2384. utils.DATA_SOURCE_PB_FINANCE: "彭博财务",
  2385. utils.DATA_SOURCE_MANUAL: "手工数据",
  2386. utils.DATA_SOURCE_LZ: "隆众",
  2387. utils.DATA_SOURCE_YS: "SMM",
  2388. utils.DATA_SOURCE_GL: "钢联",
  2389. utils.DATA_SOURCE_ZZ: "郑商所",
  2390. utils.DATA_SOURCE_DL: "大商所",
  2391. utils.DATA_SOURCE_SH: "上期所",
  2392. utils.DATA_SOURCE_CFFEX: "中金所",
  2393. utils.DATA_SOURCE_SHFE: "上期能源",
  2394. utils.DATA_SOURCE_GIE: "欧洲天然气",
  2395. utils.DATA_SOURCE_LT: "路透",
  2396. utils.DATA_SOURCE_COAL: "中国煤炭网",
  2397. utils.DATA_SOURCE_GOOGLE_TRAVEL: "our world in data",
  2398. utils.DATA_SOURCE_MYSTEEL_CHEMICAL: "钢联化工",
  2399. utils.DATA_SOURCE_EIA_STEO: "EIA STEO报告",
  2400. utils.DATA_SOURCE_COM_TRADE: "UN",
  2401. utils.DATA_SOURCE_SCI: "SCI",
  2402. utils.DATA_SOURCE_BAIINFO: "BAIINFO",
  2403. utils.DATA_SOURCE_STOCK_PLANT: "存量装置",
  2404. utils.DATA_SOURCE_NATIONAL_STATISTICS: "国家统计局",
  2405. utils.DATA_SOURCE_FUBAO: "富宝数据",
  2406. }
  2407. sourceName, ok := sourceNameMap[source]
  2408. if !ok {
  2409. edbSource := data_manage.EdbSourceIdMap[source]
  2410. if edbSource != nil {
  2411. sourceName = edbSource.SourceName
  2412. }
  2413. if sourceName == "" {
  2414. errMsg = "指标来源异常"
  2415. err = errors.New(errMsg)
  2416. return
  2417. }
  2418. }
  2419. edbInfo.SourceName = sourceName
  2420. edbType := 1 //基础指标
  2421. if source == utils.DATA_SOURCE_STOCK_PLANT {
  2422. edbType = 2 //计算指标
  2423. }
  2424. //从缓存中获取
  2425. serverUrl := ``
  2426. if edbInfo.Source == utils.DATA_SOURCE_WIND {
  2427. windCacheKey := utils.CACHE_WIND_URL + ":" + edbCode
  2428. serverUrl, _ = utils.Rc.RedisString(windCacheKey)
  2429. if serverUrl == `` {
  2430. if len(utils.Hz_Data_WIND_Url_List) >= 1 {
  2431. serverUrl = utils.Hz_Data_WIND_Url_List[len(utils.Hz_Data_WIND_Url_List)-1] //默认是最后一个服务器地址
  2432. }
  2433. }
  2434. }
  2435. //获取该层级下最大的排序数
  2436. maxSort, err := GetEdbClassifyMaxSort(classifyId, 0)
  2437. if err != nil {
  2438. errMsg = "获取失败"
  2439. err = errors.New("查询排序信息失败,Err:" + err.Error())
  2440. return
  2441. }
  2442. edbInfo.EdbCode = edbCode
  2443. edbInfo.EdbName = edbName
  2444. edbInfo.EdbNameSource = edbName
  2445. edbInfo.Frequency = frequency
  2446. edbInfo.Unit = unit
  2447. edbInfo.StartDate = startDate
  2448. edbInfo.EndDate = endDate
  2449. edbInfo.ClassifyId = classifyId
  2450. edbInfo.SysUserId = sysUserId
  2451. edbInfo.SysUserRealName = sysUserRealName
  2452. edbInfo.CreateTime = time.Now()
  2453. edbInfo.ModifyTime = time.Now()
  2454. edbInfo.ServerUrl = serverUrl
  2455. edbInfo.Sort = maxSort + 1
  2456. edbInfo.DataDateType = `交易日`
  2457. timestamp := strconv.FormatInt(time.Now().UnixNano(), 10)
  2458. edbInfo.UniqueCode = utils.MD5(utils.DATA_PREFIX + "_" + timestamp)
  2459. itemVal, err := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
  2460. if itemVal != nil && err == nil {
  2461. edbInfo.MaxValue = itemVal.MaxValue
  2462. edbInfo.MinValue = itemVal.MinValue
  2463. }
  2464. edbInfo.EdbType = edbType
  2465. edbInfoId, err := data_manage.AddEdbInfo(edbInfo)
  2466. if err != nil {
  2467. errMsg = "保存失败"
  2468. err = errors.New("保存失败,Err:" + err.Error())
  2469. return
  2470. }
  2471. edbInfo.EdbInfoId = int(edbInfoId)
  2472. //保存数据
  2473. data_manage.ModifyEdbInfoDataStatus(edbInfoId, source, edbCode)
  2474. //处理同名指标
  2475. //{
  2476. // edbNameList, tmpErr := data_manage.GetEdbInfoByName(edbName)
  2477. // if tmpErr != nil {
  2478. // errMsg = "保存失败"
  2479. // err = errors.New("获取指标信息失败,Err:" + tmpErr.Error())
  2480. // return
  2481. // }
  2482. // if len(edbNameList) >= 2 {
  2483. // for _, v := range edbNameList {
  2484. // edbName := v.EdbName + "(" + v.SourceName + ")"
  2485. // err = data_manage.ModifyEdbInfoNameSource(edbName, v.EdbInfoId)
  2486. // if err != nil {
  2487. // errMsg = "保存失败"
  2488. // err = errors.New("修改指标名称失败,Err:" + err.Error())
  2489. // return
  2490. // }
  2491. // }
  2492. // }
  2493. //}
  2494. //上传到ES
  2495. //indexName := utils.DATA_INDEX_NAME
  2496. //docId := strconv.Itoa(int(edbInfoId))
  2497. //
  2498. //go data.EsAddOrEditEdbInfo(indexName, docId, edbInfo)
  2499. maxAndMinItem, _ := data_manage.GetEdbInfoMaxAndMinInfo(source, edbCode)
  2500. if maxAndMinItem != nil {
  2501. err = data_manage.ModifyEdbInfoMaxAndMinInfo(int(edbInfoId), maxAndMinItem)
  2502. }
  2503. //添加es
  2504. AddOrEditEdbInfoToEs(int(edbInfoId))
  2505. return
  2506. }
  2507. // TraceEdbInfoByEdbInfoId 指标追溯
  2508. func TraceEdbInfoByEdbInfoId(edbInfoId int) (traceEdbInfo data_manage.TraceEdbInfoResp, err error) {
  2509. edbInfo, err := data_manage.GetEdbInfoById(edbInfoId)
  2510. if err != nil {
  2511. return
  2512. }
  2513. edbInfoRuleMap := make(map[int]string, 0)
  2514. edbMappingMap := make(map[int][]*data_manage.EdbInfoCalculateMappingInfo)
  2515. //edbInfoRuleMap[edbInfoId] = getEdbRuleTitle(edbInfo)
  2516. traceEdbInfo = data_manage.TraceEdbInfoResp{
  2517. //EdbInfoId: edbInfo.EdbInfoId,
  2518. EdbInfoId: edbInfoId,
  2519. EdbInfoType: edbInfo.EdbInfoType,
  2520. EdbName: edbInfo.EdbName,
  2521. EdbType: edbInfo.EdbType,
  2522. //Source: edbInfo.Source,
  2523. UniqueCode: edbInfo.UniqueCode,
  2524. ClassifyId: edbInfo.ClassifyId,
  2525. EdbInfo: edbInfo,
  2526. }
  2527. findIdMap := make(map[int]int)
  2528. findIdMap[edbInfoId] = edbInfoId
  2529. existMap := make(map[int]data_manage.TraceEdbInfoResp)
  2530. traceEdbInfo.Child, err = traceEdbInfoByEdbInfoId(edbInfoId, traceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
  2531. edbInfoIdList := make([]int, 0)
  2532. for _, v := range findIdMap {
  2533. edbInfoIdList = append(edbInfoIdList, v)
  2534. }
  2535. edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
  2536. if err != nil {
  2537. return
  2538. }
  2539. edbInfoMap := make(map[int]*data_manage.EdbInfo)
  2540. for _, tmpEdbInfo := range edbInfoList {
  2541. edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo
  2542. }
  2543. traceEdbInfo, err = handleTraceEdbInfo(traceEdbInfo, 0, edbInfoMap, edbMappingMap)
  2544. return
  2545. }
  2546. // TraceEdbInfoByEdbInfoIdList 指标追溯
  2547. func TraceEdbInfoByEdbInfoIdList(edbInfoIdList []int) (traceEdbInfoList []data_manage.TraceEdbInfoResp, err error) {
  2548. traceEdbInfoList = make([]data_manage.TraceEdbInfoResp, 0)
  2549. edbInfoList, err := data_manage.GetEdbInfoByIdList(edbInfoIdList)
  2550. if err != nil {
  2551. return
  2552. }
  2553. edbInfoRuleMap := make(map[int]string, 0)
  2554. edbMappingMap := make(map[int][]*data_manage.EdbInfoCalculateMappingInfo)
  2555. findIdMap := make(map[int]int)
  2556. existMap := make(map[int]data_manage.TraceEdbInfoResp)
  2557. for _, edbInfo := range edbInfoList {
  2558. findIdMap[edbInfo.EdbInfoId] = edbInfo.EdbInfoId
  2559. //edbInfoRuleMap[edbInfoId] = getEdbRuleTitle(edbInfo)
  2560. traceEdbInfo := data_manage.TraceEdbInfoResp{
  2561. //EdbInfoId: edbInfo.EdbInfoId,
  2562. EdbInfoId: edbInfo.EdbInfoId,
  2563. EdbInfoType: edbInfo.EdbInfoType,
  2564. EdbName: edbInfo.EdbName,
  2565. EdbType: edbInfo.EdbType,
  2566. //Source: edbInfo.Source,
  2567. UniqueCode: edbInfo.UniqueCode,
  2568. ClassifyId: edbInfo.ClassifyId,
  2569. EdbInfo: edbInfo,
  2570. }
  2571. traceEdbInfo.Child, err = traceEdbInfoByEdbInfoId(edbInfo.EdbInfoId, traceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
  2572. traceEdbInfoList = append(traceEdbInfoList, traceEdbInfo)
  2573. }
  2574. //findEdbInfoIdList := make([]int, 0)
  2575. //for _, v := range findIdMap {
  2576. // findEdbInfoIdList = append(findEdbInfoIdList, v)
  2577. //}
  2578. //findEdbInfoList, err := data_manage.GetEdbInfoByIdList(findEdbInfoIdList)
  2579. //if err != nil {
  2580. // return
  2581. //}
  2582. //edbInfoMap := make(map[int]*data_manage.EdbInfo)
  2583. //for _, tmpEdbInfo := range findEdbInfoList {
  2584. // edbInfoMap[tmpEdbInfo.EdbInfoId] = tmpEdbInfo
  2585. //}
  2586. //for k, traceEdbInfo := range traceEdbInfoList {
  2587. // traceEdbInfoList[k], err = handleTraceEdbInfo(traceEdbInfo, 0, edbInfoMap, edbMappingMap)
  2588. //}
  2589. return
  2590. }
  2591. // traceEdbInfoByEdbInfoId 指标追溯
  2592. 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) {
  2593. traceEdbInfo, ok := existMap[edbInfoId]
  2594. if ok {
  2595. return
  2596. }
  2597. child = make([]data_manage.TraceEdbInfoResp, 0)
  2598. edbInfoMappingList, e := data_manage.GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId)
  2599. if e != nil {
  2600. err = fmt.Errorf("GetEdbInfoCalculateMappingListByEdbInfoId err: %s", e.Error())
  2601. return
  2602. }
  2603. // 指标信息map
  2604. edbInfoMap := make(map[int]*data_manage.EdbInfo)
  2605. if len(edbInfoMappingList) > 0 {
  2606. fromEdbInfoIdList := make([]int, 0)
  2607. for _, v := range edbInfoMappingList {
  2608. fromEdbInfoIdList = append(fromEdbInfoIdList, v.FromEdbInfoId)
  2609. }
  2610. edbInfoList, tmpErr := data_manage.GetEdbInfoByIdList(fromEdbInfoIdList)
  2611. if tmpErr != nil {
  2612. err = fmt.Errorf("traceEdbInfoByEdbInfoId GetEdbInfoByIdList err: %s", tmpErr.Error())
  2613. return
  2614. }
  2615. for _, v := range edbInfoList {
  2616. edbInfoMap[v.EdbInfoId] = v
  2617. }
  2618. }
  2619. edbMappingMap[edbInfoId] = edbInfoMappingList
  2620. for _, v := range edbInfoMappingList {
  2621. tmpEdbInfoId := v.FromEdbInfoId
  2622. tmpTraceEdbInfo := data_manage.TraceEdbInfoResp{
  2623. EdbInfoId: tmpEdbInfoId,
  2624. EdbInfoType: v.FromEdbInfoType,
  2625. EdbType: v.FromEdbType,
  2626. UniqueCode: v.FromUniqueCode,
  2627. ClassifyId: v.FromClassifyId,
  2628. EdbInfo: edbInfoMap[v.FromEdbInfoId],
  2629. }
  2630. // 计算指标/预测指标继续溯源
  2631. if v.FromEdbType == 2 || v.FromEdbInfoType == 1 {
  2632. // 查过了就不查了
  2633. if _, ok2 := findIdMap[tmpEdbInfoId]; !ok2 {
  2634. tmpTraceEdbInfo.Child, e = traceEdbInfoByEdbInfoId(tmpEdbInfoId, tmpTraceEdbInfo, edbInfoRuleMap, findIdMap, existMap, edbMappingMap)
  2635. if e != nil {
  2636. err = fmt.Errorf("traceEdbInfoByEdbInfoId err: %s", e.Error())
  2637. return
  2638. }
  2639. }
  2640. }
  2641. child = append(child, tmpTraceEdbInfo)
  2642. findIdMap[tmpEdbInfoId] = tmpEdbInfoId
  2643. }
  2644. existMap[edbInfoId] = traceEdbInfo
  2645. return
  2646. }
  2647. func handleTraceEdbInfo(traceEdbInfoResp data_manage.TraceEdbInfoResp, parentEdbInfoId int, edbInfoMap map[int]*data_manage.EdbInfo, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (newTraceEdbInfoResp data_manage.TraceEdbInfoResp, err error) {
  2648. edbInfo, ok := edbInfoMap[traceEdbInfoResp.EdbInfoId]
  2649. if !ok {
  2650. err = errors.New("指标异常")
  2651. return
  2652. }
  2653. var parentEdbInfo *data_manage.EdbInfo
  2654. if parentEdbInfoId > 0 {
  2655. parentEdbInfo, ok = edbInfoMap[parentEdbInfoId]
  2656. if !ok {
  2657. err = errors.New("指标异常")
  2658. return
  2659. }
  2660. }
  2661. //traceEdbInfoResp.EdbName = edbInfo.EdbName
  2662. traceEdbInfoResp.EdbName, traceEdbInfoResp.RuleTitle = getEdbRuleTitle(edbInfo, parentEdbInfo, traceEdbInfoResp.Child, edbInfoMap, edbMappingMap)
  2663. if traceEdbInfoResp.Child != nil && len(traceEdbInfoResp.Child) > 0 {
  2664. for k, v := range traceEdbInfoResp.Child {
  2665. traceEdbInfoResp.Child[k], err = handleTraceEdbInfo(v, traceEdbInfoResp.EdbInfoId, edbInfoMap, edbMappingMap)
  2666. if err != nil {
  2667. return
  2668. }
  2669. }
  2670. }
  2671. newTraceEdbInfoResp = traceEdbInfoResp
  2672. return
  2673. }
  2674. // getEdbRule 获取规则名称
  2675. func getEdbRuleTitle(edbInfo, parentEdbInfo *data_manage.EdbInfo, childList []data_manage.TraceEdbInfoResp, edbInfoMap map[int]*data_manage.EdbInfo, edbMappingMap map[int][]*data_manage.EdbInfoCalculateMappingInfo) (edbName, ruleTitle string) {
  2676. edbName = edbInfo.EdbName
  2677. ruleTitle = `来源于` + edbInfo.SourceName
  2678. if parentEdbInfo != nil {
  2679. edbMappingList, ok := edbMappingMap[parentEdbInfo.EdbInfoId]
  2680. if !ok {
  2681. edbMappingList = []*data_manage.EdbInfoCalculateMappingInfo{}
  2682. }
  2683. // 指标名称
  2684. switch parentEdbInfo.Source {
  2685. case utils.DATA_SOURCE_CALCULATE, utils.DATA_SOURCE_PREDICT_CALCULATE:
  2686. for _, v := range edbMappingList {
  2687. if v.FromEdbInfoId == edbInfo.EdbInfoId {
  2688. edbName = fmt.Sprintf("%s(%s)", edbInfo.EdbName, v.FromTag)
  2689. }
  2690. }
  2691. case utils.DATA_SOURCE_CALCULATE_ZJPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_ZJPJ, utils.DATA_SOURCE_CALCULATE_LJZTBPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZTBPJ: // 直接拼接 ,累计值同比拼接
  2692. for _, v := range edbMappingList {
  2693. if v.FromEdbInfoId == edbInfo.EdbInfoId {
  2694. tmpName := ``
  2695. if v.FromTag == `A` {
  2696. tmpName = `拼接日期前`
  2697. } else if v.FromTag == `B` {
  2698. tmpName = `拼接日期后`
  2699. }
  2700. edbName = fmt.Sprintf("%s(%s)", edbInfo.EdbName, tmpName)
  2701. }
  2702. }
  2703. case utils.DATA_SOURCE_CALCULATE_NHCC, utils.DATA_SOURCE_PREDICT_CALCULATE_NHCC: //计算指标(拟合残差)
  2704. for _, v := range edbMappingList {
  2705. //(需对上游指标+自变量,领先10天/因变量)
  2706. if v.FromEdbInfoId == edbInfo.EdbInfoId {
  2707. tmpName := ``
  2708. if v.FromTag == `A` {
  2709. tmpName = fmt.Sprintf(`自变量,领先%d天`, v.MoveValue)
  2710. } else if v.FromTag == `B` {
  2711. tmpName = `因变量`
  2712. }
  2713. edbName = fmt.Sprintf("%s(%s)", edbInfo.EdbName, tmpName)
  2714. }
  2715. }
  2716. case utils.DATA_SOURCE_CALCULATE_CORRELATION: // 滚动相关性
  2717. for _, v := range edbMappingList {
  2718. if v.FromEdbInfoId == edbInfo.EdbInfoId {
  2719. edbName = fmt.Sprintf("%s(%s)", edbInfo.EdbName, v.FromTag)
  2720. }
  2721. }
  2722. }
  2723. }
  2724. if edbInfo.EdbType == 1 {
  2725. // 基础指标的话,直接返回来源名称
  2726. //ruleTitle = `来源于`+edbInfo.SourceName
  2727. return
  2728. }
  2729. // 规则
  2730. switch edbInfo.Source {
  2731. case utils.DATA_SOURCE_CALCULATE, utils.DATA_SOURCE_PREDICT_CALCULATE:
  2732. ruleTitle = "=" + edbInfo.CalculateFormula
  2733. case utils.DATA_SOURCE_CALCULATE_LJZZY, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZZY:
  2734. ruleTitle = `累计转月值计算`
  2735. case utils.DATA_SOURCE_CALCULATE_TBZ, utils.DATA_SOURCE_PREDICT_CALCULATE_TBZ:
  2736. ruleTitle = `同比值计算`
  2737. case utils.DATA_SOURCE_CALCULATE_TCZ, utils.DATA_SOURCE_PREDICT_CALCULATE_TCZ:
  2738. ruleTitle = `同差值计算`
  2739. case utils.DATA_SOURCE_CALCULATE_NSZYDPJJS, utils.DATA_SOURCE_PREDICT_CALCULATE_NSZYDPJJS:
  2740. ruleTitle = fmt.Sprintf("N数值移动均值计算(N=%s)", edbInfo.CalculateFormula)
  2741. case utils.DATA_SOURCE_CALCULATE_HBZ, utils.DATA_SOURCE_PREDICT_CALCULATE_HBZ:
  2742. ruleTitle = fmt.Sprintf("N数值环比值计算(N=%s)", edbInfo.CalculateFormula)
  2743. case utils.DATA_SOURCE_CALCULATE_HCZ, utils.DATA_SOURCE_PREDICT_CALCULATE_HCZ:
  2744. ruleTitle = fmt.Sprintf("N数值环差值计算(N=%s)", edbInfo.CalculateFormula)
  2745. case utils.DATA_SOURCE_CALCULATE_TIME_SHIFT, utils.DATA_SOURCE_PREDICT_CALCULATE_TIME_SHIFT:
  2746. moveType := `领先`
  2747. if edbInfo.MoveType == 2 {
  2748. moveType = "滞后"
  2749. }
  2750. ruleTitle = fmt.Sprintf("时间移位计算(%s%s%s)", moveType, edbInfo.CalculateFormula, edbInfo.MoveFrequency)
  2751. case utils.DATA_SOURCE_CALCULATE_BP, utils.DATA_SOURCE_PREDICT_CALCULATE_BP: // 变频
  2752. childFrequency := ``
  2753. if len(childList) > 0 {
  2754. if childEdbInfo, ok := edbInfoMap[childList[0].EdbInfoId]; ok {
  2755. childFrequency = childEdbInfo.Frequency
  2756. }
  2757. }
  2758. ruleTitle = fmt.Sprintf("升频计算(%s转%s)", childFrequency, edbInfo.Frequency)
  2759. case utils.DATA_SOURCE_CALCULATE_ZJPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_ZJPJ: // 直接拼接
  2760. ruleTitle = fmt.Sprintf("直接拼接计算(%s)", edbInfo.CalculateFormula)
  2761. case utils.DATA_SOURCE_CALCULATE_LJZTBPJ, utils.DATA_SOURCE_PREDICT_CALCULATE_LJZTBPJ: // 累计值同比拼
  2762. ruleTitle = fmt.Sprintf("累计值同比值拼接计算(%s)", edbInfo.CalculateFormula)
  2763. case utils.DATA_SOURCE_PYTHON:
  2764. ruleTitle = `代码运算`
  2765. case utils.DATA_SOURCE_CALCULATE_CJJX, utils.DATA_SOURCE_PREDICT_CALCULATE_CJJX:
  2766. ruleTitle = fmt.Sprintf("超季节性计算(N=%s,%s)", edbInfo.CalculateFormula, edbInfo.Calendar)
  2767. case utils.DATA_SOURCE_CALCULATE_NHCC, utils.DATA_SOURCE_PREDICT_CALCULATE_NHCC: //计算指标(拟合残差)
  2768. var startDate, endDate string
  2769. dateList := strings.Split(edbInfo.CalculateFormula, ",")
  2770. if len(dateList) == 2 {
  2771. startDate = dateList[0]
  2772. endDate = dateList[1]
  2773. }
  2774. ruleTitle = fmt.Sprintf("拟合残差计算(%s至%s)", startDate, endDate)
  2775. case utils.DATA_SOURCE_CALCULATE_ADJUST:
  2776. ruleTitle = `数据调整`
  2777. case utils.DATA_SOURCE_CALCULATE_NH, utils.DATA_SOURCE_PREDICT_CALCULATE_NH:
  2778. ruleTitle = `年化计算`
  2779. case utils.DATA_SOURCE_CALCULATE_KSZS, utils.DATA_SOURCE_PREDICT_CALCULATE_KSZS: // 扩散指数->53
  2780. type KszsConfig struct {
  2781. DateType int `description:"扩散指标日期;1:全部指标日期并集;2:部分指标日期并集"`
  2782. CheckList []string `description:"选中的数据,A,B,C"`
  2783. }
  2784. var config KszsConfig
  2785. err := json.Unmarshal([]byte(edbInfo.CalculateFormula), &config)
  2786. if err != nil {
  2787. return
  2788. }
  2789. var startDate, endDate time.Time
  2790. childEdbInfoIdList := make([]int, 0)
  2791. if config.DateType == 1 {
  2792. for _, v := range childList {
  2793. childEdbInfoIdList = append(childEdbInfoIdList, v.EdbInfoId)
  2794. }
  2795. } else {
  2796. if parentEdbInfo != nil {
  2797. edbMappingList, ok := edbMappingMap[parentEdbInfo.EdbInfoId]
  2798. if !ok {
  2799. edbMappingList = []*data_manage.EdbInfoCalculateMappingInfo{}
  2800. }
  2801. tagMap := make(map[string]int)
  2802. for _, v := range edbMappingList {
  2803. tagMap[v.FromTag] = v.FromEdbInfoId
  2804. }
  2805. for _, v := range config.CheckList {
  2806. if tmpEdbInfoId, ok := tagMap[v]; ok {
  2807. childEdbInfoIdList = append(childEdbInfoIdList, tmpEdbInfoId)
  2808. }
  2809. }
  2810. }
  2811. }
  2812. for _, v := range childEdbInfoIdList {
  2813. if childEdbInfo, ok := edbInfoMap[v]; ok {
  2814. tmpStartDate, tmpErr := time.ParseInLocation(utils.FormatDate, childEdbInfo.StartDate, time.Local)
  2815. if tmpErr != nil {
  2816. return
  2817. }
  2818. if startDate.IsZero() || startDate.After(tmpStartDate) {
  2819. startDate = tmpStartDate
  2820. }
  2821. tmpEndDate, tmpErr := time.ParseInLocation(utils.FormatDate, childEdbInfo.EndDate, time.Local)
  2822. if tmpErr != nil {
  2823. return
  2824. }
  2825. if endDate.IsZero() || endDate.Before(tmpEndDate) {
  2826. endDate = tmpEndDate
  2827. }
  2828. }
  2829. }
  2830. ruleTitle = fmt.Sprintf("扩散指数计算(%s至%s)", startDate.Format(utils.FormatDate), endDate.Format(utils.FormatDate))
  2831. case utils.DATA_SOURCE_STOCK_PLANT:
  2832. ruleTitle = `来源于装置分析`
  2833. case utils.DATA_SOURCE_CALCULATE_CORRELATION:
  2834. type EdbCalculateFormula struct {
  2835. BaseCalculateValue int `description:"基础计算窗口"`
  2836. BaseCalculateUnit string `description:"基础计算频度"`
  2837. LeadValue int `description:"领先期数"`
  2838. LeadUnit string `description:"频度"`
  2839. CalculateValue int `description:"计算窗口"`
  2840. CalculateUnit string `description:"计算频度"`
  2841. }
  2842. var correlationConf EdbCalculateFormula
  2843. err := json.Unmarshal([]byte(edbInfo.CalculateFormula), &correlationConf)
  2844. if err != nil {
  2845. return
  2846. }
  2847. ruleTitle = fmt.Sprintf("滚动相关性(计算窗口%d%s,B领先A%d%s)", correlationConf.CalculateValue, correlationConf.CalculateUnit, correlationConf.LeadValue, correlationConf.LeadUnit)
  2848. case utils.DATA_SOURCE_CALCULATE_JP, utils.DATA_SOURCE_PREDICT_CALCULATE_JP:
  2849. childFrequency := ``
  2850. if len(childList) > 0 {
  2851. if childEdbInfo, ok := edbInfoMap[childList[0].EdbInfoId]; ok {
  2852. childFrequency = childEdbInfo.Frequency
  2853. }
  2854. }
  2855. ruleTitle = fmt.Sprintf("降频计算(%s转%s,%s)", childFrequency, edbInfo.Frequency, edbInfo.CalculateFormula)
  2856. case utils.DATA_SOURCE_CALCULATE_STANDARD_DEVIATION:
  2857. ruleTitle = fmt.Sprintf("标准差(滚动%s期)", edbInfo.CalculateFormula)
  2858. case utils.DATA_SOURCE_CALCULATE_PERCENTILE, utils.DATA_SOURCE_PREDICT_CALCULATE_PERCENTILE:
  2859. type TempCalculate struct {
  2860. CalculateValue int `description:"计算窗口"`
  2861. CalculateUnit string `description:"计算频度"`
  2862. }
  2863. cf := TempCalculate{}
  2864. if e := json.Unmarshal([]byte(edbInfo.CalculateFormula), &cf); e != nil {
  2865. return
  2866. }
  2867. ruleTitle = fmt.Sprintf("百分位(时间长度%d%s)", cf.CalculateValue, cf.CalculateUnit)
  2868. case utils.DATA_SOURCE_CALCULATE_ZSXY, utils.DATA_SOURCE_PREDICT_CALCULATE_ZSXY:
  2869. ruleTitle = `指数修匀计算`
  2870. }
  2871. return
  2872. }
  2873. // GetEdbChartAdminList
  2874. // @param source 来源 :1:手工数据指标 2:钢联化工数据库 3:ETA指标库 4:ETA预测指标 5:图库
  2875. func GetEdbChartAdminList(source int) (list []int, err error) {
  2876. switch source {
  2877. case 1: //手工数据指标
  2878. list, err = models.GetEdbInfoAdminList()
  2879. if err != nil {
  2880. return
  2881. }
  2882. case 2: //钢联化工数据库
  2883. list, err = data_manage.GetMysteelChemicalIndexAdminList()
  2884. if err != nil {
  2885. return
  2886. }
  2887. case 3: //ETA指标库
  2888. list, err = data_manage.GetEdbInfoAdminList(0)
  2889. if err != nil {
  2890. return
  2891. }
  2892. case 4: //ETA预测指标
  2893. list, err = data_manage.GetEdbInfoAdminList(1)
  2894. if err != nil {
  2895. return
  2896. }
  2897. case 5: //图库
  2898. list, err = data_manage.GetChartInfoAdminList()
  2899. if err != nil {
  2900. return
  2901. }
  2902. default:
  2903. return
  2904. }
  2905. return
  2906. }
  2907. // GetEdbMenuTreeRecursive 递归指标库菜单树
  2908. func GetEdbMenuTreeRecursive(list []*data_manage.EdbClassifyItems, parentId int) []*data_manage.EdbChartClassify {
  2909. res := make([]*data_manage.EdbChartClassify, 0)
  2910. for _, v := range list {
  2911. t := new(data_manage.EdbChartClassify)
  2912. t.ClassifyId = v.ClassifyId
  2913. t.ClassifyName = v.ClassifyName
  2914. t.ParentId = v.ParentId
  2915. if v.ParentId == parentId {
  2916. t.Child = GetEdbMenuTreeRecursive(list, v.ClassifyId)
  2917. res = append(res, t)
  2918. }
  2919. }
  2920. return res
  2921. }
  2922. // GetChartMenuTreeRecursive 递归指标库菜单树
  2923. func GetChartMenuTreeRecursive(list []*data_manage.ChartClassifyItems, parentId int) []*data_manage.EdbChartClassify {
  2924. res := make([]*data_manage.EdbChartClassify, 0)
  2925. for _, v := range list {
  2926. t := new(data_manage.EdbChartClassify)
  2927. t.ClassifyId = v.ChartClassifyId
  2928. t.ClassifyName = v.ChartClassifyName
  2929. t.ParentId = v.ParentId
  2930. if v.ParentId == parentId {
  2931. t.Child = GetChartMenuTreeRecursive(list, v.ChartClassifyId)
  2932. res = append(res, t)
  2933. }
  2934. }
  2935. return res
  2936. }