Ein Modul von A bis Z

Wir bauen ein Notes-Modul: Notiz speichern, Notizen auflisten, eine löschen. Es nutzt Speicher, Argumente, Aliase, Filter und Übersetzungen — fast alles, was ein echtes Modul braucht.

1. Erzeugen

.newmod Notes

2. Form des Speichers

Notizen gehören zum Chat, also eine Map nach Chat-ID mit den Notizen als Liste:

package modules

import (
	"fmt"
	"strconv"
	"strings"

	"goroku/goroku"
	"goroku/goroku/utils"
)

type Notes struct {
	goroku.Base
}

func (m *Notes) Name() string { return "Notes" }

// notesFor liefert die in einem Chat gespeicherten Notizen.
func (m *Notes) notesFor(chatID int64) []string {
	all := m.DB.GetStringMapStringSlice(m.Name(), "notes", nil)
	if all == nil {
		return nil
	}
	return all[strconv.FormatInt(chatID, 10)]
}

// saveNotes ersetzt die Notizen eines Chats.
func (m *Notes) saveNotes(chatID int64, notes []string) error {
	all := m.DB.GetStringMapStringSlice(m.Name(), "notes", nil)
	if all == nil {
		all = map[string][]string{}
	}
	all[strconv.FormatInt(chatID, 10)] = notes
	if err := m.DB.SetStringMapStringSlice(m.Name(), "notes", all); err != nil {
		return fmt.Errorf("Notizen speichern: %w", err)
	}
	return nil
}

Der Getter gibt eine Kopie zurück, also lesen, ändern, zurückschreiben.

3. Strings

func (m *Notes) Strings() map[string]string {
	return map[string]string{
		"name":            "Notes",
		"_cls_doc":        "Notizen pro Chat",
		"_cmd_doc_note":   "[Text] — Notiz speichern oder auf eine Nachricht antworten",
		"_cmd_doc_notes":  "Gespeicherte Notizen auflisten",
		"_cmd_doc_delnote": "[Nummer] — Notiz löschen",

		"saved":     "📝 <b>Gespeichert als #{n}</b>",
		"empty":     "📭 <b>Noch keine Notizen</b>",
		"no_text":   "❌ <b>Sende Text oder antworte auf eine Nachricht</b>",
		"bad_index": "❌ <b>Gib die Notiznummer an, siehe .notes</b>",
		"deleted":   "🗑 <b>#{n} gelöscht</b>",
	}
}

4. Befehle

func (m *Notes) Commands() map[string]goroku.CommandHandler {
	return map[string]goroku.CommandHandler{
		"note":    m.NoteCmd,
		"notes":   m.NotesCmd,
		"delnote": m.DelNoteCmd,
	}
}

func (m *Notes) CommandMetas() map[string]goroku.CommandMeta {
	return map[string]goroku.CommandMeta{
		"note":    {Aliases: []string{"n"}, OnlyOwner: true},
		"notes":   {OnlyOwner: true},
		"delnote": {Aliases: []string{"dn"}, OnlyOwner: true},
	}
}

Nur für den Besitzer: die Befehle greifen auf deinen eigenen Speicher zu.

5. Speichern

func (m *Notes) NoteCmd(msg *goroku.Message) error {
	text := msg.ArgsOrReply()
	if text == "" {
		return msg.Answer(m.T("no_text", "❌ <b>Sende Text oder antworte auf eine Nachricht</b>"))
	}

	notes := append(m.notesFor(msg.ChatID), text)
	if err := m.saveNotes(msg.ChatID, notes); err != nil {
		return err
	}

	tpl := m.T("saved", "📝 <b>Gespeichert als #{n}</b>")
	return msg.Answer(strings.Replace(tpl, "{n}", strconv.Itoa(len(notes)), 1))
}

ArgsOrReply liefert uns .note Milch kaufen und das Antworten auf eine Nachricht mit .note gratis dazu.

6. Auflisten

func (m *Notes) NotesCmd(msg *goroku.Message) error {
	notes := m.notesFor(msg.ChatID)
	if len(notes) == 0 {
		return msg.Answer(m.T("empty", "📭 <b>Noch keine Notizen</b>"))
	}

	var b strings.Builder
	b.WriteString("📝 <b>Notizen</b>\n\n")
	for i, note := range notes {
		fmt.Fprintf(&b, "%d. %s\n", i+1, utils.EscapeHTML(note))
	}
	return msg.Answer(b.String())
}

EscapeHTML ist wichtig: eine Notiz mit < würde die Nachricht sonst zerbrechen.

7. Löschen

func (m *Notes) DelNoteCmd(msg *goroku.Message) error {
	notes := m.notesFor(msg.ChatID)
	if len(notes) == 0 {
		return msg.Answer(m.T("empty", "📭 <b>Noch keine Notizen</b>"))
	}

	n, err := strconv.Atoi(msg.Arg(0))
	if err != nil || n < 1 || n > len(notes) {
		return msg.Answer(m.T("bad_index", "❌ <b>Gib die Notiznummer an, siehe .notes</b>"))
	}

	notes = append(notes[:n-1], notes[n:]...)
	if err := m.saveNotes(msg.ChatID, notes); err != nil {
		return err
	}

	tpl := m.T("deleted", "🗑 <b>#{n} gelöscht</b>")
	return msg.Answer(strings.Replace(tpl, "{n}", strconv.Itoa(n), 1))
}

msg.Arg(0) ist grenzsicher — .delnote ohne Argument ergibt "", was Atoi ablehnt, und der Nutzer bekommt die freundliche Meldung.

8. Installieren

Datei schicken, darauf antworten, .loadmod. Dann:

.note Milch kaufen
.note      (als Antwort auf etwas)
.notes
.delnote 1

Was hier vorkam

Funktion	Wo
Speicher mit Lesen-Ändern-Schreiben	notesFor / saveNotes
Argumente oder Antworttext	ArgsOrReply
Grenzsichere Argumente	Arg(0)
Aliase und Nur-Besitzer	CommandMetas
Übersetzbarer Text mit Standardwert	m.T
HTML-Escaping von Nutzerdaten	utils.EscapeHTML
Fehler mit Kontext	fmt.Errorf("...: %w", err)

Weiter

• Eine max_notes-Einstellung ergänzen — Konfiguration
• Auf Unterhaltung reagieren — Watcher
• Weitergeben — Modul installieren