predict_edb_conf.go 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430
  1. package models
  2. import (
  3. "github.com/beego/beego/v2/client/orm"
  4. "hongze/hongze_edb_lib/services/alarm_msg"
  5. "hongze/hongze_edb_lib/utils"
  6. "time"
  7. )
  8. // AddPredictEdbInfoReq 添加预测指标请求
  9. type AddPredictEdbInfoReq struct {
  10. EdbInfoId int `description:"指标ID"`
  11. ClassifyId int `description:"分类id"`
  12. AdminId int `description:"添加人id"`
  13. AdminName string `description:"添加人名称"`
  14. SourceEdbInfoId int `description:"来源指标id"`
  15. EdbName string `description:"指标名称"`
  16. RuleList []RuleConfig `description:"配置规则列表"`
  17. MaxValue float64 `description:"最大值"`
  18. MinValue float64 `description:"最小值"`
  19. }
  20. // RuleConfig 预测规则配置
  21. type RuleConfig struct {
  22. RuleType int `description:"预测规则,1:最新,2:固定值,3:同比,4:同差,5:环比,6:环差,7:N期移动均值,8:N期段线性外推值,9:动态环差"`
  23. Value string `description:"值/计算公式"`
  24. EndDate string `description:"截止日期"`
  25. EdbInfoIdArr []EdbInfoFromTag `description:"指标信息"`
  26. }
  27. // EditPredictEdbInfoReq 编辑预测指标请求
  28. type EditPredictEdbInfoReq struct {
  29. EdbInfoId int `description:"指标ID"`
  30. ClassifyId int `description:"分类id"`
  31. EdbName string `description:"指标名称"`
  32. RuleList []RuleConfig `description:"配置规则列表"`
  33. }
  34. type PredictEdbConf struct {
  35. ConfigId int `orm:"column(config_id);pk" description:"规则id"`
  36. PredictEdbInfoId int `orm:"column(predict_edb_info_id)" description:"预测指标id"`
  37. SourceEdbInfoId int `description:"来源指标id"`
  38. RuleType int `description:"预测规则,1:最新,2:固定值,3:同比,4:同差,5:环比,6:环差,7:N期移动均值,8:N期段线性外推值"`
  39. FixedValue float64 `description:"固定值"`
  40. Value string `description:"配置的值"`
  41. EndDate time.Time `description:"截止日期"`
  42. ModifyTime time.Time `description:"修改时间"`
  43. CreateTime time.Time `description:"添加时间"`
  44. }
  45. // PredictEdbConfAndData 预测规则和其对应的动态数据
  46. type PredictEdbConfAndData struct {
  47. ConfigId int `orm:"column(config_id);pk" description:"规则id"`
  48. PredictEdbInfoId int `orm:"column(predict_edb_info_id)" description:"预测指标id"`
  49. SourceEdbInfoId int `description:"来源指标id"`
  50. RuleType int `description:"预测规则,1:最新,2:固定值,3:同比,4:同差,5:环比,6:环差,7:N期移动均值,8:N期段线性外推值,9:动态环差"`
  51. FixedValue float64 `description:"固定值"`
  52. Value string `description:"配置的值"`
  53. EndDate time.Time `description:"截止日期"`
  54. ModifyTime time.Time `description:"修改时间"`
  55. CreateTime time.Time `description:"添加时间"`
  56. DataList []*EdbInfoSearchData `description:"动态数据"`
  57. }
  58. // GetPredictEdbConfById 根据预测指标id获取预测指标配置信息
  59. func GetPredictEdbConfById(edbInfoId int) (item *PredictEdbConf, err error) {
  60. o := orm.NewOrm()
  61. sql := ` SELECT * FROM predict_edb_conf WHERE predict_edb_info_id=? `
  62. err = o.Raw(sql, edbInfoId).QueryRow(&item)
  63. return
  64. }
  65. // GetPredictEdbConfCount 根据来源指标id获取被引用的次数
  66. func GetPredictEdbConfCount(sourceEdbInfoId int) (count int, err error) {
  67. o := orm.NewOrm()
  68. sql := ` SELECT COUNT(1) AS count FROM predict_edb_conf WHERE source_edb_info_id=? `
  69. err = o.Raw(sql, sourceEdbInfoId).QueryRow(&count)
  70. return
  71. }
  72. // GetPredictEdbConfListById 根据预测指标id获取预测指标配置信息列表
  73. func GetPredictEdbConfListById(edbInfoId int) (items []*PredictEdbConf, err error) {
  74. o := orm.NewOrm()
  75. sql := ` SELECT * FROM predict_edb_conf WHERE predict_edb_info_id=? ORDER BY config_id ASC`
  76. _, err = o.Raw(sql, edbInfoId).QueryRows(&items)
  77. return
  78. }
  79. // GetPredictEdbConfAndDataListById 根据预测指标id获取预测指标配置信息列表
  80. func GetPredictEdbConfAndDataListById(edbInfoId int) (items []*PredictEdbConfAndData, err error) {
  81. o := orm.NewOrm()
  82. sql := ` SELECT * FROM predict_edb_conf WHERE predict_edb_info_id=? ORDER BY config_id ASC`
  83. _, err = o.Raw(sql, edbInfoId).QueryRows(&items)
  84. return
  85. }
  86. // GetPredictEdbConfListByConfigIdList 根据预测指标id列表获取预测指标配置信息列表
  87. func GetPredictEdbConfListByConfigIdList(configIdList []int) (items []*PredictEdbConf, err error) {
  88. num := len(configIdList)
  89. if num <= 0 {
  90. return
  91. }
  92. o := orm.NewOrm()
  93. sql := ` SELECT * FROM predict_edb_conf WHERE config_id in (` + utils.GetOrmInReplace(num) + `) ORDER BY config_id ASC`
  94. _, err = o.Raw(sql, configIdList).QueryRows(&items)
  95. return
  96. }
  97. // ModifyPredictEdbInfoMaxAndMinInfoBySourceEdbInfoId 根据来源指标修改预测指标的最新数据信息
  98. func ModifyPredictEdbInfoMaxAndMinInfoBySourceEdbInfoId(sourceEdbInfoId int, item *EdbInfoMaxAndMinInfo) (err error) {
  99. return
  100. o := orm.NewOrm()
  101. var list []*PredictEdbConf
  102. sql := ` SELECT * FROM predict_edb_conf WHERE source_edb_info_id=? `
  103. total, err := o.Raw(sql, sourceEdbInfoId).QueryRows(&list)
  104. if err != nil {
  105. return
  106. }
  107. if total > 0 {
  108. idList := make([]int, 0)
  109. for _, v := range list {
  110. idList = append(idList, v.PredictEdbInfoId)
  111. }
  112. sql := ` UPDATE edb_info SET start_date=?,min_value=?,max_value=?,is_update=2,latest_date=?,latest_value=?,modify_time=NOW() WHERE edb_info_id in (` + utils.GetOrmInReplace(int(total)) + `) `
  113. _, err = o.Raw(sql, item.MinDate, item.MinValue, item.MaxValue, item.MaxDate, item.LatestValue, idList).Exec()
  114. }
  115. return
  116. }
  117. // GetPredictEdbConfBySourceEdbInfoId 根据来源指标id获取配置
  118. func GetPredictEdbConfBySourceEdbInfoId(sourceEdbInfoId int) (item *PredictEdbConf, err error) {
  119. o := orm.NewOrm()
  120. sql := ` SELECT * FROM predict_edb_conf WHERE source_edb_info_id=? `
  121. err = o.Raw(sql, sourceEdbInfoId).QueryRow(&item)
  122. return
  123. }
  124. // AddPredictEdbConf 添加预测指标规则
  125. func AddPredictEdbConf(item *PredictEdbConf) (lastId int64, err error) {
  126. o := orm.NewOrm()
  127. lastId, err = o.Insert(item)
  128. return
  129. }
  130. // AddPredictEdb 添加预测指标
  131. // edbInfo, calculateMappingList, predictEdbConfList,calculateRule9List,trendsMappingList
  132. func AddPredictEdb(item *EdbInfo, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleMap map[int]CalculateRule) (err error, errMsg string) {
  133. o := orm.NewOrm()
  134. tx, err := o.Begin()
  135. if err != nil {
  136. return
  137. }
  138. defer func() {
  139. if err != nil {
  140. tmpErr := tx.Rollback()
  141. if tmpErr != nil {
  142. go alarm_msg.SendAlarmMsg("AddPredictEdb 事务回滚失败,Err:"+tmpErr.Error(), 3)
  143. }
  144. } else {
  145. err = tx.Commit()
  146. }
  147. }()
  148. // 新增预测指标
  149. edbInfoId, err := tx.Insert(item)
  150. if err != nil {
  151. return
  152. }
  153. item.EdbInfoId = int(edbInfoId)
  154. // 新增预测指标的关联关系
  155. lenCalculateMapping := len(calculateMappingList)
  156. if lenCalculateMapping > 0 {
  157. for _, calculateMappingItem := range calculateMappingList {
  158. calculateMappingItem.EdbInfoId = item.EdbInfoId
  159. calculateMappingItem.EdbCode = item.EdbCode
  160. }
  161. _, err = tx.InsertMulti(lenCalculateMapping, calculateMappingList)
  162. if err != nil {
  163. return
  164. }
  165. }
  166. predictEdbConfAndDataList := make([]*PredictEdbConfAndData, 0)
  167. // 新增预测指标配置
  168. for k, v := range predictEdbConfList {
  169. v.PredictEdbInfoId = item.EdbInfoId
  170. configId, tmpErr := tx.Insert(v)
  171. if tmpErr != nil {
  172. err = tmpErr
  173. return
  174. }
  175. v.ConfigId = int(configId)
  176. // 每次规则计算的时候,产生的临时数据
  177. resultDataList := make([]*EdbInfoSearchData, 0)
  178. switch v.RuleType {
  179. case 9: //动态环差规则
  180. calculateRule := calculateRuleMap[k]
  181. calculateRule.ConfigId = v.ConfigId
  182. calculateRule.EdbInfoId = v.PredictEdbInfoId
  183. // 指标与规则的动态数据生成入库
  184. resultDataList, err = CalculateByRuleBy9(tx, calculateRule)
  185. if err != nil {
  186. return
  187. }
  188. // 规则与指标的关系入库
  189. lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
  190. if lenTrendsCalculateMapping > 0 {
  191. for _, vv := range calculateRule.TrendsCalculateMappingList {
  192. vv.EdbInfoId = item.EdbInfoId
  193. vv.ConfigId = v.ConfigId
  194. }
  195. _, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
  196. if err != nil {
  197. return
  198. }
  199. }
  200. case 14: //14:根据 一元线性拟合 规则获取预测数据
  201. calculateRule := calculateRuleMap[k]
  202. calculateRule.ConfigId = v.ConfigId
  203. calculateRule.EdbInfoId = v.PredictEdbInfoId
  204. // 指标与规则的动态数据(拟合数据)生成入库
  205. err, errMsg = CalculateByRuleByRuleLineNh(tx, *item, predictEdbConfAndDataList, *v)
  206. if err != nil {
  207. return
  208. }
  209. // 规则与指标的关系入库
  210. lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
  211. if lenTrendsCalculateMapping > 0 {
  212. for _, vv := range calculateRule.TrendsCalculateMappingList {
  213. vv.EdbInfoId = item.EdbInfoId
  214. vv.ConfigId = v.ConfigId
  215. }
  216. _, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
  217. if err != nil {
  218. return
  219. }
  220. }
  221. }
  222. // 规则配置(含数据)
  223. tmpPredictEdbConfAndData := &PredictEdbConfAndData{
  224. ConfigId: 0,
  225. PredictEdbInfoId: 0,
  226. SourceEdbInfoId: v.SourceEdbInfoId,
  227. RuleType: v.RuleType,
  228. FixedValue: v.FixedValue,
  229. Value: v.Value,
  230. EndDate: v.EndDate,
  231. ModifyTime: v.ModifyTime,
  232. CreateTime: v.CreateTime,
  233. DataList: resultDataList,
  234. }
  235. predictEdbConfAndDataList = append(predictEdbConfAndDataList, tmpPredictEdbConfAndData)
  236. }
  237. return
  238. }
  239. // EditPredictEdb 修改预测指标
  240. func EditPredictEdb(edbInfo *EdbInfo, updateEdbInfoCol []string, calculateMappingList []*EdbInfoCalculateMapping, predictEdbConfList []*PredictEdbConf, calculateRuleMap map[int]CalculateRule) (err error, errMsg string) {
  241. o := orm.NewOrm()
  242. tx, err := o.Begin()
  243. if err != nil {
  244. return
  245. }
  246. defer func() {
  247. if err != nil {
  248. tmpErr := tx.Rollback()
  249. if tmpErr != nil {
  250. go alarm_msg.SendAlarmMsg("AddPredictEdb 事务回滚失败,Err:"+tmpErr.Error(), 3)
  251. }
  252. } else {
  253. err = tx.Commit()
  254. }
  255. }()
  256. // 修改预测指标
  257. _, err = tx.Update(edbInfo, updateEdbInfoCol...)
  258. if err != nil {
  259. return
  260. }
  261. // 先删除原有的预测指标 与 其他指标的 关联关系
  262. sql := ` DELETE FROM edb_info_calculate_mapping WHERE edb_info_id = ?`
  263. _, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
  264. if err != nil {
  265. return
  266. }
  267. // 先删除原有的配置
  268. sql = ` DELETE FROM predict_edb_conf WHERE predict_edb_info_id = ?`
  269. _, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
  270. if err != nil {
  271. return
  272. }
  273. // 删除基础预测指标 规则配置 与 其他指标的 关联关系
  274. sql = ` DELETE FROM predict_edb_conf_calculate_mapping WHERE edb_info_id = ?`
  275. _, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
  276. if err != nil {
  277. return
  278. }
  279. // 删除基础预测指标 规则配置 生成的动态数据值
  280. sql = ` DELETE FROM predict_edb_rule_data WHERE edb_info_id = ?`
  281. _, err = tx.Raw(sql, edbInfo.EdbInfoId).Exec()
  282. if err != nil {
  283. return
  284. }
  285. // 新增预测指标的关联关系
  286. lenCalculateMapping := len(calculateMappingList)
  287. if lenCalculateMapping > 0 {
  288. for _, calculateMappingItem := range calculateMappingList {
  289. calculateMappingItem.EdbInfoId = edbInfo.EdbInfoId
  290. calculateMappingItem.EdbCode = edbInfo.EdbCode
  291. }
  292. _, err = tx.InsertMulti(lenCalculateMapping, calculateMappingList)
  293. if err != nil {
  294. return
  295. }
  296. }
  297. calculateRuleIndex := 0 // 预测计算规则下标
  298. predictEdbConfAndDataList := make([]*PredictEdbConfAndData, 0)
  299. // 新增预测指标配置
  300. for confIndex, v := range predictEdbConfList {
  301. configId, tmpErr := tx.Insert(v)
  302. if tmpErr != nil {
  303. err = tmpErr
  304. return
  305. }
  306. v.ConfigId = int(configId)
  307. // 每次规则计算的时候,产生的临时数据
  308. resultDataList := make([]*EdbInfoSearchData, 0)
  309. switch v.RuleType {
  310. case 9: //动态环差规则
  311. calculateRule := calculateRuleMap[confIndex]
  312. calculateRule.ConfigId = v.ConfigId
  313. calculateRule.EdbInfoId = v.PredictEdbInfoId
  314. // 指标与规则的动态数据生成入库
  315. resultDataList, err = CalculateByRuleBy9(tx, calculateRule)
  316. if err != nil {
  317. return
  318. }
  319. // 规则与指标的关系入库
  320. lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
  321. if lenTrendsCalculateMapping > 0 {
  322. for _, vv := range calculateRule.TrendsCalculateMappingList {
  323. vv.EdbInfoId = edbInfo.EdbInfoId
  324. vv.ConfigId = v.ConfigId
  325. }
  326. _, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
  327. if err != nil {
  328. return
  329. }
  330. }
  331. case 14: //14:根据 一元线性拟合 规则获取预测数据
  332. calculateRule := calculateRuleMap[confIndex]
  333. calculateRule.ConfigId = v.ConfigId
  334. calculateRule.EdbInfoId = v.PredictEdbInfoId
  335. // 指标与规则的动态数据(拟合数据)生成入库
  336. err, errMsg = CalculateByRuleByRuleLineNh(tx, *edbInfo, predictEdbConfAndDataList, *v)
  337. if err != nil {
  338. return
  339. }
  340. // 规则与指标的关系入库
  341. lenTrendsCalculateMapping := len(calculateRule.TrendsCalculateMappingList)
  342. if lenTrendsCalculateMapping > 0 {
  343. for _, vv := range calculateRule.TrendsCalculateMappingList {
  344. vv.EdbInfoId = edbInfo.EdbInfoId
  345. vv.ConfigId = v.ConfigId
  346. }
  347. _, err = tx.InsertMulti(lenTrendsCalculateMapping, calculateRule.TrendsCalculateMappingList)
  348. if err != nil {
  349. return
  350. }
  351. }
  352. }
  353. calculateRuleIndex++
  354. // 规则配置(含数据)
  355. tmpPredictEdbConfAndData := &PredictEdbConfAndData{
  356. ConfigId: 0,
  357. PredictEdbInfoId: 0,
  358. SourceEdbInfoId: v.SourceEdbInfoId,
  359. RuleType: v.RuleType,
  360. FixedValue: v.FixedValue,
  361. Value: v.Value,
  362. EndDate: v.EndDate,
  363. ModifyTime: v.ModifyTime,
  364. CreateTime: v.CreateTime,
  365. DataList: resultDataList,
  366. }
  367. predictEdbConfAndDataList = append(predictEdbConfAndDataList, tmpPredictEdbConfAndData)
  368. }
  369. return
  370. }
  371. // GetPredictEdbInfoAllCalculate 根据基础预测指标id集合 获取 所有的普通指标列表数据
  372. func GetPredictEdbInfoAllCalculate(edbInfoIdList []int) (list []*EdbInfo, err error) {
  373. num := len(edbInfoIdList)
  374. if num <= 0 {
  375. return
  376. }
  377. o := orm.NewOrm()
  378. sql := ` SELECT b.* FROM predict_edb_conf AS a
  379. INNER JOIN edb_info AS b ON a.source_edb_info_id=b.edb_info_id
  380. WHERE a.predict_edb_info_id in (` + utils.GetOrmInReplace(num) + `)
  381. GROUP BY a.source_edb_info_id
  382. ORDER BY a.source_edb_info_id ASC `
  383. _, err = o.Raw(sql, edbInfoIdList).QueryRows(&list)
  384. return
  385. }