export strucs

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{},
+		entityListeners: map[string][]*EntityListener{},
-		eventListeners:  map[string][]*eventListener{},
+		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}
 		}
 	}
 }

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 {
+func (b elBuilder2) Call(callback EntityListenerCallback) elBuilder3 {
-	b.entityListener.callback = callback
+	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.betweenStart = start
-	b.entityListener.betweenEnd = end
+	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 {
+func (b elBuilder3) Build() EntityListener {
-	return b.entityListener
+	return b.EntityListener
 }
 
 /* Functions */

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 {
+func (b eventListenerBuilder2) Call(callback EventListenerCallback) eventListenerBuilder3 {
-	b.eventListener.callback = callback
+	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.betweenStart = start
-	b.eventListener.betweenEnd = end
+	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 {
+func (b eventListenerBuilder3) Build() EventListener {
-	return b.eventListener
+	return b.EventListener
 }
 
 type BaseEventMsg struct {

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 {
+type Schedule struct {
-	/*
+	frequency     time.Duration
-		frequency is a time.Duration representing how often you want to run your function.
+	callback      ScheduleCallback
-
-		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")
-	*/
 	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})