Matterbridge is optional and can appear many times

config.go

@@ -25,16 +25,25 @@ type SatelChangeType struct {
 	changeType satel.ChangeType
 }
 
+type MatterbridgeConfig struct {
+	URI     string `yaml:"uri"`
+	Token   string `yaml:"token"`
+	Gateway string `yaml:"gateway"`
+	/// Username from which the messages will appear
+	Username string `yaml:"username"`
+}
+
 type AppConfig struct {
-	SatelAddr          string            `yaml:"satel-addr"`
+	SatelAddr          string               `yaml:"satel-addr"`
-	ChatIds            []int64           `yaml:"tg-chat-ids"`
+	ChatIds            []int64              `yaml:"tg-chat-ids"`
-	AllowedTypes       []SatelChangeType `yaml:"allowed-types"`
+	AllowedTypes       []SatelChangeType    `yaml:"allowed-types"`
-	AllowedIndexes     []int             `yaml:"allowed-indexes"`
+	AllowedIndexes     []int                `yaml:"allowed-indexes"`
-	PoolInterval       OwnDuration       `yaml:"pool-interval"`
+	PoolInterval       OwnDuration          `yaml:"pool-interval"`
-	ArmCallbackUrls    []string          `yaml:"arm-callback-urls"`
+	ArmCallbackUrls    []string             `yaml:"arm-callback-urls"`
-	DisarmCallbackUrls []string          `yaml:"disarm-callback-urls"`
+	DisarmCallbackUrls []string             `yaml:"disarm-callback-urls"`
-	AlarmCallbackUrls  []string          `yaml:"alarm-callback-urls"`
+	AlarmCallbackUrls  []string             `yaml:"alarm-callback-urls"`
-	WriteMemoryProfile bool              `yaml:"write-memory-profile"`
+	WriteMemoryProfile bool                 `yaml:"write-memory-profile"`
+	Matterbridge       []MatterbridgeConfig `yaml:"matterbridge"`
 }
 
 func (m *SatelChangeType) UnmarshalYAML(unmarshal func(interface{}) error) error {

config_test.go

@@ -32,6 +32,15 @@ disarm-callback-urls:
 alarm-callback-urls:
  - "test alarm callback url"
  - "second test alarm callback url"
+matterbridge:
+ - uri: test_uri_1
+   token: test_token_1
+   gateway: test_gateway_1
+   username: test_username_1
+ - uri: test_uri_2
+   token: test_token_2
+   gateway: test_gateway_2
+   username: test_username_2
 `
 
 func TestParseYamlConfig(t *testing.T) {
@@ -47,4 +56,13 @@ func TestParseYamlConfig(t *testing.T) {
 	a.ElementsMatch([]string{"test arm callback url", "second test arm callback url"}, actualConfig.ArmCallbackUrls)
 	a.ElementsMatch([]string{"test disarm callback url", "second test disarm callback url"}, actualConfig.DisarmCallbackUrls)
 	a.ElementsMatch([]string{"test alarm callback url", "second test alarm callback url"}, actualConfig.AlarmCallbackUrls)
+
+	a.Equal(actualConfig.Matterbridge[0].URI, "test_uri_1")
+	a.Equal(actualConfig.Matterbridge[0].Token, "test_token_1")
+	a.Equal(actualConfig.Matterbridge[0].Gateway, "test_gateway_1")
+	a.Equal(actualConfig.Matterbridge[0].Username, "test_username_1")
+	a.Equal(actualConfig.Matterbridge[1].URI, "test_uri_2")
+	a.Equal(actualConfig.Matterbridge[1].Token, "test_token_2")
+	a.Equal(actualConfig.Matterbridge[1].Gateway, "test_gateway_2")
+	a.Equal(actualConfig.Matterbridge[1].Username, "test_username_2")
 }

main.go

@@ -69,14 +69,17 @@ func main() {
 
 	tgSender := TgSender{bot, s, log.New(os.Stderr, "TgFormatter", log.Lmicroseconds), config.ChatIds}
 
-	tpl := template.Must(template.New("TelegramMessage").Parse(TelegramMessageTemplate))
+	tgTpl := template.Must(template.New("TelegramMessage").Parse(TelegramMessageTemplate))
+	ircTpl := template.Must(template.New("IRCMessage").Parse(IRCMessageTemplate))
 
 	dataStore := MakeDataStore(log.New(os.Stderr, "DataStore", log.Lmicroseconds), getPersistenceFilePath())
 
 	Consume(
-		SendToTg(Throttle(NotifyViaHTTP(tgEvents, config, &wg, log.New(os.Stderr, "HTTPNotify", log.Lmicroseconds)),
+		SendToMatterbridge(
-			&wg, sleeper, log.New(os.Stderr, "MessageThrottle", log.Lmicroseconds)),
+			SendToTg(Throttle(NotifyViaHTTP(tgEvents, config, &wg, log.New(os.Stderr, "HTTPNotify", log.Lmicroseconds)),
-			tgSender, &wg, log.New(os.Stderr, "SendToTg", log.Lmicroseconds), tpl),
+				&wg, sleeper, log.New(os.Stderr, "MessageThrottle", log.Lmicroseconds)),
+				tgSender, &wg, log.New(os.Stderr, "SendToTg", log.Lmicroseconds), tgTpl),
+			s, config, &wg, log.New(os.Stderr, "SendToMatterbridge", log.Lmicroseconds), ircTpl),
 	)
 
 	go CloseSatelOnCtrlC(s, &cleanShutdown)

sender_worker.go

@@ -1,6 +1,9 @@
 package main
 
 import (
+	"bytes"
+	"encoding/json"
+	"fmt"
 	"html/template"
 	"log"
 	"net/http"
@@ -106,3 +109,42 @@ func NotifyViaHTTP(events <-chan GenericMessage, config AppConfig, wg *sync.Wait
 
 	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
+			for _, matterbridgeConfig := range config.Matterbridge {
+				body, err := json.Marshal(MatterbridgeMessage{
+					Text:     e.Format(tpl, s, logger),
+					Username: matterbridgeConfig.Username,
+					Gateway:  matterbridgeConfig.Gateway,
+				})
+				if err != nil {
+					logger.Fatal("Could not marshal a JSON message: ", err)
+				}
+				req, err := http.NewRequest(http.MethodPost, matterbridgeConfig.URI, bytes.NewBuffer(body))
+				req.Header["Authorization"] = []string{fmt.Sprint("Bearer ", matterbridgeConfig.Token)}
+				res, err := http.DefaultClient.Do(req)
+				if err != nil {
+					logger.Print("Could not POST ", matterbridgeConfig.URI, ": ", err)
+					return
+				}
+				logger.Print("Notified via Matterbridge with result ", res.StatusCode)
+			}
+		}
+		close(returnEvents)
+	}()
+
+	return returnEvents
+}

templates.go

@@ -5,3 +5,7 @@ const TelegramMessageTemplate = `{{- range .Messages}}
 {{- else -}}
 Huh, no messages - this is a bug
 {{- end}}`
+
+const IRCMessageTemplate = `{{- range .Messages}} {{.GetName}}: {{.FormatEvent}}; {{- else -}}
+Huh, no messages - this is a bug
+{{- end}}`

templates_test.go

@@ -53,3 +53,17 @@ func TestTelegramTemplate(t *testing.T) {
 
 	// assert.Equal(t, "siemka", mockSender.message)
 }
+
+func TestIRCTemplate(t *testing.T) {
+	testEvents := make(chan GenericMessage)
+	wg := sync.WaitGroup{}
+	mockSender := MockTemplateSender{s: MockSatelNameGetter{"mockPart"}}
+	tpl, err := template.New("TestIRCTemplate").Parse(IRCMessageTemplate)
+	assert.NoError(t, err)
+	Consume(SendToTg(testEvents, &mockSender, &wg, log.New(io.Discard, "", log.Ltime), tpl))
+	testEvents <- GenericMessage{[]satel.BasicEventElement{tplMessageTest1, tplMessageTest2}}
+	close(testEvents)
+	wg.Wait()
+
+	// assert.Equal(t, "siemka", mockSender.message)
+}