undo group nonsense in hue bridge.

Co-authored-by: Gisle Aune <dev@gisle.me>
Reviewed-on: #1
Co-authored-by: gisle <gisle@hidden-email>
Co-committed-by: gisle <gisle@hidden-email>

.drone.yml

@@ -4,15 +4,6 @@ kind: pipeline
 type: docker
 
 steps:
-  - name: go-build
-    image: golang:1.17
-    commands:
-      - go test -v ./...
-    when:
-      event:
-        exclude:
-          - tag
-
   - name: go-test
     image: golang:1.17
     commands:

app/api/bridges.go

@@ -52,7 +52,7 @@ func Bridges(r gin.IRoutes) {
 			return []models.Bridge{bridge}, nil
 		}
 
-		bridges, err := driver.SearchBridge(ctxOf(c), body.Address, body.DryRun)
+		bridges, err := driver.SearchBridge(ctxOf(c), body.Address, body.Token, body.DryRun)
 		if err != nil {
 			return nil, err
 		}

app/api/devices.go

@@ -3,9 +3,9 @@ package api
 import (
 	"context"
 	"git.aiterp.net/lucifer/new-server/app/config"
+	"git.aiterp.net/lucifer/new-server/app/services/publisher"
 	"git.aiterp.net/lucifer/new-server/models"
 	"github.com/gin-gonic/gin"
-	"golang.org/x/sync/errgroup"
 	"log"
 	"time"
 )
@@ -17,11 +17,21 @@ func fetchDevices(ctx context.Context, fetchStr string) ([]models.Device, error)
 
 func Devices(r gin.IRoutes) {
 	r.GET("", handler(func(c *gin.Context) (interface{}, error) {
-		return config.DeviceRepository().FetchByReference(ctxOf(c), models.RKAll, "")
+		devices, err := config.DeviceRepository().FetchByReference(ctxOf(c), models.RKAll, "")
+		if err != nil {
+			return nil, err
+		}
+
+		return withSceneState(devices), nil
 	}))
 
 	r.GET("/:fetch", handler(func(c *gin.Context) (interface{}, error) {
-		return fetchDevices(ctxOf(c), c.Param("fetch"))
+		devices, err := fetchDevices(ctxOf(c), c.Param("fetch"))
+		if err != nil {
+			return nil, err
+		}
+
+		return withSceneState(devices), nil
 	}))
 
 	r.PUT("", handler(func(c *gin.Context) (interface{}, error) {
@@ -72,7 +82,7 @@ func Devices(r gin.IRoutes) {
 			}
 		}()
 
-		return changed, nil
+		return withSceneState(changed), nil
 	}))
 
 	r.PUT("/:fetch", handler(func(c *gin.Context) (interface{}, error) {
@@ -100,7 +110,7 @@ func Devices(r gin.IRoutes) {
 			}
 		}
 
-		return devices, nil
+		return withSceneState(devices), nil
 	}))
 
 	r.PUT("/:fetch/state", handler(func(c *gin.Context) (interface{}, error) {
@@ -127,17 +137,12 @@ func Devices(r gin.IRoutes) {
 
 		config.PublishChannel <- devices
 
-		go func() {
-			for _, device := range devices {
-				err := config.DeviceRepository().Save(context.Background(), &device, models.SMState)
-				if err != nil {
-					log.Println("Failed to save device for state:", err)
-					continue
-				}
-			}
-		}()
+		err = config.DeviceRepository().SaveMany(ctxOf(c), models.SMState, devices)
+		if err != nil {
+			log.Println("Failed to save devices states")
+		}
 
-		return devices, nil
+		return withSceneState(devices), nil
 	}))
 
 	r.PUT("/:fetch/tags", handler(func(c *gin.Context) (interface{}, error) {
@@ -194,7 +199,7 @@ func Devices(r gin.IRoutes) {
 			}
 		}
 
-		return devices, nil
+		return withSceneState(devices), nil
 	}))
 
 	r.PUT("/:fetch/scene", handler(func(c *gin.Context) (interface{}, error) {
@@ -221,25 +226,53 @@ func Devices(r gin.IRoutes) {
 		}
 		body.StartTime = time.Now()
 
+		pushMode := c.Query("push") == "true"
 		for i := range devices {
-			devices[i].SceneAssignments = []models.DeviceSceneAssignment{body}
+			if pushMode {
+				devices[i].SceneAssignments = append(devices[i].SceneAssignments, body)
+			} else {
+				devices[i].SceneAssignments = []models.DeviceSceneAssignment{body}
+			}
 		}
 		config.PublishChannel <- devices
 
-		eg := errgroup.Group{}
-		for i := range devices {
-			device := devices[i]
-
-			eg.Go(func() error {
-				return config.DeviceRepository().Save(ctxOf(c), &device, 0)
-			})
-		}
-
-		err = eg.Wait()
+		err = config.DeviceRepository().SaveMany(ctxOf(c), 0, devices)
 		if err != nil {
 			return nil, err
 		}
 
-		return devices, nil
+		return withSceneState(devices), nil
+	}))
+
+	r.DELETE("/:fetch/scene", handler(func(c *gin.Context) (interface{}, error) {
+		devices, err := fetchDevices(ctxOf(c), c.Param("fetch"))
+		if err != nil {
+			return nil, err
+		}
+		if len(devices) == 0 {
+			return []models.Device{}, nil
+		}
+
+		for i := range devices {
+			devices[i].SceneAssignments = []models.DeviceSceneAssignment{}
+		}
+		config.PublishChannel <- devices
+
+		err = config.DeviceRepository().SaveMany(ctxOf(c), 0, devices)
+		if err != nil {
+			return nil, err
+		}
+
+		return withSceneState(devices), nil
 	}))
 }
+
+func withSceneState(devices []models.Device) []models.Device {
+	res := make([]models.Device, 0, len(devices))
+	for _, device := range devices {
+		device.SceneState = publisher.Global().SceneState(device.ID)
+		res = append(res, device)
+	}
+
+	return res
+}

app/api/handlers.go

@@ -35,17 +35,28 @@ func EventHandlers(r gin.IRoutes) {
 	}))
 
 	r.PUT("/:id", handler(func(c *gin.Context) (interface{}, error) {
-		var body models.EventHandlerUpdate
-		err := parseBody(c, &body)
-		if err != nil {
-			return nil, err
-		}
+
 
 		handler, err := config.EventHandlerRepository().FindByID(ctxOf(c), intParam(c, "id"))
 		if err != nil {
 			return nil, err
 		}
-		handler.ApplyUpdate(body)
+
+		if c.Query("hard") == "true" {
+			var body models.EventHandler
+			err := parseBody(c, &body)
+			if err != nil || body.ID != intParam(c, "id") {
+				return nil, err
+			}
+			handler = &body
+		} else {
+			var body models.EventHandlerUpdate
+			err := parseBody(c, &body)
+			if err != nil {
+				return nil, err
+			}
+			handler.ApplyUpdate(body)
+		}
 
 		err = config.EventHandlerRepository().Save(ctxOf(c), handler)
 		if err != nil {

app/api/scenes.go

@@ -2,6 +2,7 @@ package api
 
 import (
 	"git.aiterp.net/lucifer/new-server/app/config"
+	"git.aiterp.net/lucifer/new-server/app/services/publisher"
 	"git.aiterp.net/lucifer/new-server/models"
 	"github.com/gin-gonic/gin"
 )
@@ -32,6 +33,36 @@ func Scenes(r gin.IRoutes) {
 			return nil, err
 		}
 
+		publisher.Global().UpdateScene(body)
+
 		return body, nil
 	}))
-}
+
+	r.PUT("/:id", handler(func(c *gin.Context) (interface{}, error) {
+		var body models.Scene
+		err := parseBody(c, &body)
+		if err != nil {
+			return nil, err
+		}
+
+		scene, err := config.SceneRepository().Find(ctxOf(c), intParam(c, "id"))
+		if err != nil {
+			return nil, err
+		}
+
+		body.ID = scene.ID
+		err = body.Validate()
+		if err != nil {
+			return nil, err
+		}
+
+		err = config.SceneRepository().Save(ctxOf(c), &body)
+		if err != nil {
+			return nil, err
+		}
+
+		publisher.Global().UpdateScene(body)
+
+		return body, nil
+	}))
+}

app/client/client.go

@@ -60,6 +60,31 @@ func (client *Client) PutDeviceTags(ctx context.Context, fetchStr string, addTag
 	return devices, nil
 }
 
+func (client *Client) AssignDevice(ctx context.Context, fetchStr string, push bool, assignment models.DeviceSceneAssignment) ([]models.Device, error) {
+	query := ""
+	if push {
+		query = "?push=true"
+	}
+
+	devices := make([]models.Device, 0, 16)
+	err := client.Fetch(ctx, "PUT", "/api/devices/"+fetchStr+"/scene"+query, &devices, assignment)
+	if err != nil {
+		return nil, err
+	}
+
+	return devices, nil
+}
+
+func (client *Client) ClearDevice(ctx context.Context, fetchStr string) ([]models.Device, error) {
+	devices := make([]models.Device, 0, 16)
+	err := client.Fetch(ctx, "DELETE", "/api/devices/"+fetchStr+"/scene", &devices, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return devices, nil
+}
+
 func (client *Client) FireEvent(ctx context.Context, event models.Event) error {
 	err := client.Fetch(ctx, "POST", "/api/events", nil, event)
 	if err != nil {

app/client/handler.go

@@ -16,6 +16,26 @@ func (client *Client) GetHandlers(ctx context.Context) ([]models.EventHandler, e
 	return handlers, nil
 }
 
+func (client *Client) GetHandler(ctx context.Context, id int) (*models.EventHandler, error) {
+	var handler models.EventHandler
+	err := client.Fetch(ctx, "GET", fmt.Sprintf("/api/event-handlers/%d", id), &handler, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return &handler, nil
+}
+
+func (client *Client) PutHandler(ctx context.Context, handler *models.EventHandler) (*models.EventHandler, error) {
+	var response models.EventHandler
+	err := client.Fetch(ctx, "PUT", fmt.Sprintf("/api/event-handlers/%d?hard=true", handler.ID), &response, handler)
+	if err != nil {
+		return nil, err
+	}
+
+	return &response, nil
+}
+
 func (client *Client) AddHandler(ctx context.Context, handler models.EventHandler) (*models.EventHandler, error) {
 	var result models.EventHandler
 	err := client.Fetch(ctx, "POST", "/api/event-handlers", &result, handler)

app/client/scene.go

@@ -0,0 +1,16 @@
+package client
+
+import (
+	"context"
+	"git.aiterp.net/lucifer/new-server/models"
+)
+
+func (client *Client) GetScenes(ctx context.Context) ([]models.Scene, error) {
+	scenes := make([]models.Scene, 0, 16)
+	err := client.Fetch(ctx, "GET", "/api/scenes", &scenes, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return scenes, nil
+}

app/config/driver.go

@@ -4,6 +4,7 @@ import (
 	"git.aiterp.net/lucifer/new-server/internal/drivers"
 	"git.aiterp.net/lucifer/new-server/internal/drivers/hue"
 	"git.aiterp.net/lucifer/new-server/internal/drivers/lifx"
+	"git.aiterp.net/lucifer/new-server/internal/drivers/mill"
 	"git.aiterp.net/lucifer/new-server/internal/drivers/nanoleaf"
 	"git.aiterp.net/lucifer/new-server/models"
 	"sync"
@@ -18,6 +19,7 @@ func DriverProvider() models.DriverProvider {
 			models.DTNanoLeaf: &nanoleaf.Driver{},
 			models.DTHue:      &hue.Driver{},
 			models.DTLIFX:     &lifx.Driver{},
+			models.DTMill:     &mill.Driver{},
 		}
 	})
 

app/config/env.go

@@ -1,17 +1,34 @@
 package config
 
 import (
+	"log"
 	"os"
 	"strconv"
+	"time"
 )
 
+func Location() *time.Location {
+	env, ok := os.LookupEnv("LUCIFER_LOCATION")
+	if !ok {
+		return time.UTC
+	}
+
+	loc, err := time.LoadLocation(env)
+	if err != nil {
+		log.Printf("Location lookup failed: %s (%s)", env, err.Error())
+		return time.UTC
+	}
+
+	return loc
+}
+
 func MySqlHost() string     { return strEnv("LUCIFER_MYSQL_HOST") }
 func MySqlPort() int        { return intEnv("LUCIFER_MYSQL_PORT") }
 func MySqlSchema() string   { return strEnv("LUCIFER_MYSQL_SCHEMA") }
 func MySqlUsername() string { return strEnv("LUCIFER_MYSQL_USERNAME") }
 func MySQlPassword() string { return strEnv("LUCIFER_MYSQL_PASSWORD") }
 
-func ServerPort() int       { return intEnv("LUCIFER_SERVER_PORT") }
+func ServerPort() int { return intEnv("LUCIFER_SERVER_PORT") }
 
 func strEnv(key string) string {
 	env, ok := os.LookupEnv(key)

app/server.go

@@ -7,13 +7,14 @@ import (
 	"git.aiterp.net/lucifer/new-server/app/config"
 	"git.aiterp.net/lucifer/new-server/app/services"
 	"git.aiterp.net/lucifer/new-server/app/services/publisher"
+	"git.aiterp.net/lucifer/new-server/models"
 	"github.com/gin-gonic/gin"
 	"log"
 	"time"
 )
 
 func StartServer() {
-	setupCtx, cancel := context.WithTimeout(context.Background(), time.Second * 10)
+	setupCtx, cancel := context.WithTimeout(context.Background(), time.Second*10)
 	defer cancel()
 
 	err := publisher.Initialize(setupCtx)
@@ -38,5 +39,7 @@ func StartServer() {
 	api.EventHandlers(apiGin.Group("/event-handlers"))
 	api.Scenes(apiGin.Group("/scenes"))
 
+	models.TimeOfDayTimeZone = config.Location()
+
 	log.Fatal(ginny.Run(fmt.Sprintf("0.0.0.0:%d", config.ServerPort())))
 }

app/services/bridges.go

@@ -5,7 +5,6 @@ import (
 	"git.aiterp.net/lucifer/new-server/app/config"
 	"git.aiterp.net/lucifer/new-server/models"
 	"log"
-	"strconv"
 	"sync"
 	"time"
 )
@@ -53,15 +52,6 @@ func runConnectToBridges() error {
 		log.Printf("Running bridge \"%s\" (%d)", bridge.Name, bridge.ID)
 
 		go func(bridge models.Bridge, cancel func()) {
-			savedDevices, err := config.DeviceRepository().FetchByReference(ctx, models.RKBridgeID, strconv.Itoa(bridge.ID))
-			if err != nil {
-				log.Println("Failed to fetch devices from db for refresh:", err)
-			}
-			err = driver.Publish(ctx, bridge, savedDevices)
-			if err != nil {
-				log.Println("Failed to publish devices from db before run:", err)
-			}
-
 			err = driver.Run(ctx, bridge, config.EventChannel)
 			log.Printf("Bridge \"%s\" (%d) stopped: %s", bridge.Name, bridge.ID, err)
 

app/services/events.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"git.aiterp.net/lucifer/new-server/app/config"
+	"git.aiterp.net/lucifer/new-server/app/services/publisher"
 	"git.aiterp.net/lucifer/new-server/models"
 	"log"
 	"math"
@@ -66,7 +67,6 @@ func handleEvent(event models.Event) (responses []models.Event) {
 	err := handleSpecial(event)
 	if err != nil {
 		log.Printf("Special event handler error (%s): %v", event.Name, err)
-		return
 	}
 
 	paramStrings := make([]string, 0, 8)
@@ -155,6 +155,15 @@ func handleEvent(event models.Event) (responses []models.Event) {
 		if err != nil {
 			log.Println("Error updating state for device", device.ID, "err:", err)
 		}
+
+		if action.SetScene != nil {
+			action.SetScene.StartTime = time.Now()
+			allDevices[i].SceneAssignments = []models.DeviceSceneAssignment{*action.SetScene}
+		}
+		if action.PushScene != nil {
+			action.PushScene.StartTime = time.Now()
+			allDevices[i].SceneAssignments = append(allDevices[i].SceneAssignments, *action.PushScene)
+		}
 	}
 
 	config.PublishChannel <- allDevices
@@ -211,7 +220,30 @@ func handleSpecial(event models.Event) error {
 		}
 
 		return driver.Publish(ctx, bridge, devices)
+	case models.ENSensorPresenceStarted, models.ENSensorPresenceEnded, models.ENSensorTemperature:
+		id, _ := strconv.Atoi(event.Payload["deviceId"])
+		updateTime, _ := strconv.ParseInt(event.Payload["lastUpdated"], 10, 64)
+		state := models.SceneSensor{
+			ID:          id,
+			UpdateTime:  time.Unix(updateTime, 0),
+		}
+
+		switch event.Name {
+		case models.ENSensorPresenceStarted:
+			presence := true
+			state.Presence = &presence
+		case models.ENSensorPresenceEnded:
+			presence := false
+			state.Presence = &presence
+		case models.ENSensorTemperature:
+			temperature, _ := strconv.ParseFloat(event.Payload["temperature"], 64)
+			state.Temperature = &temperature
+		}
+
+		publisher.Global().UpdateSensor(state)
+
+		return nil
 	default:
 		return nil
 	}
-}
+}

app/services/handlerfactory/config.go

@@ -0,0 +1,62 @@
+package handlerfactory
+
+import (
+	"git.aiterp.net/lucifer/new-server/models"
+	"gopkg.in/yaml.v2"
+	"io"
+	"io/ioutil"
+	"strings"
+)
+
+type FactoryConfig struct {
+	Mode            FCMOde   `yaml:"mode"`
+	Target          string   `yaml:"target"`
+	SceneNames      []string `yaml:"scenes"`
+	TriggerDeviceID string   `yaml:"trigger_device_id"`
+	After           []After  `yaml:"after"`
+	From            string   `yaml:"from"`
+	To              string   `yaml:"to"`
+}
+
+type FCMOde string
+
+var (
+	SceneDimmer  FCMOde = "SceneDimmer"
+	MotionSensor FCMOde = "MotionSensor"
+)
+
+type After struct {
+	Minutes  int                   `yaml:"minutes"`
+	NewState models.NewDeviceState `yaml:"new_state"`
+}
+
+func ParseConfigs(reader io.Reader) ([]FactoryConfig, error) {
+	readAll, err := ioutil.ReadAll(reader)
+	if err != nil {
+		return nil, err
+	}
+
+	splits := strings.Split(string(readAll), "\n---\n")
+	configs := make([]FactoryConfig, 0, 8)
+	for _, split := range splits {
+		var factoryConfig FactoryConfig
+		err := yaml.NewDecoder(strings.NewReader(split)).Decode(&factoryConfig)
+		if err != nil {
+			return nil, err
+		}
+
+		configs = append(configs, factoryConfig)
+	}
+
+	return configs, nil
+}
+
+func (f *FactoryConfig) FromTime() models.TimeOfDay {
+	tod, _ := models.ParseTimeOfDay(f.From)
+	return tod
+}
+
+func (f *FactoryConfig) ToTime() models.TimeOfDay {
+	tod, _ := models.ParseTimeOfDay(f.To)
+	return tod
+}

app/services/handlerfactory/factory.go

@@ -0,0 +1,235 @@
+package handlerfactory
+
+import (
+	"fmt"
+	"git.aiterp.net/lucifer/new-server/models"
+)
+
+func CreateHandlers(
+	config FactoryConfig,
+	scenes []models.Scene,
+	existing []models.EventHandler,
+) ([]models.EventHandler, []models.EventHandler) {
+	switch config.Mode {
+	case SceneDimmer:
+		return sceneDimmer(config, scenes, existing)
+	case MotionSensor:
+		return motionSensor(config, existing)
+	default:
+		return []models.EventHandler{}, []models.EventHandler{}
+	}
+}
+
+func sceneDimmer(
+	config FactoryConfig,
+	scenes []models.Scene,
+	existing []models.EventHandler,
+) ([]models.EventHandler, []models.EventHandler) {
+	kind, refValue := models.ParseFetchString(config.Target)
+
+	toRemove := make([]models.EventHandler, 0, 8)
+	for _, old := range existing {
+		if old.Conditions["deviceId"].EQ == config.TriggerDeviceID {
+			toRemove = append(toRemove, old)
+		}
+	}
+
+	resolvedScenes := make([]models.Scene, 0, len(config.SceneNames))
+	for _, name := range config.SceneNames {
+		for _, scene := range scenes {
+			if name == scene.Name {
+				resolvedScenes = append(resolvedScenes, scene)
+				break
+			}
+		}
+	}
+
+	if len(scenes) < 2 {
+		return []models.EventHandler{}, []models.EventHandler{}
+	}
+
+	handlers := make([]models.EventHandler, 0, len(scenes)+4)
+
+	handlers = append(handlers, models.EventHandler{
+		EventName: "ButtonPressed",
+		Conditions: map[string]models.EventCondition{
+			"deviceId":   {EQ: config.TriggerDeviceID},
+			"buttonName": {EQ: "On"},
+		},
+		OneShot:     false,
+		Priority:    100,
+		TargetKind:  kind,
+		TargetValue: refValue,
+		Actions:     models.EventAction{SetPower: &myTrue},
+		From:        config.FromTime(),
+		To:          config.ToTime(),
+	})
+
+	handlers = append(handlers, models.EventHandler{
+		EventName: "ButtonPressed",
+		Conditions: map[string]models.EventCondition{
+			"deviceId":   {EQ: config.TriggerDeviceID},
+			"buttonName": {EQ: "Off"},
+		},
+		OneShot:     false,
+		Priority:    100,
+		TargetKind:  kind,
+		TargetValue: refValue,
+		Actions:     models.EventAction{SetPower: &myFalse},
+		From:        config.FromTime(),
+		To:          config.ToTime(),
+	})
+
+	for i, scene := range resolvedScenes {
+		if i > 0 {
+			handlers = append(handlers, models.EventHandler{
+				EventName: "ButtonPressed",
+				Conditions: map[string]models.EventCondition{
+					"deviceId":   {EQ: config.TriggerDeviceID},
+					"buttonName": {EQ: "DimDown"},
+					"any.scene":  {EQ: fmt.Sprintf("%d", scene.ID)},
+				},
+				OneShot:     false,
+				Priority:    100,
+				TargetKind:  kind,
+				TargetValue: refValue,
+				Actions: models.EventAction{SetScene: &models.DeviceSceneAssignment{
+					SceneID:    resolvedScenes[i-1].ID,
+					Group:      refValue,
+					DurationMS: 0,
+				}},
+				From: config.FromTime(),
+				To:   config.ToTime(),
+			})
+		}
+
+		if i < len(resolvedScenes)-1 {
+			handlers = append(handlers, models.EventHandler{
+				EventName: "ButtonPressed",
+				Conditions: map[string]models.EventCondition{
+					"deviceId":   {EQ: config.TriggerDeviceID},
+					"buttonName": {EQ: "DimUp"},
+					"any.scene":  {EQ: fmt.Sprintf("%d", scene.ID)},
+				},
+				OneShot:     false,
+				Priority:    100,
+				TargetKind:  kind,
+				TargetValue: refValue,
+				Actions: models.EventAction{SetScene: &models.DeviceSceneAssignment{
+					SceneID:    resolvedScenes[i+1].ID,
+					Group:      refValue,
+					DurationMS: 0,
+				}},
+				From: config.FromTime(),
+				To:   config.ToTime(),
+			})
+		}
+	}
+
+	handlers = append(handlers, models.EventHandler{
+		EventName: "ButtonPressed",
+		Conditions: map[string]models.EventCondition{
+			"deviceId":   {EQ: config.TriggerDeviceID},
+			"buttonName": {EQ: "DimDown"},
+		},
+		OneShot:     false,
+		Priority:    90,
+		TargetKind:  kind,
+		TargetValue: refValue,
+		Actions: models.EventAction{SetScene: &models.DeviceSceneAssignment{
+			SceneID:    resolvedScenes[len(resolvedScenes)-1].ID,
+			Group:      refValue,
+			DurationMS: 0,
+		}},
+		From: config.FromTime(),
+		To:   config.ToTime(),
+	})
+
+	handlers = append(handlers, models.EventHandler{
+		EventName: "ButtonPressed",
+		Conditions: map[string]models.EventCondition{
+			"deviceId":   {EQ: config.TriggerDeviceID},
+			"buttonName": {EQ: "DimUp"},
+		},
+		OneShot:     false,
+		Priority:    90,
+		TargetKind:  kind,
+		TargetValue: refValue,
+		Actions: models.EventAction{SetScene: &models.DeviceSceneAssignment{
+			SceneID:    resolvedScenes[0].ID,
+			Group:      refValue,
+			DurationMS: 0,
+		}},
+		From: config.FromTime(),
+		To:   config.ToTime(),
+	})
+
+	return optimizeLists(handlers, toRemove)
+}
+
+func motionSensor(
+	config FactoryConfig,
+	existing []models.EventHandler,
+) ([]models.EventHandler, []models.EventHandler) {
+	kind, refValue := models.ParseFetchString(config.Target)
+
+	toRemove := make([]models.EventHandler, 0, 8)
+	for _, old := range existing {
+		if old.From != config.FromTime() || old.To != config.ToTime() {
+			continue
+		}
+
+		if old.Conditions["deviceId"].EQ == config.TriggerDeviceID {
+			toRemove = append(toRemove, old)
+		}
+	}
+
+	handlers := make([]models.EventHandler, 0, len(config.After))
+	for _, after := range config.After {
+		if after.Minutes == 0 {
+			handlers = append(handlers, models.EventHandler{
+				EventName: "SensorPresenceStarted",
+				Conditions: map[string]models.EventCondition{
+					"deviceId": {EQ: config.TriggerDeviceID},
+				},
+				OneShot:     false,
+				Priority:    100,
+				TargetKind:  kind,
+				TargetValue: refValue,
+				Actions: models.EventAction{
+					SetPower:       after.NewState.Power,
+					SetColor:       after.NewState.Color,
+					SetIntensity:   after.NewState.Intensity,
+					SetTemperature: after.NewState.Temperature,
+				},
+				From: config.FromTime(),
+				To:   config.ToTime(),
+			})
+		} else {
+			handlers = append(handlers, models.EventHandler{
+				EventName: "SensorPresenceEnded",
+				Conditions: map[string]models.EventCondition{
+					"deviceId":       {EQ: config.TriggerDeviceID},
+					"minutesElapsed": {EQ: fmt.Sprintf("%d", after.Minutes)},
+				},
+				OneShot:     false,
+				Priority:    100,
+				TargetKind:  kind,
+				TargetValue: refValue,
+				Actions: models.EventAction{
+					SetPower:       after.NewState.Power,
+					SetColor:       after.NewState.Color,
+					SetIntensity:   after.NewState.Intensity,
+					SetTemperature: after.NewState.Temperature,
+				},
+				From: config.FromTime(),
+				To:   config.ToTime(),
+			})
+		}
+	}
+
+	return optimizeLists(handlers, toRemove)
+}
+
+var myTrue = true
+var myFalse = false

app/services/handlerfactory/utils.go

@@ -0,0 +1,72 @@
+package handlerfactory
+
+import (
+	"git.aiterp.net/lucifer/new-server/models"
+)
+
+func optimizeLists(
+	add []models.EventHandler,
+	del []models.EventHandler,
+) ([]models.EventHandler, []models.EventHandler) {
+	newAdd := make([]models.EventHandler, 0, len(add))
+	newDel := make([]models.EventHandler, 0, len(del))
+
+OptimizeLoop1:
+	for _, addItem := range add {
+		for _, delItem := range del {
+			if checkDuplicate(&addItem, &delItem) {
+				continue OptimizeLoop1
+			}
+		}
+
+		newAdd = append(newAdd, addItem)
+	}
+
+OptimizeLoop2:
+	for _, delItem := range del {
+		for _, addItem := range add {
+			if checkDuplicate(&addItem, &delItem) {
+				continue OptimizeLoop2
+			}
+		}
+
+		newDel = append(newDel, delItem)
+	}
+
+	return newAdd, newDel
+}
+
+func checkDuplicate(a *models.EventHandler, b *models.EventHandler) bool {
+	check := true
+	check = check && a.EventName == b.EventName
+	check = check && len(a.Conditions) == len(b.Conditions)
+	for k := range a.Conditions {
+		check = check && a.Conditions[k] == b.Conditions[k]
+	}
+	check = check && a.OneShot == b.OneShot
+	check = check && a.Priority == b.Priority
+	check = check && a.TargetKind == b.TargetKind
+	check = check && a.TargetValue == b.TargetValue
+	check = check && a.From == b.From
+	check = check && a.To == b.To
+
+	aPower := a.Actions.SetPower
+	bPower := b.Actions.SetPower
+	powerEq := (aPower == nil && bPower == nil) || (aPower != nil && bPower != nil && *aPower == *bPower)
+
+	aColor := a.Actions.SetColor
+	bColor := b.Actions.SetColor
+	colorEq := (aColor == nil && bColor == nil) || (aColor != nil && bColor != nil && *aColor == *bColor)
+
+	aInt := a.Actions.SetIntensity
+	bInt := b.Actions.SetIntensity
+	intEq := (aInt == nil && bInt == nil) || (aInt != nil && bInt != nil && *aInt == *bInt)
+
+	aTemp := a.Actions.SetTemperature
+	bTemp := b.Actions.SetTemperature
+	tempEq := (aTemp == nil && bTemp == nil) || (aTemp != nil && bTemp != nil && *aTemp == *bTemp)
+
+	check = check && powerEq && colorEq && intEq && tempEq
+
+	return check
+}

app/services/publisher/publisher.go

@@ -17,6 +17,39 @@ type Publisher struct {
 	started         map[int]bool
 	pending         map[int][]models.Device
 	waiting         map[int]chan struct{}
+	sensorCache     map[int]models.SceneSensor
+}
+
+func (p *Publisher) SceneState(deviceID int) *models.DeviceState {
+	p.mu.Lock()
+	defer p.mu.Unlock()
+
+	if s := p.sceneAssignment[deviceID]; s != nil {
+		return s.LastState(deviceID)
+	}
+
+	return nil
+}
+
+func (p *Publisher) UpdateScene(data models.Scene) {
+	p.mu.Lock()
+	p.sceneData[data.ID] = &data
+
+	for _, scene := range p.scenes {
+		if scene.data.ID == data.ID {
+			scene.UpdateScene(data)
+		}
+	}
+	p.mu.Unlock()
+}
+
+func (p *Publisher) UpdateSensor(data models.SceneSensor) {
+	p.mu.Lock()
+	if assignment := p.sceneAssignment[data.ID]; assignment != nil {
+		assignment.UpdateSensor(data)
+	}
+	p.sensorCache[data.ID] = data
+	p.mu.Unlock()
 }
 
 func (p *Publisher) ReloadScenes(ctx context.Context) error {
@@ -26,8 +59,12 @@ func (p *Publisher) ReloadScenes(ctx context.Context) error {
 	}
 
 	p.mu.Lock()
-	for _, scene := range scenes {
-		p.sceneData[scene.ID] = &scene
+	for i, scene := range scenes {
+		p.sceneData[scene.ID] = &scenes[i]
+	}
+
+	for _, scene := range p.scenes {
+		scene.UpdateScene(*p.sceneData[scene.data.ID])
 	}
 	p.mu.Unlock()
 
@@ -63,6 +100,10 @@ func (p *Publisher) Publish(devices ...models.Device) {
 
 		if p.sceneAssignment[device.ID] != nil {
 			p.sceneAssignment[device.ID].UpsertDevice(device)
+
+			if cache, ok := p.sensorCache[device.ID]; ok {
+				p.sceneAssignment[device.ID].UpdateSensor(cache)
+			}
 		} else {
 			p.pending[device.BridgeID] = append(p.pending[device.BridgeID], device)
 			if p.waiting[device.BridgeID] != nil {
@@ -90,10 +131,12 @@ func (p *Publisher) Run() {
 
 		p.mu.Lock()
 		for i, scene := range p.scenes {
-			if !scene.endTime.IsZero() && time.Now().After(scene.endTime) {
+			if (!scene.endTime.IsZero() && time.Now().After(scene.endTime)) || scene.Empty() {
 				deleteList = append(deleteList, i-len(deleteList))
 				updatedList = append(updatedList, scene.AllDevices()...)
 
+				log.Printf("Removing scene instance for %s (%d)", scene.data.Name, scene.data.ID)
+
 				for _, device := range scene.AllDevices() {
 					p.sceneAssignment[device.ID] = nil
 				}
@@ -109,7 +152,7 @@ func (p *Publisher) Run() {
 		for _, i := range deleteList {
 			p.scenes = append(p.scenes[:i], p.scenes[i+1:]...)
 		}
-		
+
 		for _, device := range updatedList {
 			if !p.started[device.BridgeID] {
 				p.started[device.BridgeID] = true
@@ -148,6 +191,11 @@ func (p *Publisher) reassignDevice(device models.Device) bool {
 
 		// Stop here, no scene should be assigned.
 		return false
+	} else {
+		if p.sceneData[selectedAssignment.SceneID] == nil {
+			// Freeze until scene becomes available.
+			return false
+		}
 	}
 
 	if p.sceneAssignment[device.ID] != nil {
@@ -175,6 +223,7 @@ func (p *Publisher) reassignDevice(device models.Device) bool {
 		endTime:    selectedAssignment.StartTime.Add(time.Duration(selectedAssignment.DurationMS) * time.Millisecond),
 		roleMap:    make(map[int]int, 16),
 		roleList:   make(map[int][]models.Device, 16),
+		lastStates: make(map[int]models.DeviceState, 16),
 		due:        true,
 	}
 	p.sceneAssignment[device.ID] = newScene
@@ -256,10 +305,15 @@ var publisher = Publisher{
 	started:         make(map[int]bool),
 	pending:         make(map[int][]models.Device),
 	waiting:         make(map[int]chan struct{}),
+	sensorCache:     make(map[int]models.SceneSensor),
+}
+
+func Global() *Publisher {
+	return &publisher
 }
 
 func Initialize(ctx context.Context) error {
-	err :=publisher.ReloadScenes(ctx)
+	err := publisher.ReloadScenes(ctx)
 	if err != nil {
 		return err
 	}
@@ -268,8 +322,9 @@ func Initialize(ctx context.Context) error {
 		return err
 	}
 
-	go publisher.PublishChannel(config.PublishChannel)
 	go publisher.Run()
+	time.Sleep(time.Millisecond * 50)
+	go publisher.PublishChannel(config.PublishChannel)
 
 	return nil
 }

app/services/publisher/scene.go

@@ -6,17 +6,32 @@ import (
 )
 
 type Scene struct {
-	data      *models.Scene
-	group     string
-	startTime time.Time
-	endTime   time.Time
-	roleMap   map[int]int
-	roleList  map[int][]models.Device
+	data       *models.Scene
+	group      string
+	startTime  time.Time
+	endTime    time.Time
+	roleMap    map[int]int
+	roleList   map[int][]models.Device
+	lastStates map[int]models.DeviceState
+	sensors    []models.SceneSensor
 
 	due          bool
 	lastInterval int64
 }
 
+func (s *Scene) UpdateSensor(data models.SceneSensor) {
+	s.due = true
+
+	for i, sensor := range s.sensors {
+		if sensor.ID == data.ID {
+			s.sensors[i] = data
+			return
+		}
+	}
+
+	s.sensors = append(s.sensors, data)
+}
+
 // UpdateScene updates the scene data and re-seats all devices.
 func (s *Scene) UpdateScene(data models.Scene) {
 	devices := make([]models.Device, 0, 16)
@@ -84,6 +99,24 @@ func (s *Scene) RemoveDevice(device models.Device) {
 	s.due = true
 
 	delete(s.roleMap, device.ID)
+	delete(s.lastStates, device.ID)
+
+	for i, sensor := range s.sensors {
+		if sensor.ID == device.ID {
+			s.sensors = append(s.sensors[:i], s.sensors[i+1:]...)
+			break
+		}
+	}
+}
+
+func (s *Scene) Empty() bool {
+	for _, list := range s.roleList {
+		if len(list) > 0 {
+			return false
+		}
+	}
+
+	return true
 }
 
 func (s *Scene) Due() bool {
@@ -118,6 +151,7 @@ func (s *Scene) Run() []models.Device {
 		return []models.Device{}
 	}
 
+	currentTime := time.Now()
 	intervalNumber := int64(0)
 	intervalMax := int64(1)
 	if s.data.IntervalMS > 0 {
@@ -137,14 +171,31 @@ func (s *Scene) Run() []models.Device {
 			continue
 		}
 
+		sensorCount := 0
+		for _, device := range list {
+			if device.IsOnlySensor() {
+				sensorCount += 1
+			}
+		}
+
 		role := s.data.Roles[i]
 
+		jSkip := 0
+
 		for j, device := range list {
+			if device.IsOnlySensor() {
+				updatedDevices = append(updatedDevices, device)
+				jSkip += 1
+				continue
+			}
+
 			newState := role.ApplyEffect(&device, models.SceneRunContext{
-				Index:          j,
-				Length:         len(list),
+				CurrentTime:    currentTime,
+				Index:          j - jSkip,
+				Length:         len(list) - sensorCount,
 				IntervalNumber: intervalNumber,
 				IntervalMax:    intervalMax,
+				Sensors:        s.sensors,
 			})
 
 			err := device.SetState(newState)
@@ -152,6 +203,8 @@ func (s *Scene) Run() []models.Device {
 				continue
 			}
 
+			s.lastStates[device.ID] = device.State
+
 			updatedDevices = append(updatedDevices, device)
 		}
 	}
@@ -161,3 +214,12 @@ func (s *Scene) Run() []models.Device {
 
 	return updatedDevices
 }
+
+func (s *Scene) LastState(id int) *models.DeviceState {
+	lastState, ok := s.lastStates[id]
+	if !ok {
+		return nil
+	}
+
+	return &lastState
+}

cmd/bridgetest/main.go

@@ -33,7 +33,7 @@ func main() {
 	}
 
 	// Find bridge
-	bridges, err := driver.SearchBridge(context.Background(), *flagAddress, !*flagPair)
+	bridges, err := driver.SearchBridge(context.Background(), *flagAddress, *flagToken, !*flagPair)
 	if err != nil {
 		log.Fatalln("Failed to search bridge:", err)
 	}

cmd/lucy/command.go

@@ -5,6 +5,7 @@ import (
 	"log"
 	"strconv"
 	"strings"
+	"time"
 )
 
 type Param struct {
@@ -221,6 +222,17 @@ func (p Params) DeviceState(prefix string) models.NewDeviceState {
 	}
 }
 
+func (p Params) SceneAssignment(prefix string) *models.DeviceSceneAssignment {
+	if p.Get(prefix+"scene") == nil {
+		return nil
+	}
+
+	return &models.DeviceSceneAssignment{
+		SceneID:    p.Get(prefix+"scene").IntOr(-1),
+		Group:      p.Get(prefix+"scene.group").StringOr(time.Now().Format(time.RFC3339)),
+		DurationMS: int64(p.Get(prefix+"scene.duration").IntOr(0)),
+	}
+}
 
 type Command struct {
 	Name   string

cmd/lucy/factorycmd.go

@@ -0,0 +1,75 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"git.aiterp.net/lucifer/new-server/app/client"
+	"git.aiterp.net/lucifer/new-server/app/services/handlerfactory"
+	"log"
+	"os"
+)
+
+func factoryCmd(
+	ctx context.Context,
+	c client.Client,
+) {
+	cmd := parseCommand(os.Args[2:])
+
+	switch cmd.Name {
+	case "run":
+		fileName := cmd.Params.Get(0).String()
+		if fileName == nil {
+			log.Fatalln("Missing filename")
+		}
+
+		scenes, err := c.GetScenes(ctx)
+		if err != nil {
+			log.Fatalln(err.Error())
+		}
+
+		handlers, err := c.GetHandlers(ctx)
+		if err != nil {
+			log.Fatalln(err.Error())
+		}
+
+		file, err := os.Open(*fileName)
+		if err != nil {
+			log.Fatalln("Failed to open file:", err)
+		}
+		defer file.Close()
+
+		configs, err := handlerfactory.ParseConfigs(file)
+		if err != nil {
+			log.Fatalln("Failed to parse file:", err)
+		}
+
+		for _, config := range configs {
+			toAdd, toRemove := handlerfactory.CreateHandlers(config, scenes, handlers)
+
+			for _, removing := range toRemove {
+				_, err := c.DeleteHandler(ctx, removing.ID)
+				if err != nil {
+					log.Fatalln(err.Error())
+				}
+
+				log.Printf("Removed handler %d", removing.ID)
+			}
+
+			for _, adding := range toAdd {
+				res, err := c.AddHandler(ctx, adding)
+				if err != nil {
+					log.Fatalln(err.Error())
+				}
+
+				log.Printf("Added handler %d", res.ID)
+			}
+		}
+
+	default:
+		if cmd.Name != "help" {
+			log.Println("Unknown command:", cmd.Name)
+		}
+
+		_, _ = fmt.Fprintln(os.Stderr, helpString[1:])
+	}
+}

cmd/lucy/handlercmd.go

@@ -7,6 +7,7 @@ import (
 	"git.aiterp.net/lucifer/new-server/models"
 	"log"
 	"os"
+	"strings"
 )
 
 func handlerCmd(
@@ -38,47 +39,7 @@ func handlerCmd(
 			log.Fatalln("Search filter needed!")
 		}
 		model.TargetKind, model.TargetValue = models.ParseFetchString(*fetchStr)
-
-		// From / To
-		model.From = cmd.Params.Get("from").TimeOfDayOr(models.Never)
-		model.To = cmd.Params.Get("to").TimeOfDayOr(models.Never)
-		if model.From.IsNever() != model.To.IsNever() {
-			log.Fatalln("from and to must be specified together!")
-		}
-
-		// One shot
-		model.OneShot = cmd.Params.Get("one-shot").StringOr("false") == "true"
-
-		// Priority
-		model.Priority = cmd.Params.Get("priority").IntOr(100)
-
-		// Conditions
-		model.Conditions = cmd.Params.Subset("conditions").EventConditions()
-
-		// Power, Color, Intensity, Temperature
-		nds := cmd.Params.DeviceState("set-")
-		model.Actions.SetPower = nds.Power
-		model.Actions.SetColor = nds.Color
-		model.Actions.SetIntensity = nds.Intensity
-
-		// Add intensity
-		model.Actions.AddIntensity = cmd.Params.Get("add-intensity").Float()
-
-		// Fire
-		fireParams := cmd.Params.Subset("fire")
-		fireName := fireParams.Get("name").String()
-		if fireName != nil {
-			firePayloadParams := fireParams.Subset("payload")
-
-			model.Actions.FireEvent = &models.Event{
-				Name:    *fireName,
-				Payload: make(map[string]string, len(firePayloadParams)),
-			}
-
-			for key, value := range firePayloadParams.StringMap() {
-				model.Actions.FireEvent.Payload[key] = value
-			}
-		}
+		model = applyCmdToHandler(model, cmd)
 
 		newHandler, err := c.AddHandler(ctx, model)
 		if err != nil {
@@ -86,18 +47,62 @@ func handlerCmd(
 		}
 
 		WriteHandlerInfoTable(os.Stdout, []models.EventHandler{*newHandler})
-	case "delete":
-		id := cmd.Params.Get(0).Int()
-		if id == nil {
+	case "edit":
+		id := cmd.Params.Get(0).IntOr(0)
+		if id == 0 {
 			log.Fatalln("ID missing")
 		}
 
-		handler, err := c.DeleteHandler(ctx, *id)
+		model, err := c.GetHandler(ctx, id)
 		if err != nil {
-			log.Fatalln(err)
+			log.Fatalln(err.Error())
 		}
 
-		WriteHandlerInfoTable(os.Stdout, []models.EventHandler{*handler})
+		eventStr := cmd.Params.Get("event").String()
+		if eventStr != nil {
+			model.EventName = *eventStr
+		}
+
+		fetchStr := cmd.Params.Get("search").String()
+		if fetchStr != nil {
+			model.TargetKind, model.TargetValue = models.ParseFetchString(*fetchStr)
+		}
+
+		modified := applyCmdToHandler(*model, cmd)
+		returned, err := c.PutHandler(ctx, &modified)
+		if err != nil {
+			log.Fatalln(err.Error())
+		}
+
+		WriteHandlerInfoTable(os.Stdout, []models.EventHandler{*returned})
+	case "delete":
+		if cmd.Params.Get(0).StringOr("_not") == "all" {
+			handlers, err := c.GetHandlers(ctx)
+			if err != nil {
+				log.Fatalln(err)
+			}
+
+			for _, handler := range handlers {
+				_, err = c.DeleteHandler(ctx, handler.ID)
+				if err != nil {
+					log.Fatalln(err)
+				}
+			}
+
+			log.Printf("Deleted %d handlers", len(handlers))
+		} else {
+			id := cmd.Params.Get(0).Int()
+			if id == nil {
+				log.Fatalln("ID missing")
+			}
+
+			handler, err := c.DeleteHandler(ctx, *id)
+			if err != nil {
+				log.Fatalln(err)
+			}
+
+			WriteHandlerInfoTable(os.Stdout, []models.EventHandler{*handler})
+		}
 	default:
 		if cmd.Name != "help" {
 			log.Println("Unknown command:", cmd.Name)
@@ -106,3 +111,92 @@ func handlerCmd(
 		_, _ = fmt.Fprintln(os.Stderr, helpString[1:])
 	}
 }
+
+func applyCmdToHandler(model models.EventHandler, cmd Command) models.EventHandler {
+	// Remove keys
+	for _, elem := range cmd.Params.Strings(1) {
+		if !strings.HasPrefix(elem, "-") {
+			continue
+		}
+		keyToRemove := elem[1:]
+
+		if strings.HasPrefix(keyToRemove, "conditions.") {
+			condKeyToRemove := keyToRemove[11:]
+			delete(model.Conditions, condKeyToRemove)
+		} else if strings.HasPrefix(keyToRemove, "fire.payload.") && model.Actions.FireEvent != nil {
+			firePayloadKeyToRemove := keyToRemove[13:]
+			delete(model.Actions.FireEvent.Payload, firePayloadKeyToRemove)
+		} else {
+			switch keyToRemove {
+			case "set-power":
+				model.Actions.SetPower = nil
+			case "set-color":
+				model.Actions.SetColor = nil
+			case "set-intensity":
+				model.Actions.SetIntensity = nil
+			case "add-intensity":
+				model.Actions.AddIntensity = nil
+			case "fire":
+				fallthrough
+			case "fire.name":
+				model.Actions.FireEvent = nil
+			case "from":
+				model.From = models.Never
+			case "to":
+				model.To = models.Never
+			case "set-scene":
+				model.Actions.SetScene = nil
+			case "push-scene":
+				model.Actions.PushScene = nil
+			}
+		}
+	}
+
+	// From / To
+	model.From = cmd.Params.Get("from").TimeOfDayOr(models.Never)
+	model.To = cmd.Params.Get("to").TimeOfDayOr(models.Never)
+	if model.From.IsNever() != model.To.IsNever() {
+		log.Fatalln("from and to must be specified together!")
+	}
+
+	// One shot
+	model.OneShot = cmd.Params.Get("one-shot").StringOr("false") == "true"
+
+	// Priority
+	model.Priority = cmd.Params.Get("priority").IntOr(100)
+
+	// Conditions
+	model.Conditions = cmd.Params.Subset("conditions").EventConditions()
+
+	// Power, Color, Intensity, Temperature
+	nds := cmd.Params.DeviceState("set-")
+	model.Actions.SetPower = nds.Power
+	model.Actions.SetColor = nds.Color
+	model.Actions.SetIntensity = nds.Intensity
+	model.Actions.SetTemperature = nds.Temperature
+
+	// Add intensity
+	model.Actions.AddIntensity = cmd.Params.Get("add-intensity").Float()
+
+	// Fire
+	fireParams := cmd.Params.Subset("fire")
+	fireName := fireParams.Get("name").String()
+	if fireName != nil {
+		firePayloadParams := fireParams.Subset("payload")
+
+		model.Actions.FireEvent = &models.Event{
+			Name:    *fireName,
+			Payload: make(map[string]string, len(firePayloadParams)),
+		}
+
+		for key, value := range firePayloadParams.StringMap() {
+			model.Actions.FireEvent.Payload[key] = value
+		}
+	}
+
+	// Scenes
+	model.Actions.SetScene = cmd.Params.SceneAssignment("set-")
+	model.Actions.PushScene = cmd.Params.SceneAssignment("push-")
+
+	return model
+}

cmd/lucy/help.go

@@ -23,8 +23,47 @@ EVENT HANDLER COMMANDS
               <set-power=B> <set-color=C> <set-intensity=F> <set-temperature=N> \
               <add-intensity=F> \
               <fire.name=S> <fire.payload.*=S>
+  handler edit <id> \
+               (...all arguments from 'add', appending conditions and fire payload matchers...) \
+               <event=S> <search=S>
+               <-from> <-to> \
+               <-set-power> <-set-color> <-set-intensity> <-set-temperature> \
+               <-conditions.*> \
+               <-fire> <-fire.payload.*>
   handler delete <id>
 
+EVENT HANDLER FACTORY COMMANDS
+
+  factory run <file.yaml>
+
+File example (use '---' to delimit multiple configs in one file):
+mode: SceneDimmer
+target: tag:Soverom
+scenes:
+ - kveldslys
+ - landskap
+ - vasking
+trigger_device_id: 14
+---
+mode: MotionSensor
+target: tag:Bod
+trigger_device_id: 36
+after:
+ - minutes: 0
+   new_state:
+     power: true
+     color: hs:240,0.6
+     intensity: 0.8
+ - minutes: 1
+   new_state:
+     power: false
+from: 08:00
+to: 15:59:59
+---
+(more modes coming soon)
+
+WARNING: Similar event handlers will be removed!
+
 EVENT COMMANDS
   run <event name> <*=S>
 

cmd/lucy/main.go

@@ -82,8 +82,8 @@ func main() {
 	case "update":
 		{
 			devices, err := c.PutDevice(ctx, cmd.Params.Get(0).StringOr("all"), models.DeviceUpdate{
-				Name: cmd.Params.Get("name").String(),
-				Icon: cmd.Params.Get("icon").String(),
+				Name:           cmd.Params.Get("name").String(),
+				Icon:           cmd.Params.Get("icon").String(),
 				UserProperties: cmd.Params.Subset("prop.").StringPtrMap(),
 			})
 			if err != nil {
@@ -93,9 +93,15 @@ func main() {
 			WriteDeviceInfoTable(os.Stdout, devices)
 		}
 
+	case "factory":
+		factoryCmd(ctx, c)
+
 	case "handler":
 		handlerCmd(ctx, c)
 
+	case "scene":
+		sceneCmd(ctx, c)
+
 	// EVENT
 	case "run":
 		{
@@ -123,4 +129,3 @@ func main() {
 		_, _ = fmt.Fprintln(os.Stderr, helpString[1:])
 	}
 }
-

cmd/lucy/scenecmd.go

@@ -0,0 +1,165 @@
+package main
+
+import (
+	"context"
+	"git.aiterp.net/lucifer/new-server/app/client"
+	"git.aiterp.net/lucifer/new-server/models"
+	"gopkg.in/yaml.v2"
+	"log"
+	"os"
+	"strconv"
+	"strings"
+	"unicode"
+)
+
+func sceneCmd(
+	ctx context.Context,
+	c client.Client,
+) {
+	cmd := parseCommand(os.Args[2:])
+
+	switch cmd.Name {
+	case "create", "update":
+		{
+			fileName := cmd.Params.Get(0).String()
+			if fileName == nil {
+				log.Fatalln("Missing filename")
+			}
+
+			file, err := os.Open(*fileName)
+			if err != nil {
+				log.Fatalln("Failed to open file:", err)
+			}
+			defer file.Close()
+
+			yamlData := make(map[string]interface{})
+			err = yaml.NewDecoder(file).Decode(yamlData)
+			if err != nil {
+				log.Fatalln("Failed to decode file:", err)
+				return
+			}
+
+			yamlData = camelCasify(yamlData)
+			name, nameOk := yamlData["name"]
+			if !nameOk {
+				log.Fatalln("Missing name in yaml data.")
+			}
+
+			var scene models.Scene
+			if cmd.Name == "create" {
+				err := c.Fetch(ctx, "POST", "/api/scenes", &scene, yamlData)
+				if err != nil {
+					log.Fatalln("Failed to create scene:", err)
+					return
+				}
+			} else {
+				scenes, err := c.GetScenes(ctx)
+				if err != nil {
+					log.Fatalln("Failed to fetch existing scenes:", err)
+					return
+				}
+
+				id := -1
+				for _, scene := range scenes {
+					if scene.Name == name {
+						id = scene.ID
+						break
+					}
+				}
+				if id == -1 {
+					log.Fatalln("Could not find scene with name", name)
+					return
+				}
+
+				err = c.Fetch(ctx, "PUT", "/api/scenes/"+strconv.Itoa(id), &scene, yamlData)
+				if err != nil {
+					log.Fatalln("Failed to update scene:", err)
+					return
+				}
+			}
+		}
+
+	case "push", "assign":
+		{
+			fetch := cmd.Params.Get(0).String()
+			id := cmd.Params.Get(1).Int()
+			if fetch == nil || id == nil {
+				log.Println("Usage: lucy scene assign <fetch> <id> <group=S> <duration=I>")
+			}
+
+			devices, err := c.AssignDevice(ctx, *fetch, cmd.Name == "push", models.DeviceSceneAssignment{
+				SceneID:    *id,
+				Group:      cmd.Params.Get("group").StringOr(*fetch),
+				DurationMS: int64(cmd.Params.Get("duration").IntOr(0)),
+			})
+			if err != nil {
+				log.Println("Could not assign devices:", err)
+				return
+			}
+
+			WriteDeviceInfoTable(os.Stdout, devices)
+		}
+
+	case "clear":
+		fetch := cmd.Params.Get(0).String()
+		if fetch == nil {
+			log.Println("Usage: lucy scene clear <fetch>")
+		}
+
+		devices, err := c.ClearDevice(ctx, *fetch)
+		if err != nil {
+			log.Println("Could not clear devices:", err)
+			return
+		}
+
+		WriteDeviceInfoTable(os.Stdout, devices)
+	}
+}
+
+func camelCasify(m map[string]interface{}) map[string]interface{} {
+	m2 := make(map[string]interface{}, len(m))
+	for key, value := range m {
+		b := strings.Builder{}
+		snake := false
+		for _, ch := range key {
+			if ch == '_' {
+				snake = true
+			} else if snake {
+				b.WriteRune(unicode.ToUpper(ch))
+				snake = false
+			} else {
+				b.WriteRune(ch)
+			}
+		}
+
+		switch value := value.(type) {
+		case []interface{}:
+			valueCopy := make([]interface{}, len(value))
+			for i, elem := range value {
+				switch elem := elem.(type) {
+				case map[interface{}]interface{}:
+					m3 := make(map[string]interface{})
+					for k, v := range elem {
+						if kStr, ok := k.(string); ok {
+							m3[kStr] = v
+						}
+					}
+
+					valueCopy[i] = camelCasify(m3)
+				case map[string]interface{}:
+					valueCopy[i] = camelCasify(elem)
+				default:
+					valueCopy[i] = elem
+				}
+			}
+
+			m2[b.String()] = valueCopy
+		case map[string]interface{}:
+			m2[b.String()] = camelCasify(value)
+		default:
+			m2[b.String()] = value
+		}
+	}
+
+	return m2
+}

cmd/lucy/tables.go

@@ -14,26 +14,46 @@ func WriteDeviceStateTable(w io.Writer, devices []models.Device) {
 	table.SetHeader([]string{"ID", "NAME", "POWER", "COLOR", "INTENSITY", "TEMPERATURE"})
 
 	table.SetReflowDuringAutoWrap(true)
+	table.SetColumnAlignment([]int{
+		tablewriter.ALIGN_RIGHT,
+		tablewriter.ALIGN_LEFT,
+		tablewriter.ALIGN_RIGHT,
+		tablewriter.ALIGN_LEFT,
+		tablewriter.ALIGN_RIGHT,
+		tablewriter.ALIGN_RIGHT,
+	})
 
 	for _, v := range devices {
 		powerStr := ""
 		if v.HasCapability(models.DCPower) {
-			powerStr = strconv.FormatBool(v.State.Power)
+			if v.SceneState != nil && v.SceneState.Power != v.State.Power {
+				powerStr = strconv.FormatBool(v.SceneState.Power) + "*"
+			} else {
+				powerStr = strconv.FormatBool(v.State.Power)
+			}
 		}
 
 		colorStr := ""
 		if v.HasCapability(models.DCColorHSK, models.DCColorHS, models.DCColorKelvin) {
-			colorStr = v.State.Color.String()
+			if v.SceneState != nil && v.SceneState.Color.String() != v.State.Color.String() {
+				colorStr = v.SceneState.Color.String() + "*"
+			} else {
+				colorStr = v.State.Color.String()
+			}
 		}
 
 		temperatureString := ""
 		if v.HasCapability(models.DCTemperatureControl, models.DCTemperatureSensor) {
-			temperatureString = strconv.FormatFloat(v.State.Temperature, 'f', -1, 64)
+			temperatureString = fmt.Sprintf("%d", v.State.Temperature)
 		}
 
 		intensityString := ""
 		if v.HasCapability(models.DCIntensity) {
-			intensityString = strconv.FormatFloat(v.State.Intensity, 'f', -1, 64)
+			if v.SceneState != nil && v.SceneState.Intensity != v.State.Intensity {
+				intensityString = strconv.FormatFloat(v.SceneState.Intensity, 'g', 2, 64) + "*"
+			} else {
+				intensityString = strconv.FormatFloat(v.State.Intensity, 'f', -1, 64)
+			}
 		}
 
 		table.Append([]string{
@@ -104,6 +124,17 @@ func WriteHandlerInfoTable(w io.Writer, handlers []models.EventHandler) {
 		if h.Actions.FireEvent != nil {
 			actionStr += fmt.Sprintf("fireEvent=%s ", (*h.Actions.FireEvent).Name)
 		}
+		if h.Actions.FireEvent != nil {
+			actionStr += fmt.Sprintf("fireEvent=%s ", (*h.Actions.FireEvent).Name)
+		}
+		if h.Actions.SetScene != nil {
+			s := h.Actions.SetScene
+			actionStr += fmt.Sprintf("setScene=(id=%d,group=\"%s\",duration=%d) ", s.SceneID, s.Group, s.DurationMS)
+		}
+		if h.Actions.PushScene != nil {
+			s := h.Actions.PushScene
+			actionStr += fmt.Sprintf("pushScene=(id=%d,group=\"%s\",duration=%d) ", s.SceneID, s.Group, s.DurationMS)
+		}
 
 		eventName := h.EventName
 		if h.OneShot {

internal/drivers/hue/bridge.go

@@ -10,6 +10,7 @@ import (
 	"io"
 	"net"
 	"net/http"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -170,6 +171,10 @@ func (b *Bridge) putLightState(ctx context.Context, index int, input LightStateI
 	return b.put(ctx, fmt.Sprintf("lights/%d/state", index), input, nil)
 }
 
+func (b *Bridge) putGroupLightState(ctx context.Context, index int, input LightStateInput) error {
+	return b.put(ctx, fmt.Sprintf("groups/%d/action", index), input, nil)
+}
+
 func (b *Bridge) getToken(ctx context.Context) (string, error) {
 	result := make([]CreateUserResponse, 0, 1)
 	err := b.post(ctx, "", CreateUserInput{DeviceType: "git.aiterp.net/lucifer"}, &result)
@@ -207,6 +212,33 @@ func (b *Bridge) getSensors(ctx context.Context) (map[int]SensorData, error) {
 	return result, nil
 }
 
+func (b *Bridge) getGroups(ctx context.Context) (map[int]GroupData, error) {
+	result := make(map[int]GroupData, 16)
+	err := b.get(ctx, "groups", &result)
+	if err != nil {
+		return nil, err
+	}
+
+	return result, nil
+}
+
+func (b *Bridge) postGroup(ctx context.Context, input GroupData) (int, error) {
+	var res []struct {
+		Success struct {
+			ID string `json:"id"`
+		} `json:"success"`
+	}
+	err := b.post(ctx, "groups", input, &res)
+
+	id, _ := strconv.Atoi(res[0].Success.ID)
+
+	return id, err
+}
+
+func (b *Bridge) deleteGroup(ctx context.Context, index int) error {
+	return b.delete(ctx, "groups/"+strconv.Itoa(index), nil)
+}
+
 func (b *Bridge) get(ctx context.Context, resource string, target interface{}) error {
 	if b.token != "" {
 		resource = b.token + "/" + resource
@@ -226,6 +258,29 @@ func (b *Bridge) get(ctx context.Context, resource string, target interface{}) e
 	return json.NewDecoder(res.Body).Decode(target)
 }
 
+func (b *Bridge) delete(ctx context.Context, resource string, target interface{}) error {
+	if b.token != "" {
+		resource = b.token + "/" + resource
+	}
+
+	req, err := http.NewRequest("DELETE", fmt.Sprintf("http://%s/api/%s", b.host, resource), nil)
+	if err != nil {
+		return err
+	}
+
+	res, err := httpClient.Do(req.WithContext(ctx))
+	if err != nil {
+		return err
+	}
+	defer res.Body.Close()
+
+	if target == nil {
+		return nil
+	}
+
+	return json.NewDecoder(res.Body).Decode(target)
+}
+
 func (b *Bridge) post(ctx context.Context, resource string, body interface{}, target interface{}) error {
 	rb, err := reqBody(body)
 	if err != nil {

internal/drivers/hue/data.go

@@ -3,8 +3,14 @@ package hue
 import (
 	"encoding/xml"
 	"errors"
+	"strconv"
 )
 
+type GroupData struct {
+	Name   string   `json:"name"`
+	Lights []string `json:"lights"`
+}
+
 type DiscoveryEntry struct {
 	Id                string `json:"id"`
 	InternalIPAddress string `json:"internalipaddress"`
@@ -83,6 +89,58 @@ type LightStateInput struct {
 	TransitionTime *int        `json:"transitiontime,omitempty"`
 }
 
+func (input *LightStateInput) Equal(other LightStateInput) bool {
+	if (input.On != nil) != (other.On != nil) {
+		return false
+	} else if input.On != nil && *input.On != *other.On {
+		return false
+	}
+
+	if (input.Bri != nil) != (other.Bri != nil) {
+		return false
+	} else if input.Bri != nil && *input.Bri != *other.Bri {
+		return false
+	}
+
+	if (input.Hue != nil) != (other.Hue != nil) {
+		return false
+	} else if input.Hue != nil && *input.Hue != *other.Hue {
+		return false
+	}
+
+	if (input.Sat != nil) != (other.Sat != nil) {
+		return false
+	} else if input.Sat != nil && *input.Sat != *other.Sat {
+		return false
+	}
+
+	if (input.Effect != nil) != (other.Effect != nil) {
+		return false
+	} else if input.Effect != nil && *input.Effect != *other.Effect {
+		return false
+	}
+
+	if (input.XY != nil) != (other.XY != nil) {
+		return false
+	} else if input.XY != nil && *input.XY != *other.XY {
+		return false
+	}
+
+	if (input.CT != nil) != (other.CT != nil) {
+		return false
+	} else if input.CT != nil && *input.CT != *other.CT {
+		return false
+	}
+
+	if (input.Alert != nil) != (other.Alert != nil) {
+		return false
+	} else if input.Alert != nil && *input.Alert != *other.Alert {
+		return false
+	}
+
+	return true
+}
+
 type LightData struct {
 	State            LightState `json:"state"`
 	Type             string     `json:"type"`
@@ -192,6 +250,36 @@ type BridgeDeviceInfo struct {
 	} `xml:"device"`
 }
 
+type syncGroup struct {
+	GroupIndex   int
+	State        LightStateInput
+	Indexes      []int
+	ArrayIndexes []int
+}
+
+func (sg *syncGroup) Matches(group *GroupData) bool {
+	if len(sg.Indexes) != len(group.Lights) {
+		return false
+	}
+
+	for _, idx := range sg.Indexes {
+		found := false
+		for _, idx2 := range group.Lights {
+			n := strconv.Itoa(idx)
+			if n == idx2 {
+				found = true
+				break
+			}
+		}
+
+		if !found {
+			return false
+		}
+	}
+
+	return true
+}
+
 var buttonNames = []string{"On", "DimUp", "DimDown", "Off"}
 
 var errLinkButtonNotPressed = errors.New("link button not pressed")

internal/drivers/hue/driver.go

@@ -19,7 +19,7 @@ type Driver struct {
 	bridges []*Bridge
 }
 
-func (d *Driver) SearchBridge(ctx context.Context, address string, dryRun bool) ([]models.Bridge, error) {
+func (d *Driver) SearchBridge(ctx context.Context, address, _ string, dryRun bool) ([]models.Bridge, error) {
 	if address == "" {
 		if !dryRun {
 			return nil, models.ErrAddressOnlyDryRunnable

internal/drivers/hue/state.go

@@ -1,6 +1,7 @@
 package hue
 
 import (
+	"encoding/json"
 	"git.aiterp.net/lucifer/new-server/models"
 	"strconv"
 	"time"
@@ -16,12 +17,37 @@ type hueLightState struct {
 	stale bool
 }
 
+func (s *hueLightState) MarshalJSON() ([]byte, error) {
+	return json.Marshal(struct {
+		Index      int             `json:"index"`
+		UniqueID   string          `json:"uniqueId"`
+		ExternalID int             `json:"externalId"`
+		Info       LightData       `json:"info"`
+		Input      LightStateInput `json:"input"`
+		Stale      bool            `json:"stale"`
+	}{
+		Index:      s.index,
+		UniqueID:   s.uniqueID,
+		ExternalID: s.externalID,
+		Info:       s.info,
+		Input:      s.input,
+		Stale:      s.stale,
+	})
+}
+
 func (s *hueLightState) Update(state models.DeviceState) {
 	input := LightStateInput{}
 	if state.Power {
 		input.On = ptrBool(true)
 		if state.Color.IsKelvin() {
 			input.CT = ptrInt(1000000 / state.Color.Kelvin)
+			if *input.CT < s.info.Capabilities.Control.CT.Min {
+				*input.CT = s.info.Capabilities.Control.CT.Min
+			}
+			if *input.CT > s.info.Capabilities.Control.CT.Max {
+				*input.CT = s.info.Capabilities.Control.CT.Max
+			}
+
 			if s.input.CT == nil || *s.input.CT != *input.CT {
 				s.stale = true
 			}
@@ -67,6 +93,13 @@ func (s *hueLightState) Update(state models.DeviceState) {
 }
 
 func (s *hueLightState) CheckStaleness(state LightState) {
+	if s.input.On == nil || state.On != *s.input.On {
+		s.stale = true
+	}
+	if !state.On {
+		return
+	}
+
 	if state.ColorMode == "xy" {
 		s.stale = true
 		if s.input.CT == nil && s.input.Hue == nil {
@@ -80,7 +113,7 @@ func (s *hueLightState) CheckStaleness(state LightState) {
 			s.stale = true
 		}
 	} else {
-		if s.input.Hue == nil || state.Hue != *s.input.Hue || s.input.Sat == nil || state.Sat == *s.input.Sat {
+		if s.input.Hue == nil || state.Hue != *s.input.Hue || s.input.Sat == nil || state.Sat != *s.input.Sat {
 			s.stale = true
 		}
 	}
@@ -122,6 +155,9 @@ func (state *hueSensorState) Update(newData SensorData) *models.Event {
 			if time.Since(stateTime) > time.Second*3 {
 				return nil
 			}
+			if state.prevData == nil {
+				return nil
+			}
 
 			pe := state.prevData.State.ButtonEvent
 			ce := newData.State.ButtonEvent
@@ -183,6 +219,7 @@ func (state *hueSensorState) Update(newData SensorData) *models.Event {
 						"deviceInternalId": newData.UniqueID,
 						"minutesElapsed":   strconv.Itoa(state.presenceCooldown - 1),
 						"secondsElapsed":   strconv.Itoa((state.presenceCooldown - 1) * 60),
+						"lastUpdated":      strconv.FormatInt(stateTime.Unix(), 10),
 					},
 				}
 			}
@@ -199,6 +236,7 @@ func (state *hueSensorState) Update(newData SensorData) *models.Event {
 					"temperature":      strconv.FormatFloat(float64(newData.State.Temperature)/100, 'f', 2, 64),
 					"deviceId":         strconv.Itoa(state.externalID),
 					"deviceInternalId": newData.UniqueID,
+					"lastUpdated":      strconv.FormatInt(stateTime.Unix(), 10),
 				},
 			}
 		}

internal/drivers/lifx/driver.go

@@ -14,7 +14,7 @@ type Driver struct {
 	bridges []*Bridge
 }
 
-func (d *Driver) SearchBridge(ctx context.Context, address string, _ bool) ([]models.Bridge, error) {
+func (d *Driver) SearchBridge(ctx context.Context, address, _ string, _ bool) ([]models.Bridge, error) {
 	if address == "" {
 		ifaces, err := net.Interfaces()
 		if err != nil {

internal/drivers/mill/bridge.go

@@ -0,0 +1,240 @@
+package mill
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"crypto/sha1"
+	"encoding/json"
+	"fmt"
+	"git.aiterp.net/lucifer/new-server/models"
+	"io"
+	"log"
+	"net/http"
+	"strconv"
+	"sync"
+	"time"
+)
+
+type bridge struct {
+	mu sync.Mutex
+
+	luciferID int
+	username  string
+	password  string
+
+	token         string
+	userId        int
+	mustRefreshBy time.Time
+
+	luciferMillIDMap map[int]int
+	millLuciferIDMap map[int]int
+}
+
+func (b *bridge) listDevices(ctx context.Context) ([]models.Device, error) {
+	err := b.authenticate(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var shlRes listHomeResBody
+	err = b.command(ctx, "selectHomeList", listHomeReqBody{}, &shlRes)
+	if err != nil {
+		return nil, err
+	}
+
+	devices := make([]millDevice, 0, 16)
+	for _, home := range shlRes.HomeList {
+		var gidRes listDeviceResBody
+		err = b.command(ctx, "getIndependentDevices", listDeviceReqBody{HomeID: home.HomeID}, &gidRes)
+		if err != nil {
+			return nil, err
+		}
+
+		devices = append(devices, gidRes.DeviceInfo...)
+	}
+
+	luciferDevices := make([]models.Device, len(devices), len(devices))
+	for i, device := range devices {
+		luciferDevices[i] = models.Device{
+			ID:           b.millLuciferIDMap[device.DeviceID],
+			BridgeID:     b.luciferID,
+			InternalID:   fmt.Sprintf("%d", device.DeviceID),
+			Icon:         "heater",
+			Name:         device.DeviceName,
+			Capabilities: []models.DeviceCapability{models.DCTemperatureControl, models.DCPower},
+			ButtonNames:  nil,
+			DriverProperties: map[string]interface{}{
+				"subDomain": fmt.Sprintf("%d", device.SubDomainID),
+			},
+			UserProperties:   nil,
+			SceneAssignments: nil,
+			SceneState:       nil,
+			State: models.DeviceState{
+				Power:       device.PowerStatus > 0,
+				Temperature: device.HolidayTemp,
+			},
+			Tags: nil,
+		}
+	}
+
+	return luciferDevices, nil
+}
+
+func (b *bridge) pushStateChange(ctx context.Context, deviceModel models.Device) error {
+	b.mu.Lock()
+	if b.luciferMillIDMap == nil {
+		b.luciferMillIDMap = make(map[int]int, 4)
+		b.millLuciferIDMap = make(map[int]int, 4)
+	}
+
+	if b.luciferMillIDMap[deviceModel.ID] == 0 {
+		millID, _ := strconv.Atoi(deviceModel.InternalID)
+		b.luciferMillIDMap[deviceModel.ID] = millID
+		b.millLuciferIDMap[millID] = deviceModel.ID
+	}
+	b.mu.Unlock()
+
+	status := 0
+	if deviceModel.State.Power {
+		status = 1
+	}
+	powerReq := deviceControlReqBody{
+		SubDomain:  deviceModel.DriverProperties["subDomain"].(string),
+		DeviceID:   b.luciferMillIDMap[deviceModel.ID],
+		TestStatus: 1,
+		Status:     status,
+	}
+	err := b.command(ctx, "deviceControl", powerReq, nil)
+	if err != nil {
+		return err
+	}
+
+	tempReq := changeInfoReqBody{
+		DeviceID:    b.luciferMillIDMap[deviceModel.ID],
+		Value:       deviceModel.State.Temperature,
+		TimeZoneNum: "+02:00",
+		Key:         "holidayTemp",
+	}
+	err = b.command(ctx, "changeDeviceInfo", tempReq, nil)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (b *bridge) command(ctx context.Context, command string, payload interface{}, target interface{}) error {
+	err := b.authenticate(ctx)
+	if err != nil {
+		return err
+	}
+
+	url := serviceEndpoint + command
+	method := "POST"
+	nonce := makeNonce()
+	timestamp := fmt.Sprintf("%d", time.Now().Unix())
+	timeout := "300"
+
+	h := sha1.New()
+	h.Write([]byte(timeout))
+	h.Write([]byte(timestamp))
+	h.Write([]byte(nonce))
+	h.Write([]byte(b.token))
+	signature := fmt.Sprintf("%x", h.Sum(nil))
+
+	body, err := json.Marshal(payload)
+	if err != nil {
+		return err
+	}
+
+	req, err := http.NewRequestWithContext(ctx, method, url, bytes.NewReader(body))
+	if err != nil {
+		return err
+	}
+
+	addDefaultHeaders(req)
+	req.Header.Add("X-Zc-Timestamp", timestamp)
+	req.Header.Add("X-Zc-Timeout", timeout)
+	req.Header.Add("X-Zc-Nonce", nonce)
+	req.Header.Add("X-Zc-User-Id", fmt.Sprintf("%d", b.userId))
+	req.Header.Add("X-Zc-User-Signature", signature)
+	req.Header.Add("X-Zc-Content-Length", fmt.Sprintf("%d", len(body)))
+
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return models.ErrCannotForwardRequest
+	} else if res.StatusCode != 200 {
+		return models.ErrIncorrectToken
+	}
+
+	if target == nil {
+		return nil
+	}
+
+	err = json.NewDecoder(res.Body).Decode(&target)
+	if err != nil {
+		return models.ErrUnexpectedResponse
+	}
+
+	return nil
+}
+
+func (b *bridge) authenticate(ctx context.Context) error {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	if b.mustRefreshBy.Before(time.Now().Add(-1 * time.Minute)) {
+		body, err := json.Marshal(authReqBody{
+			Account:  b.username,
+			Password: b.password,
+		})
+		if err != nil {
+			return models.ErrMissingToken
+		}
+
+		req, err := http.NewRequestWithContext(ctx, "POST", accountEndpoint + "login", bytes.NewReader(body))
+		if err != nil {
+			return models.ErrMissingToken
+		}
+
+		addDefaultHeaders(req)
+
+		res, err := http.DefaultClient.Do(req)
+		if err != nil {
+			return models.ErrCannotForwardRequest
+		} else if res.StatusCode != 200 {
+			return models.ErrIncorrectToken
+		}
+
+		var resBody authResBody
+		err = json.NewDecoder(res.Body).Decode(&resBody)
+		if err != nil {
+			return models.ErrBridgeSearchFailed
+		}
+
+		log.Printf("Mill: Authenticated as %s", resBody.NickName)
+		b.userId = resBody.UserID
+		b.token = resBody.Token
+		b.mustRefreshBy, err = time.ParseInLocation("2006-01-02 15:04:05", resBody.TokenExpire, location)
+	}
+
+	return nil
+}
+
+func makeNonce() string {
+	buf := make([]byte, 8)
+	_, _ = io.ReadFull(rand.Reader, buf)
+
+	return fmt.Sprintf("%x", buf)
+}
+
+func addDefaultHeaders(req *http.Request) {
+	req.Header.Add("Content-Type", "application/x-zc-object")
+	req.Header.Add("Connection", "Keep-Alive")
+	req.Header.Add("X-Zc-Major-Domain", "seanywell")
+	req.Header.Add("X-Zc-Msg-Name", "millService")
+	req.Header.Add("X-Zc-Sub-Domain", "milltype")
+	req.Header.Add("X-Zc-Seq-Id", "1")
+	req.Header.Add("X-Zc-Version", "1")
+}

internal/drivers/mill/driver.go

@@ -0,0 +1,100 @@
+package mill
+
+import (
+	"context"
+	"fmt"
+	"git.aiterp.net/lucifer/new-server/models"
+	"sync"
+	"time"
+)
+
+type Driver struct {
+	mu      sync.Mutex
+	bridges map[int]*bridge
+}
+
+func (d *Driver) SearchBridge(ctx context.Context, address, token string, _ bool) ([]models.Bridge, error) {
+	bridgeData := models.Bridge{
+		Name:    fmt.Sprintf("Mill account (%s)", address),
+		Driver:  models.DTMill,
+		Address: address,
+		Token:   token,
+	}
+
+	b, err := d.ensureBridge(bridgeData)
+	if err != nil {
+		return nil, err
+	}
+
+	err = b.authenticate(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return []models.Bridge{bridgeData}, nil
+}
+
+func (d *Driver) SearchDevices(context.Context, models.Bridge, time.Duration) ([]models.Device, error) {
+	// You would have to configure devices with the Mill app, unfortunately.
+	return []models.Device{}, nil
+}
+
+func (d *Driver) ListDevices(ctx context.Context, bridge models.Bridge) ([]models.Device, error) {
+	b, err := d.ensureBridge(bridge)
+	if err != nil {
+		return nil, err
+	}
+
+	return b.listDevices(ctx)
+}
+
+func (d *Driver) Publish(ctx context.Context, bridge models.Bridge, devices []models.Device) error {
+	b, err := d.ensureBridge(bridge)
+	if err != nil {
+		return err
+	}
+
+	for _, device := range devices {
+		err = b.pushStateChange(ctx, device)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (d *Driver) Run(ctx context.Context, _ models.Bridge, _ chan<- models.Event) error {
+	// TODO: Maybe do something with the thermostat on the device
+	for {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		}
+	}
+}
+
+func (d *Driver) ensureBridge(model models.Bridge) (*bridge, error) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	if d.bridges == nil {
+		d.bridges = make(map[int]*bridge, 4)
+	}
+
+	if d.bridges[model.ID] == nil {
+		newBridge := &bridge{
+			luciferID: model.ID,
+			username:  model.Address,
+			password:  model.Token,
+		}
+
+		if model.ID <= 0 {
+			return newBridge, nil
+		}
+
+		d.bridges[model.ID] = newBridge
+	}
+
+	return d.bridges[model.ID], nil
+}

internal/drivers/mill/mill.go

@@ -0,0 +1,77 @@
+package mill
+
+import "time"
+
+const accountEndpoint = "https://eurouter.ablecloud.cn:9005/zc-account/v1/"
+
+const serviceEndpoint = "https://eurouter.ablecloud.cn:9005/millService/v1/"
+
+type millHome struct {
+	HomeID   int64  `json:"homeId"`
+	HomeName string `json:"homeName"`
+}
+
+type millDevice struct {
+	DeviceID    int     `json:"deviceId"`
+	DeviceName  string  `json:"deviceName"`
+	PowerStatus int     `json:"powerStatus"`
+	HolidayTemp int     `json:"holidayTemp"`
+	CurrentTemp float64 `json:"currentTemp"`
+	SubDomainID int     `json:"subDomainId"`
+}
+
+type authReqBody struct {
+	Account  string `json:"account"`
+	Password string `json:"password"`
+}
+
+type authResBody struct {
+	Token       string `json:"token"`
+	UserID      int    `json:"userId"`
+	NickName    string `json:"nickName"`
+	TokenExpire string `json:"tokenExpire"`
+}
+
+type listHomeReqBody struct{}
+
+type listHomeResBody struct {
+	HomeList []millHome `json:"homeList"`
+}
+
+type listDeviceReqBody struct {
+	HomeID int64 `json:"homeId"`
+}
+
+type listDeviceResBody struct {
+	DeviceInfo []millDevice `json:"deviceInfo"`
+}
+
+type changeInfoReqBody struct {
+	HomeType    int    `json:"homeType"`
+	DeviceID    int    `json:"deviceId"`
+	Value       int    `json:"value"`
+	TimeZoneNum string `json:"timeZoneNum"`
+	Key         string `json:"key"`
+}
+
+type deviceControlReqBody struct {
+	SubDomain  string `json:"subDomain"`
+	DeviceID   int    `json:"deviceId"`
+	TestStatus int    `json:"testStatus"`
+	Operation  int    `json:"operation"`
+	Status     int    `json:"status"`
+	WindStatus int    `json:"windStatus"`
+	TempType   int    `json:"tempType"`
+	PowerLevel int    `json:"powerLevel"`
+}
+
+var location *time.Location
+
+func init() {
+	myLocation, err := time.LoadLocation("Europe/Oslo")
+	if err != nil {
+		panic(err.Error())
+	}
+
+	location = myLocation
+}

internal/drivers/nanoleaf/bridge.go

@@ -177,7 +177,7 @@ func (b *bridge) Update(devices []models.Device) {
 					red, green, blue := color.RGB255()
 					newColor := [4]byte{red, green, blue, 255}
 					if newColor != panel.ColorRGBA {
-						panel.update(newColor, time.Now().Add(time.Millisecond*120))
+						panel.update(newColor, time.Now().Add(time.Millisecond*220))
 					}
 				} else {
 					panel.update([4]byte{0, 0, 0, 0}, time.Now())

internal/drivers/nanoleaf/driver.go

@@ -17,7 +17,7 @@ type Driver struct {
 
 // SearchBridge checks the bridge at the address. If it's not a dry-run, you must hold down the power button
 // before calling this function and wait for the pattern.
-func (d *Driver) SearchBridge(ctx context.Context, address string, dryRun bool) ([]models.Bridge, error) {
+func (d *Driver) SearchBridge(ctx context.Context, address, _ string, dryRun bool) ([]models.Bridge, error) {
 	res, err := http.Get(fmt.Sprintf("http://%s/device_info", address))
 	if err != nil {
 		return nil, err

internal/mysql/devicerepo.go

@@ -23,12 +23,13 @@ type deviceRecord struct {
 }
 
 type deviceStateRecord struct {
-	DeviceID   int     `db:"device_id"`
-	Hue        float64 `db:"hue"`
-	Saturation float64 `db:"saturation"`
-	Kelvin     int     `db:"kelvin"`
-	Power      bool    `db:"power"`
-	Intensity  float64 `db:"intensity"`
+	DeviceID    int     `db:"device_id"`
+	Hue         float64 `db:"hue"`
+	Saturation  float64 `db:"saturation"`
+	Kelvin      int     `db:"kelvin"`
+	Power       bool    `db:"power"`
+	Intensity   float64 `db:"intensity"`
+	Temperature int     `db:"temperature"`
 }
 
 type devicePropertyRecord struct {
@@ -227,15 +228,16 @@ func (r *DeviceRepo) SaveMany(ctx context.Context, mode models.SaveMode, devices
 
 		if mode == 0 || mode&models.SMState != 0 {
 			_, err = tx.NamedExecContext(ctx, `
-			REPLACE INTO device_state(device_id, hue, saturation, kelvin, power, intensity) 
-			VALUES (:device_id, :hue, :saturation, :kelvin, :power, :intensity)
+			REPLACE INTO device_state(device_id, hue, saturation, kelvin, power, intensity, temperature)
+			VALUES (:device_id, :hue, :saturation, :kelvin, :power, :intensity, :temperature)
 		`, deviceStateRecord{
-				DeviceID:   record.ID,
-				Hue:        device.State.Color.Hue,
-				Saturation: device.State.Color.Saturation,
-				Kelvin:     device.State.Color.Kelvin,
-				Power:      device.State.Power,
-				Intensity:  device.State.Intensity,
+				DeviceID:    record.ID,
+				Hue:         device.State.Color.Hue,
+				Saturation:  device.State.Color.Saturation,
+				Kelvin:      device.State.Color.Kelvin,
+				Power:       device.State.Power,
+				Intensity:   device.State.Intensity,
+				Temperature: device.State.Temperature,
 			})
 			if err != nil {
 				return dbErr(err)
@@ -379,6 +381,7 @@ func (r *DeviceRepo) populate(ctx context.Context, records []deviceRecord) ([]mo
 						Kelvin:     state.Kelvin,
 					},
 					Intensity: state.Intensity,
+					Temperature: state.Temperature,
 				}
 			}
 		}

internal/mysql/scenerepo.go

@@ -2,6 +2,7 @@ package mysql
 
 import (
 	"context"
+	"database/sql"
 	"encoding/json"
 	"git.aiterp.net/lucifer/new-server/models"
 	"github.com/jmoiron/sqlx"
@@ -32,6 +33,10 @@ func (r *SceneRepo) FetchAll(ctx context.Context) ([]models.Scene, error) {
 	scenes := make([]sceneRecord, 0, 8)
 	err := r.DBX.SelectContext(ctx, &scenes, "SELECT * FROM scene")
 	if err != nil {
+		if err == sql.ErrNoRows {
+			return []models.Scene{}, nil
+		}
+
 		return nil, dbErr(err)
 	}
 

models/bridge.go

@@ -23,6 +23,7 @@ var (
 	DTHue      DriverKind = "Hue"
 	DTNanoLeaf DriverKind = "Nanoleaf"
 	DTLIFX     DriverKind = "LIFX"
+	DTMill     DriverKind = "Mill"
 )
 
 var ValidDriverKinds = []DriverKind{

models/colorvalue.go

@@ -26,9 +26,11 @@ func (c *ColorValue) String() string {
 		return fmt.Sprintf("k:%d", c.Kelvin)
 	}
 
-	return fmt.Sprintf("hs:%g,%g", c.Hue, c.Saturation)
+	return fmt.Sprintf("hs:%.4g,%.3g", c.Hue, c.Saturation)
 }
 
+
+
 func ParseColorValue(raw string) (ColorValue, error) {
 	tokens := strings.SplitN(raw, ":", 2)
 	if len(tokens) != 2 {

models/device.go

@@ -2,7 +2,6 @@ package models
 
 import (
 	"context"
-	"math"
 	"strings"
 	"time"
 )
@@ -18,6 +17,7 @@ type Device struct {
 	DriverProperties map[string]interface{}  `json:"driverProperties"`
 	UserProperties   map[string]string       `json:"userProperties"`
 	SceneAssignments []DeviceSceneAssignment `json:"sceneAssignments"`
+	SceneState       *DeviceState            `json:"sceneState"`
 	State            DeviceState             `json:"state"`
 	Tags             []string                `json:"tags"`
 }
@@ -37,7 +37,7 @@ type DeviceState struct {
 	Power       bool       `json:"power"`
 	Color       ColorValue `json:"color,omitempty"`
 	Intensity   float64    `json:"intensity,omitempty"`
-	Temperature float64    `json:"temperature"`
+	Temperature int        `json:"temperature"`
 }
 
 type DeviceScene struct {
@@ -155,6 +155,17 @@ func (d *Device) HasTag(tags ...string) bool {
 	return false
 }
 
+func (d *Device) IsOnlySensor() bool {
+	return !d.HasCapability(
+		DCPower,
+		DCColorHS,
+		DCColorHSK,
+		DCColorKelvin,
+		DCIntensity,
+		DCTemperatureControl,
+	)
+}
+
 func (d *Device) HasCapability(capabilities ...DeviceCapability) bool {
 	for _, c := range d.Capabilities {
 		for _, c2 := range capabilities {
@@ -187,6 +198,10 @@ func (d *Device) SetState(newState NewDeviceState) error {
 		d.State.Intensity = *newState.Intensity
 	}
 
+	if newState.Temperature != nil && d.HasCapability(DCTemperatureControl) {
+		d.State.Temperature = *newState.Temperature
+	}
+
 	return nil
 }
 
@@ -197,14 +212,6 @@ func (s *NewDeviceState) RelativeTo(device Device) NewDeviceState {
 		intensity := device.State.Intensity * *s.Intensity
 		n.Intensity = &intensity
 	}
-	if s.Color != nil {
-		c, err := ParseColorValue(*s.Color)
-		if err == nil {
-			c.Hue = math.Mod(device.State.Color.Hue + c.Hue, 360)
-			c.Saturation *= device.State.Color.Saturation
-			c.Kelvin += device.State.Color.Kelvin
-		}
-	}
 
 	return n
 }

models/driver.go

@@ -10,7 +10,7 @@ type DriverProvider interface {
 }
 
 type Driver interface {
-	SearchBridge(ctx context.Context, address string, dryRun bool) ([]Bridge, error)
+	SearchBridge(ctx context.Context, address, token string, dryRun bool) ([]Bridge, error)
 	SearchDevices(ctx context.Context, bridge Bridge, timeout time.Duration) ([]Device, error)
 	ListDevices(ctx context.Context, bridge Bridge) ([]Device, error)
 	Publish(ctx context.Context, bridge Bridge, devices []Device) error

models/errors.go

@@ -15,6 +15,7 @@ var ErrIncorrectToken = errors.New("driver is not accepting authentication infor
 var ErrUnexpectedResponse = errors.New("driver api returned unexpected response (wrong driver selected?)")
 var ErrBridgeSearchFailed = errors.New("bridge search failed")
 var ErrAddressOnlyDryRunnable = errors.New("this address may only be used for a dry run")
+var ErrCannotForwardRequest = errors.New("driver is not able to forward requests")
 
 var ErrInvalidAddress = errors.New("invalid mac address")
 var ErrPayloadTooShort = errors.New("payload too short")

models/event.go

@@ -24,7 +24,6 @@ var (
 	ENBridgeDisconnected    = "BridgeDisconnected"
 	ENButtonPressed         = "ButtonPressed"
 	ENSensorPresenceStarted = "SensorPresenceStarted"
-	ENSensorPresenceEnding  = "SensorPresenceEnding"
 	ENSensorPresenceEnded   = "SensorPresenceEnded"
 	ENSensorTemperature     = "SensorTemperature"
 )

models/eventhandler.go

@@ -5,6 +5,7 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
+	"time"
 )
 
 type EventHandler struct {
@@ -167,7 +168,17 @@ func (c *EventCondition) checkDevice(key string, device Device) (matches bool, s
 			return false, true
 		}
 
-		return c.matches(strconv.FormatFloat(device.State.Temperature, 'f', -1, 64)), false
+		return c.matches(strconv.Itoa(device.State.Temperature)), false
+	case "scene":
+		sceneId := -1
+		for _, assignment := range device.SceneAssignments {
+			duration := time.Duration(assignment.DurationMS) * time.Millisecond
+			if duration <= 0 || time.Now().Before(assignment.StartTime.Add(duration)) {
+				sceneId = assignment.SceneID
+			}
+		}
+
+		return c.matches(strconv.Itoa(sceneId)), false
 	default:
 		return false, true
 	}
@@ -214,12 +225,14 @@ func (c *EventCondition) matches(value string) bool {
 }
 
 type EventAction struct {
-	SetPower       *bool    `json:"setPower"`
-	SetColor       *string  `json:"setColor"`
-	SetIntensity   *float64 `json:"setIntensity"`
-	SetTemperature *int     `json:"setTemperature"`
-	AddIntensity   *float64 `json:"addIntensity"`
-	FireEvent      *Event   `json:"fireEvent"`
+	SetPower       *bool                  `json:"setPower"`
+	SetColor       *string                `json:"setColor"`
+	SetIntensity   *float64               `json:"setIntensity"`
+	SetTemperature *int                   `json:"setTemperature"`
+	AddIntensity   *float64               `json:"addIntensity"`
+	FireEvent      *Event                 `json:"fireEvent"`
+	SetScene       *DeviceSceneAssignment `json:"setScene"`
+	PushScene      *DeviceSceneAssignment `json:"pushScene"`
 }
 
 func (action *EventAction) Apply(other EventAction) {
@@ -238,6 +251,12 @@ func (action *EventAction) Apply(other EventAction) {
 	if action.FireEvent == nil {
 		action.FireEvent = other.FireEvent
 	}
+	if action.SetScene == nil {
+		action.SetScene = other.SetScene
+	}
+	if action.PushScene == nil {
+		action.PushScene = other.PushScene
+	}
 }
 
 func (c EventCondition) String() string {

models/scene.go

@@ -56,29 +56,43 @@ func (s *Scene) RoleIndex(device *Device) int {
 type SceneEffect string
 
 const (
-	SEStatic          SceneEffect = "Plain"
+	SEStatic          SceneEffect = "Static"
 	SERandom          SceneEffect = "Random"
 	SEGradient        SceneEffect = "Gradient"
 	SEWalkingGradient SceneEffect = "WalkingGradient"
 	SETransition      SceneEffect = "Transition"
+	SEMotion          SceneEffect = "Motion"
+	SETemperature     SceneEffect = "Temperature"
 )
 
 type SceneRole struct {
-	Effect      SceneEffect      `json:"effect"`
-	PowerMode   ScenePowerMode   `json:"powerMode"`
-	TargetKind  ReferenceKind    `json:"targetKind"`
-	TargetValue string           `json:"targetValue"`
-	Interpolate bool             `json:"interpolate"`
-	Relative    bool             `json:"relative"`
-	Order       string           `json:"order"`
-	States      []NewDeviceState `json:"states"`
+	Effect         SceneEffect      `json:"effect"`
+	MotionSeconds  float64          `json:"motionSeconds"`
+	MinTemperature int              `json:"minTemperature"`
+	MaxTemperature int              `json:"maxTemperature"`
+	PowerMode      ScenePowerMode   `json:"powerMode"`
+	TargetKind     ReferenceKind    `json:"targetKind"`
+	TargetValue    string           `json:"targetValue"`
+	Interpolate    bool             `json:"interpolate"`
+	Relative       bool             `json:"relative"`
+	Order          string           `json:"order"`
+	States         []NewDeviceState `json:"states"`
 }
 
 type SceneRunContext struct {
+	CurrentTime    time.Time
 	Index          int
 	Length         int
 	IntervalNumber int64
 	IntervalMax    int64
+	Sensors        []SceneSensor
+}
+
+type SceneSensor struct {
+	ID          int
+	UpdateTime  time.Time
+	Temperature *float64
+	Presence    *bool
 }
 
 func (d *SceneRunContext) PositionFacShifted() float64 {
@@ -114,13 +128,13 @@ func (r *SceneRole) Validate() error {
 	}
 
 	switch r.PowerMode {
-	case SPScene, SPDevice:
+	case SPScene, SPDevice, SPBoth:
 	default:
 		return ErrSceneRoleUnknownPowerMode
 	}
 
 	switch r.Effect {
-	case SEStatic, SERandom, SEGradient, SETransition:
+	case SEStatic, SERandom, SEGradient, SEWalkingGradient, SETransition, SEMotion, SETemperature:
 	default:
 		return ErrSceneRoleUnknownEffect
 	}
@@ -178,6 +192,53 @@ func (r *SceneRole) ApplyEffect(device *Device, c SceneRunContext) (newState New
 		newState = r.State(c.PositionFacShifted())
 	case SETransition:
 		newState = r.State(c.IntervalFac())
+	case SEMotion:
+		presence := false
+		absenceTime := time.Time{}
+
+		for _, sensors := range c.Sensors {
+			if sensors.Presence == nil {
+				continue
+			}
+
+			if *sensors.Presence {
+				presence = true
+			} else {
+				if sensors.UpdateTime.After(absenceTime) {
+					absenceTime = sensors.UpdateTime
+				}
+			}
+		}
+
+		if presence {
+			newState = r.State(0.0)
+		} else {
+			fac := c.CurrentTime.Sub(absenceTime).Seconds() / r.MotionSeconds
+			if fac < 0 {
+				fac = 0
+			} else if fac > 1 {
+				fac = 1
+			}
+
+			newState = r.State(fac)
+		}
+	case SETemperature:
+		avg := 0.0
+		count := 0
+
+		for _, sensor := range c.Sensors {
+			if sensor.Temperature == nil {
+				continue
+			}
+
+			if count == 0 {
+				avg = *sensor.Temperature
+				count = 1
+			} else {
+				avg = ((avg * float64(count)) + *sensor.Temperature) / float64(count+1)
+				count += 1
+			}
+		}
 	}
 
 	if r.Relative {
@@ -189,6 +250,11 @@ func (r *SceneRole) ApplyEffect(device *Device, c SceneRunContext) (newState New
 		newState.Power = nil
 	case SPScene:
 		// Do nothing
+	case SPBoth:
+		if newState.Power != nil {
+			powerIntersection := *newState.Power && device.State.Power
+			newState.Power = &powerIntersection
+		}
 	}
 
 	return
@@ -201,8 +267,6 @@ func (r *SceneRole) State(fac float64) NewDeviceState {
 		return r.States[0]
 	}
 
-
-
 	if r.Interpolate {
 		if len(r.States) == 2 {
 			return r.States[0].Interpolate(r.States[1], fac)
@@ -228,6 +292,7 @@ type ScenePowerMode string
 const (
 	SPDevice ScenePowerMode = "Device" // Device state decides power. Scene state may only power off.
 	SPScene  ScenePowerMode = "Scene"  // Scene state decide power.
+	SPBoth   ScenePowerMode = "Both"   // Power is only on if both Device and Scene says it is.
 )
 
 // DeviceSceneAssignment is an entry on the device stack. StartTime and DurationMS are only respected when the scene

models/timeofday.go

@@ -9,6 +9,8 @@ import (
 	"time"
 )
 
+var TimeOfDayTimeZone = time.UTC
+
 type TimeOfDay int
 
 func (t *TimeOfDay) UnmarshalJSON(v []byte) error {
@@ -29,7 +31,6 @@ func (t *TimeOfDay) UnmarshalJSON(v []byte) error {
 		}
 	}
 
-
 	t2, err := ParseTimeOfDay(str)
 	if err != nil {
 		return err
@@ -82,11 +83,12 @@ func (t TimeOfDay) IsBetween(from TimeOfDay, to TimeOfDay) bool {
 }
 
 func CurrentTimeOfDay() TimeOfDay {
-	return TimeOfDayFromDate(time.Now().Local())
+	return TimeOfDayFromDate(time.Now().In(TimeOfDayTimeZone))
 }
 
 func TimeOfDayFromDate(date time.Time) TimeOfDay {
-	return NewTimeOfDay(date.Hour(), date.Minute(), date.Second())
+	localDate := date.In(TimeOfDayTimeZone)
+	return NewTimeOfDay(localDate.Hour(), localDate.Minute(), localDate.Second())
 }
 
 func NewTimeOfDay(hours, minutes, seconds int) TimeOfDay {

scene-examples/evening.yaml

@@ -0,0 +1,63 @@
+name: Evening
+interval: 1500
+roles:
+  - effect: WalkingGradient
+    power_mode: Device
+    target_kind: Tag
+    target_value: Hexagon
+    interpolate: true
+    relative: false
+    order: -name
+    states:
+      - color: 'hs:30,1'
+        intensity: 0.20
+      - color: 'hs:30,1'
+        intensity: 0.15
+
+  - effect: Gradient
+    power_mode: Device
+    target_kind: Tag
+    target_value: SquareLeft
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:25,1'
+        intensity: 0.075
+      - color: 'hs:50,1'
+        intensity: 0.15
+
+  - effect: Random
+    power_mode: Device
+    target_kind: Tag
+    target_value: SquareRight
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:220,0.7'
+        intensity: 0.22
+      - color: 'hs:220,0.6'
+        intensity: 0.25
+
+  - effect: Static
+    power_mode: Device
+    target_kind: Tag
+    target_value: Accent
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:250,0.7'
+        intensity: 0.25
+
+  - effect: Static
+    power_mode: Device
+    target_kind: All
+    target_value: ""
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'k:2000'
+        intensity: 0.3

scene-examples/flash.yaml

@@ -0,0 +1,26 @@
+name: Flash
+interval: 0
+roles:
+  - effect: Static
+    power_mode: Device
+    target_kind: Tag
+    target_value: Nanoleaf
+    states:
+      - intensity: 1
+        color: hs:220,0.1
+
+  - effect: Static
+    power_mode: Device
+    target_kind: Tag
+    target_value: Hue
+    states:
+      - intensity: 1
+        color: k:6500
+
+  - effect: Static
+    power_mode: Device
+    target_kind: All
+    target_value: ""
+    states:
+      - intensity: 1
+        color: hs:0,0

scene-examples/late.yaml

@@ -0,0 +1,57 @@
+name: Late
+interval: 60000
+roles:
+  - effect: Random
+    power_mode: Device
+    target_kind: Tag
+    target_value: Hexagon
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:35,1'
+        intensity: 0.08
+      - color: 'hs:35,1'
+        intensity: 0.085
+      - color: 'hs:35,1'
+        intensity: 0.09
+      - color: 'hs:35,1'
+        intensity: 0.12
+
+  - effect: Gradient
+    power_mode: Both
+    target_kind: Tag
+    target_value: Square
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:25,1'
+        intensity: 0.05
+        power: off
+      - color: 'hs:30,1'
+        intensity: 0.06
+        power: off
+      - color: 'hs:35,1'
+        intensity: 0.07
+        power: on
+
+  - effect: Static
+    power_mode: Device
+    target_kind: Tag
+    target_value: Nightstand
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'k:2000'
+        intensity: 0.15
+
+  - effect: Static
+    power_mode: Scene
+    target_kind: All
+    target_value: ''
+    interpolate: true
+    relative: false
+    states:
+      - power: false

scene-examples/morning.yaml

@@ -0,0 +1,40 @@
+name: Morning
+interval: 1000
+roles:
+  - effect: WalkingGradient
+    power_mode: Device
+    target_kind: Tag
+    target_value: Hexagon
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:220,0.4'
+        intensity: 0.65
+      - color: 'hs:220,0.5'
+        intensity: 0.50
+
+  - effect: Random
+    power_mode: Device
+    target_kind: Tag
+    target_value: Square
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:220,0.6'
+        intensity: 0.30
+      - color: 'hs:220,0.5'
+        intensity: 0.35
+
+  - effect: Static
+    power_mode: Device
+    target_kind: All
+    target_value: ''
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:250,0.6'
+        intensity: 0.3
+

scene-examples/saturday.yaml

@@ -0,0 +1,42 @@
+name: Saturday
+interval: 700
+roles:
+  - effect: WalkingGradient
+    power_mode: Device
+    target_kind: Tag
+    target_value: Hexagon
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:220,0.5'
+        intensity: 0.25
+      - color: 'hs:220,0.5'
+        intensity: 0.30
+
+  - effect: Random
+    power_mode: Device
+    target_kind: Tag
+    target_value: Square
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:220,0.6'
+        intensity: 0.15
+      - color: 'hs:220,0.55'
+        intensity: 0.16
+      - color: 'hs:220,0.5'
+        intensity: 0.20
+
+  - effect: Static
+    power_mode: Device
+    target_kind: All
+    target_value: ''
+    interpolate: true
+    relative: false
+    order: +name
+    states:
+      - color: 'hs:250,0.7'
+        intensity: 0.3
+

scripts/20211106223238_device_state_temperature.sql

@@ -0,0 +1,11 @@
+-- +goose Up
+-- +goose StatementBegin
+ALTER TABLE device_state
+    ADD COLUMN temperature INT NOT NULL DEFAULT 0;
+-- +goose StatementEnd
+
+-- +goose Down
+-- +goose StatementBegin
+ALTER TABLE device_state
+    DROP COLUMN temperature;
+-- +goose StatementEnd