core/server: refactory to use shared params/request structs

2026-01-27 23:12:49 -05:00 · 2025-12-09 14:13:20 -05:00
parent 993f14a31f
commit 85968ec417
23 changed files with 913 additions and 953 deletions
--- a/core/internal/server/bluez/handlers.go
+++ b/core/internal/server/bluez/handlers.go
@@ -6,25 +6,15 @@ import (
 	"net"

 	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/models"
+	"github.com/AvengeMedia/DankMaterialShell/core/internal/server/params"
 )

-type Request struct {
-	ID     int            `json:"id,omitempty"`
-	Method string         `json:"method"`
-	Params map[string]any `json:"params,omitempty"`
-}
-
-type SuccessResult struct {
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
 type BluetoothEvent struct {
 	Type string         `json:"type"`
 	Data BluetoothState `json:"data"`
 }

-func HandleRequest(conn net.Conn, req Request, manager *Manager) {
+func HandleRequest(conn net.Conn, req models.Request, manager *Manager) {
 	switch req.Method {
 	case "bluetooth.getState":
 		handleGetState(conn, req, manager)
@@ -57,31 +47,30 @@ func HandleRequest(conn net.Conn, req Request, manager *Manager) {
 	}
 }

-func handleGetState(conn net.Conn, req Request, manager *Manager) {
-	state := manager.GetState()
-	models.Respond(conn, req.ID, state)
+func handleGetState(conn net.Conn, req models.Request, manager *Manager) {
+	models.Respond(conn, req.ID, manager.GetState())
 }

-func handleStartDiscovery(conn net.Conn, req Request, manager *Manager) {
+func handleStartDiscovery(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.StartDiscovery(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "discovery started"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "discovery started"})
 }

-func handleStopDiscovery(conn net.Conn, req Request, manager *Manager) {
+func handleStopDiscovery(conn net.Conn, req models.Request, manager *Manager) {
 	if err := manager.StopDiscovery(); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "discovery stopped"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "discovery stopped"})
 }

-func handleSetPowered(conn net.Conn, req Request, manager *Manager) {
-	powered, ok := req.Params["powered"].(bool)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'powered' parameter")
+func handleSetPowered(conn net.Conn, req models.Request, manager *Manager) {
+	powered, err := params.Bool(req.Params, "powered")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

@@ -90,13 +79,13 @@ func handleSetPowered(conn net.Conn, req Request, manager *Manager) {
 		return
 	}

-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "powered state updated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "powered state updated"})
 }

-func handlePairDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handlePairDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

@@ -105,13 +94,13 @@ func handlePairDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}

-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "pairing initiated"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "pairing initiated"})
 }

-func handleConnectDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handleConnectDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

@@ -120,13 +109,13 @@ func handleConnectDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}

-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "connecting"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "connecting"})
 }

-func handleDisconnectDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handleDisconnectDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

@@ -135,13 +124,13 @@ func handleDisconnectDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}

-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "disconnected"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "disconnected"})
 }

-func handleRemoveDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handleRemoveDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

@@ -150,13 +139,13 @@ func handleRemoveDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}

-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "device removed"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "device removed"})
 }

-func handleTrustDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handleTrustDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

@@ -165,13 +154,13 @@ func handleTrustDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}

-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "device trusted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "device trusted"})
 }

-func handleUntrustDevice(conn net.Conn, req Request, manager *Manager) {
-	devicePath, ok := req.Params["device"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'device' parameter")
+func handleUntrustDevice(conn net.Conn, req models.Request, manager *Manager) {
+	devicePath, err := params.String(req.Params, "device")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

@@ -180,43 +169,31 @@ func handleUntrustDevice(conn net.Conn, req Request, manager *Manager) {
 		return
 	}

-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "device untrusted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "device untrusted"})
 }

-func handlePairingSubmit(conn net.Conn, req Request, manager *Manager) {
-	token, ok := req.Params["token"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'token' parameter")
+func handlePairingSubmit(conn net.Conn, req models.Request, manager *Manager) {
+	token, err := params.String(req.Params, "token")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

-	secretsRaw, ok := req.Params["secrets"].(map[string]any)
-	secrets := make(map[string]string)
-	if ok {
-		for k, v := range secretsRaw {
-			if str, ok := v.(string); ok {
-				secrets[k] = str
-			}
-		}
-	}
-
-	accept := false
-	if acceptParam, ok := req.Params["accept"].(bool); ok {
-		accept = acceptParam
-	}
+	secrets := params.StringMapOpt(req.Params, "secrets")
+	accept := params.BoolOpt(req.Params, "accept", false)

 	if err := manager.SubmitPairing(token, secrets, accept); err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "pairing response submitted"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "pairing response submitted"})
 }

-func handlePairingCancel(conn net.Conn, req Request, manager *Manager) {
-	token, ok := req.Params["token"].(string)
-	if !ok {
-		models.RespondError(conn, req.ID, "missing or invalid 'token' parameter")
+func handlePairingCancel(conn net.Conn, req models.Request, manager *Manager) {
+	token, err := params.String(req.Params, "token")
+	if err != nil {
+		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

@@ -225,10 +202,10 @@ func handlePairingCancel(conn net.Conn, req Request, manager *Manager) {
 		return
 	}

-	models.Respond(conn, req.ID, SuccessResult{Success: true, Message: "pairing cancelled"})
+	models.Respond(conn, req.ID, models.SuccessResult{Success: true, Message: "pairing cancelled"})
 }

-func handleSubscribe(conn net.Conn, req Request, manager *Manager) {
+func handleSubscribe(conn net.Conn, req models.Request, manager *Manager) {
 	clientID := fmt.Sprintf("client-%p", conn)
 	stateChan := manager.Subscribe(clientID)
 	defer manager.Unsubscribe(clientID)