Merge branch 'asmodeus' into feature-scenesystem

new scene system is kind of working. I haven't tested changing between scenes and Transition effect yet, though.
2021-10-04 20:14:16 +02:00 · 2021-10-04 20:13:57 +02:00 · 2021-10-03 18:42:33 +02:00 · 2021-09-28 21:57:28 +02:00 · 2021-09-26 22:15:49 +02:00 · 2021-09-26 16:20:02 +02:00
44 changed files with 137 additions and 1591 deletions
@@ -4,6 +4,15 @@ 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:
@@ -52,7 +52,7 @@ func Bridges(r gin.IRoutes) {
 			return []models.Bridge{bridge}, nil
 		}

-		bridges, err := driver.SearchBridge(ctxOf(c), body.Address, body.Token, body.DryRun)
+		bridges, err := driver.SearchBridge(ctxOf(c), body.Address, body.DryRun)
 		if err != nil {
 			return nil, err
 		}
@@ -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,21 +17,11 @@ func fetchDevices(ctx context.Context, fetchStr string) ([]models.Device, error)

 func Devices(r gin.IRoutes) {
 	r.GET("", handler(func(c *gin.Context) (interface{}, error) {
-		devices, err := config.DeviceRepository().FetchByReference(ctxOf(c), models.RKAll, "")
-		if err != nil {
-			return nil, err
-		}
-
-		return withSceneState(devices), nil
+		return config.DeviceRepository().FetchByReference(ctxOf(c), models.RKAll, "")
 	}))

 	r.GET("/:fetch", handler(func(c *gin.Context) (interface{}, error) {
-		devices, err := fetchDevices(ctxOf(c), c.Param("fetch"))
-		if err != nil {
-			return nil, err
-		}
-
-		return withSceneState(devices), nil
+		return fetchDevices(ctxOf(c), c.Param("fetch"))
 	}))

 	r.PUT("", handler(func(c *gin.Context) (interface{}, error) {
@@ -82,7 +72,7 @@ func Devices(r gin.IRoutes) {
 			}
 		}()

-		return withSceneState(changed), nil
+		return changed, nil
 	}))

 	r.PUT("/:fetch", handler(func(c *gin.Context) (interface{}, error) {
@@ -110,7 +100,7 @@ func Devices(r gin.IRoutes) {
 			}
 		}

-		return withSceneState(devices), nil
+		return devices, nil
 	}))

 	r.PUT("/:fetch/state", handler(func(c *gin.Context) (interface{}, error) {
@@ -137,12 +127,17 @@ func Devices(r gin.IRoutes) {

 		config.PublishChannel <- devices

-		err = config.DeviceRepository().SaveMany(ctxOf(c), models.SMState, devices)
-		if err != nil {
-			log.Println("Failed to save devices states")
-		}
+		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
+				}
+			}
+		}()

-		return withSceneState(devices), nil
+		return devices, nil
 	}))

 	r.PUT("/:fetch/tags", handler(func(c *gin.Context) (interface{}, error) {
@@ -199,7 +194,7 @@ func Devices(r gin.IRoutes) {
 			}
 		}

-		return withSceneState(devices), nil
+		return devices, nil
 	}))

 	r.PUT("/:fetch/scene", handler(func(c *gin.Context) (interface{}, error) {
@@ -226,53 +221,25 @@ func Devices(r gin.IRoutes) {
 		}
 		body.StartTime = time.Now()

-		pushMode := c.Query("push") == "true"
 		for i := range devices {
-			if pushMode {
-				devices[i].SceneAssignments = append(devices[i].SceneAssignments, body)
-			} else {
-				devices[i].SceneAssignments = []models.DeviceSceneAssignment{body}
-			}
+			devices[i].SceneAssignments = []models.DeviceSceneAssignment{body}
 		}
 		config.PublishChannel <- devices

-		err = config.DeviceRepository().SaveMany(ctxOf(c), 0, devices)
-		if err != nil {
-			return nil, err
-		}
-
-		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
-		}
-
+		eg := errgroup.Group{}
 		for i := range devices {
-			devices[i].SceneAssignments = []models.DeviceSceneAssignment{}
-		}
-		config.PublishChannel <- devices
+			device := devices[i]

-		err = config.DeviceRepository().SaveMany(ctxOf(c), 0, devices)
+			eg.Go(func() error {
+				return config.DeviceRepository().Save(ctxOf(c), &device, 0)
+			})
+		}
+
+		err = eg.Wait()
 		if err != nil {
 			return nil, err
 		}

-		return withSceneState(devices), nil
+		return 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
-}
@@ -2,7 +2,6 @@ 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"
 )
@@ -33,36 +32,6 @@ 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
-	}))
-}
+}
@@ -60,31 +60,6 @@ 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 {
@@ -28,7 +28,7 @@ func (client *Client) GetHandler(ctx context.Context, id int) (*models.EventHand

 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)
+	err := client.Fetch(ctx, "PUT", fmt.Sprintf("/api/event-handlers/%d", handler.ID), &response, handler)
 	if err != nil {
 		return nil, err
 	}
@@ -1,16 +0,0 @@
-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
-}
@@ -4,7 +4,6 @@ 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"
@@ -19,7 +18,6 @@ func DriverProvider() models.DriverProvider {
 			models.DTNanoLeaf: &nanoleaf.Driver{},
 			models.DTHue:      &hue.Driver{},
 			models.DTLIFX:     &lifx.Driver{},
-			models.DTMill:     &mill.Driver{},
 		}
 	})

@@ -5,6 +5,7 @@ import (
 	"git.aiterp.net/lucifer/new-server/app/config"
 	"git.aiterp.net/lucifer/new-server/models"
 	"log"
+	"strconv"
 	"sync"
 	"time"
 )
@@ -52,6 +53,15 @@ 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)

@@ -4,7 +4,6 @@ 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"
@@ -67,6 +66,7 @@ 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,15 +155,6 @@ 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
@@ -220,30 +211,7 @@ 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
 	}
-}
+}
@@ -17,39 +17,6 @@ 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 {
@@ -59,12 +26,8 @@ func (p *Publisher) ReloadScenes(ctx context.Context) error {
 	}

 	p.mu.Lock()
-	for i, scene := range scenes {
-		p.sceneData[scene.ID] = &scenes[i]
-	}
-
-	for _, scene := range p.scenes {
-		scene.UpdateScene(*p.sceneData[scene.data.ID])
+	for _, scene := range scenes {
+		p.sceneData[scene.ID] = &scene
 	}
 	p.mu.Unlock()

@@ -100,10 +63,6 @@ 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 {
@@ -131,12 +90,10 @@ func (p *Publisher) Run() {

 		p.mu.Lock()
 		for i, scene := range p.scenes {
-			if (!scene.endTime.IsZero() && time.Now().After(scene.endTime)) || scene.Empty() {
+			if !scene.endTime.IsZero() && time.Now().After(scene.endTime) {
 				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
 				}
@@ -152,7 +109,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
@@ -191,11 +148,6 @@ 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 {
@@ -223,7 +175,6 @@ 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
@@ -305,15 +256,10 @@ 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
 	}
@@ -322,9 +268,8 @@ func Initialize(ctx context.Context) error {
 		return err
 	}

-	go publisher.Run()
-	time.Sleep(time.Millisecond * 50)
 	go publisher.PublishChannel(config.PublishChannel)
+	go publisher.Run()

 	return nil
 }
@@ -6,32 +6,17 @@ import (
 )

 type Scene struct {
-	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
+	data      *models.Scene
+	group     string
+	startTime time.Time
+	endTime   time.Time
+	roleMap   map[int]int
+	roleList  map[int][]models.Device

 	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)
@@ -99,24 +84,6 @@ 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 {
@@ -151,7 +118,6 @@ func (s *Scene) Run() []models.Device {
 		return []models.Device{}
 	}

-	currentTime := time.Now()
 	intervalNumber := int64(0)
 	intervalMax := int64(1)
 	if s.data.IntervalMS > 0 {
@@ -171,31 +137,14 @@ 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{
-				CurrentTime:    currentTime,
-				Index:          j - jSkip,
-				Length:         len(list) - sensorCount,
+				Index:          j,
+				Length:         len(list),
 				IntervalNumber: intervalNumber,
 				IntervalMax:    intervalMax,
-				Sensors:        s.sensors,
 			})

 			err := device.SetState(newState)
@@ -203,8 +152,6 @@ func (s *Scene) Run() []models.Device {
 				continue
 			}

-			s.lastStates[device.ID] = device.State
-
 			updatedDevices = append(updatedDevices, device)
 		}
 	}
@@ -214,12 +161,3 @@ 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
-}
@@ -33,7 +33,7 @@ func main() {
 	}

 	// Find bridge
-	bridges, err := driver.SearchBridge(context.Background(), *flagAddress, *flagToken, !*flagPair)
+	bridges, err := driver.SearchBridge(context.Background(), *flagAddress, !*flagPair)
 	if err != nil {
 		log.Fatalln("Failed to search bridge:", err)
 	}
@@ -5,7 +5,6 @@ import (
 	"log"
 	"strconv"
 	"strings"
-	"time"
 )

 type Param struct {
@@ -222,17 +221,6 @@ 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
@@ -99,7 +99,7 @@ func handlerCmd(
 func applyCmdToHandler(model models.EventHandler, cmd Command) models.EventHandler {
 	// Remove keys
 	for _, elem := range cmd.Params.Strings(1) {
-		if !strings.HasPrefix(elem, "-") {
+		if elem[0] != '-' {
 			continue
 		}
 		keyToRemove := elem[1:]
@@ -128,10 +128,6 @@ func applyCmdToHandler(model models.EventHandler, cmd Command) models.EventHandl
 				model.From = models.Never
 			case "to":
 				model.To = models.Never
-			case "set-scene":
-				model.Actions.SetScene = nil
-			case "push-scene":
-				model.Actions.PushScene = nil
 			}
 		}
 	}
@@ -177,9 +173,5 @@ func applyCmdToHandler(model models.EventHandler, cmd Command) models.EventHandl
 		}
 	}

-	// Scenes
-	model.Actions.SetScene = cmd.Params.SceneAssignment("set-")
-	model.Actions.PushScene = cmd.Params.SceneAssignment("push-")
-
 	return model
 }
@@ -96,9 +96,6 @@ func main() {
 	case "handler":
 		handlerCmd(ctx, c)

-	case "scene":
-		sceneCmd(ctx, c)
-
 	// EVENT
 	case "run":
 		{
@@ -1,165 +0,0 @@
-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
-}
@@ -14,46 +14,26 @@ 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) {
-			if v.SceneState != nil && v.SceneState.Power != v.State.Power {
-				powerStr = strconv.FormatBool(v.SceneState.Power) + "*"
-			} else {
-				powerStr = strconv.FormatBool(v.State.Power)
-			}
+			powerStr = strconv.FormatBool(v.State.Power)
 		}

 		colorStr := ""
 		if v.HasCapability(models.DCColorHSK, models.DCColorHS, models.DCColorKelvin) {
-			if v.SceneState != nil && v.SceneState.Color.String() != v.State.Color.String() {
-				colorStr = v.SceneState.Color.String() + "*"
-			} else {
-				colorStr = v.State.Color.String()
-			}
+			colorStr = v.State.Color.String()
 		}

 		temperatureString := ""
 		if v.HasCapability(models.DCTemperatureControl, models.DCTemperatureSensor) {
-			temperatureString = fmt.Sprintf("%d", v.State.Temperature)
+			temperatureString = strconv.FormatFloat(v.State.Temperature, 'f', -1, 64)
 		}

 		intensityString := ""
 		if v.HasCapability(models.DCIntensity) {
-			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)
-			}
+			intensityString = strconv.FormatFloat(v.State.Intensity, 'f', -1, 64)
 		}

 		table.Append([]string{
@@ -124,17 +104,6 @@ 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 {
@@ -6,11 +6,10 @@ import (
 	"encoding/json"
 	"fmt"
 	"git.aiterp.net/lucifer/new-server/models"
+	"golang.org/x/sync/errgroup"
 	"io"
-	"log"
 	"net"
 	"net/http"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -98,17 +97,17 @@ func (b *Bridge) Refresh(ctx context.Context) error {

 func (b *Bridge) SyncStale(ctx context.Context) error {
 	indices := make([]int, 0, 4)
-	arrayIndices := make([]int, 0, 4)
 	inputs := make([]LightStateInput, 0, 4)

+	eg, ctx := errgroup.WithContext(ctx)
+
 	b.mu.Lock()
-	for i, state := range b.lightStates {
+	for _, state := range b.lightStates {
 		if !state.stale {
 			continue
 		}

 		indices = append(indices, state.index)
-		arrayIndices = append(arrayIndices, i)
 		inputs = append(inputs, state.input)
 	}
 	b.mu.Unlock()
@@ -117,85 +116,24 @@ func (b *Bridge) SyncStale(ctx context.Context) error {
 		return nil
 	}

-	groups := make([]*syncGroup, 0, 4)
-	for i := range inputs {
-		input := inputs[i]
+	for i, input := range inputs {
+		iCopy := i
+		index := indices[i]
+		inputCopy := input

-		found := false
-		for _, group := range groups {
-			if group.State.Equal(input) {
-				group.Indexes = append(group.Indexes, indices[i])
-				group.ArrayIndexes = append(group.ArrayIndexes, arrayIndices[i])
-				found = true
-			}
-		}
-		if !found {
-			groups = append(groups, &syncGroup{
-				GroupIndex:   -1,
-				State:        input,
-				Indexes:      []int{indices[i]},
-				ArrayIndexes: []int{arrayIndices[i]},
-			})
-		}
-	}
-
-	groupMap, err := b.getGroups(ctx)
-	if err != nil {
-		return err
-	}
-
-	for id, data := range groupMap {
-		for _, group := range groups {
-			if group.Matches(&data) {
-				group.GroupIndex = id
-				break
-			}
-		}
-	}
-
-	for _, group := range groups {
-		if group.GroupIndex == -1 {
-			data := GroupData{
-				Name:   "lucifer_auto_group",
-				Lights: []string{},
-			}
-
-			for _, idx := range group.Indexes {
-				data.Lights = append(data.Lights, strconv.Itoa(idx))
-			}
-
-			id, err := b.postGroup(ctx, data)
+		eg.Go(func() error {
+			err := b.putLightState(ctx, index, inputCopy)
 			if err != nil {
 				return err
 			}

-			group.GroupIndex = id
-		}
+			b.lightStates[iCopy].stale = false
+
+			return nil
+		})
 	}

-	log.Println("Updating", len(inputs), "lights on Hue bridge", b.externalID, "in", len(groups), "groups")
-
-	for _, group := range groups {
-		err := b.putGroupLightState(ctx, group.GroupIndex, group.State)
-		if err != nil {
-			return err
-		}
-
-		b.mu.Lock()
-		for _, arrayIndex := range group.ArrayIndexes {
-			b.lightStates[arrayIndex].stale = false
-		}
-		b.mu.Unlock()
-
-		if groupMap[group.GroupIndex].Name == "lucifer_auto_group" {
-			err := b.deleteGroup(ctx, group.GroupIndex)
-			if err != nil {
-				log.Println("Could not delete temporary group", err)
-			}
-		}
-	}
-
-	return nil
+	return eg.Wait()
 }

 func (b *Bridge) SyncSensors(ctx context.Context) ([]models.Event, error) {
@@ -232,10 +170,6 @@ 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)
@@ -273,34 +207,6 @@ 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
@@ -320,30 +226,6 @@ 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 {
@@ -3,14 +3,8 @@ 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"`
@@ -89,58 +83,6 @@ 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"`
@@ -250,36 +192,6 @@ 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")
@@ -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
@@ -1,7 +1,6 @@
 package hue

 import (
-	"encoding/json"
 	"git.aiterp.net/lucifer/new-server/models"
 	"strconv"
 	"time"
@@ -17,37 +16,12 @@ 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
 			}
@@ -93,13 +67,6 @@ 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 {
@@ -113,7 +80,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
 		}
 	}
@@ -155,9 +122,6 @@ 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
@@ -219,7 +183,6 @@ 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),
 					},
 				}
 			}
@@ -236,7 +199,6 @@ 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),
 				},
 			}
 		}
@@ -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 {
@@ -1,240 +0,0 @@
-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")
-}
@@ -1,100 +0,0 @@
-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
-}
@@ -1,77 +0,0 @@
-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
-}
@@ -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*220))
+						panel.update(newColor, time.Now().Add(time.Millisecond*120))
 					}
 				} else {
 					panel.update([4]byte{0, 0, 0, 0}, time.Now())
@@ -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
@@ -23,13 +23,12 @@ 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"`
-	Temperature int     `db:"temperature"`
+	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"`
 }

 type devicePropertyRecord struct {
@@ -228,16 +227,15 @@ 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, temperature)
-			VALUES (:device_id, :hue, :saturation, :kelvin, :power, :intensity, :temperature)
+			REPLACE INTO device_state(device_id, hue, saturation, kelvin, power, intensity) 
+			VALUES (:device_id, :hue, :saturation, :kelvin, :power, :intensity)
 		`, 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,
-				Temperature: device.State.Temperature,
+				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,
 			})
 			if err != nil {
 				return dbErr(err)
@@ -381,7 +379,6 @@ func (r *DeviceRepo) populate(ctx context.Context, records []deviceRecord) ([]mo
 						Kelvin:     state.Kelvin,
 					},
 					Intensity: state.Intensity,
-					Temperature: state.Temperature,
 				}
 			}
 		}
@@ -2,7 +2,6 @@ package mysql

 import (
 	"context"
-	"database/sql"
 	"encoding/json"
 	"git.aiterp.net/lucifer/new-server/models"
 	"github.com/jmoiron/sqlx"
@@ -33,10 +32,6 @@ 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)
 	}

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

 var ValidDriverKinds = []DriverKind{
@@ -26,11 +26,9 @@ func (c *ColorValue) String() string {
 		return fmt.Sprintf("k:%d", c.Kelvin)
 	}

-	return fmt.Sprintf("hs:%.4g,%.3g", c.Hue, c.Saturation)
+	return fmt.Sprintf("hs:%g,%g", c.Hue, c.Saturation)
 }

-
-
 func ParseColorValue(raw string) (ColorValue, error) {
 	tokens := strings.SplitN(raw, ":", 2)
 	if len(tokens) != 2 {
@@ -2,6 +2,7 @@ package models

 import (
 	"context"
+	"math"
 	"strings"
 	"time"
 )
@@ -17,7 +18,6 @@ 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 int        `json:"temperature"`
+	Temperature float64    `json:"temperature"`
 }

 type DeviceScene struct {
@@ -155,17 +155,6 @@ 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 {
@@ -208,6 +197,14 @@ 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
 }
@@ -10,7 +10,7 @@ type DriverProvider interface {
 }

 type Driver interface {
-	SearchBridge(ctx context.Context, address, token string, dryRun bool) ([]Bridge, error)
+	SearchBridge(ctx context.Context, address 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
@@ -15,7 +15,6 @@ 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")
@@ -24,6 +24,7 @@ var (
 	ENBridgeDisconnected    = "BridgeDisconnected"
 	ENButtonPressed         = "ButtonPressed"
 	ENSensorPresenceStarted = "SensorPresenceStarted"
+	ENSensorPresenceEnding  = "SensorPresenceEnding"
 	ENSensorPresenceEnded   = "SensorPresenceEnded"
 	ENSensorTemperature     = "SensorTemperature"
 )
@@ -5,7 +5,6 @@ import (
 	"regexp"
 	"strconv"
 	"strings"
-	"time"
 )

 type EventHandler struct {
@@ -168,17 +167,7 @@ func (c *EventCondition) checkDevice(key string, device Device) (matches bool, s
 			return false, true
 		}

-		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
+		return c.matches(strconv.FormatFloat(device.State.Temperature, 'f', -1, 64)), false
 	default:
 		return false, true
 	}
@@ -225,14 +214,12 @@ 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"`
-	SetScene       *DeviceSceneAssignment `json:"setScene"`
-	PushScene      *DeviceSceneAssignment `json:"pushScene"`
+	SetPower       *bool    `json:"setPower"`
+	SetColor       *string  `json:"setColor"`
+	SetIntensity   *float64 `json:"setIntensity"`
+	SetTemperature *int     `json:"setTemperature"`
+	AddIntensity   *float64 `json:"addIntensity"`
+	FireEvent      *Event   `json:"fireEvent"`
 }

 func (action *EventAction) Apply(other EventAction) {
@@ -251,12 +238,6 @@ 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 {
@@ -56,43 +56,29 @@ func (s *Scene) RoleIndex(device *Device) int {
 type SceneEffect string

 const (
-	SEStatic          SceneEffect = "Static"
+	SEStatic          SceneEffect = "Plain"
 	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"`
-	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"`
+	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"`
 }

 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 {
@@ -128,13 +114,13 @@ func (r *SceneRole) Validate() error {
 	}

 	switch r.PowerMode {
-	case SPScene, SPDevice, SPBoth:
+	case SPScene, SPDevice:
 	default:
 		return ErrSceneRoleUnknownPowerMode
 	}

 	switch r.Effect {
-	case SEStatic, SERandom, SEGradient, SEWalkingGradient, SETransition, SEMotion, SETemperature:
+	case SEStatic, SERandom, SEGradient, SETransition:
 	default:
 		return ErrSceneRoleUnknownEffect
 	}
@@ -192,53 +178,6 @@ 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 {
@@ -250,11 +189,6 @@ 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
@@ -267,6 +201,8 @@ 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)
@@ -292,7 +228,6 @@ 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
@@ -1,63 +0,0 @@
-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
@@ -1,26 +0,0 @@
-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
@@ -1,57 +0,0 @@
-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
@@ -1,40 +0,0 @@
-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
-
@@ -1,42 +0,0 @@
-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
-
@@ -1,11 +0,0 @@
-- +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
Author	SHA1	Message	Date
gisle	07173e4e56	Merge branch 'asmodeus' into feature-scenesystem continuous-integration/drone/push Build is passing Details	2021-10-04 20:14:16 +02:00
gisle	7b0028ee2b	new scene system is kind of working. I haven't tested changing between scenes and Transition effect yet, though. continuous-integration/drone/push Build is passing Details	2021-10-04 20:13:57 +02:00
gisle	d23a7327ef	Merge branch 'asmodeus' into feature-scenesystem continuous-integration/drone/push Build is failing Details	2021-10-03 18:42:33 +02:00
gisle	a3695a3ddd	some more work. continuous-integration/drone/push Build is failing Details	2021-09-28 21:57:28 +02:00
gisle	ffa757f742	rewrite of publishing mechanism to make scenes first-class. continuous-integration/drone/push Build is failing Details	2021-09-26 22:15:49 +02:00
gisle	f87c69efc7	this does not work, it needs massive changes. continuous-integration/drone/push Build is passing Details	2021-09-26 16:20:02 +02:00
gisle	b4fd6df454	Merge branch 'asmodeus' into feature-scenesystem continuous-integration/drone/push Build is failing Details	2021-09-26 10:51:28 +02:00
gisle	44716c84d1	scene system so far. continuous-integration/drone/push Build is failing Details	2021-09-25 19:04:54 +02:00