123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381 |
- package services
- import (
- "eta_gn/eta_index_lib/models"
- "eta_gn/eta_index_lib/services/alarm_msg"
- "eta_gn/eta_index_lib/utils"
- "fmt"
- "sort"
- "strconv"
- "time"
- )
- // 重置单个计算指标中的引用关系
- func ResetEdbRelation(edbInfoId int) {
- var logMsg string
- var replaceTotal int
- var err error
- defer func() {
- if err != nil {
- msg := fmt.Sprintf(" 重置单个计算指标中的引用关系失败 ResetEdbRelation err: %v", err)
- utils.FileLog.Info(msg)
- fmt.Println(msg)
- go alarm_msg.SendAlarmMsg(msg, 3)
- }
- if logMsg != `` {
- utils.FileLog.Info(fmt.Sprintf("重置单个计算指标中的引用关系失败 重置总数%d,涉及到的引用id:%s", replaceTotal, logMsg))
- }
- }()
- //查询与该计算指标相关的间接引用或者间接引用关系,如果记录不存在,则不处理
- _, err = models.GetEdbInfoRelationByChildEdbInfoId(edbInfoId)
- if err != nil {
- if err.Error() == utils.ErrNoRow() {
- err = nil
- return
- }
- err = fmt.Errorf("查询与该计算指标相关的间接引用或者间接引用关系失败,错误信息:%s", err.Error())
- return
- }
- //查询当前计算指标最新的引用指标列表
- newMappingList, err := models.GetEdbInfoCalculateDetailList(edbInfoId)
- if err != nil {
- err = fmt.Errorf("查询当前计算指标最新的指标列表失败,错误信息:%s", err.Error())
- return
- }
- //整理关联的来源指标ID
- newEdbIdList := make([]string, 0)
- newMappingListMap := make(map[int]*models.EdbInfoCalculateDetail)
- for _, v := range newMappingList {
- newEdbIdList = append(newEdbIdList, strconv.Itoa(v.FromEdbInfoId))
- newMappingListMap[v.FromEdbInfoId] = v
- }
- //对指标ID进行排序
- sort.Strings(newEdbIdList)
- newEdbIdStr := ""
- for _, v := range newEdbIdList {
- newEdbIdStr += v + ","
- }
- //二者匹配一下,如果相同,则不处理,如果不同,先查询所有旧的间接引用记录,整理并分组,则删除旧的间接引用记录,新增新的间接引用记录,
- tmpList, err := models.GetEdbInfoRelationListByChildEdbInfoId(edbInfoId)
- if err != nil {
- err = fmt.Errorf("查询当前计算指标的间接引用关系失败,错误信息:%s", err.Error())
- return
- }
- parentRelationIds := make([]int, 0)
- for _, v := range tmpList {
- parentRelationIds = append(parentRelationIds, v.ParentRelationId)
- }
- if len(parentRelationIds) > 0 {
- // 查询单个项目的引用列表作为判断依据
- oldEdbIdList, err := models.GetEdbInfoRelationEdbIdsByParentRelationId(parentRelationIds[0], edbInfoId)
- if err != nil {
- err = fmt.Errorf("查询当前计算指标的间接引用关系失败,错误信息:%s", err.Error())
- return
- }
- sort.Ints(oldEdbIdList)
- oldEdbIdStr := ""
- for _, v := range oldEdbIdList {
- oldEdbIdStr += strconv.Itoa(v) + ","
- }
- // 把切片转成字符串
- if newEdbIdStr == oldEdbIdStr {
- return
- }
- list, e := models.GetEdbInfoRelationByRelationIds(parentRelationIds)
- if e != nil {
- err = fmt.Errorf("查询图表关联指标列表失败 Err:%s", e)
- return
- }
- //查询直接引用指标关联关系
- edbInfoListMap := make(map[int]struct{})
- edbInfoIds := make([]int, 0)
- for _, v := range list {
- if _, ok := edbInfoListMap[v.EdbInfoId]; !ok {
- edbInfoListMap[v.EdbInfoId] = struct{}{}
- edbInfoIds = append(edbInfoIds, v.EdbInfoId)
- }
- }
- edbInfoList := make([]*models.EdbInfo, 0)
- if len(edbInfoIds) > 0 {
- // 查询指标信息
- edbInfoList, err = models.GetEdbInfoByIdList(edbInfoIds)
- if err != nil {
- err = fmt.Errorf("查询指标信息失败 Err:%s", err)
- return
- }
- }
- calculateEdbMappingListMap, calculateEdbMappingIdsMap, err := GetEdbListByEdbInfoId(edbInfoList)
- if err != nil {
- err = fmt.Errorf("查询指标关联指标列表失败 Err:%s", err)
- return
- }
- //如何过滤掉只有间接引用,没有直接引用的
- replaceTotal1, logMsg1, e := UpdateSecondEdbInRelation(list, calculateEdbMappingListMap, calculateEdbMappingIdsMap, edbInfoList)
- if e != nil {
- err = e
- return
- }
- replaceTotal += replaceTotal1
- logMsg += logMsg1
- }
- return
- }
- // 更新间接引用
- func UpdateSecondEdbInRelation(list []*models.EdbInfoRelation, calculateEdbMappingListMap map[int]*models.EdbInfoCalculateMapping, calculateEdbMappingIdsMap map[int][]int, edbInfoList []*models.EdbInfo) (replaceTotal int, logMsg string, err error) {
- nowTime := time.Now()
- edbInfoRelationIds := make([]int, 0)
- indexCodeList := make([]string, 0)
- addList := make([]*models.EdbInfoRelation, 0)
- refreshIds := make([]int, 0)
- edbInfoMap := make(map[int]*models.EdbInfo)
- for _, v := range edbInfoList {
- edbInfoMap[v.EdbInfoId] = v
- }
- // 查询所有的直接引用,删除所有的间接引用,添加所有直接引用的间接引用
- for _, v := range list {
- if v.RelationType == 0 {
- edbInfoRelationIds = append(edbInfoRelationIds, v.EdbInfoRelationId)
- edbInfo, ok := edbInfoMap[v.EdbInfoId]
- if !ok {
- err = fmt.Errorf("查询指标信息失败 EdbInfoId:%d", v.EdbInfoId)
- return
- }
- if edbInfo.EdbType == 2 { //计算指标
- childEdbMappingIds, ok := calculateEdbMappingIdsMap[edbInfo.EdbInfoId]
- if !ok {
- err = fmt.Errorf("查询%d指标关联指标列表为空", edbInfo.EdbInfoId)
- return
- }
- for _, childEdbMappingId := range childEdbMappingIds {
- childEdbMapping, ok2 := calculateEdbMappingListMap[childEdbMappingId]
- if !ok2 {
- continue
- }
- if childEdbMapping.FromSource == utils.DATA_SOURCE_MYSTEEL_CHEMICAL {
- indexCodeList = append(indexCodeList, childEdbMapping.FromEdbCode)
- }
- tmp1 := &models.EdbInfoRelation{
- ReferObjectId: v.ReferObjectId,
- ReferObjectType: v.ReferObjectType,
- ReferObjectSubType: v.ReferObjectSubType,
- EdbInfoId: childEdbMapping.FromEdbInfoId,
- EdbName: childEdbMapping.FromEdbName,
- Source: childEdbMapping.FromSource,
- EdbCode: childEdbMapping.FromEdbCode,
- CreateTime: nowTime,
- ModifyTime: nowTime,
- RelationTime: childEdbMapping.CreateTime,
- RelationType: 1,
- RootEdbInfoId: edbInfo.EdbInfoId,
- ChildEdbInfoId: childEdbMapping.EdbInfoId,
- }
- tmp1.RelationCode = fmt.Sprintf("%d_%d_%d_%d", tmp1.RootEdbInfoId, tmp1.ReferObjectId, tmp1.ReferObjectType, tmp1.ReferObjectSubType)
- addList = append(addList, tmp1)
- refreshIds = append(refreshIds, childEdbMapping.FromEdbInfoId)
- }
- }
- }
- }
- if len(edbInfoRelationIds) > 0 {
- err = models.UpdateSecondRelationEdbInfoId(edbInfoRelationIds, addList, refreshIds, indexCodeList)
- if err != nil {
- logMsg = ""
- err = fmt.Errorf("替换指标引用表中的指标ID失败 Err:%s", err)
- return
- }
- replaceTotal = len(edbInfoRelationIds)
- }
- return
- }
- // 设置成禁用状态
- func DisableEdbInfoNoUpdate(edbInfo *models.EdbInfo) (err error) {
- // 如果一个计算指标里,包涵的基础指标是停用状态,那么计算指标也要是停用状态停用状态
- newBaseEdbInfoList := make([]int, 0)
- hasFind := make(map[int]struct{})
- newBaseEdbInfoIds, err := FindBaseEdbInfo(edbInfo.EdbInfoId, newBaseEdbInfoList, hasFind)
- if err != nil {
- err = fmt.Errorf("查找基础指标信息失败,err:%v", err)
- return
- }
- // 查询是否存在停用指标,如果存在,则计算指标也要是停用状态
- total, err := models.GetEdbInfoNoUpdateTotalByIdList(newBaseEdbInfoIds)
- if err != nil {
- err = fmt.Errorf("查询基础指标信息失败,err:%v", err)
- return
- }
- if total > 0 {
- edbInfo.NoUpdate = 1
- edbInfo.ModifyTime = time.Now()
- err = edbInfo.Update([]string{"NoUpdate", "ModifyTime"})
- if err != nil {
- err = fmt.Errorf("更新计算指标刷新状态失败,err:%v", err)
- return
- }
- }
- return
- }
- // 找到基础指标的过程
- func FindBaseEdbInfo(edbInfoId int, baseEdbInfoList []int, hasFind map[int]struct{}) (newBaseEdbInfoList []int, err error) {
- newBaseEdbInfoList = baseEdbInfoList
- if _, ok := hasFind[edbInfoId]; ok {
- return
- }
- // 先找到所有的引用关系
- //查询当前计算指标最新的引用指标列表
- newMappingList, err := models.GetEdbInfoCalculateDetailList(edbInfoId)
- if err != nil {
- err = fmt.Errorf("查询当前计算指标最新的指标列表失败,错误信息:%s", err.Error())
- return
- }
- hasFind[edbInfoId] = struct{}{}
- for _, mapping := range newMappingList {
- newBaseEdbInfoList = append(newBaseEdbInfoList, mapping.FromEdbInfoId)
- if mapping.EdbType == 1 { // 如果是基础指标,则加入,否则继续找
- } else {
- newBaseEdbInfoList, err = FindBaseEdbInfo(mapping.FromEdbInfoId, newBaseEdbInfoList, hasFind)
- }
- }
- return
- }
- // 查找当前计算指标的所有溯源指标
- func GetEdbListByEdbInfoId(edbInfoList []*models.EdbInfo) (edbMappingListMap map[int]*models.EdbInfoCalculateMapping, edbInfoMappingRootIdsMap map[int][]int, err error) {
- if len(edbInfoList) == 0 {
- return
- }
- edbInfoIds := make([]int, 0)
- for _, v := range edbInfoList {
- if v.EdbType == 2 && v.EdbInfoType == 0 { //普通计算指标,排除预算指标
- edbInfoIds = append(edbInfoIds, v.EdbInfoId)
- }
- }
- if len(edbInfoIds) == 0 {
- return
- }
- //查询指标信息
- allEdbMappingMap := make(map[int][]*models.EdbInfoCalculateMappingInfo, 0)
- allMappingList, e := models.GetEdbInfoCalculateMappingListByEdbInfoIds(edbInfoIds)
- if e != nil {
- err = fmt.Errorf("GetEdbInfoCalculateMappingListByEdbInfoIds err: %s", e.Error())
- return
- }
- for _, v := range allMappingList {
- if _, ok := allEdbMappingMap[v.EdbInfoId]; !ok {
- allEdbMappingMap[v.EdbInfoId] = make([]*models.EdbInfoCalculateMappingInfo, 0)
- }
- allEdbMappingMap[v.EdbInfoId] = append(allEdbMappingMap[v.EdbInfoId], v)
- }
- //查询指标映射
- //查询所有指标数据
- //查询这个指标相关的mapping信息放到数组里,
- //将得到的指标ID信息放到数组里
- hasFindMap := make(map[int]struct{})
- edbInfoIdMap := make(map[int]struct{})
- edbMappingList := make([]*models.EdbInfoCalculateMapping, 0)
- edbInfoMappingRootIdsMap = make(map[int][]int, 0)
- edbMappingMap := make(map[int]struct{})
- for _, edbInfo := range edbInfoList {
- if edbInfo.EdbType == 2 && edbInfo.EdbInfoType == 0 {
- edbInfoId := edbInfo.EdbInfoId
- edbMappingList, err = getCalculateEdbInfoByEdbInfoId(allEdbMappingMap, 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)
- }
- edbMappingListMap = make(map[int]*models.EdbInfoCalculateMapping)
- if len(edbMappingList) > 0 {
- for _, v := range edbMappingList {
- edbMappingListMap[v.EdbInfoCalculateMappingId] = v
- }
- }
- return
- }
- // getCalculateEdbInfoByEdbInfoId 计算指标追溯
- func getCalculateEdbInfoByEdbInfoId(allEdbMappingMap map[int][]*models.EdbInfoCalculateMappingInfo, edbInfoId int, hasFindMap map[int]struct{}, edbInfoIdMap map[int]struct{}, edbMappingList []*models.EdbInfoCalculateMapping, edbMappingMap map[int]struct{}, edbInfoMappingRootIdsMap map[int][]int, rootEdbInfoId int) (newEdbMappingList []*models.EdbInfoCalculateMapping, err error) {
- newEdbMappingList = edbMappingList
- _, ok := hasFindMap[edbInfoId]
- if ok {
- return
- }
- if _, ok1 := edbInfoIdMap[edbInfoId]; !ok1 {
- edbInfoIdMap[edbInfoId] = struct{}{}
- }
- edbInfoMappingList := make([]*models.EdbInfoCalculateMappingInfo, 0)
- edbInfoMappingList, ok = allEdbMappingMap[edbInfoId]
- if !ok {
- edbInfoMappingList, err = models.GetEdbInfoCalculateMappingListByEdbInfoId(edbInfoId)
- if err != nil {
- err = fmt.Errorf("GetEdbInfoCalculateMappingListByEdbInfoId err: %s", err.Error())
- return
- }
- }
- hasFindMap[edbInfoId] = struct{}{}
- 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 := &models.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, err = getCalculateEdbInfoByEdbInfoId(allEdbMappingMap, v.FromEdbInfoId, hasFindMap, edbInfoIdMap, newEdbMappingList, edbMappingMap, edbInfoMappingRootIdsMap, rootEdbInfoId)
- if err != nil {
- err = fmt.Errorf("traceEdbInfoByEdbInfoId err: %s", err.Error())
- return
- }
- }
- }
- hasFindMap[v.FromEdbInfoId] = struct{}{}
- }
- edbInfoMappingRootIdsMap[rootEdbInfoId] = append(edbInfoMappingRootIdsMap[rootEdbInfoId], edbInfoMappingIdList...)
- }
- return
- }
|