modelRT/handler/real_time_data_receive.go

package handler

import (
	"modelRT/logger"
	"modelRT/network"

	"github.com/gin-gonic/gin"
	"github.com/gorilla/websocket"
	jsoniter "github.com/json-iterator/go"
	"go.uber.org/zap"

	realtimedata "modelRT/real-time-data"
)

var upgrader = websocket.Upgrader{
	ReadBufferSize:  1024,
	WriteBufferSize: 1024,
}

// RealTimeDataReceivehandler define real time data receive and process API
func RealTimeDataReceivehandler(c *gin.Context) {
	logger := logger.GetLoggerInstance()

	conn, err := upgrader.Upgrade(c.Writer, c.Request, nil)
	if err != nil {
		logger.Error("upgrade http protocol to websocket protocal failed", zap.Error(err))
		return
	}
	defer conn.Close()

	for {
		messageType, p, err := conn.ReadMessage()
		if err != nil {
			logger.Error("read message from websocket connection failed", zap.Error(err))

			respByte := processResponse(-1, "read message from websocket connection failed", nil)
			if len(respByte) == 0 {
				logger.Error("process message from byte failed", zap.Error(err))
				continue
			}

			err = conn.WriteMessage(messageType, respByte)
			if err != nil {
				logger.Error("write message to websocket connection failed", zap.Error(err))
				continue
			}
			continue
		}

		var request network.RealTimeDataReceiveRequest
		err = jsoniter.Unmarshal([]byte(p), &request)
		if err != nil {
			logger.Error("unmarshal message from byte failed", zap.Error(err))

			respByte := processResponse(-1, "unmarshal message from byte failed", nil)
			if len(respByte) == 0 {
				logger.Error("process message from byte failed", zap.Error(err))
				continue
			}

			err = conn.WriteMessage(messageType, respByte)
			if err != nil {
				logger.Error("write message to websocket connection failed", zap.Error(err))
				continue
			}
			continue
		}

		realtimedata.RealTimeDataChan <- request

		payload := map[string]interface{}{
			"component_id": request.PayLoad.ComponentID,
			"point":        request.PayLoad.Point,
		}
		respByte := processResponse(0, "success", payload)
		if len(respByte) == 0 {
			logger.Error("process message from byte failed", zap.Error(err))
			continue
		}

		err = conn.WriteMessage(messageType, respByte)
		if err != nil {
			logger.Error("write message to websocket connection failed", zap.Error(err))
			continue
		}
	}
}

func processResponse(code int64, msg string, payload map[string]interface{}) []byte {
	resp := map[string]interface{}{
		"code":    code,
		"msg":     msg,
		"payload": payload,
	}

	respByte, err := jsoniter.Marshal(resp)
	if err != nil {
		return []byte("")
	}

	return respByte
}