feat(multilang): add scripts handlers for user messages

Author: escalopa

.pre-commit-config.yaml

@@ -13,9 +13,9 @@ repos:
       - id: go-imports
       - id: no-go-testing
       - id: golangci-lint
-        stages: [ push ]
+        stages: [push, merge-commit]
       - id: go-unit-tests
-        stages: [ push ]
+        stages: [push, merge-commit]
       - id: validate-toml
   - repo: https://github.com/alessandrojcm/commitlint-pre-commit-hook
     rev: v8.0.0

pkg/language/script.go

@@ -1,5 +1,7 @@
 package language
 
+import "strings"
+
 // Script is a struct that holds all the scripts for each language
 type Script struct {
 	DataPickerStart string `json:"DataPickerStart"`
@@ -55,7 +57,7 @@ type Script struct {
 }
 
 func (s *Script) GetPrayerByName(name string) string {
-	switch name {
+	switch strings.ToLower(name) {
 	case "fajr":
 		return s.Fajr
 	case "sunrise":

telegram/cmd/main.go

@@ -114,6 +114,9 @@ func run(ctx context.Context, b *bt.Bot, ownerID int, useCases *application.UseC
 		if update.Message == nil {
 			continue
 		}
-		h.Help(update)
+		_, err := b.SendMessage(update.Message.Chat.Id, "/help", "", 0, false, false)
+		if err != nil {
+			log.Printf("failed to send message on unknown command, %v", err)
+		}
 	}
 }

telegram/internal/handler/admin.go

@@ -0,0 +1,140 @@
+package handler
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strconv"
+	"time"
+
+	objs "github.com/SakoDroid/telego/objects"
+)
+
+// Respond to a user's feedback or bug report
+func (h *Handler) Respond(u *objs.Update) {
+	chatID := strconv.Itoa(u.Message.Chat.Id)
+	ch, err := h.b.AdvancedMode().RegisterChannel(chatID, "message")
+	defer h.b.AdvancedMode().UnRegisterChannel(chatID, "message")
+	if err != nil {
+		log.Printf("failed to register channel for /respond: %s", err)
+		return
+	}
+
+	// Check if reply message is provided
+	if u.Message.ReplyToMessage == nil {
+		h.simpleSend(u.Message.Chat.Id, "No reply message provided, /respond", 0)
+		return
+	}
+
+	// Read userID, messageID, username from the old message that will be replied to
+	userID, responseMessageID, _, ok := parseUserMessage(u.Message.ReplyToMessage.Text)
+	if !ok {
+		h.simpleSend(u.Message.Chat.Id, "Invalid message.", 0)
+		return
+	}
+
+	// Read response message
+	messageID := h.simpleSend(u.Message.Chat.Id, "Send your response message, Or /cancel", 0)
+	defer h.deleteMessage(u.Message.Chat.Id, messageID)
+
+	// Create new command context
+	ctx, cancel := context.WithTimeout(h.userCtx[u.Message.Chat.Id].ctx, 1*time.Minute)
+	defer cancel()
+
+	select {
+	case <-ctx.Done():
+		return
+	case u = <-*ch:
+	}
+
+	if h.cancelOperation(u.Message.Text, "Canceled response.", u.Message.Chat.Id) {
+		return
+	}
+
+	// Send response message to user
+	_, err = h.b.SendMessage(userID, u.Message.Text, "", responseMessageID, false, false)
+	if err != nil {
+		h.simpleSend(u.Message.Chat.Id, "Failed to send response.", 0)
+		log.Printf("failed to respond on user's message on : %s", err)
+		return
+	}
+
+	h.simpleSend(u.Message.Chat.Id, "Response sent successfully.", 0)
+}
+
+// GetSubscribers returns the number of subscribers to the bot
+func (h *Handler) GetSubscribers(u *objs.Update) {
+	ids, err := h.u.GetSubscribers(h.c)
+	if err != nil {
+		h.simpleSend(u.Message.Chat.Id, "Failed to get subscribers.", 0)
+		log.Printf("failed to get subscribers on /subs : %s", err)
+		return
+	}
+	h.simpleSend(u.Message.Chat.Id, fmt.Sprintf("Subscribers: %d", len(ids)), 0)
+}
+
+// SendAll broadcasts a message to all subscribers
+func (h *Handler) SendAll(u *objs.Update) {
+	// Register channel to receive messages
+	chatID := u.Message.Chat.Id
+	ch, err := h.b.AdvancedMode().RegisterChannel(strconv.Itoa(u.Message.Chat.Id), "message")
+	defer h.b.AdvancedMode().UnRegisterChannel(strconv.Itoa(u.Message.Chat.Id), "message")
+	if err != nil {
+		log.Printf("failed to register channel for /sendall: %s", err)
+		return
+	}
+
+	// Wait for message or timeout after 2 minutes
+	messageID := h.simpleSend(chatID, "Send your message, Or /cancel", 0)
+	defer h.deleteMessage(chatID, messageID)
+
+	ctx1, cancel1 := context.WithTimeout(h.userCtx[chatID].ctx, 1*time.Minute)
+	defer cancel1()
+
+	select {
+	case u = <-*ch:
+	case <-ctx1.Done():
+		return
+	}
+	broadcastMessage := u.Message.Text
+
+	if h.cancelOperation(u.Message.Text, "Canceled broadcast.", chatID) {
+		return
+	}
+
+	// Double check that the owner still wants to send the message
+	messageID = h.simpleSend(chatID, "Use /confirm to send the message, Or /cancel", 0)
+	defer h.deleteMessage(chatID, messageID)
+
+	// Wait for confirmation message or timeout after 5 minutes
+	ctx2, cancel2 := context.WithTimeout(h.userCtx[chatID].ctx, 1*time.Minute)
+	defer cancel2()
+
+	select {
+	case <-ctx2.Done():
+		return
+	case u = <-*ch:
+	}
+
+	// Delete the bot message if the user sends the message or if the context times out
+	defer h.deleteMessage(chatID, u.Message.MessageId)
+
+	if u.Message.Text != "/confirm" || h.cancelOperation(u.Message.Text, "Canceled broadcast.", chatID) {
+		return
+	}
+	// Send message to all subscribers in a goroutine
+	go func() {
+		// Get all subscribers
+		ids, err := h.u.GetSubscribers(h.c)
+		if err != nil {
+			h.simpleSend(chatID, "Failed to send message.", 0)
+			log.Printf("failed to send message subscribers on /sendall : %s", err)
+			return
+		}
+		// Send message to all subscribers
+		for _, id := range ids {
+			h.simpleSend(id, broadcastMessage, 0)
+		}
+		h.simpleSend(chatID, "Message sent successfully.", 0)
+	}()
+}

telegram/internal/handler/calendar.go

@@ -13,15 +13,16 @@ import (
 // The date is passed as two integers, day and month.
 func (h *Handler) newCalendar(chatID int, callBack func(int, int)) telego.MarkUps {
 	kb := h.b.CreateInlineKeyboard()
-	for i, v := range h.userScript[chatID].GetMonthNames() {
-		row := (i-1)/2 + 1 // 3 buttons(months) per row.
-		kb.AddCallbackButtonHandler(v, strconv.Itoa(i), row, func(u1 *objs.Update) {
+	months := h.userScript[chatID].GetMonthNames()
+	for i := 1; i <= 12; i++ {
+		row := (i-1)/3 + 1 // 3 buttons(months) per row.
+		kb.AddCallbackButtonHandler(months[i-1], strconv.Itoa(i), row, func(u1 *objs.Update) {
 			// Sets the language.
 			kb = h.b.CreateInlineKeyboard()
 			month, _ := strconv.Atoi(u1.CallbackQuery.Data)
 			daysInMonth := daysIn(time.Month(month), time.Now().Year())
 			for j := 1; j <= daysInMonth; j++ {
-				row := (j-1)/7 + 1 // 7 buttons(days) per row.
+				row := (j-1)/3 + 1 // 3 buttons(days) per row.
 				kb.AddCallbackButtonHandler(strconv.Itoa(j), strconv.Itoa(j), row, func(u2 *objs.Update) {
 					day, _ := strconv.Atoi(u2.CallbackQuery.Data)
 					callBack(day, month)
@@ -30,7 +31,7 @@ func (h *Handler) newCalendar(chatID int, callBack func(int, int)) telego.MarkUp
 			editor := h.b.GetMsgEditor(u1.CallbackQuery.Message.Chat.Id)
 			_, err := editor.EditText(
 				u1.CallbackQuery.Message.MessageId,
-				"Please choose date",
+				h.userScript[chatID].DataPickerStart,
 				"",
 				"",
 				nil,

telegram/internal/handler/handler.go

@@ -46,39 +46,39 @@ func (h *Handler) Run() error {
 
 func (h *Handler) register() error {
 	var err error
-	err = h.b.AddHandler("/start", h.contextWrapper(h.Start), "all")
+	err = h.b.AddHandler("/start", h.contextWrapper(h.scriptWrapper(h.Start)), "all")
 	if err != nil {
 		return err
 	}
-	err = h.b.AddHandler("/help", h.contextWrapper(h.Help), "all")
+	err = h.b.AddHandler("/help", h.contextWrapper(h.scriptWrapper(h.Help)), "all")
 	if err != nil {
 		return err
 	}
-	err = h.b.AddHandler("/subscribe", h.contextWrapper(h.Subscribe), "all")
+	err = h.b.AddHandler("/subscribe", h.contextWrapper(h.scriptWrapper(h.Subscribe)), "all")
 	if err != nil {
 		return err
 	}
-	err = h.b.AddHandler("/unsubscribe", h.contextWrapper(h.Unsubscribe), "all")
+	err = h.b.AddHandler("/unsubscribe", h.contextWrapper(h.scriptWrapper(h.Unsubscribe)), "all")
 	if err != nil {
 		return err
 	}
-	err = h.b.AddHandler("/today", h.contextWrapper(h.GetPrayers), "all")
+	err = h.b.AddHandler("/today", h.contextWrapper(h.scriptWrapper(h.GetPrayers)), "all")
 	if err != nil {
 		return err
 	}
-	err = h.b.AddHandler("/date", h.contextWrapper(h.GetPrayersByDate), "all")
+	err = h.b.AddHandler("/date", h.contextWrapper(h.scriptWrapper(h.GetPrayersByDate)), "all")
 	if err != nil {
 		return err
 	}
-	err = h.b.AddHandler("/lang", h.contextWrapper(h.SetLang), "all")
+	err = h.b.AddHandler("/lang", h.contextWrapper(h.scriptWrapper(h.SetLang)), "all")
 	if err != nil {
 		return err
 	}
-	err = h.b.AddHandler("/feedback", h.contextWrapper(h.Feedback), "all")
+	err = h.b.AddHandler("/feedback", h.contextWrapper(h.scriptWrapper(h.Feedback)), "all")
 	if err != nil {
 		return err
 	}
-	err = h.b.AddHandler("/bug", h.contextWrapper(h.Bug), "all")
+	err = h.b.AddHandler("/bug", h.contextWrapper(h.scriptWrapper(h.Bug)), "all")
 	if err != nil {
 		return err
 	}
@@ -87,15 +87,15 @@ func (h *Handler) register() error {
 	///// Admin Commands /////
 	//////////////////////////
 
-	err = h.b.AddHandler("/respond", h.admin(h.contextWrapper(h.Respond)), "all")
+	err = h.b.AddHandler("/respond", h.admin(h.contextWrapper(h.scriptWrapper(h.Respond))), "all")
 	if err != nil {
 		return err
 	}
-	err = h.b.AddHandler("/subs", h.admin(h.contextWrapper(h.GetSubscribers)), "all")
+	err = h.b.AddHandler("/subs", h.admin(h.contextWrapper(h.scriptWrapper(h.GetSubscribers))), "all")
 	if err != nil {
 		return err
 	}
-	err = h.b.AddHandler("/sall", h.admin(h.contextWrapper(h.SendAll)), "all")
+	err = h.b.AddHandler("/sall", h.admin(h.contextWrapper(h.scriptWrapper(h.SendAll))), "all")
 	if err != nil {
 		return err
 	}

telegram/internal/handler/language.go

@@ -35,7 +35,7 @@ func (h *Handler) SetLang(u *objs.Update) {
 			if err != nil {
 				log.Printf("failed to set lang to %s: %v", u.CallbackQuery.Data, err)
 				_, err = h.b.AdvancedMode().AAnswerCallbackQuery(u.CallbackQuery.Id,
-					fmt.Sprintf("Failed to set lang to %s, Please try again later", u.CallbackQuery.Data),
+					fmt.Sprintf(h.userScript[chatID].LanguageSelectionFail, u.CallbackQuery.Data),
 					true, "", 0)
 				if err != nil {
 					log.Printf("failed to send callback query on /lang: %s", err)
@@ -47,7 +47,7 @@ func (h *Handler) SetLang(u *objs.Update) {
 			if err != nil {
 				log.Printf("failed to get script for %s: %v", u.CallbackQuery.Data, err)
 				_, err = h.b.AdvancedMode().AAnswerCallbackQuery(u.CallbackQuery.Id,
-					fmt.Sprintf("Failed to set lang to %s, Please try again later", u.CallbackQuery.Data),
+					fmt.Sprintf(h.userScript[chatID].LanguageSelectionFail, u.CallbackQuery.Data),
 					true, "", 0)
 				if err != nil {
 					log.Printf("failed to send callback query on /lang: %s", err)
@@ -56,12 +56,26 @@ func (h *Handler) SetLang(u *objs.Update) {
 			}
 			// Update the user script.
 			h.userScript[chatID] = script
-			h.simpleSend(chatID, fmt.Sprintf("Successfully set lang to %s", u.CallbackQuery.Data), 0)
+			_, err = h.b.SendMessage(chatID, fmt.Sprintf(h.userScript[chatID].LanguageSelectionSuccess, u.CallbackQuery.Data), "HTML", 0, false, false)
+			if err != nil {
+				log.Printf("failed to send message on /lang: %s", err)
+			}
 		})
 	}
 
 	// Sends the message along with the keyboard.
-	r, err := h.b.AdvancedMode().ASendMessage(u.Message.Chat.Id, "Choose lang", "", u.Message.MessageId, false, false, nil, false, false, kb)
+	r, err := h.b.AdvancedMode().ASendMessage(
+		chatID,
+		h.userScript[chatID].LanguageSelectionStart,
+		"",
+		u.Message.MessageId,
+		false,
+		false,
+		nil,
+		false,
+		false,
+		kb,
+	)
 	if err != nil {
 		log.Printf("failed to send message on /lang: %s", err)
 	}