Merge branch 'asmodeus' into feature-scenesystem

2021-10-03 18:42:33 +02:00
parent a3695a3ddd ade49589a9
commit d23a7327ef
18 changed files with 514 additions and 77 deletions
@@ -16,6 +16,8 @@ type EventHandler struct {
 	TargetKind  ReferenceKind             `json:"targetKind"`
 	TargetValue string                    `json:"targetValue"`
 	Actions     EventAction               `json:"actions"`
+	From        TimeOfDay                 `json:"from"`
+	To          TimeOfDay                 `json:"to"`
 }

 type EventHandlerRepository interface {
@@ -42,6 +44,8 @@ type EventHandlerUpdate struct {
 	SetConditions   map[string]EventCondition  `json:"setConditions"`
 	PatchConditions map[string]*EventCondition `json:"patchConditions"`
 	SetActions      *EventAction               `json:"setActions"`
+	SetFrom         *TimeOfDay                 `json:"setFrom"`
+	SetTo           *TimeOfDay                 `json:"setTo"`
 }

 func (h *EventHandler) ApplyUpdate(update EventHandlerUpdate) {
@@ -63,6 +67,12 @@ func (h *EventHandler) ApplyUpdate(update EventHandlerUpdate) {
 	if update.SetOneShot != nil {
 		h.OneShot = *update.SetOneShot
 	}
+	if update.SetFrom != nil {
+		h.From = *update.SetFrom
+	}
+	if update.SetFrom != nil {
+		h.To = *update.SetFrom
+	}

 	if update.SetConditions != nil {
 		h.Conditions = update.SetConditions
@@ -100,6 +110,14 @@ func (h *EventHandler) MatchesEvent(event Event, targets []Device) bool {
 	return true
 }

+func (h *EventHandler) IsWithinTimeRange() bool {
+	if h.From.IsNever() || h.To.IsNever() {
+		return true
+	}
+
+	return CurrentTimeOfDay().IsBetween(h.From, h.To)
+}
+
 func (c *EventCondition) check(key, value string, targets []Device) bool {
 	any := strings.HasPrefix(key, "any.")
 	all := strings.HasPrefix(key, "all.")
@@ -155,11 +173,11 @@ func (c *EventCondition) checkDevice(key string, device Device) (matches bool, s
 	}
 }

-var numRegex = regexp.MustCompile("^{-[0-9].}+$")
+var numRegex = regexp.MustCompile("^-*[0-9]+(.[0-9]+)*$")

 func (c *EventCondition) matches(value string) bool {
 	if numRegex.MatchString(value) {
-		numValue, _ := strconv.ParseFloat(c.LT, 64)
+		numValue, _ := strconv.ParseFloat(value, 64)
 		stillAlive := true

 		if c.LT != "" {
@@ -179,7 +197,7 @@ func (c *EventCondition) matches(value string) bool {

 		if stillAlive && c.GTE != "" {
 			gte, _ := strconv.ParseFloat(c.GTE, 64)
-			stillAlive = numValue == gte
+			stillAlive = numValue >= gte
 		}

 		if stillAlive && c.GT != "" {
@@ -196,11 +214,12 @@ func (c *EventCondition) matches(value string) bool {
 }

 type EventAction struct {
-	SetPower     *bool    `json:"setPower"`
-	SetColor     *string  `json:"setColor"`
-	SetIntensity *float64 `json:"setIntensity"`
-	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"`
 }

 func (action *EventAction) Apply(other EventAction) {
@@ -224,19 +243,19 @@ func (action *EventAction) Apply(other EventAction) {
 func (c EventCondition) String() string {
 	str := make([]string, 0, 5)
 	if len(c.LT) > 0 {
-		str = append(str, "lt:" + c.LT)
+		str = append(str, "lt:"+c.LT)
 	}
 	if len(c.LTE) > 0 {
-		str = append(str, "lte:" + c.LTE)
+		str = append(str, "lte:"+c.LTE)
 	}
 	if len(c.EQ) > 0 {
 		str = append(str, c.EQ)
 	}
 	if len(c.GTE) > 0 {
-		str = append(str, "gte:" + c.GTE)
+		str = append(str, "gte:"+c.GTE)
 	}
 	if len(c.GT) > 0 {
-		str = append(str, "gte:" + c.GT)
+		str = append(str, "gte:"+c.GT)
 	}

 	return strings.Join(str, ";")
@@ -64,3 +64,24 @@ func (rk ReferenceKind) Matches(device *Device, value string) bool {

 	return false
 }
+
+func ParseFetchString(fetchStr string) (ReferenceKind, string) {
+	if strings.HasPrefix(fetchStr, "tag:") {
+		return RKTag, fetchStr[4:]
+	} else if strings.HasPrefix(fetchStr, "bridge:") {
+		return RKBridgeID, fetchStr[7:]
+	} else if strings.HasPrefix(fetchStr, "id:") {
+		return RKDeviceID, fetchStr[7:]
+	} else if strings.HasPrefix(fetchStr, "name:") {
+		return RKName, fetchStr[7:]
+	} else if fetchStr == "all" {
+		return RKAll, ""
+	} else {
+		_, err := strconv.Atoi(fetchStr)
+		if err != nil {
+			return RKName, fetchStr
+		}
+
+		return RKDeviceID, fetchStr
+	}
+}
@@ -0,0 +1,138 @@
+package models
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strconv"
+	"strings"
+	"time"
+)
+
+type TimeOfDay int
+
+func (t *TimeOfDay) UnmarshalJSON(v []byte) error {
+	if bytes.Equal(v, []byte("null")) {
+		*t = -1
+	}
+
+	var str string
+	err := json.Unmarshal(v, &str)
+	if err != nil {
+		var n int
+		err = json.Unmarshal(v, &n)
+		if err != nil {
+			return err
+		}
+		if n < -1 && n >= 86400 {
+			return fmt.Errorf("value outside range 0..86400: %d", n)
+		}
+	}
+
+
+	t2, err := ParseTimeOfDay(str)
+	if err != nil {
+		return err
+	}
+
+	*t = t2
+
+	return nil
+}
+
+func (t TimeOfDay) MarshalJSON() ([]byte, error) {
+	if t.IsNever() {
+		return []byte("null"), nil
+	}
+
+	return json.Marshal(t.String())
+}
+
+const Never = TimeOfDay(-1)
+
+func (t *TimeOfDay) String() string {
+	if *t < 0 {
+		return "n/a"
+	}
+
+	return fmt.Sprintf("%02d:%02d:%02d", *t/3600, (*t/60)%60, *t%60)
+}
+
+func (t *TimeOfDay) StringPtr() *string {
+	if *t < 0 {
+		return nil
+	}
+
+	s := t.String()
+	return &s
+}
+
+func (t TimeOfDay) IsNever() bool {
+	return t == Never
+}
+
+func (t TimeOfDay) IsBetween(from TimeOfDay, to TimeOfDay) bool {
+	if from == to {
+		return t == from
+	} else if from > to {
+		return t >= from || t <= to
+	} else {
+		return t >= from && t <= to
+	}
+}
+
+func CurrentTimeOfDay() TimeOfDay {
+	return TimeOfDayFromDate(time.Now().Local())
+}
+
+func TimeOfDayFromDate(date time.Time) TimeOfDay {
+	return NewTimeOfDay(date.Hour(), date.Minute(), date.Second())
+}
+
+func NewTimeOfDay(hours, minutes, seconds int) TimeOfDay {
+	return TimeOfDay(((hours % 24) * 3600) + ((minutes % 60) * 60) + seconds)
+}
+
+func ParseTimeOfDayPtr(str *string) (TimeOfDay, error) {
+	if str == nil {
+		return Never, nil
+	}
+
+	return ParseTimeOfDay(*str)
+}
+
+func ParseTimeOfDay(str string) (TimeOfDay, error) {
+	if str == "" || str == "n/a" || str == "N/A" {
+		return -1, nil
+	}
+
+	split := strings.SplitN(str, ":", 4)
+	res := 0
+
+	n, err := strconv.Atoi(split[0])
+	if err != nil {
+		return Never, err
+	}
+	res += n * 3600
+
+	if len(split) >= 2 {
+		n, err := strconv.Atoi(split[1])
+		if err != nil {
+			return Never, err
+		}
+		res += n * 60
+	}
+	if len(split) >= 3 {
+		n, err := strconv.Atoi(split[2])
+		if err != nil {
+			return Never, err
+		}
+		res += n
+	}
+
+	if res >= 86400 || res < 0 {
+		return Never, fmt.Errorf("invalid time of day string %s (=%d)", str, res)
+	}
+
+	return TimeOfDay(res), nil
+}
@@ -0,0 +1,42 @@
+package models
+
+import (
+	"fmt"
+	"testing"
+)
+
+func tod(s string) TimeOfDay {
+	tod, err := ParseTimeOfDay(s)
+	if err != nil {
+		panic(err)
+	}
+
+	return tod
+}
+
+func TestTimeOfDay_IsBetween(t *testing.T) {
+	table := []struct{
+		Value TimeOfDay
+		From TimeOfDay
+		To TimeOfDay
+		Expected bool
+	}{
+		{ tod("16:13:11"), tod("07"), tod("21:30"), true },
+		{ tod("16:13:31"), tod("21:30"), tod("07"), false },
+		{ tod("23:15:32"), tod("21:30"), tod("07"), true },
+		{ tod("04:13:57"), tod("21:30"), tod("07"), true },
+		{ tod("16:14:43"), tod("15:30"), tod("16:00"), false },
+		{ tod("16:14:43"), tod("15:30"), tod("16:15"), true },
+		{ tod("08:45:43"), tod("07:00:00"), tod("21:30:00"), true },
+		{ tod("07:00:00"), tod("07:00:00"), tod("21:30:00"), true },
+	}
+
+	for i, row := range table {
+		t.Run(fmt.Sprintf("row_%d", i), func (t *testing.T) {
+			if row.Value.IsBetween(row.From, row.To) != row.Expected {
+				t.Log(row.Value, row.From, row.To)
+				t.Fail()
+			}
+		})
+	}
+}