bileiqi/05.code/backend/rtelec_app_public_lib/service/model_service.go

package service

import (
	"encoding/json"
	"fmt"
	"reflect"
	"rtzh_elec_temperature/conf"
	"rtzh_elec_temperature/datachannel"
	"rtzh_elec_temperature/global"
	"rtzh_elec_temperature/logger"
	"rtzh_elec_temperature/mqtt"
	"rtzh_elec_temperature/rtelec_app_public_lib/utils"
	"rtzh_elec_temperature/tools"
	"strconv"
	"strings"
	"sync"

	"github.com/spf13/cast"

	"github.com/astaxie/beego/orm"
)

var DeviceModel = make(map[string]interface{})
var modelList = []interface{}{}
var modelAttrList = new(sync.Map)
var modelPeriod = new(sync.Map)

//模型相关服务
type ModelService struct {
	BaseService
}

func init() {
	logger.Logger.Println("初始化模型服务")
	go func() {
		for {
			data, ok := <-datachannel.Service_Model_Chanl
			logger.Logger.Debug(fmt.Sprintf("=======接收到中台回复的模型查询数据:%+v", data))
			if ok {
				ins := new(ModelService)
				go ins.HandleModel(data, tools.IsEmpty(data["mid"]))
			}
		}
	}()
	go func() {
		for {
			data, ok := <-datachannel.Service_ModelAttr_Chanl
			logger.Logger.Debug(fmt.Sprintf("=======接收到中台回复的模型属性查询数据:%+v", data))
			if ok {
				ins := new(ModelService)
				go ins.HandleModelAttr(data, tools.IsEmpty(data["mid"]))
			}
		}
	}()
}

func (t *ModelService) GetModelAttrListObj() *sync.Map {
	return modelAttrList
}
func (t *ModelService) SetModelAttrListObj(key int64, value []interface{}) {
	modelAttrList.Store(key, value)
}
func (t *ModelService) GetModelListObj() []interface{} {
	return modelList
}

//根据模型名称 返回模型id
func (t *ModelService) GetModelId(name string) int {
	for _, row2 := range modelList {
		row := row2.(map[string]interface{})
		if tools.IsEmpty(row["model_name"]) == name {
			id, _ := strconv.Atoi(string(row["id"].(json.Number)))
			return id
		}
	}
	return 0
}

//根据模型Id返回模型信息
func (t *ModelService) GetModelInfo(id string) interface{} {
	for _, row2 := range modelList {
		row := row2.(map[string]interface{})
		if string(row["id"].(json.Number)) == id {
			return row
		}
	}
	return nil
}

func (t *ModelService) SetModelListObj(mm []interface{}) {
	modelList = mm
}

//获取所有模型数据
func (t *ModelService) QueryAllModel(messageId string) {
	var parameter = make(map[string]interface{})
	parameter["mid"] = messageId
	parameter["token"] = RtelecManageApp().AppToken
	value, _ := json.Marshal(parameter)
	utils.MessageIds.Set(messageId, messageId)
	mqtt.PublishMessage(global.Rtelec_Topics["model_get"], string(value))
}

//根据模型ID返回属性列表
func (t *ModelService) GetModelAttrList(modelId int64) []interface{} {
	lst, ok := modelAttrList.Load(modelId)
	if ok {
		return lst.([]interface{})
	}
	return nil
}

//根据模型ID返回属性对象。以attr_name为key
func (t *ModelService) GetModelAttrMap(modelId int64) map[string]interface{} {
	lst, ok := modelAttrList.Load(modelId)
	if ok {
		result := map[string]interface{}{}
		for _, r := range lst.([]interface{}) {
			r1 := r.(map[string]interface{})
			result[tools.IsEmpty(r1["attr_name"])] = r1
		}
		return result
	}
	return nil
}

//获取属性
func (t *ModelService) QueryModelAttr(modelId int64, messageId string) {
	logger.Logger.Debug(fmt.Sprintf("获取模型%d的属性定义列表！", modelId))
	var modelName = ""
	for _, record := range t.GetModelListObj() {
		row := record.(map[string]interface{})
		v, _ := strconv.ParseInt(string(row["id"].(json.Number)), 10, 64)
		if v == modelId {
			modelName = row["model_name"].(string)
			break
		}
	}
	if modelName == "" {
		return
	}
	var para = make(map[string]interface{})
	para["modelId"] = modelId
	para["modelName"] = modelName
	var parameter = make(map[string]interface{})
	parameter["mid"] = messageId
	utils.MessageIds.Set(messageId, messageId)
	parameter["token"] = RtelecManageApp().AppToken
	Message, _ := json.Marshal(para)
	msg, _ := new(utils.ToolsLogic).EncryptMsg(Message, []byte(conf.GlobalConfig["rtelec_manage_password"]), true)
	parameter["message"] = msg
	value, _ := json.Marshal(parameter)
	logger.Logger.Debug(fmt.Sprintf("发送模型%d的属性定义列表查询数据：%s", modelId, string(value)))
	mqtt.PublishMessage(global.Rtelec_Topics["attr_get"], string(value))
}

//处理接收的mqtt模型数据
//接收到的是中台所有模型，需要根据应用的场景-模型关系进行过滤出本应用的模型。如果没有配置场景模型关系，则返回所有模型
func (t *ModelService) HandleModel(data map[string]interface{}, MessageId string) {
	if msg, ok := data["message"]; ok {
		sceneParas := map[string]string{}
		localAppSceneList, _ := new(SceneService).QueryScene(sceneParas)
		localAppSceneDict := map[string]orm.Params{}
		if localAppSceneList != nil {
			//将list转换成Map
			for _, row := range localAppSceneList {
				localAppSceneDict[tools.IsEmpty(row["modelid"])] = row
			}
		}
		if reflect.TypeOf(msg).Kind() == reflect.String {
			decoder := json.NewDecoder(strings.NewReader(msg.(string)))
			decoder.UseNumber()
			err := decoder.Decode(&data)
			if err != nil {
				logger.Logger.Error(err, cast.ToString(msg))
				return
			}
		} else {
			data = msg.(map[string]interface{})
		}
		logger.Logger.Debug(localAppSceneDict)
		if list, ok := data["list"]; ok {
			new(utils.MsgStateManage).SetMessageStateObj(MessageId, utils.MsgState{Success: true, State: true, Message: "操作成功", Value: list})
			var tempData = list.([]interface{})
			tmmpModelList := []interface{}{}
			for _, record := range tempData {
				row := record.(map[string]interface{})
				//logger.Logger.Debug(record)
				_, has := localAppSceneDict[tools.IsEmpty(row["id"])]
				if len(localAppSceneDict) == 0 || has {
					tmmpModelList = append(tmmpModelList, row)
				}
			}
			t.SetModelListObj(tmmpModelList)
			//获取模型属性
			for _, mlst := range tmmpModelList {
				row := mlst.(map[string]interface{})
				modleid := tools.IsEmpty(row["id"])
				t.QueryModelAttr(cast.ToInt64(modleid), tools.GetUid())
			}
		} else {
			new(utils.MsgStateManage).SetMessageStateObj(MessageId, utils.MsgState{Success: false, State: false, Message: "获取南向模型失败", Value: []string{}})
		}
	}
}

//处理接收的mqtt模型属性数据
func (t *ModelService) HandleModelAttr(data map[string]interface{}, messageId string) {
	if mid, ok := data["mid"]; ok && mid != "" {
		if msg, ok := data["message"]; ok {
			if reflect.TypeOf(msg).Kind() == reflect.String {
				decoder := json.NewDecoder(strings.NewReader(msg.(string)))
				decoder.UseNumber()
				err := decoder.Decode(&data)
				if err == nil {
					//ModelAttrList
					if list, ok := data["list"]; ok {
						modeid := int64(0)
						lst := list.([]interface{})
						for _, row := range lst {
							row2 := row.(map[string]interface{})
							modeid, _ = strconv.ParseInt(string(row2["model_id"].(json.Number)), 10, 64)
							break
						}
						t.SetModelAttrListObj(modeid, lst)
						new(utils.MsgStateManage).SetMessageStateObj(messageId, utils.MsgState{Success: true, State: true, Message: "获取属性信息成功", Value: list})
					} else {
						new(utils.MsgStateManage).SetMessageStateObj(messageId, utils.MsgState{Success: false, State: false, Message: "获取属性信息失败", Value: []string{}})
					}
				}
			}
		}
	}
}