complete model load api

database/query_topologic.go

@@ -39,7 +39,7 @@ func QueryTopologicByPageID(ctx context.Context, logger *zap.Logger, pageID int6
 }
 
 // InitCircuitDiagramTopologic return circuit diagram topologic info from postgres
-func InitCircuitDiagramTopologic(topologicNodes []orm.Topologic) error {
+func InitCircuitDiagramTopologic(pageID int64, topologicNodes []orm.Topologic) error {
 	var rootVertex uuid.UUID
 
 	for _, node := range topologicNodes {
@@ -57,6 +57,7 @@ func InitCircuitDiagramTopologic(topologicNodes []orm.Topologic) error {
 		}
 		topologicSet.AddEdge(node.UUIDFrom, node.UUIDTo)
 	}
+	diagram.DiagramsOverview.Store(pageID, topologicSet)
 	return nil
 }
 
@@ -74,12 +75,11 @@ func QueryTopologicFromDB(ctx context.Context, logger *zap.Logger, gridID, zoneI
 			logger.Error("query topologic info by pageID failed", zap.Int64("pageID", page.ID), zap.Error(err))
 			return err
 		}
-		err = InitCircuitDiagramTopologic(topologicInfos)
+		err = InitCircuitDiagramTopologic(page.ID, topologicInfos)
 		if err != nil {
 			logger.Error("init topologic failed", zap.Error(err))
 			return err
 		}
-
 	}
 	return nil
 }

diagram/component_map.go

@@ -8,12 +8,14 @@ import (
 	cmap "github.com/orcaman/concurrent-map/v2"
 )
 
+// DiagramsOverview define struct of storage all circuit diagram data
 var DiagramsOverview sync.Map
 
-func GetComponentMap(key string) (*cmap.ConcurrentMap[string, any], error) {
-	value, ok := DiagramsOverview.Load(key)
+// GetComponentMap define func of get circuit diagram data by global uuid
+func GetComponentMap(uuid string) (*cmap.ConcurrentMap[string, any], error) {
+	value, ok := DiagramsOverview.Load(uuid)
 	if !ok {
-		return nil, fmt.Errorf("can not find graph by pageID:%s", key)
+		return nil, fmt.Errorf("can not find graph by global uuid:%s", uuid)
 	}
 	paramsMap, ok := value.(*cmap.ConcurrentMap[string, any])
 	if !ok {

diagram/topologic_set.go

@@ -6,12 +6,14 @@ import (
 	"sync"
 )
 
+// GraphOverview define struct of storage all circuit diagram topologic data
 var GraphOverview sync.Map
 
-func GetGraphMap(key string) (*Graph, error) {
-	value, ok := GraphOverview.Load(key)
+// GetGraphMap define func of get circuit diagram topologic data by pageID
+func GetGraphMap(pageID int64) (*Graph, error) {
+	value, ok := GraphOverview.Load(pageID)
 	if !ok {
-		return nil, fmt.Errorf("can not find graph by pageID:%s", key)
+		return nil, fmt.Errorf("can not find graph by pageID:%d", pageID)
 	}
 	graph, ok := value.(*Graph)
 	if !ok {

handler/model_load.go

@@ -2,19 +2,83 @@ package handler
 
 import (
 	"fmt"
+	"net/http"
+	"strconv"
 
-	"modelRT/database"
+	"modelRT/diagram"
+	"modelRT/log"
+	"modelRT/network"
 
 	"github.com/gin-gonic/gin"
+	"go.uber.org/zap"
 )
 
 // ModelLoad define model load process API
-func ModelLoad(ctx *gin.Context) {
-	ctx.Writer.Write([]byte("Hi Boy"))
-	pgClient := database.GetPostgresDBInstance(ctx, "")
-	fmt.Println(pgClient)
-	// TODO
-	// step1 查询电路具体信息表 circuit_diagram_xxx获取所有 uuid
-	// step2 根据 uuid 获取所有的电路图map 结构
-	// step3 json化相关数据并返回结果
+func ModelLoad(c *gin.Context) {
+	logger := log.LoggerInstance()
+	pageID, err := strconv.ParseInt(c.Query("page_id"), 10, 64)
+	if err != nil {
+		logger.Error("get pageID from url param failed", zap.Error(err))
+		header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
+		resp := network.BasicResponse{
+			ResponseHeader: header,
+			PayLoad: map[string]interface{}{
+				"page_id": pageID,
+			},
+		}
+		c.JSON(http.StatusOK, resp)
+	}
+
+	topologicInfo, err := diagram.GetGraphMap(pageID)
+	if err != nil {
+		logger.Error("get topologic data from set by pageID failed", zap.Error(err))
+		header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
+		resp := network.BasicResponse{
+			ResponseHeader: header,
+			PayLoad: map[string]interface{}{
+				"page_id": pageID,
+			},
+		}
+		c.JSON(http.StatusOK, resp)
+	}
+	payLoad := make(map[string]interface{})
+	payLoad["root_vertex"] = topologicInfo.RootVertex
+	payLoad["topologic"] = topologicInfo.VerticeLinks
+
+	componentParamMap := make(map[string][]byte)
+	for _, VerticeLink := range topologicInfo.VerticeLinks {
+		fmt.Println(VerticeLink)
+		for _, componentUUID := range VerticeLink {
+			UUIDStr := componentUUID.String()
+			componentParams, err := diagram.GetComponentMap(UUIDStr)
+			if err != nil {
+				logger.Error("get component data from set by uuid failed", zap.Error(err))
+				header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
+				resp := network.BasicResponse{
+					ResponseHeader: header,
+					PayLoad: map[string]interface{}{
+						"uuid": UUIDStr,
+					},
+				}
+				c.JSON(http.StatusOK, resp)
+			}
+			byteSlice, err := componentParams.MarshalJSON()
+			if err != nil {
+				logger.Error("marshal component data failed", zap.Error(err))
+				header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
+				resp := network.BasicResponse{
+					ResponseHeader: header,
+				}
+				c.JSON(http.StatusOK, resp)
+			}
+			componentParamMap[UUIDStr] = byteSlice
+		}
+	}
+	payLoad["component_params"] = componentParamMap
+
+	resp := network.DiagramLoadResponse{
+		ResponseHeader: network.ResponseHeader{Status: http.StatusOK, ErrMsg: ""},
+		PayLoad:        payLoad,
+	}
+	c.JSON(http.StatusOK, resp)
 }

log/init.go

@@ -13,8 +13,9 @@ import (
 )
 
 var (
-	logger *zap.Logger
 	once            sync.Once
+	_globalLoggerMu sync.RWMutex
+	_globalLogger   *zap.Logger
 )
 
 // CutLogConfig define log config of wave record project
@@ -69,16 +70,24 @@ func initLogger(lCfg CutLogConfig) *zap.Logger {
 	}
 
 	core := zapcore.NewCore(encoder, writeSyncer, l)
-	logger = zap.New(core, zap.AddCaller())
-	zap.ReplaceGlobals(logger)
+	_globalLogger = zap.New(core, zap.AddCaller())
+	zap.ReplaceGlobals(_globalLogger)
 
-	return logger
+	return _globalLogger
 }
 
 // GetLoggerInstance return instance of zap logger
 func GetLoggerInstance(lCfg CutLogConfig) *zap.Logger {
 	once.Do(func() {
-		logger = initLogger(lCfg)
+		_globalLogger = initLogger(lCfg)
 	})
+	return _globalLogger
+}
+
+// LoggerInstance returns the global logger instance It's safe for concurrent use.
+func LoggerInstance() *zap.Logger {
+	_globalLoggerMu.RLock()
+	logger := _globalLogger
+	_globalLoggerMu.RUnlock()
 	return logger
 }

network/resp.go

@@ -0,0 +1,17 @@
+// Package network define struct of network operation
+package network
+
+type ResponseHeader struct {
+	Status int    `json:"status"`
+	ErrMsg string `json:"err_msg"`
+}
+
+type BasicResponse struct {
+	ResponseHeader
+	PayLoad map[string]interface{} `json:"payload"`
+}
+
+type DiagramLoadResponse struct {
+	ResponseHeader
+	PayLoad map[string]interface{} `json:"payload"`
+}