sparrow/services/knowoapi/services/device.go

package services

import (
	"github.com/gogf/gf/encoding/gjson"
	"sparrow/pkg/models"
	"sparrow/pkg/rpcs"
	"sparrow/pkg/server"
	"sparrow/services/knowoapi/model"
)

// DeviceService device service接口
type DeviceService interface {
	// 获取厂商已经激活的设备总数
	GetDeviceCount(vendorid string) (int, error)
	//返回厂商某天激活的设备数
	GetActiveNumberOfDate(vendor string, datetime string) (int, error)
	//获取厂商某天活跃的设备数
	GetLivelyCountOfDate(string, string) (int, error)
	//获取近N日激活设备数据
	GetActiveOfNumDays(string, int) ([]map[string]interface{}, error)
	//获取近N日活跃设备数据
	GetLivelyOfNumDays(string, int) ([]map[string]interface{}, error)
	//获取已经激活的设备列表
	GetDevices(vendorid, proid string, pi, ps int, deviceid string) ([]*models.Devices, int, error)
	//获取用户下所有设备的数量，在线设备的数量，离线设备的数量
	GetDevicesCountByVenderId(vendorid string) (map[string]interface{}, error)
	// 发起设备OTA升级
	Upgrade(params *models.UpgradeParams) error
	// GetUpgradeProgress 获取ota升级进度
	GetUpgradeProgress(deviceId string) (rpcs.ReplyOtaProgress, error)
	// 获取设备状态数据
	GetDeviceStatus(deviceId string) (*gjson.Json, error)
	// 获取分体式五恒获取网关信息
	GetSplitInfo(deviceId string) error
}

type deviceservice struct {
	models *model.All
}

// NewDeviceService create device service
func NewDeviceService(models *model.All) DeviceService {
	return deviceservice{
		models: models,
	}
}
func (a deviceservice) GetDevices(vendorid, proid string, pi, ps int, deviceid string) ([]*models.Devices, int, error) {

	data, total, err := a.models.Device.GetDevices(vendorid, proid, pi, ps, deviceid)

	if err != nil {
		return nil, 0, err
	}

	dataMap := make([]*models.Devices, 0)

	for _, device := range data {

		onlineargs := rpcs.ArgsGetDeviceOnlineStatus{
			Id: device.DeviceIdentifier,
		}

		onlinereply := rpcs.ReplyGetDeviceOnlineStatus{}
		err = server.RPCCallByName(nil, rpcs.DeviceManagerName, "DeviceManager.GetDeviceOnlineStatus", onlineargs, &onlinereply)
		if err != nil && err.Error() != "redigo: nil returned" {
			server.Log.Errorf("get devie online status error: %v", err)

			return nil, 0, err
		}

		devices := new(models.Devices)

		devices.Device = device

		if int(onlinereply.HeartbeatInterval) > 0 && len(onlinereply.ClientIP) > 0 {
			devices.Status = 1
		}

		dataMap = append(dataMap, devices)
	}

	return dataMap, total, nil
}
func (a deviceservice) GetDeviceCount(vendorid string) (int, error) {
	return a.models.Device.GetDeviceCount(vendorid)
}
func (a deviceservice) GetActiveNumberOfDate(vendorid string, datetime string) (int, error) {
	return a.models.Device.GetActiveNumberOfDate(vendorid, datetime)
}
func (a deviceservice) GetLivelyCountOfDate(vendorid string, datetime string) (int, error) {
	return a.models.Device.GetLivelyCountOfDate(vendorid, datetime)
}
func (a deviceservice) GetActiveOfNumDays(vendorid string, days int) ([]map[string]interface{}, error) {
	return a.models.Device.GetActiveOfNumDays(vendorid, days)
}
func (a deviceservice) GetLivelyOfNumDays(vendorid string, days int) ([]map[string]interface{}, error) {
	return a.models.Device.GetLivelyOfNumDays(vendorid, days)
}
func (a deviceservice) GetDevicesCountByVenderId(vendorid string) (map[string]interface{}, error) {
	data, err := a.models.Device.GetDevicesByVenderId(vendorid)

	if err != nil {
		return nil, err
	}

	var onlineCount int

	var offlineCount int
	for _, device := range data {
		onlineargs := rpcs.ArgsGetDeviceOnlineStatus{
			Id: device.DeviceIdentifier,
		}
		onlinereply := rpcs.ReplyGetDeviceOnlineStatus{}
		err = server.RPCCallByName(nil, rpcs.DeviceManagerName, "DeviceManager.GetDeviceOnlineStatus", onlineargs, &onlinereply)
		if err != nil && err.Error() != "redigo: nil returned" {
			server.Log.Errorf("get devie online status error: %v", err)
			return nil, err
		}

		if int(onlinereply.HeartbeatInterval) > 0 && len(onlinereply.ClientIP) > 0 {
			onlineCount += 1
		} else {
			offlineCount += 1
		}
	}

	deviceCount := map[string]interface{}{
		"TotalData":    len(data),
		"OnlineCount":  onlineCount,
		"OfflineCount": offlineCount,
	}

	return deviceCount, nil
}

func (a deviceservice) Upgrade(param *models.UpgradeParams) error {

	//var fileArgs rpcs.ArgsOtaFile
	//fileArgs.FileData = param.File
	//fileArgs.FileId = guid.S()
	//var reply rpcs.ReplyEmptyResult
	//
	//err := server.RPCCallByName(nil, rpcs.DeviceManagerName, "DeviceManager.SavaFile", fileArgs, &reply)
	//if err != nil {
	//	server.Log.Errorf("OTA升级文件保存失败：%v", err)
	//	return err
	//}
	//
	//var args rpcs.ArgsUpgrade4G
	//args.DeviceId = param.DeviceID
	//args.FileId = fileArgs.FileId
	//args.FileSize = param.FileSize
	//
	//err = server.RPCCallByName(nil, rpcs.MQTTAccessName, "Access.UpgradeFor4G", args, &reply)
	//if err != nil {
	//	server.Log.Errorf("4G模组OTA升级失败：%v", err)
	//	return err
	//}
	server.Log.Debugf("ota升级请求成功")
	return nil
}

func (a deviceservice) GetUpgradeProgress(deviceId string) (rpcs.ReplyOtaProgress, error) {
	//var args rpcs.ArgsOtaProgress
	//args.DeviceId = deviceId
	//
	var reply rpcs.ReplyOtaProgress
	//
	//err := server.RPCCallByName(nil, rpcs.DeviceManagerName, "DeviceManager.GetProgress", args, &reply)
	//if err != nil {
	//	server.Log.Errorf("OTA升级进度获取失败：%v", err)
	//	return reply, err
	//}
	server.Log.Debugf("获取升级进度请求成功")
	return reply, nil
}

func (a deviceservice) GetDeviceStatus(deviceId string) (*gjson.Json, error) {
	var args rpcs.ArgsGetStatus
	args.Id = deviceId

	//var reply rpcs.ReplyStatus

	str := `{
      "power": 1,
      "mode": 1,
      "fan_speed": 3,
      "set_temp": 25,
      "env_temp": 2348,
      "env_humidity": 4336,
      "env_co2": 612,
      "env_pm25": 22,
      "status_code": 29,
      "air_mode": 3,
      "ac_type": 1,
      "air_type": 3,
      "hum_type": 0
    }`
	j := gjson.New(str)
	server.Log.Debugf("获取设备信息请求成功")
	return j, nil
	//err := server.RPCCallByName(nil, rpcs.DeviceManagerName, "DeviceManager.GetDeviceStatus", args, &reply)
	//if err != nil {
	//	server.Log.Errorf("设备状态数据获取失败：%v", err)
	//	return reply.Status, err
	//}
	//
	//return reply.Status, nil
}

func (a deviceservice) GetSplitInfo(deviceId string) error {
	//var args rpcs.ArgsSendCommand
	//args.DeviceId = deviceId
	//args.Cmd = "getInfo"
	//var reply rpcs.ReplySendCommand
	//err := server.RPCCallByName(nil, rpcs.ControllerName, "Controller.SendCommand", args, &reply)
	//if err != nil {
	//	server.Log.Errorf("设备状态数据获取失败：%v", err)
	//	return err
	//}
	server.Log.Debugf("更新设备信息请求成功")
	return nil
}