init

cmd/cache/cache_cmd.go

@@ -33,6 +33,9 @@ func init() {
 	if Instance() == nil {
 		log.Fatal(ErrRedisInit)
 	}
+
+	// 初始化配置数据到缓存
+	InitCacheData()
 }
 
 func Instance() redis.UniversalClient {

cmd/cache/cache_data_init.go

@@ -1,5 +1,174 @@
 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 {
+		log.Fatal(err1.Error())
+		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
+	}
 }

pkg/model/service/model_object_oam_service.go

@@ -17,7 +17,7 @@ type ModelObjectOAMService interface {
 	Update(d *datamodel.ModelObjectOAM) error
 	Delete(m map[string]interface{}) error
 
-	CacheBizObjectOAM(modelId, objectId, oamId int64) error
+	CacheModelObjectOAM(modelId, objectId, oamId int64) error
 }
 
 type modelObjectOAMService struct {
@@ -53,7 +53,7 @@ func (s *modelObjectOAMService) Create(o *datamodel.ModelObjectOAM) error {
 
 	modelId := o.ModelId
 	objectId := o.ObjectId
-	return s.CacheBizObjectOAM(modelId, objectId, oamId)
+	return s.CacheModelObjectOAM(modelId, objectId, oamId)
 }
 
 func (s *modelObjectOAMService) Update(o *datamodel.ModelObjectOAM) error {
@@ -65,14 +65,14 @@ func (s *modelObjectOAMService) Update(o *datamodel.ModelObjectOAM) error {
 	modelId := o.ModelId
 	objectId := o.ObjectId
 	oamId := o.OamId
-	return s.CacheBizObjectOAM(modelId, objectId, oamId)
+	return s.CacheModelObjectOAM(modelId, objectId, oamId)
 }
 
 func (s *modelObjectOAMService) Delete(m map[string]interface{}) error {
 	return s.repo.Delete(m)
 }
 
-func (s *modelObjectOAMService) CacheBizObjectOAM(modelId, objectId, oamId int64) error {
+func (s *modelObjectOAMService) CacheModelObjectOAM(modelId, objectId, oamId int64) error {
 	oam, err1 := s.repo.GetById(modelId, objectId, oamId)
 	if err1 != nil {
 		return err1

pkg/model/viewmodel/model_object_oam_info.go

@@ -1,5 +1,7 @@
 package viewmodel
 
+import "encoding/json"
+
 type ModelObjectOAMInfo struct {
 	ModelId      int64  `json:"modelId"         xorm:"'model_id'        bigint      pk comment('Model ID')       "`
 	ObjectId     int64  `json:"objectId"        xorm:"'object_id'       bigint      pk comment('Object ID')      "`
@@ -19,3 +21,11 @@ type ModelObjectOAMInfo struct {
 func (t *ModelObjectOAMInfo) TableName() string {
 	return "ds_object_oam"
 }
+
+func (t *ModelObjectOAMInfo) MarshalBinary() (data []byte, err error) {
+	return json.Marshal(t)
+}
+
+func (t *ModelObjectOAMInfo) UnmarshalBinary(data []byte) (err error) {
+	return json.Unmarshal(data, t)
+}