remote-msg/internal/controller/hello/hello_v1_hello.go

package hello

import (
	"context"
	"encoding/json"
	"fmt"
	"github.com/gogf/gf/v2/errors/gerror"
	"github.com/gogf/gf/v2/frame/g"
	"github.com/gogf/gf/v2/util/gconv"
	"github.com/gogf/gf/v2/util/guid"
	"remote-msg/internal/model"
	"remote-msg/internal/service"
	"sync"

	"remote-msg/api/hello/v1"
)

var (
	subscribeTopic string
	publishTopic   string
)

type MqttInstance struct {
	mqttClient *service.MqttClient
}

var once sync.Once
var mqttInstance *MqttInstance

func GetMqttInstance() *MqttInstance {
	once.Do(func() {
		mqttInstance = &MqttInstance{}
		mqttInstance.MqttConnect()
	})
	return mqttInstance
}

func (c *MqttInstance) MqttConnect() {
	c.mqttClient = &service.MqttClient{
		ClientId: "ctwingListener_" + guid.S(),
	}
	ctwingBroker, _ := g.Cfg().Get(context.Background(), "mqtt.ctwing.broker")
	ctwingUsername, _ := g.Cfg().Get(context.Background(), "mqtt.ctwing.username")
	ctwingPassword, _ := g.Cfg().Get(context.Background(), "mqtt.ctwing.password")
	c.mqttClient.Broker = ctwingBroker.String()
	c.mqttClient.UserName = ctwingUsername.String()
	c.mqttClient.PassWord = ctwingPassword.String()

	err := c.mqttClient.Connect()
	if err != nil {
		panic("mqtt监听失败")
	}
}

func (c *ControllerV1) Hello(ctx context.Context, req *v1.HelloReq) (res *v1.HelloRes, err error) {
	g.RequestFromCtx(ctx).Response.Writeln("Hello World!")
	return
}

func (c *ControllerV1) Get(ctx context.Context, req *v1.GetReq) (res *v1.GetRes, err error) {
	//获取get请求参数
	param := g.RequestFromCtx(ctx).URL.Query()
	fmt.Println(gconv.String(param))
	g.RequestFromCtx(ctx).Response.Writeln("get success!")
	return
}

func (c *ControllerV1) Post(ctx context.Context, req *v1.PostReq) (res *v1.PostRes, err error) {
	res = new(v1.PostRes)
	//获取post请求参数
	body := g.RequestFromCtx(ctx).GetBody()
	var dataMap = make(map[string]interface{})
	err = json.Unmarshal(body, &dataMap)
	if IMEI, ok := dataMap["IMEI"]; ok {
		publishTopic = "/drgyen/" + gconv.String(IMEI) + "/up/"
	} else if imei, ok := dataMap["imei"]; ok {
		publishTopic = "/drgyen/" + gconv.String(imei) + "/up/"
	} else {
		g.Log().Error(ctx, "invalid device imei")
		return
	}
	if dataMap["messageType"] == "dataReport" {
		var postDataDto model.PostDataDto
		err = json.Unmarshal(body, &postDataDto)
		var pushData model.PostParamDto
		pushData.Action = "post_P"
		pushData.Timestamp = postDataDto.Timestamp
		pushData.MsgId = gconv.String(postDataDto.Timestamp)
		pushData.DeviceSN = gconv.String(postDataDto.IMEI)
		pushData.Gateway = gconv.String(postDataDto.IMEI)
		var postParamData model.PostParamData
		postParamData.Data = gconv.String(postDataDto.Payload)
		postParamData.Len = postDataDto.ServiceId
		pushData.Data = append(pushData.Data, postParamData)

		err = PublishMessage(pushData)
		if err != nil {
			g.Log().Error(ctx, "publish message error", err)
			return
		}
		writeStr := gconv.String(pushData)
		res.Data = writeStr
		return

	} else if dataMap["messageType"] == "eventReport" {
		var eventPull model.EventPullDto
		err = json.Unmarshal(body, &eventPull)
		var pushData model.PostParamDto
		pushData.Action = "post_E"
		pushData.Timestamp = eventPull.Timestamp
		pushData.MsgId = gconv.String(eventPull.Timestamp)
		pushData.DeviceSN = gconv.String(eventPull.IMEI)
		pushData.Gateway = gconv.String(eventPull.IMEI)
		var postEventData model.PostEventData
		postEventData.Timestamp = eventPull.Timestamp
		eventDataMap := make(map[string]interface{})
		switch eventPull.ServiceId {
		case 1001:
			postEventData.EventCode = "SmokeAlarm"
			var smokeAlarm model.SmokeAlarm
			gconv.Struct(eventPull.EventContent, &smokeAlarm)
			eventDataMap["state"] = smokeAlarm.SmokeState
			eventDataMap["value"] = smokeAlarm.SmokeValue
			break
		case 1002:
			postEventData.EventCode = "TemperatureAlarm"
			var temperatureAlarm model.TemperatureAlarm
			gconv.Struct(eventPull.EventContent, &temperatureAlarm)
			eventDataMap["state"] = temperatureAlarm.TemperatureState
			eventDataMap["value"] = temperatureAlarm.Temperature
			break
		case 1003:
			postEventData.EventCode = "BatteryVoltageLowAlarm"
			var temperatureAlarm model.BatteryVoltageLowAlarm
			gconv.Struct(eventPull.EventContent, &temperatureAlarm)
			eventDataMap["state"] = temperatureAlarm.BatteryState
			eventDataMap["value"] = temperatureAlarm.BatteryVoltage
			break
		case 1004:
			postEventData.EventCode = "TamperAlarm"
			var tamperAlarm model.TamperAlarm
			gconv.Struct(eventPull.EventContent, &tamperAlarm)
			eventDataMap["state"] = tamperAlarm.TamperState
			eventDataMap["value"] = tamperAlarm.TamperState
			break
		case 1005:
			postEventData.EventCode = "ErrorCodeReport"
			var temperatureAlarm model.ErrorCodeReport
			gconv.Struct(eventPull.EventContent, &temperatureAlarm)
			eventDataMap["state"] = temperatureAlarm.ErrorCode
			eventDataMap["value"] = temperatureAlarm.ErrorCode
			break
		default:
			return
		}
		postEventData.Data = append(postEventData.Data, eventDataMap)
		pushData.Data = append(pushData.Data, postEventData)
		err = PublishMessage(pushData)
		if err != nil {
			g.Log().Error(ctx, "publish message error", err)
			return
		}
		writeStr := gconv.String(pushData)
		res.Data = writeStr
		return
	} else if dataMap["messageType"] == "deviceOnlineOfflineReport" {
		var reportPull model.ReportPullDto
		err = json.Unmarshal(body, &reportPull)
		writeStr := gconv.String(reportPull.ModuleParams)
		err = PublishMessage(writeStr)
		if err != nil {
			g.Log().Error(ctx, "publish message error", err)
			return
		}
		res.Data = writeStr
		return
	} else {
		return
	}

}

func PublishMessage(message interface{}) error {
	mqttClient := GetMqttInstance().mqttClient
	if mqttClient != nil && !mqttClient.GetClient().IsConnected() {
		return gerror.New("mqtt client is not connected")
	}
	if mqttClient == nil {
		return gerror.New("mqtt client is not connected")
	}
	if publishTopic == "" {
		return gerror.New("publish topic is empty")
	}

	return mqttClient.Publish(publishTopic, false, gconv.String(message))

}