show current state of lights.

Makefile

+# ----------------------------------------------------------------------------
+# "THE BEER-WARE LICENSE" (Revision 42):
+# <xythobuz@xythobuz.de> wrote this file.  As long as you retain this notice
+# you can do whatever you want with this stuff. If we meet some day, and you
+# think this stuff is worth it, you can buy me a beer in return.   Thomas Buck
+# ----------------------------------------------------------------------------
+
+HOST = iot
+
+# ----------------------------------------------------------------------------
+
+# https://tech.davis-hansson.com/p/make/
+
+SHELL := bash
+.ONESHELL:
+.SHELLFLAGS := -eu -o pipefail -c
+.DELETE_ON_ERROR:
+MAKEFLAGS += --warn-undefined-variables
+MAKEFLAGS += --no-builtin-rules
+
+# check for recent make
+ifeq ($(origin .RECIPEPREFIX), undefined)
+  $(error This Make does not support .RECIPEPREFIX. Please use GNU Make 4.0 or later)
+endif
+.RECIPEPREFIX = >
+
+# ----------------------------------------------------------------------------
+
+all: lights-telegram
+
+lights-telegram: lights-telegram.go
+> CGO_ENABLED=0 go build
+
+clean:
+> rm -rf lights-telegram
+
+upload: lights-telegram
+> ssh $(HOST) sudo systemctl stop lights-telegram
+> scp lights-telegram $(HOST):~/bin/lights-telegram/lights-telegram
+> sleep 1
+> ssh $(HOST) sudo systemctl start lights-telegram
+.PHONY: upload
+
+download:
+> scp $(HOST):~/bin/lights-telegram/config.yaml config.yaml
+.PHONY: download

README.md

     systemctl daemon-reload
     systemctl enable --now lights-telegram
 
+You can also look at the log output of the app.
+
+    journalctl -u lights-telegram -b -f
+
 ## Dependencies
 
  * [tgbotapi](https://pkg.go.dev/github.com/go-telegram-bot-api/telegram-bot-api/v5)

lights-telegram.go

     Name string `yaml:"name"`
     Topic string `yaml:"topic"`
     Values []string `yaml:"values"`
+    lastValue string
 }
 
 type Config struct {
     }
 }
 
-func sendKeyboardReply(name string, chat int64, message int) {
+func sendKeyboardReply(text string, name string, chat int64, message int) {
     var rows [][]tgbotapi.KeyboardButton
     for reg := range config.Registration {
         if name == config.Registration[reg].Name {
     }
     keyboard := tgbotapi.NewOneTimeReplyKeyboard(rows...)
 
-    msg := tgbotapi.NewMessage(chat, "Select option below...")
+    msg := tgbotapi.NewMessage(chat, text)
     msg.ReplyToMessageID = message
     msg.ReplyMarkup = keyboard
     _, err := bot.Send(msg)
 
     config.Registration = append(config.Registration, r)
     writeConfig()
+
+
+    token := mqttClient.Subscribe(topic, 0, onMessageReceived)
+    if token.Wait() && token.Error() != nil {
+        log.Printf("MQTT sub error: %v", token.Error())
+    }
+
     return nil
 }
 
 func unregister(name string) error {
     for reg := range config.Registration {
         if name == config.Registration[reg].Name {
+            token := mqttClient.Unsubscribe(config.Registration[reg].Topic)
+            if token.Wait() && token.Error() != nil {
+                log.Println("MQTT unsub error: %v", token.Error())
+            }
+
             config.Registration = remove(config.Registration, reg)
             writeConfig()
+
             return nil
         }
     }
     return "unknown"
 }
 
+func lastValueForCommand(name string) string {
+    ret := ""
+
+    for reg := range config.Registration {
+        if name == config.Registration[reg].Name {
+            if len(config.Registration[reg].lastValue) > 0 {
+                ret = "Current state: \""
+                ret += config.Registration[reg].lastValue
+                ret += "\"\n"
+            }
+            break
+        }
+    }
+
+    ret += "Select option below..."
+    return ret
+}
+
+func onMessageReceived(client mqtt.Client, message mqtt.Message) {
+    log.Printf("MQTT Rx: %s @ %s", message.Payload(), message.Topic())
+
+    for reg := range config.Registration {
+        if config.Registration[reg].Topic == message.Topic() {
+            config.Registration[reg].lastValue = string(message.Payload()[:])
+        }
+    }
+}
+
 func main() {
     err := readConfig()
     if err != nil {
     opts.SetPassword(config.Mqtt.Pass)
 
     mqttClient = mqtt.NewClient(opts)
-    if token := mqttClient.Connect(); token.Wait() && token.Error() != nil {
+    token := mqttClient.Connect();
+    if token.Wait() && token.Error() != nil {
         log.Printf("MQTT error: %v", token.Error())
         os.Exit(1)
     }
 
+    // Subscribe to registered topics
+    for reg := range config.Registration {
+        token := mqttClient.Subscribe(config.Registration[reg].Topic, 0, onMessageReceived)
+        if token.Wait() && token.Error() != nil {
+            log.Printf("MQTT sub error: %v", token.Error())
+        }
+    }
+
     // Initialize Telegram
     bot, err = tgbotapi.NewBotAPI(config.Key)
     if err != nil {
                                 reply = fmt.Sprintf("Error authorizing ID! %v", err)
                             } else {
                                 reply = fmt.Sprintf("Ok, authorized %d.", id)
+
+                                // also notify user
+                                text := "You have now been authorized by the admin. Try /help for commands."
+                                sendMessage(text, id)
                             }
                         }
                     } else {
                         }
                     } else if isRegisteredCommand(update.Message.Text[1:]) {
                         reply = ""
-                        sendKeyboardReply(update.Message.Text[1:], update.Message.Chat.ID, update.Message.MessageID)
+                        text := lastValueForCommand(update.Message.Text[1:])
+                        sendKeyboardReply(text, update.Message.Text[1:], update.Message.Chat.ID, update.Message.MessageID)
                     }
             }
         } else {
-            log.Printf("Message from unauthorized user. %s %d", update.Message.From.UserName, update.Message.From.ID)
-            notifyAdminAuthorization(update.Message.From.ID, update.Message.From.UserName)
+            // only request admin-auth when /start has been sent!
+            // this avoids most bot spam.
+            if update.Message.Text == "/start" {
+                log.Printf("Message from unauthorized user. %s %d", update.Message.From.UserName, update.Message.From.ID)
+                notifyAdminAuthorization(update.Message.From.ID, update.Message.From.UserName)
 
-            reply = "Sorry, you are not authorized. Administrator confirmation required."
+                reply = "Sorry, you are not authorized. Administrator confirmation required."
+            }
         }
 
         // send a reply