IOT/SERVER/IotAdmin/iot/db/meter_calc.go

package iotDb

import (
	"IotAdmin/app/iot/models"
	"IotAdmin/core/logger"
	"IotAdmin/core/sdk"
	"IotAdmin/core/storage"
	iotInterface "IotAdmin/iot/interface"
	iotMap "IotAdmin/iot/map"
	iotProtocol "IotAdmin/iot/protocol"
	"IotAdmin/iot/struct/electric"
	"encoding/json"
	"errors"
	"fmt"
)

// LoadMeterCalcMap 加载表计计算配置
func LoadMeterCalcMap() error {
	calcArr := make([]models.IotMeterCalc, 0)
	if len(dbMap) == 0 {
		return errors.New("dbMap is empty")
	}
	for _, db := range dbMap {
		arr := make([]models.IotMeterCalc, 0)
		mc := &models.IotMeterCalc{}
		err := db.Model(mc).Preload("Device").Find(&arr).Error
		if err != nil {
			continue
		}
		calcArr = append(calcArr, arr...)
	}
	return loadMeterCalcMap(&calcArr)
}

func loadMeterCalcMap(arr *[]models.IotMeterCalc) error {
	iotMap.MapMeterCalc.Clean()
	for _, v := range *arr {
		if v.Device == nil || v.Device.Protocol == "" {
			continue
		}
		if err := addMeterCalc(v); err != nil {
			return err
		}
	}
	return nil
}

// AddMaterCalc 添加表计计算配置
func AddMaterCalc(id, host string) error {
	if host == "" {
		host = "*"
	}
	db := dbMap[host]
	if db == nil {
		return errors.New("db is nil")
	}
	mc := &models.IotMeterCalc{}
	db.Model(mc).Preload("Device").Where("id = ?", id).Find(mc)
	return addMeterCalc(*mc)
}

func addMeterCalc(mc models.IotMeterCalc) (err error) {
	if mc.Device == nil || mc.Device.Protocol == "" {
		return errors.New("device is nil")
	}
	var meterCalc iotInterface.MeterCalc
	switch mc.Device.Protocol {
	case iotProtocol.MeterAdw300:
		meterCalc, err = electric.NewMeterADW300(mc.Id, mc.Time, mc.Data, mc.Device.OtherConfig)
		if err != nil {
			return
		}
	case iotProtocol.MeterPmc350b:
		meterCalc, err = electric.NewMeterPMC350B(mc.Id, mc.Time, mc.Data, mc.Device.OtherConfig)
		if err != nil {
			return
		}
	default:
		return
	}
	iotMap.MapMeterCalc.Add(mc.Id, &meterCalc)
	return

}

func UpdateMeterCalc(message storage.Message) (err error) {
	db := sdk.Runtime.GetDbByKey(message.GetPrefix())
	if db == nil {
		err = errors.New("db not exist")
		logger.Errorf("host[%s]'s %s", message.GetPrefix(), err.Error())
		return nil
	}
	var rb []byte
	rb, err = json.Marshal(message.GetValues())
	if err != nil {
		err = fmt.Errorf("json Marshal error,%s, %v", string(rb), err.Error())
		return err
	}
	var val = &models.IotMeterCalc{}
	err = json.Unmarshal(rb, val)
	if err != nil {
		err = fmt.Errorf("json Unmarshal error,%s, %v", string(rb), err.Error())
		return err
	}
	err = db.Model(val).Where("id = ?", val.Id).Assign(models.IotMeterCalc{
		Time: val.Time,
		Data: val.Data,
	}).FirstOrCreate(val).Error
	if err != nil {
		err = fmt.Errorf("db update error, %v", err.Error())
		return err
	}
	return
}