modelRT/handler/circuit_diagram_update.go

package handler

import (
	"fmt"
	"net/http"

	"modelRT/constant"
	"modelRT/database"
	"modelRT/diagram"
	"modelRT/log"
	"modelRT/model"
	"modelRT/network"

	"github.com/gin-gonic/gin"
	jsoniter "github.com/json-iterator/go"
	cmap "github.com/orcaman/concurrent-map/v2"
	"go.uber.org/zap"
)

// CircuitDiagramUpdateHandler define circuit diagram update process API
func CircuitDiagramUpdateHandler(c *gin.Context) {
	logger := log.GetLoggerInstance()
	pgClient := database.GetPostgresDBClient()

	var request network.CircuitDiagramUpdateRequest
	if err := c.ShouldBindJSON(&request); err != nil {
		logger.Error("unmarshal circuit diagram update info failed", zap.Error(err))
		header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
		resp := network.BasicResponse{
			ResponseHeader: header,
		}
		c.JSON(http.StatusOK, resp)
		return
	}

	graph, err := diagram.GetGraphMap(request.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": request.PageID,
			},
		}
		c.JSON(http.StatusOK, resp)
		return
	}

	var topologicChangeInfos []network.TopologicUUIDChangeInfos
	for _, topologicLink := range request.TopologicLinks {
		changeInfo, err := network.ParseUUID(topologicLink)
		if err != nil {
			logger.Error("format uuid from string failed", zap.Error(err))
			header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
			resp := network.BasicResponse{
				ResponseHeader: header,
				PayLoad: map[string]interface{}{
					"topologic_info": topologicLink,
				},
			}
			c.JSON(http.StatusOK, resp)
			return
		}
		topologicChangeInfos = append(topologicChangeInfos, changeInfo)
	}

	// open transaction
	tx := pgClient.Begin()

	for _, topologicChangeInfo := range topologicChangeInfos {
		err = database.UpdateTopologicIntoDB(c, tx, request.PageID, topologicChangeInfo)
		if err != nil {
			tx.Rollback()

			logger.Error("update topologic info into DB failed", zap.Any("topologic_info", topologicChangeInfo), zap.Error(err))
			header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
			resp := network.BasicResponse{
				ResponseHeader: header,
				PayLoad: map[string]interface{}{
					"topologic_info": topologicChangeInfo,
				},
			}
			c.JSON(http.StatusOK, resp)
			return
		}

		err = graph.UpdateEdge(topologicChangeInfo)
		if err != nil {
			tx.Rollback()

			logger.Error("update topologic info failed", zap.Any("topologic_info", topologicChangeInfo), zap.Error(err))
			header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
			resp := network.BasicResponse{
				ResponseHeader: header,
				PayLoad: map[string]interface{}{
					"topologic_info": topologicChangeInfo,
				},
			}
			c.JSON(http.StatusOK, resp)
			return
		}
	}

	for _, componentInfo := range request.ComponentInfos {
		parseStruct := model.SelectModelByType(componentInfo.ComponentType)
		if parseStruct == nil {
			tx.Rollback()

			err := fmt.Errorf("can not get component model by model type %d", componentInfo.ComponentType)
			logger.Error("get component model by model type failed", zap.String("uuid", componentInfo.UUID), zap.Int("component_type", componentInfo.ComponentType), zap.Error(err))
			header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
			resp := network.BasicResponse{
				ResponseHeader: header,
				PayLoad: map[string]interface{}{
					"uuid":           componentInfo.UUID,
					"component_type": componentInfo.ComponentType,
				},
			}
			c.JSON(http.StatusOK, resp)
			return
		}

		err := jsoniter.Unmarshal([]byte(componentInfo.Params), parseStruct)
		if err != nil {
			tx.Rollback()

			componentStructName := model.SelectModelNameByType(componentInfo.ComponentType)
			logger.Error("unmarshal component info by component struct failed", zap.String("component_struct_name", componentStructName), zap.Error(err))
			header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
			resp := network.BasicResponse{
				ResponseHeader: header,
				PayLoad: map[string]interface{}{
					"uuid":                  componentInfo.UUID,
					"component_type":        componentInfo.ComponentType,
					"component_struct_name": componentStructName,
				},
			}
			c.JSON(http.StatusOK, resp)
			return
		}

		result := tx.Where("uuid = ?", componentInfo.UUID).Save(parseStruct)
		if result.Error != nil || result.RowsAffected == 0 {
			tx.Rollback()

			err := result.Error
			if result.RowsAffected == 0 {
				err = fmt.Errorf("%w:please check where conditions", constant.ErrUpdateRowZero)
			}
			logger.Error("store component info into postgresDB failed", zap.Any("component_params", parseStruct), zap.Error(err))
			header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
			resp := network.BasicResponse{
				ResponseHeader: header,
				PayLoad: map[string]interface{}{
					"uuid":             componentInfo.UUID,
					"component_params": parseStruct,
				},
			}
			c.JSON(http.StatusOK, resp)
			return
		}

		parseMap := cmap.New[any]()
		err = parseMap.UnmarshalJSON([]byte(componentInfo.Params))
		if err != nil {
			logger.Error("unmarshal component info by concurrent map failed", zap.String("component_params", componentInfo.Params), zap.Error(err))
			header := network.ResponseHeader{Status: http.StatusBadRequest, ErrMsg: err.Error()}
			resp := network.BasicResponse{
				ResponseHeader: header,
				PayLoad: map[string]interface{}{
					"uuid":             componentInfo.UUID,
					"component_params": componentInfo.Params,
				},
			}
			c.JSON(http.StatusOK, resp)
			return
		}
		diagram.UpdateComponentMap(componentInfo.UUID, &parseMap)
	}

	// commit transsction
	tx.Commit()

	resp := network.BasicResponse{
		ResponseHeader: network.ResponseHeader{Status: http.StatusOK},
		PayLoad: map[string]interface{}{
			"page_id": request.PageID,
		},
	}
	c.JSON(http.StatusOK, resp)
}