Added function for switches & getting websocketport

Author: Pake-TU

ZigBeeValve/thing.go

@@ -13,8 +13,7 @@ import (
 	"net/http"
 	"time"
 
-	"github.com/coder/websocket"
-	// "github.com/coder/websocket/wsjson"
+	"github.com/gorilla/websocket"
 	"github.com/sdoque/mbaigo/components"
 	"github.com/sdoque/mbaigo/forms"
 	"github.com/sdoque/mbaigo/usecases"
@@ -45,6 +44,7 @@ type UnitAsset struct {
 	deviceIndex string
 	Period      time.Duration `json:"period"`
 	Setpt       float64       `json:"setpoint"`
+	Slaves      []string      `json:"slaves"`
 	Apikey      string        `json:"APIkey"`
 }
 
@@ -98,6 +98,7 @@ func initTemplate() components.UnitAsset {
 		deviceIndex: "",
 		Period:      10,
 		Setpt:       20,
+		Slaves:      []string{},
 		Apikey:      "1234",
 		ServicesMap: components.Services{
 			setPointService.SubPath: &setPointService,
@@ -132,6 +133,7 @@ func newResource(uac UnitAsset, sys *components.System, servs []components.Servi
 		deviceIndex: uac.deviceIndex,
 		Period:      uac.Period,
 		Setpt:       uac.Setpt,
+		Slaves:      uac.Slaves,
 		Apikey:      uac.Apikey,
 		CervicesMap: components.Cervices{
 			t.Name: t,
@@ -146,33 +148,26 @@ func newResource(uac UnitAsset, sys *components.System, servs []components.Servi
 	ua.CervicesMap["temperature"].Details = components.MergeDetails(ua.Details, ref.Details)
 
 	return ua, func() {
-		if ua.Model == "ZHAThermostat" {
-			/*
-				// Get correct index in list returned by api/sensors to make sure we always change correct device
-				err := ua.getConnectedUnits("sensors")
-				if err != nil {
-					log.Println("Error occured during startup, while calling getConnectedUnits:", err)
-				}
-			*/
+		if websocketport == "startup" {
+			ua.getWebsocketPort()
+		}
+		switch ua.Model {
+		case "ZHAThermostat":
 			err := ua.sendSetPoint()
 			if err != nil {
 				log.Println("Error occured during startup, while calling sendSetPoint():", err)
-				// TODO: Turn off system if this startup() fails?
 			}
-		} else if ua.Model == "Smart plug" {
-			/*
-				// Get correct index in list returned by api/lights to make sure we always change correct device
-				err := ua.getConnectedUnits("lights")
-				if err != nil {
-					log.Println("Error occured during startup, while calling getConnectedUnits:", err)
-				}
-			*/
+		case "Smart plug":
 			// Not all smart plugs should be handled by the feedbackloop, some should be handled by a switch
-			if ua.Period != 0 {
+			if ua.Period > 0 {
 				// start the unit assets feedbackloop, this fetches the temperature from ds18b20 and and toggles
 				// between on/off depending on temperature in the room and a set temperature in the unitasset
 				go ua.feedbackLoop(ua.Owner.Ctx)
 			}
+		case "ZHASwitch":
+			// Starts listening to the websocket to find buttonevents (button presses) and then
+			// turns its controlled devices on/off
+			go ua.initWebsocketClient(ua.Owner.Ctx)
 		}
 	}
 }
@@ -301,7 +296,6 @@ func (ua *UnitAsset) toggleState(state bool) (err error) {
 }
 
 // Useless function? Noticed uniqueid can be used as "id" to send requests instead of the index while testing, wasn't clear from documentation. Will need to test this more though
-// TODO: Rewrite this to instead get the websocketport.
 func (ua *UnitAsset) getConnectedUnits(unitType string) (err error) {
 	// --- Get all devices ---
 	apiURL := fmt.Sprintf("http://%s/api/%s/%s", gateway, ua.Apikey, unitType)
@@ -369,40 +363,112 @@ func sendRequest(req *http.Request) (err error) {
 // Port 443, can be found by curl -v "http://localhost:8080/api/[apikey]/config", and getting the "websocketport". Will make a function to automatically get this port
 // https://dresden-elektronik.github.io/deconz-rest-doc/endpoints/websocket/
 // https://stackoverflow.com/questions/32745716/i-need-to-connect-to-an-existing-websocket-server-using-go-lang
-// https://pkg.go.dev/github.com/coder/websocket#Dial
-// https://pkg.go.dev/github.com/coder/websocket#Conn.Reader
-
-// Not sure if this will work, still a work in progress.
-func initWebsocketClient(ctx context.Context) (err error) {
-	fmt.Println("Starting Client")
-	ws, _, err := websocket.Dial(ctx, "ws://localhost:443", nil) // Start listening to websocket
-	defer ws.CloseNow()                                          // Make sure connection is closed when returning from function
+// https://github.com/gorilla/websocket
+
+var websocketport = "startup"
+
+type eventJSON struct {
+	State struct {
+		Buttonevent int `json:"buttonevent"`
+	} `json:"state"`
+	UniqueID string `json:"uniqueid"`
+}
+
+func (ua *UnitAsset) getWebsocketPort() (err error) {
+	// --- Get config ---
+	apiURL := fmt.Sprintf("http://%s/api/%s/config", gateway, ua.Apikey)
+	// Create a new request (Get)
+	// Put data into buffer
+	req, err := http.NewRequest(http.MethodGet, apiURL, nil) // Put request is made
+	req.Header.Set("Content-Type", "application/json")       // Make sure it's JSON
+	// Send the request
+	resp, err := http.DefaultClient.Do(req) // Perform the http request
 	if err != nil {
-		fmt.Printf("Dial failed: %s\n", err)
 		return err
 	}
-	_, body, err := ws.Reader(ctx) // Start reading from connection, returned body will be used to get buttonevents
+	defer resp.Body.Close()
+	resBody, err := io.ReadAll(resp.Body) // Read the response body, and check for errors/bad statuscodes
 	if err != nil {
-		log.Println("Error while reading from websocket:", err)
-		return
+		return err
 	}
-	data, err := io.ReadAll(body)
-	if err != nil {
-		log.Println("Error while converthing from io.Reader to []byte:", err)
-		return
+	if resp.StatusCode > 299 {
+		return errStatusCode
 	}
-	var bodyString map[string]interface{}
-	err = json.Unmarshal(data, &bodyString) // Unmarshal body into json, easier to be able to point to specific data with ".example"
+	// How to access maps inside of maps below!
+	// https://stackoverflow.com/questions/28806951/accessing-nested-map-of-type-mapstringinterface-in-golang
+	var configMap map[string]interface{}
+	err = json.Unmarshal([]byte(resBody), &configMap)
 	if err != nil {
-		log.Println("Error while unmarshaling data:", err)
-		return
+		return err
 	}
-	log.Println("Read from websocket:", bodyString)
-	err = ws.Close(websocket.StatusNormalClosure, "No longer need to listen to websocket")
+	websocketport = fmt.Sprint(configMap["websocketport"])
+	// log.Println(configMap["websocketport"])
+	return
+}
+
+func (ua *UnitAsset) toggleSlaves(currentState bool) (err error) {
+	for i := range ua.Slaves {
+		// Add check if current slave is smart plug or a light, like philips hue
+
+		// API call to toggle smart plug on/off, PUT call should be sent to URL/api/apikey/lights/sensor_id/config
+		apiURL := fmt.Sprintf("http://%s/api/%s/lights/%s/state", gateway, ua.Apikey, ua.Slaves[i])
+		// Create http friendly payload
+		s := fmt.Sprintf(`{"on":%t}`, currentState) // Create payload
+		req, err := createRequest(s, apiURL)
+		if err != nil {
+			return err
+		}
+		sendRequest(req)
+	}
+	return err
+}
+
+// Function starts listening to a websocket, every message received through websocket is read, and checked if it's what we're looking for
+// The uniqueid (UniqueID in systemconfig.json file) from the connected switch is used to filter out messages
+func (ua *UnitAsset) initWebsocketClient(ctx context.Context) error {
+	dialer := websocket.Dialer{}
+	wsURL := fmt.Sprintf("ws://localhost:%s", websocketport)
+	conn, _, err := dialer.Dial(wsURL, nil)
 	if err != nil {
-		log.Println("Error while doing normal closure on websocket")
-		return
+		log.Fatal("Error occured while dialing:", err)
+	}
+	log.Println("Connected to websocket")
+	defer conn.Close()
+	currentState := false
+	log.Println(currentState)
+	for {
+		select {
+		case <-ctx.Done():
+			return nil
+		default:
+			_, p, err := conn.ReadMessage()
+			if err != nil {
+				log.Println("Error occured while reading message:", err)
+				return err
+			}
+			var message eventJSON
+			//var message interface{}
+			err = json.Unmarshal(p, &message)
+			if err != nil {
+				log.Println("Error unmarshalling message:", err)
+				return err
+			}
+
+			if message.UniqueID == ua.Uniqueid && (message.State.Buttonevent == 1002 || message.State.Buttonevent == 2002) {
+				bEvent := message.State.Buttonevent
+				if bEvent == 1002 {
+					if currentState == true {
+						currentState = false
+					} else {
+						currentState = true
+					}
+					ua.toggleSlaves(currentState)
+				}
+				if bEvent == 2002 {
+					// Turn on the philips hue light
+					// TODO: Find out how "long presses" works and if it can be used through websocket
+				}
+			}
+		}
 	}
-	return
-	// Have to do something fancy to make sure we update "connected" plugs/lights when Reader returns a body actually containing a buttonevent (something w/ channels?)
 }

go.mod

@@ -4,6 +4,6 @@ go 1.23
 
 require github.com/sdoque/mbaigo v0.0.0-20241019053937-4e5abf6a2df4
 
-require github.com/coder/websocket v1.8.12
+require github.com/gorilla/websocket v1.5.3
 
 replace github.com/sdoque/mbaigo v0.0.0-20241019053937-4e5abf6a2df4 => github.com/lmas/mbaigo v0.0.0-20250123014631-ad869265483c

go.sum

@@ -1,4 +1,4 @@
-github.com/coder/websocket v1.8.12 h1:5bUXkEPPIbewrnkU8LTCLVaxi4N4J8ahufH2vlo4NAo=
-github.com/coder/websocket v1.8.12/go.mod h1:LNVeNrXQZfe5qhS9ALED3uA+l5pPqvwXg3CKoDBB2gs=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/lmas/mbaigo v0.0.0-20250123014631-ad869265483c h1:W+Jr5GQGKN4BiFOeAc6Uaq/Xc3k4/O5l+XzvsGlnlCQ=
 github.com/lmas/mbaigo v0.0.0-20250123014631-ad869265483c/go.mod h1:Bfx9Uj0uiTT7BCzzlImMiRd6vMoPQdsZIHGMQOVjx80=