添加计算指标引用时，把相关的指标也加入到指标引用表中

models/data_manage/edb_info_relation.go

@@ -19,6 +19,9 @@ type EdbInfoRelation struct {
 	CreateTime         time.Time `description:"创建时间"`
 	ModifyTime         time.Time `description:"修改时间"`
 	RelationTime       time.Time `description:"引用时间"`
+	RelationType       int       `description:"引用类型，0:直接饮用，1间接引用"`
+	RootEdbInfoId      int       `description:"间接引用时，关联的直接引用的指标ID"`
+	ChildEdbInfoId     int       `description:"间接引用时，计算指标直接关联的指标ID"`
 }
 
 func (e *EdbInfoRelation) TableName() string {
@@ -33,16 +36,24 @@ func GetEdbInfoRelationByEdbInfoIds(edbInfoIds []int) (edbIds []int, err error)
 	return
 }
 
-// GetEdbInfoRelationByReferObjectId 查询引用的指标ID
+// GetEdbInfoRelationByReferObjectId 查询直接引用的指标ID
 func GetEdbInfoRelationByReferObjectId(referObjectId int, referObjectType int) (items []*EdbInfoRelation, err error) {
 	o := orm.NewOrmUsingDB("data")
-	msql := ` SELECT * FROM edb_info_relation WHERE refer_object_id =? AND refer_object_type=?  GROUP BY edb_info_id `
+	msql := ` SELECT * FROM edb_info_relation WHERE refer_object_id =? and relation_type=0 AND refer_object_type=?  GROUP BY edb_info_id `
 	_, err = o.Raw(msql, referObjectId, referObjectType).QueryRows(&items)
 	return
 }
 
 // GetEdbInfoRelationByReferObjectIds 查询引用的指标ID
 func GetEdbInfoRelationByReferObjectIds(referObjectIds []int, referObjectType int) (items []*EdbInfoRelation, err error) {
+	o := orm.NewOrmUsingDB("data")
+	msql := ` SELECT * FROM edb_info_relation WHERE refer_object_id in (` + utils.GetOrmInReplace(len(referObjectIds)) + `) AND refer_object_type=? and relation_type=0`
+	_, err = o.Raw(msql, referObjectIds, referObjectType).QueryRows(&items)
+	return
+}
+
+// GetEdbInfoRelationAllByReferObjectIds 查询引用的指标ID
+func GetEdbInfoRelationAllByReferObjectIds(referObjectIds []int, referObjectType int) (items []*EdbInfoRelation, err error) {
 	o := orm.NewOrmUsingDB("data")
 	msql := ` SELECT * FROM edb_info_relation WHERE refer_object_id in (` + utils.GetOrmInReplace(len(referObjectIds)) + `) AND refer_object_type=?`
 	_, err = o.Raw(msql, referObjectIds, referObjectType).QueryRows(&items)
@@ -50,7 +61,7 @@ func GetEdbInfoRelationByReferObjectIds(referObjectIds []int, referObjectType in
 }
 
 // 新增记录
-func AddOrUpdateEdbInfoRelation(relationList []*EdbInfoRelation, deleteIds []int, refreshEdbInfoIds []int, indexCodeList []string) (err error) {
+func AddOrUpdateEdbInfoRelation(objectId, objectType int, relationList []*EdbInfoRelation, deleteEdbInfoIds []int, refreshEdbInfoIds []int, indexCodeList []string) (err error) {
 	o, err := orm.NewOrmUsingDB("data").Begin()
 	if err != nil {
 		return
@@ -63,9 +74,15 @@ func AddOrUpdateEdbInfoRelation(relationList []*EdbInfoRelation, deleteIds []int
 		_ = o.Commit()
 	}()
 
-	if len(deleteIds) > 0 {
-		sql := ` DELETE FROM edb_info_relation WHERE edb_info_relation_id in (` + utils.GetOrmInReplace(len(deleteIds)) + `) `
-		_, err = o.Raw(sql, deleteIds).Exec()
+	if len(deleteEdbInfoIds) > 0 {
+		sql := ` DELETE FROM edb_info_relation WHERE refer_object_id = ? AND refer_object_type=? AND edb_info_id in (` + utils.GetOrmInReplace(len(deleteEdbInfoIds)) + `) AND relation_type=0`
+		_, err = o.Raw(sql, objectId, objectType, deleteEdbInfoIds).Exec()
+		if err != nil {
+			return
+		}
+		// 同时删除相关连的间接引用的指标ID
+		sql = ` DELETE FROM edb_info_relation WHERE refer_object_id = ? AND refer_object_type=? AND parent_edb_info_id in (` + utils.GetOrmInReplace(len(deleteEdbInfoIds)) + `) AND relation_type=1 `
+		_, err = o.Raw(sql, objectId, objectType, deleteEdbInfoIds).Exec()
 		if err != nil {
 			return
 		}
@@ -100,6 +117,50 @@ func AddOrUpdateEdbInfoRelation(relationList []*EdbInfoRelation, deleteIds []int
 	return
 }
 
+// 新增记录
+func AddOrUpdateEdbInfoRelationFeMatter(relationList []*EdbInfoRelation, refreshEdbInfoIds []int, indexCodeList []string) (err error) {
+	o, err := orm.NewOrmUsingDB("data").Begin()
+	if err != nil {
+		return
+	}
+	defer func() {
+		if err != nil {
+			_ = o.Rollback()
+			return
+		}
+		_ = o.Commit()
+	}()
+
+	if len(relationList) > 0 {
+		_, err = o.InsertMulti(len(relationList), relationList)
+		if err != nil {
+			return
+		}
+	}
+
+	if len(refreshEdbInfoIds) > 0 {
+		// todo 更新指标的刷新状态
+		sql := ` UPDATE edb_info SET no_update = 0 WHERE source in (?, ?) AND edb_info_id IN (` + utils.GetOrmInReplace(len(refreshEdbInfoIds)) + `) AND no_update = 1`
+		_, err = o.Raw(sql, utils.DATA_SOURCE_MYSTEEL_CHEMICAL, utils.DATA_SOURCE_WIND, refreshEdbInfoIds).Exec()
+		if err != nil {
+			return
+		}
+	}
+
+	//更新数据源钢联化工指标
+	if len(indexCodeList) > 0 {
+		// 更改数据源的更新状态
+		sql := ` UPDATE base_from_mysteel_chemical_index SET is_stop = 0 WHERE index_code IN (` + utils.GetOrmInReplace(len(indexCodeList)) + `) and is_stop=1`
+		_, err = o.Raw(sql, indexCodeList).Exec()
+		if err != nil {
+			return
+		}
+	}
+
+	// todo 由此被禁用的计算指标是否能恢复刷新
+	return
+}
+
 // 删除指标引用内容
 func DeleteEdbRelationByObjectIds(referObjectIds []int, referObjectType int) (err error) {
 	o := orm.NewOrm()

services/data/edb_info_relation.go

@@ -39,11 +39,19 @@ func saveEdbInfoRelation(edbInfoIds []int, objectId, objectType, objectSubType i
 		err = fmt.Errorf("查询指标信息失败，%s", e.Error())
 		return
 	}
+
+	// 查询计算指标信息，并且建立关联关系
+	// 查询间接引用的指标信息
+	calculateEdbListMap, calculateEdbMappingListMap, calculateEdbMappingIdsMap, e := GetEdbListByEdbInfoId(edbInfoList)
+	if e != nil {
+		err = fmt.Errorf("查询计算指标信息失败，%s", e.Error())
+		return
+	}
 	// 只统计钢联化工和wind来源的指标
 	for _, edbInfo := range edbInfoList {
-		if edbInfo.Source != utils.DATA_SOURCE_WIND && edbInfo.Source != utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
+		/*if edbInfo.Source != utils.DATA_SOURCE_WIND && edbInfo.Source != utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
 			continue
-		}
+		}*/
 		refreshIds = append(refreshIds, edbInfo.EdbInfoId)
 		if edbInfo.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
 			indexCodeList = append(indexCodeList, edbInfo.EdbCode)
@@ -66,11 +74,11 @@ func saveEdbInfoRelation(edbInfoIds []int, objectId, objectType, objectSubType i
 	// 删除不再需要的引用关系
 	nowTime := time.Now()
 	addList := make([]*data_manage.EdbInfoRelation, 0)
-	deleteRelationIds := make([]int, 0)
+	deleteEdbInfoIds := make([]int, 0)
 	for _, edbInfo := range edbInfoList {
-		if edbInfo.Source != utils.DATA_SOURCE_WIND && edbInfo.Source != utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
+		/*if edbInfo.Source != utils.DATA_SOURCE_WIND && edbInfo.Source != utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
 			continue
-		}
+		}*/
 		if _, ok := relationMap[edbInfo.EdbInfoId]; ok {
 			delete(deleteMap, edbInfo.EdbInfoId)
 		} else {
@@ -87,15 +95,53 @@ func saveEdbInfoRelation(edbInfoIds []int, objectId, objectType, objectSubType i
 				RelationTime:       nowTime,
 			}
 			addList = append(addList, tmp)
+			if edbInfo.EdbType == 2 {
+				childEdbMappingIds, ok1 := calculateEdbMappingIdsMap[edbInfo.EdbInfoId]
+				if !ok1 {
+					continue
+				}
+				for _, childEdbMappingId := range childEdbMappingIds {
+					childEdbMapping, ok2 := calculateEdbMappingListMap[childEdbMappingId]
+					if !ok2 {
+						continue
+					}
+					childEdb, ok2 := calculateEdbListMap[childEdbMapping.FromEdbInfoId]
+					if !ok2 {
+						continue
+					}
+					if childEdb.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
+						indexCodeList = append(indexCodeList, childEdb.EdbCode)
+					}
+					tmp1 := &data_manage.EdbInfoRelation{
+						ReferObjectId:      objectId,
+						ReferObjectType:    objectType,
+						ReferObjectSubType: objectSubType,
+						EdbInfoId:          childEdb.EdbInfoId,
+						EdbName:            childEdb.EdbName,
+						Source:             childEdb.Source,
+						EdbCode:            childEdb.EdbCode,
+						CreateTime:         nowTime,
+						ModifyTime:         nowTime,
+						RelationTime:       nowTime,
+						RelationType:       1,
+						RootEdbInfoId:      edbInfo.EdbInfoId,
+						ChildEdbInfoId:     childEdbMapping.EdbInfoId,
+					}
+					addList = append(addList, tmp1)
+					refreshIds = append(refreshIds, childEdb.EdbInfoId)
+					// todo 防止重复
+				}
+			}
+
 		}
 	}
 
 	// 删除不再需要的引用关系
 	for deleteId, _ := range deleteMap {
-		deleteRelationIds = append(deleteRelationIds, deleteId)
+		deleteEdbInfoIds = append(deleteEdbInfoIds, deleteId)
 	}
 	//更新指标刷新状态为启用
-	err = data_manage.AddOrUpdateEdbInfoRelation(addList, deleteRelationIds, refreshIds, indexCodeList)
+	err = data_manage.AddOrUpdateEdbInfoRelation(objectId, objectType, addList, deleteEdbInfoIds, refreshIds, indexCodeList)
 	if err != nil {
 		err = fmt.Errorf("删除不再需要的引用关系失败，%s", err.Error())
 		return
@@ -134,31 +180,30 @@ func SaveCalendarEdbInfoRelation(chartPermissionId int, matterDate string, editM
 	}
 
 	//删除ID，先删除
-	deleteRelationIds := make([]int, 0)
+	deleteObjectIds := make([]int, 0)
 	if len(matterIds) > 0 {
-		relationList, e := data_manage.GetEdbInfoRelationByReferObjectIds(matterIds, utils.EDB_RELATION_CALENDAR)
+		relationList, e := data_manage.GetEdbInfoRelationAllByReferObjectIds(matterIds, utils.EDB_RELATION_CALENDAR)
 		if e != nil {
 			err = fmt.Errorf("查询事件日历指标引用失败，%s", e.Error())
 			return
 		}
 		for _, relation := range relationList {
 			if _, ok := deleteMatterMap[relation.ReferObjectId]; ok {
-				deleteRelationIds = append(deleteRelationIds, relation.EdbInfoRelationId)
+				deleteObjectIds = append(deleteObjectIds, relation.ReferObjectId)
 			}
 			if newMatter, ok := updateMatterMap[relation.ReferObjectId]; ok {
 				if relation.EdbInfoId != newMatter.EdbInfoId {
-					deleteRelationIds = append(deleteRelationIds, relation.EdbInfoRelationId)
+					deleteObjectIds = append(deleteObjectIds, relation.ReferObjectId)
 				}
 			}
 		}
 	}
-	if len(deleteRelationIds) > 0 {
-		err = data_manage.DeleteEdbRelationByObjectIds(deleteRelationIds, utils.EDB_RELATION_CALENDAR)
+	if len(deleteObjectIds) > 0 {
+		err = data_manage.DeleteEdbRelationByObjectIds(deleteObjectIds, utils.EDB_RELATION_CALENDAR)
 		if err != nil {
 			err = fmt.Errorf("删除事件日历指标引用失败，%s", err.Error())
 			return
 		}
-		deleteRelationIds = make([]int, 0)
 	}
 
 	// 获取已有事项
@@ -189,18 +234,26 @@ func SaveCalendarEdbInfoRelation(chartPermissionId int, matterDate string, editM
 		err = fmt.Errorf("查询指标信息失败，%s", e.Error())
 		return
 	}
-	// 只统计钢联化工和wind来源的指标
+
+	// 查询计算指标信息，并且建立关联关系
+	// 查询间接引用的指标信息
+	calculateEdbListMap, calculateEdbMappingListMap, calculateEdbMappingIdsMap, e := GetEdbListByEdbInfoId(edbInfoList)
+	if e != nil {
+		err = fmt.Errorf("查询计算指标信息失败，%s", e.Error())
+		return
+	}
 	addEdbInfoIdMap := make(map[int]*data_manage.EdbInfo)
 	for _, edbInfo := range edbInfoList {
-		if edbInfo.Source != utils.DATA_SOURCE_WIND && edbInfo.Source != utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
+		/*if edbInfo.Source != utils.DATA_SOURCE_WIND && edbInfo.Source != utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
 			continue
-		}
+		}*/
 		refreshIds = append(refreshIds, edbInfo.EdbInfoId)
 		addEdbInfoIdMap[edbInfo.EdbInfoId] = edbInfo
 		if edbInfo.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
 			indexCodeList = append(indexCodeList, edbInfo.EdbCode)
 		}
 	}
+
 	relationMap := make(map[int]struct{})
 	if len(newMatterIds) > 0 {
 		//查询已有的matters
@@ -231,13 +284,50 @@ func SaveCalendarEdbInfoRelation(chartPermissionId int, matterDate string, editM
 				ModifyTime:         nowTime,
 			}
 			addList = append(addList, tmp)
+			//todo 添加指标间接引用
+			if edbInfo.EdbType == 2 {
+				childEdbMappingIds, ok1 := calculateEdbMappingIdsMap[edbInfo.EdbInfoId]
+				if !ok1 {
+					continue
+				}
+				for _, childEdbMappingId := range childEdbMappingIds {
+					childEdbMapping, ok2 := calculateEdbMappingListMap[childEdbMappingId]
+					if !ok2 {
+						continue
+					}
+					childEdb, ok2 := calculateEdbListMap[childEdbMapping.FromEdbInfoId]
+					if !ok2 {
+						continue
+					}
+					if childEdb.Source == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
+						indexCodeList = append(indexCodeList, childEdb.EdbCode)
+					}
+					tmp1 := &data_manage.EdbInfoRelation{
+						ReferObjectId:      matter.FeCalendarMatterId,
+						ReferObjectType:    utils.EDB_RELATION_CALENDAR,
+						ReferObjectSubType: 0,
+						EdbInfoId:          childEdb.EdbInfoId,
+						EdbName:            childEdb.EdbName,
+						Source:             childEdb.Source,
+						EdbCode:            childEdb.EdbCode,
+						CreateTime:         nowTime,
+						ModifyTime:         nowTime,
+						RelationTime:       nowTime,
+						RelationType:       1,
+						RootEdbInfoId:      edbInfo.EdbInfoId,
+						ChildEdbInfoId:     childEdbMapping.EdbInfoId,
+					}
+					addList = append(addList, tmp1)
+					refreshIds = append(refreshIds, childEdb.EdbInfoId)
+					// todo 防止重复
+				}
+			}
 		}
 	}
-
 	//更新指标刷新状态为启用
-	err = data_manage.AddOrUpdateEdbInfoRelation(addList, deleteRelationIds, refreshIds, indexCodeList)
+	err = data_manage.AddOrUpdateEdbInfoRelationFeMatter(addList, refreshIds, indexCodeList)
 	if err != nil {
-		err = fmt.Errorf("删除不再需要的引用关系失败，%s", err.Error())
+		err = fmt.Errorf("添加指标引用，%s", err.Error())
 		return
 	}
 	return
@@ -314,3 +404,122 @@ func GetEdbRelationList(source int, classifyId, sysUserId, frequency, keyword, s
 
 	return
 }
+
+func GetEdbListByEdbInfoId(edbInfoList []*data_manage.EdbInfo) (edbInfoMap map[int]*data_manage.EdbInfo, edbMappingListMap map[int]*data_manage.EdbInfoCalculateMapping, edbInfoMappingRootIdsMap map[int][]int, err error) {
+	//查询指标信息
+	//查询指标映射
+	//查询所有指标数据
+	//查询这个指标相关的mapping信息放到数组里，
+	//将得到的指标ID信息放到数组里
+	hasFindMap := make(map[int]struct{})
+	edbInfoIdMap := make(map[int]struct{})
+	edbMappingList := make([]*data_manage.EdbInfoCalculateMapping, 0)
+	edbInfoMappingRootIdsMap = make(map[int][]int, 0)
+	edbMappingMap := make(map[int]struct{})
+	for _, edbInfo := range edbInfoList {
+		if edbInfo.EdbType == 2 {
+			edbInfoId := edbInfo.EdbInfoId
+			edbMappingList, err = GetCalculateEdbInfoByEdbInfoId(edbInfoId, hasFindMap, edbInfoIdMap, edbMappingList, edbMappingMap, edbInfoMappingRootIdsMap, edbInfoId)
+			if err != nil {
+				err = fmt.Errorf(" GetCalculateEdbInfoByEdbInfoId err: %s", err.Error())
+				return
+			}
+		}
+	}
+	if len(edbMappingList) == 0 {
+		return
+	}
+	// 查询指标信息
+	// 指标信息map
+	edbInfoIdList := make([]int, 0)
+	for k, _ := range edbInfoIdMap {
+		edbInfoIdList = append(edbInfoIdList, k)
+	}
+	edbInfoMap = make(map[int]*data_manage.EdbInfo)
+	edbMappingListMap = make(map[int]*data_manage.EdbInfoCalculateMapping)
+	if len(edbInfoIdList) > 0 {
+		edbInfoList, err = data_manage.GetEdbInfoByIdList(edbInfoIdList)
+		if err != nil {
+			err = fmt.Errorf(" GetEdbInfoByIdList err: %s", err.Error())
+			return
+		}
+		for _, v := range edbInfoList {
+			edbInfoMap[v.EdbInfoId] = v
+		}
+	}
+
+	if len(edbMappingList) > 0 {
+		for _, v := range edbMappingList {
+			edbMappingListMap[v.EdbInfoCalculateMappingId] = v
+		}
+	}
+	return
+}
+
+// GetCalculateEdbInfoByEdbInfoId 计算指标追溯
+func GetCalculateEdbInfoByEdbInfoId(edbInfoId int, hasFindMap map[int]struct{}, edbInfoIdMap map[int]struct{}, edbMappingList []*data_manage.EdbInfoCalculateMapping, edbMappingMap map[int]struct{}, edbInfoMappingRootIdsMap map[int][]int, rootEdbInfoId int) (newEdbMappingList []*data_manage.EdbInfoCalculateMapping, err error) {
+	newEdbMappingList = edbMappingList
+	_, ok := hasFindMap[edbInfoId]
+	if ok {
+		return
+	}
+
+	if _, ok1 := edbInfoIdMap[edbInfoId]; !ok1 {
+		edbInfoIdMap[edbInfoId] = struct{}{}
+	}
+
+	edbInfoMappingList, e := data_manage.GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId)
+	if e != nil {
+		err = fmt.Errorf("GetEdbInfoCalculateMappingListByEdbInfoId err: %s", e.Error())
+		return
+	}
+
+	if len(edbInfoMappingList) > 0 {
+		fromEdbInfoIdList := make([]int, 0)
+		edbInfoMappingIdList := make([]int, 0)
+		for _, v := range edbInfoMappingList {
+			fromEdbInfoIdList = append(fromEdbInfoIdList, v.FromEdbInfoId)
+			edbInfoMappingIdList = append(edbInfoMappingIdList, v.EdbInfoCalculateMappingId)
+			if _, ok1 := edbInfoIdMap[v.FromEdbInfoId]; !ok1 {
+				edbInfoIdMap[v.FromEdbInfoId] = struct{}{}
+			}
+			if _, ok2 := edbMappingMap[v.EdbInfoCalculateMappingId]; !ok2 {
+				edbMappingMap[v.EdbInfoCalculateMappingId] = struct{}{}
+				tmp := &data_manage.EdbInfoCalculateMapping{
+					EdbInfoCalculateMappingId: v.EdbInfoCalculateMappingId,
+					EdbInfoId:                 v.EdbInfoId,
+					Source:                    v.Source,
+					SourceName:                v.SourceName,
+					EdbCode:                   v.EdbCode,
+					FromEdbInfoId:             v.FromEdbInfoId,
+					FromEdbCode:               v.FromEdbCode,
+					FromEdbName:               v.FromEdbName,
+					FromSource:                v.FromSource,
+					FromSourceName:            v.FromSourceName,
+					FromTag:                   v.FromTag,
+					Sort:                      v.Sort,
+					CreateTime:                v.CreateTime,
+					ModifyTime:                v.ModifyTime,
+				}
+				newEdbMappingList = append(newEdbMappingList, tmp)
+
+			}
+
+			if edbInfoId != v.FromEdbInfoId && (v.FromEdbType == 2 || v.FromEdbInfoType == 1) {
+				// 查过了就不查了
+				if _, ok2 := hasFindMap[v.FromEdbInfoId]; !ok2 {
+					newEdbMappingList, e = GetCalculateEdbInfoByEdbInfoId(v.FromEdbInfoId, hasFindMap, edbInfoIdMap, newEdbMappingList, edbMappingMap, edbInfoMappingRootIdsMap, rootEdbInfoId)
+					if e != nil {
+						err = fmt.Errorf("traceEdbInfoByEdbInfoId err: %s", e.Error())
+						return
+					}
+				}
+			}
+			hasFindMap[v.FromEdbInfoId] = struct{}{}
+		}
+		edbInfoMappingRootIdsMap[rootEdbInfoId] = append(edbInfoMappingRootIdsMap[rootEdbInfoId], edbInfoMappingIdList...)
+	}
+
+	hasFindMap[edbInfoId] = struct{}{}
+	return
+}