power.go

package api

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

	"github.com/MikMuellerDev/smarthome/core/database"
	"github.com/MikMuellerDev/smarthome/core/event"
	"github.com/MikMuellerDev/smarthome/core/hardware"
	"github.com/MikMuellerDev/smarthome/server/middleware"
)

type PowerRequest struct {
	Switch  string `json:"switch"`
	PowerOn bool   `json:"powerOn"`
}

// API endpoint for manipulating power states and (de) activating sockets, authentication required
// Permission and switch permission is needed to interact with this endpoint
func PowerPostHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	decoder := json.NewDecoder(r.Body)
	decoder.DisallowUnknownFields()
	var request PowerRequest
	if err := decoder.Decode(&request); err != nil {
		w.WriteHeader(http.StatusBadRequest)
		Res(w, Response{Success: false, Message: "bad request", Error: "invalid request body"})
		return
	}
	username, err := middleware.GetUserFromCurrentSession(w, r)
	if err != nil {
		return
	}
	_, switchExists, err := database.GetSwitchById(request.Switch)
	if err != nil {
		w.WriteHeader(http.StatusServiceUnavailable)
		Res(w, Response{Success: false, Message: "failed to check existence of this switch", Error: "database error"})
		return
	}
	if !switchExists {
		w.WriteHeader(http.StatusUnprocessableEntity)
		Res(w, Response{Success: false, Message: "failed to set power: invalid switch id", Error: "switch not found"})
		return
	}
	userHasPermission, err := database.UserHasSwitchPermission(username, request.Switch)
	if err != nil {
		w.WriteHeader(http.StatusServiceUnavailable)
		Res(w, Response{Success: false, Message: "failed to check permission for this switch", Error: "database error"})
		return
	}
	if !userHasPermission {
		w.WriteHeader(http.StatusForbidden)
		Res(w, Response{Success: false, Message: "permission denied", Error: "missing permission to interact with this switch, contact your administrator"})
		return
	}
	if err := hardware.SetPower(request.Switch, request.PowerOn); err != nil {
		w.WriteHeader(http.StatusServiceUnavailable)
		Res(w, Response{Success: false, Message: "hardware error", Error: "failed to communicate with hardware"})
		go event.Warn("Hardware Error", fmt.Sprintf("The hardware failed while %s tried to interact with switch %s.", username, request.Switch))
		return
	}
	Res(w, Response{Success: true, Message: "power action successful"})
	if request.PowerOn {
		go event.Info("User Activated Switch", fmt.Sprintf("%s activated switch %s", username, request.Switch))
	} else {
		go event.Info("User Deactivated Switch", fmt.Sprintf("%s deactivated switch %s", username, request.Switch))
	}
}

// Returns a list of power states, no authentication required
// Request: empty | Response: `[{"switchId": "x", power: false}, {...}]`
func GetPowerStates(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "application/json")
	powerStates, err := database.GetPowerStates()
	if err != nil {
		w.WriteHeader(http.StatusServiceUnavailable)
		Res(w, Response{Success: false, Message: "database error", Error: "database error"})
		return
	}
	if err := json.NewEncoder(w).Encode(powerStates); err != nil {
		log.Error(err.Error())
		Res(w, Response{Success: false, Message: "failed to get power states", Error: "could not encode content"})
	}
}