From 5e2d6cb092d91c7682658056c4c0345295311faa Mon Sep 17 00:00:00 2001 From: Sam Lewis Date: Wed, 26 Oct 2022 23:05:14 -0400 Subject: [PATCH] export strucs --- app.go | 18 ++++++++-------- entitylistener.go | 38 ++++++++++++++++----------------- eventListener.go | 32 ++++++++++++++-------------- schedule.go | 54 +++++++++++++++++------------------------------ 4 files changed, 63 insertions(+), 79 deletions(-) diff --git a/app.go b/app.go index ec56622..dadce47 100644 --- a/app.go +++ b/app.go @@ -25,9 +25,9 @@ type app struct { state *State schedules pq.PriorityQueue - entityListeners map[string][]*entityListener + entityListeners map[string][]*EntityListener entityListenersId int64 - eventListeners map[string][]*eventListener + eventListeners map[string][]*EventListener } type TimeString string @@ -53,8 +53,8 @@ func NewApp(connString string) *app { service: service, state: state, schedules: pq.New(), - entityListeners: map[string][]*entityListener{}, - eventListeners: map[string][]*eventListener{}, + entityListeners: map[string][]*EntityListener{}, + eventListeners: map[string][]*EventListener{}, } } @@ -64,7 +64,7 @@ func (a *app) Cleanup() { } } -func (a *app) RegisterSchedule(s schedule) { +func (a *app) RegisterSchedule(s Schedule) { // realStartTime already set for sunset/sunrise if s.isSunrise || s.isSunset { a.schedules.Insert(s, float64(s.realStartTime.Unix())) @@ -91,23 +91,23 @@ func (a *app) RegisterSchedule(s schedule) { a.schedules.Insert(s, float64(startTime.Unix())) } -func (a *app) RegisterEntityListener(etl entityListener) { +func (a *app) RegisterEntityListener(etl EntityListener) { for _, entity := range etl.entityIds { if elList, ok := a.entityListeners[entity]; ok { a.entityListeners[entity] = append(elList, &etl) } else { - a.entityListeners[entity] = []*entityListener{&etl} + a.entityListeners[entity] = []*EntityListener{&etl} } } } -func (a *app) RegisterEventListener(evl eventListener) { +func (a *app) RegisterEventListener(evl EventListener) { for _, eventType := range evl.eventTypes { if elList, ok := a.eventListeners[eventType]; ok { a.eventListeners[eventType] = append(elList, &evl) } else { ws.SubscribeToEventType(eventType, a.conn, a.ctx) - a.eventListeners[eventType] = []*eventListener{&evl} + a.eventListeners[eventType] = []*EventListener{&evl} } } } diff --git a/entitylistener.go b/entitylistener.go index c742589..b621389 100644 --- a/entitylistener.go +++ b/entitylistener.go @@ -8,9 +8,9 @@ import ( "github.com/golang-module/carbon" ) -type entityListener struct { +type EntityListener struct { entityIds []string - callback entityListenerCallback + callback EntityListenerCallback fromState string toState string betweenStart string @@ -19,7 +19,7 @@ type entityListener struct { lastRan carbon.Carbon } -type entityListenerCallback func(*Service, EntityData) +type EntityListenerCallback func(*Service, EntityData) type EntityData struct { TriggerEntityId string @@ -54,60 +54,60 @@ type msgState struct { /* Methods */ func EntityListenerBuilder() elBuilder1 { - return elBuilder1{entityListener{ + return elBuilder1{EntityListener{ lastRan: carbon.Now().StartOfCentury(), }} } type elBuilder1 struct { - entityListener + EntityListener } func (b elBuilder1) EntityIds(entityIds ...string) elBuilder2 { if len(entityIds) == 0 { log.Fatalln("must pass at least one entityId to EntityIds()") } else { - b.entityListener.entityIds = entityIds + b.EntityListener.entityIds = entityIds } return elBuilder2(b) } type elBuilder2 struct { - entityListener + EntityListener } -func (b elBuilder2) Call(callback entityListenerCallback) elBuilder3 { - b.entityListener.callback = callback +func (b elBuilder2) Call(callback EntityListenerCallback) elBuilder3 { + b.EntityListener.callback = callback return elBuilder3(b) } type elBuilder3 struct { - entityListener + EntityListener } func (b elBuilder3) OnlyBetween(start string, end string) elBuilder3 { - b.entityListener.betweenStart = start - b.entityListener.betweenEnd = end + b.EntityListener.betweenStart = start + b.EntityListener.betweenEnd = end return b } func (b elBuilder3) OnlyAfter(start string) elBuilder3 { - b.entityListener.betweenStart = start + b.EntityListener.betweenStart = start return b } func (b elBuilder3) OnlyBefore(end string) elBuilder3 { - b.entityListener.betweenEnd = end + b.EntityListener.betweenEnd = end return b } func (b elBuilder3) FromState(s string) elBuilder3 { - b.entityListener.fromState = s + b.EntityListener.fromState = s return b } func (b elBuilder3) ToState(s string) elBuilder3 { - b.entityListener.toState = s + b.EntityListener.toState = s return b } @@ -116,12 +116,12 @@ func (b elBuilder3) Throttle(s TimeString) elBuilder3 { if err != nil { log.Fatalf("Couldn't parse string duration passed to Throttle(): \"%s\" see https://pkg.go.dev/time#ParseDuration for valid time units", s) } - b.entityListener.throttle = d + b.EntityListener.throttle = d return b } -func (b elBuilder3) Build() entityListener { - return b.entityListener +func (b elBuilder3) Build() EntityListener { + return b.EntityListener } /* Functions */ diff --git a/eventListener.go b/eventListener.go index deaeb42..6af9a7a 100644 --- a/eventListener.go +++ b/eventListener.go @@ -9,16 +9,16 @@ import ( ws "github.com/saml-dev/gome-assistant/internal/websocket" ) -type eventListener struct { +type EventListener struct { eventTypes []string - callback eventListenerCallback + callback EventListenerCallback betweenStart string betweenEnd string throttle time.Duration lastRan carbon.Carbon } -type eventListenerCallback func(*Service, EventData) +type EventListenerCallback func(*Service, EventData) type EventData struct { Type string @@ -28,13 +28,13 @@ type EventData struct { /* Methods */ func EventListenerBuilder() eventListenerBuilder1 { - return eventListenerBuilder1{eventListener{ + return eventListenerBuilder1{EventListener{ lastRan: carbon.Now().StartOfCentury(), }} } type eventListenerBuilder1 struct { - eventListener + EventListener } func (b eventListenerBuilder1) EventTypes(ets ...string) eventListenerBuilder2 { @@ -43,31 +43,31 @@ func (b eventListenerBuilder1) EventTypes(ets ...string) eventListenerBuilder2 { } type eventListenerBuilder2 struct { - eventListener + EventListener } -func (b eventListenerBuilder2) Call(callback eventListenerCallback) eventListenerBuilder3 { - b.eventListener.callback = callback +func (b eventListenerBuilder2) Call(callback EventListenerCallback) eventListenerBuilder3 { + b.EventListener.callback = callback return eventListenerBuilder3(b) } type eventListenerBuilder3 struct { - eventListener + EventListener } func (b eventListenerBuilder3) OnlyBetween(start string, end string) eventListenerBuilder3 { - b.eventListener.betweenStart = start - b.eventListener.betweenEnd = end + b.EventListener.betweenStart = start + b.EventListener.betweenEnd = end return b } func (b eventListenerBuilder3) OnlyAfter(start string) eventListenerBuilder3 { - b.eventListener.betweenStart = start + b.EventListener.betweenStart = start return b } func (b eventListenerBuilder3) OnlyBefore(end string) eventListenerBuilder3 { - b.eventListener.betweenEnd = end + b.EventListener.betweenEnd = end return b } @@ -76,12 +76,12 @@ func (b eventListenerBuilder3) Throttle(s TimeString) eventListenerBuilder3 { if err != nil { log.Fatalf("Couldn't parse string duration passed to Throttle(): \"%s\" see https://pkg.go.dev/time#ParseDuration for valid time units", s) } - b.eventListener.throttle = d + b.EventListener.throttle = d return b } -func (b eventListenerBuilder3) Build() eventListener { - return b.eventListener +func (b eventListenerBuilder3) Build() EventListener { + return b.EventListener } type BaseEventMsg struct { diff --git a/schedule.go b/schedule.go index aded6b4..c375cdf 100644 --- a/schedule.go +++ b/schedule.go @@ -10,27 +10,11 @@ import ( "github.com/saml-dev/gome-assistant/internal" ) -type scheduleCallback func(*Service, *State) +type ScheduleCallback func(*Service, *State) -type schedule struct { - /* - frequency is a time.Duration representing how often you want to run your function. - - Some examples: - time.Second * 5 // runs every 5 seconds at 00:00:00, 00:00:05, etc. - time.Hour * 12 // runs at offset, +12 hours, +24 hours, etc. - gomeassistant.Daily // runs at offset, +24 hours, +48 hours, etc. Daily is a const helper for time.Hour * 24 - // Helpers include Daily, Hourly, Minutely - */ - frequency time.Duration - callback scheduleCallback - /* - offset is the base that your frequency will be added to. - Defaults to 0 (which is probably fine for most cases). - - Example: Run in the 3rd minute of every hour. - ScheduleBuilder().Call(myFunc).Every("1h").Offset("3m") - */ +type Schedule struct { + frequency time.Duration + callback ScheduleCallback offset time.Duration realStartTime time.Time @@ -39,40 +23,40 @@ type schedule struct { sunOffset TimeString } -func (s schedule) Hash() string { +func (s Schedule) Hash() string { return fmt.Sprint(s.offset, s.frequency, s.callback) } type scheduleBuilder struct { - schedule schedule + schedule Schedule } type scheduleBuilderCall struct { - schedule schedule + schedule Schedule } type scheduleBuilderDaily struct { - schedule schedule + schedule Schedule } type scheduleBuilderCustom struct { - schedule schedule + schedule Schedule } type scheduleBuilderEnd struct { - schedule schedule + schedule Schedule } func ScheduleBuilder() scheduleBuilder { return scheduleBuilder{ - schedule{ + Schedule{ frequency: 0, offset: 0, }, } } -func (s schedule) String() string { +func (s Schedule) String() string { return fmt.Sprintf("Schedule{ call %q %s %s }", getFunctionName(s.callback), frequencyToString(s.frequency), @@ -80,7 +64,7 @@ func (s schedule) String() string { ) } -func offsetToString(s schedule) string { +func offsetToString(s Schedule) string { if s.frequency.Hours() == 24 { return fmt.Sprintf("%02d:%02d", int(s.offset.Hours()), int(s.offset.Minutes())%60) } @@ -94,7 +78,7 @@ func frequencyToString(d time.Duration) string { return "every " + d.String() + " with offset" } -func (sb scheduleBuilder) Call(callback scheduleCallback) scheduleBuilderCall { +func (sb scheduleBuilder) Call(callback ScheduleCallback) scheduleBuilderCall { sb.schedule.callback = callback return scheduleBuilderCall(sb) } @@ -147,11 +131,11 @@ func (sb scheduleBuilderCustom) Offset(s TimeString) scheduleBuilderEnd { return scheduleBuilderEnd(sb) } -func (sb scheduleBuilderCustom) Build() schedule { +func (sb scheduleBuilderCustom) Build() Schedule { return sb.schedule } -func (sb scheduleBuilderEnd) Build() schedule { +func (sb scheduleBuilderEnd) Build() Schedule { return sb.schedule } @@ -183,12 +167,12 @@ func runSchedules(a *app) { } } -func popSchedule(a *app) schedule { +func popSchedule(a *app) Schedule { _sched, _ := a.schedules.Pop() - return _sched.(schedule) + return _sched.(Schedule) } -func requeueSchedule(a *app, s schedule) { +func requeueSchedule(a *app, s Schedule) { if s.isSunrise || s.isSunset { nextSunTime := getSunriseSunset(a, s.isSunrise, []TimeString{s.sunOffset})