arozos-mirror/src/mod/iot/handlerManager.go

package iot

import (
	"encoding/json"
	"fmt"
	"net/http"

	"imuslab.com/arozos/mod/database"
	"imuslab.com/arozos/mod/info/logger"
	"imuslab.com/arozos/mod/utils"
)

/*
	IoT Handler Manager
	Author: tobychui

	This manager mange all the existsing / registered ioT Manager.
	This allow a much more abstract usage in the main code

*/

type Manager struct {
	RegisteredHandler []ProtocolHandler
	cachedDeviceList  []*Device
	db                *database.Database
}

func NewIoTManager(sysdb *database.Database) *Manager {
	//Create the iot database if it doesn't exists
	if !sysdb.TableExists("iot") {
		sysdb.NewTable("iot")
	}

	//Return a new iot manager
	return &Manager{
		RegisteredHandler: []ProtocolHandler{},
		cachedDeviceList:  []*Device{},
		db:                sysdb,
	}
}

// Register the handler as one of the IoT Protocol Handler.
func (m *Manager) RegisterHandler(h ProtocolHandler) error {
	//Try to start the handler
	err := h.Start()
	if err != nil {
		//Handler startup failed
		logger.PrintAndLog("Iot", fmt.Sprint("[IoT] *ERROR* Protocol Handler Startup Failed: ", err.Error()), nil)
		return err
	}

	//Add it to the handlers
	m.RegisteredHandler = append(m.RegisteredHandler, h)
	return nil
}

// Handle listing of all avaible scanner and its stats
func (m *Manager) HandleScannerList(w http.ResponseWriter, r *http.Request) {
	stats := []Stats{}
	for _, scanner := range m.RegisteredHandler {
		thisScannerStat := scanner.Stats()
		stats = append(stats, thisScannerStat)
	}

	js, _ := json.Marshal(stats)
	utils.SendJSONResponse(w, string(js))
}

// Get the device object by id
func (m *Manager) GetDeviceByID(devid string) *Device {
	for _, dev := range m.cachedDeviceList {
		if dev.DeviceUUID == devid {
			return dev
		}
	}
	return nil
}

// Handle listing of all avaible scanner and its stats
func (m *Manager) HandleIconLoad(w http.ResponseWriter, r *http.Request) {
	devid, err := utils.GetPara(r, "devid")
	if err != nil {
		utils.SendErrorResponse(w, "Invalid device id")
		return
	}

	//Get device icon from handler
	targetDevice := m.GetDeviceByID(devid)
	iconName := targetDevice.Handler.Icon(targetDevice)

	iconFilePath := "./web/SystemAO/iot/hub/img/devices/" + iconName + ".png"
	//fmt.Println(iconFilePath)
	if utils.FileExists(iconFilePath) {
		http.ServeFile(w, r, iconFilePath)
	} else {
		http.ServeFile(w, r, "./web/SystemAO/iot/hub/img/devices/unknown.png")
	}
}

// Handle listing of all avaible scanner and its stats
func (m *Manager) HandleExecute(w http.ResponseWriter, r *http.Request) {
	devid, err := utils.PostPara(r, "devid")
	if err != nil {
		utils.SendErrorResponse(w, "Invalid device id")
		return
	}

	eptname, err := utils.PostPara(r, "eptname")
	if err != nil {
		utils.SendErrorResponse(w, "Invalid endpoint name")
		return
	}

	payload, _ := utils.PostPara(r, "payload")

	//Get device by device id
	dev := m.GetDeviceByID(devid)
	if dev == nil {
		utils.SendErrorResponse(w, "Given device id not found")
		return
	}

	//Get its endpoint
	var targetEndpoint Endpoint
	for _, ept := range dev.ControlEndpoints {
		if ept.Name == eptname {
			//This is the endpoint we are looking for
			targetEndpoint = *ept
			break
		}
	}

	//log.Println(dev.IPAddr, targetEndpoint, payload)

	//Send request to the target IoT device
	result, err := dev.Handler.Execute(dev, &targetEndpoint, payload)
	if err != nil {
		utils.SendErrorResponse(w, err.Error())
		return
	}

	js, _ := json.Marshal(result)
	utils.SendJSONResponse(w, string(js))
}

// Get status of the given device ID
func (m *Manager) HandleGetDeviceStatus(w http.ResponseWriter, r *http.Request) {
	devid, err := utils.PostPara(r, "devid")
	if err != nil {
		utils.SendErrorResponse(w, "Invalid device id")
		return
	}

	//Search for that device ID
	for _, dev := range m.cachedDeviceList {
		if dev.DeviceUUID == devid {
			//Found. Get it status and return
			status, err := dev.Handler.Status(dev)
			if err != nil {
				utils.SendErrorResponse(w, err.Error())
				return
			}

			//Return the status
			js, _ := json.Marshal(status)
			utils.SendJSONResponse(w, string(js))
			return
		}
	}

	//Not found
	utils.SendErrorResponse(w, "Given device ID does not match any scanned devices")
}

// Handle IoT Scanning Request
func (m *Manager) HandleScanning(w http.ResponseWriter, r *http.Request) {
	//Scan the devices
	scannedDevices := m.ScanDevices()

	js, _ := json.Marshal(scannedDevices)
	utils.SendJSONResponse(w, string(js))
}

// Handle IoT Listing Request
func (m *Manager) HandleListing(w http.ResponseWriter, r *http.Request) {

	if m.cachedDeviceList == nil || len(m.cachedDeviceList) == 0 {
		m.ScanDevices()
	}

	js, _ := json.Marshal(m.cachedDeviceList)
	utils.SendJSONResponse(w, string(js))
}

func (m *Manager) GetCachedDeviceList() []*Device {
	if m.cachedDeviceList == nil {
		m.ScanDevices()
	}

	return m.cachedDeviceList
}

func (m *Manager) ScanDevices() []*Device {
	scannedDevices := []*Device{}
	for _, ph := range m.RegisteredHandler {
		//Scan devices using this handler
		thisProtcolDeviceList, err := ph.Scan()
		if err != nil {
			logger.PrintAndLog("Iot", "[IoT] *ERROR* Scan Error: "+err.Error(), nil)
			continue
		}

		//Append it to list
		for _, dev := range thisProtcolDeviceList {
			scannedDevices = append(scannedDevices, dev)
		}
	}

	//Cache the scan record
	m.cachedDeviceList = scannedDevices

	return scannedDevices
}