arozos/mod/iot/handlerManager.go

package iot

import (
	"encoding/json"
	"log"
	"net/http"
)

/*
	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
}

func NewIoTManager() *Manager {
	return &Manager{
		RegisteredHandler: []ProtocolHandler{},
	}
}

//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
		log.Println("*IoT* Protocol Handler Startup Failed: ", err.Error())
		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)
	sendJSONResponse(w, string(js))
}

//Get status of the given device ID
func (m *Manager) HandleGetDeviceStatus(w http.ResponseWriter, r *http.Request) {
	devid, err := mv(r, "devid", true)
	if err != nil {
		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 {
				sendErrorResponse(w, err.Error())
				return
			}

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

	//Not found
	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) {
	scannedDevices := []*Device{}
	for _, ph := range m.RegisteredHandler {
		//Scan devices using this handler
		thisProtcolDeviceList, err := ph.Scan()
		if err != nil {
			continue
		}

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

	//Cache the scan record
	m.cachedDeviceList = scannedDevices
	js, _ := json.Marshal(scannedDevices)
	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 {
		//Scan results not exists. Scan again
		m.HandleScanning(w, r)
	} else {
		//Cache already exists. Return it
		js, _ := json.Marshal(m.cachedDeviceList)
		sendJSONResponse(w, string(js))
	}
}