xps-server-g5/cmd/cache/cache_data_init.go

package cache

import (
	"log"
	"xps/cmd/datasource"
)
import modelRepo "xps/pkg/model/repository"
import bizRepo "xps/pkg/biz/repository"

func InitCacheData() {
	modelObjectToCache()
	bizObjectToCache()
}

func modelObjectToCache() {
	modelObjectRepo := modelRepo.NewModelObjectRepo(datasource.InstanceMaster())
	modelObjectAttrRepo := modelRepo.NewModelObjectAttrRepo(datasource.InstanceMaster())
	//modelObjectOAMRepo  := modelRepo.NewModelObjectOAMRepo(datasource.InstanceMaster())

	modelObjectList, err1 := modelObjectRepo.GetAll()
	if err1 != nil {
		log.Fatal(err1.Error())
		return
	}

	for _, o := range modelObjectList {
		err2 := SetModelObject(o.ObjectCode, &o)
		if err2 != nil {
			log.Fatal(err1.Error())
			return
		}
		modelObjectAttrsToCache(modelObjectAttrRepo, o.ModelId, o.ObjectId)
		//modelObjectOAMToCache(modelObjectOAMRepo, o.ModelId, o.ObjectId)
	}
}

func modelObjectAttrsToCache(modelObjectAttrRepo *modelRepo.ModelObjectAttrRepo, modelId, objectId int64) {
	attrList, err1 := modelObjectAttrRepo.GetListById(modelId, objectId)
	if err1 != nil {
		log.Fatal(err1.Error())
		return
	}

	if len(attrList) <= 0 {
		return
	}
	objectCode := attrList[0].ObjectCode
	err2 := SetModelObjectAttrs(objectCode, attrList)
	if err2 != nil {
		log.Fatal(err2.Error())
		return
	}
}

func modelObjectOAMToCache(modelObjectOAMRepo *modelRepo.ModelObjectOAMRepo, modelId, objectId int64) {
	oamList, err1 := modelObjectOAMRepo.GetListById(modelId, objectId)
	if err1 != nil {
		log.Fatal(err1.Error())
		return
	}

	for _, oam := range oamList {
		err2 := SetModelObjectOAM(oam.ObjectCode, oam.OamCode, &oam)
		log.Fatal(err2.Error())
		return
	}
}

func bizObjectToCache() {
	bizObjectRepo := bizRepo.NewBizObjectRepo(datasource.InstanceMaster())
	bizObjectAttrRepo := bizRepo.NewBizObjectAttrRepo(datasource.InstanceMaster())
	bizObjectOAMRepo := bizRepo.NewBizObjectOAMRepo(datasource.InstanceMaster())

	bizObjectList, err1 := bizObjectRepo.GetAll()
	if err1 != nil {
		log.Fatal(err1.Error())
		return
	}

	for _, o := range bizObjectList {
		err2 := SetBizObject(o.ObjectCode, &o)
		if err2 != nil {
			log.Fatal(err1.Error())
			return
		}
		bizObjectAttrsToCache(bizObjectAttrRepo, o.BizId, o.ObjectId)
		bizObjectOAMToCache(bizObjectOAMRepo, o.BizId, o.ObjectId)
	}
}

func bizObjectAttrsToCache(bizObjectAttrRepo *bizRepo.BizObjectAttrRepo, bizId, objectId int64) {
	attrList, err1 := bizObjectAttrRepo.GetListById(bizId, objectId)
	if err1 != nil {
		log.Fatal(err1.Error())
		return
	}

	if len(attrList) <= 0 {
		log.Fatal(err1.Error())
		return
	}
	objectCode := attrList[0].ObjectCode
	err2 := SetBizObjectAttrs(objectCode, attrList)
	if err2 != nil {
		log.Fatal(err2.Error())
		return
	}
}

func bizObjectOAMToCache(bizObjectOAMRepo *bizRepo.BizObjectOAMRepo, bizId, objectId int64) {
	bizObjectOAMRuleRepo := bizRepo.NewBizObjectOAMRuleRepo(datasource.InstanceMaster())
	bizObjectOAMParamsRepo := bizRepo.NewBizObjectOAMParamsRepo(datasource.InstanceMaster())
	bizObjectOAMMappingRepo := bizRepo.NewBizObjectOAMMappingRepo(datasource.InstanceMaster())

	oamList, err1 := bizObjectOAMRepo.GetListById(bizId, objectId)
	if err1 != nil {
		log.Fatal(err1.Error())
		return
	}

	for _, oam := range oamList {
		err2 := SetBizObjectOAM(oam.ObjectCode, oam.OamCode, &oam)
		if err2 != nil {
			log.Fatal(err2.Error())
			return
		}
		bizObjectOAMRuleToCache(bizObjectOAMRuleRepo, oam.BizId, oam.ObjectId, oam.OamId, oam.ObjectCode, oam.OamCode)
		bizObjectOAMParamsToCache(bizObjectOAMParamsRepo, oam.BizId, oam.ObjectId, oam.OamId, oam.ObjectCode, oam.OamCode)
		bizObjectOAMMappingToCache(bizObjectOAMMappingRepo, oam.BizId, oam.ObjectId, oam.OamId, oam.ObjectCode, oam.OamCode)
	}
}

func bizObjectOAMRuleToCache(bizObjectOAMRuleRepo *bizRepo.BizObjectOAMRuleRepo, bizId, objectId, oamId int64, objectCode, oamCode string) {
	ruleList, err1 := bizObjectOAMRuleRepo.GetListById(bizId, objectId, oamId)
	if err1 != nil {
		log.Fatal(err1.Error())
		return
	}

	err2 := SetBizObjectOAMRules(objectCode, oamCode, ruleList)
	if err2 != nil {
		log.Fatal(err2.Error())
		return
	}
}

func bizObjectOAMParamsToCache(bizObjectOAMParamsRepo *bizRepo.BizObjectOAMParamsRepo, bizId, objectId, oamId int64, objectCode, oamCode string) {
	params, err1 := bizObjectOAMParamsRepo.GetListById(bizId, objectId, oamId)
	if err1 != nil {
		log.Fatal(err1.Error())
		return
	}

	err2 := SetBizObjectOAMParams(objectCode, oamCode, params)
	if err2 != nil {
		log.Fatal(err2.Error())
		return
	}
}

func bizObjectOAMMappingToCache(bizObjectOAMMappingRepo *bizRepo.BizObjectOAMMappingRepo, bizId, objectId, oamId int64, objectCode, oamCode string) {
	mappingList, err1 := bizObjectOAMMappingRepo.GetListById(bizId, objectId, oamId)
	if err1 != nil {
		log.Fatal(err1.Error())
		return
	}

	err2 := SetBizObjectOAMMapping(objectCode, oamCode, mappingList)
	if err2 != nil {
		log.Fatal(err2.Error())
		return
	}
}