hswro-alarm-bot/sender_worker.go

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"html/template"
	"log"
	"net/http"
	"sync"

	"git.sr.ht/~michalr/go-satel"
)

const (
	NotificationPartitionIndex = 0
)

type Sender interface {
	Send(msg GenericMessage, tpl *template.Template) error
}

type Sleeper interface {
	Sleep(ch chan<- interface{})
}

func Consume(events <-chan GenericMessage) {
	go func() {
		for range events {
		}
	}()
}

func SendToTg(events <-chan GenericMessage, s Sender, wg *sync.WaitGroup, logger *log.Logger, tpl *template.Template) <-chan GenericMessage {
	returnEvents := make(chan GenericMessage)

	wg.Add(1)
	go func() {
		defer wg.Done()
		defer close(returnEvents)

		for e := range events {
			returnEvents <- e
			err := s.Send(e, tpl)
			if err != nil {
				// TODO: handle it better
				panic(err)
			}
		}
	}()

	return returnEvents
}

func doHttpNotification(url string, logger *log.Logger, wg *sync.WaitGroup) {
	wg.Add(1)
	defer wg.Done()

	if len(url) == 0 {
		return
	}
	req, err := http.NewRequest(http.MethodPost, url, nil)

	res, err := http.DefaultClient.Do(req)
	if err != nil {
		logger.Print("Could not POST ", url, ": ", err)
		return
	}
	logger.Print("Notified via HTTP with result ", res.StatusCode)
}

func notifyAllHttp(urls []string, logger *log.Logger, wg *sync.WaitGroup) {
	for _, uri := range urls {
		go doHttpNotification(uri, logger, wg)
	}
}

func NotifyViaHTTP(events <-chan GenericMessage, config AppConfig, wg *sync.WaitGroup, logger *log.Logger) <-chan GenericMessage {
	returnEvents := make(chan GenericMessage)

	wg.Add(1)
	go func() {
		defer wg.Done()
		defer close(returnEvents)

		for e := range events {
			returnEvents <- e
		inner_arm:
			for _, basicElement := range e.Messages {
				if (basicElement.Index == NotificationPartitionIndex) && (basicElement.Type == satel.ArmedPartition) {
					if basicElement.Value == ArmedPartition_Armed {
						notifyAllHttp(config.ArmCallbackUrls, logger, wg)
					} else {
						notifyAllHttp(config.DisarmCallbackUrls, logger, wg)
					}
					break inner_arm
				}
			}
		inner_alarm:
			for _, basicElement := range e.Messages {
				if basicElement.Type == satel.PartitionAlarm {
					if basicElement.Value == PartitionAlarm_Alarm {
						notifyAllHttp(config.AlarmCallbackUrls, logger, wg)
						break inner_alarm
					}
				}
			}

		}
	}()

	return returnEvents
}

type MatterbridgeMessage struct {
	Text     string `json:"text"`
	Username string `json:"username"`
	Gateway  string `json:"gateway"`
}

func SendToMatterbridge(events <-chan GenericMessage, s SatelNameGetter, config AppConfig, wg *sync.WaitGroup, logger *log.Logger, tpl *template.Template) <-chan GenericMessage {
	returnEvents := make(chan GenericMessage)

	go func() {
		wg.Add(1)
		defer wg.Done()
		for e := range events {
			returnEvents <- e
			body, err := json.Marshal(MatterbridgeMessage{
				Text:     e.Format(tpl, s, logger),
				Username: config.Matterbridge.Username,
				Gateway:  config.Matterbridge.Gateway,
			})
			if err != nil {
				logger.Fatal("Could not marshal a JSON message: ", err)
			}
			req, err := http.NewRequest(http.MethodPost, config.Matterbridge.URI, bytes.NewBuffer(body))
			req.Header["Authorization"] = []string{fmt.Sprint("Bearer ", config.Matterbridge.Token)}
			res, err := http.DefaultClient.Do(req)
			if err != nil {
				logger.Print("Could not POST ", config.Matterbridge.URI, ": ", err)
				return
			}
			logger.Print("Notified via Matterbridge with result ", res.StatusCode)
		}
		close(returnEvents)
	}()

	return returnEvents
}