core/tg
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Simplified behaviour definition functions.

Browse source
This commit is contained in:
Andrey Parhomenko 2023-08-10 15:49:25 +03:00
parent 03a2f60436
commit fbfa0ec388
15 changed files with 297 additions and 268 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -1,3 +1,4 @@
exe
*.exe
*.swp
tmp

144
cmd/test/main.go
View file

@ -1,111 +1,65 @@
package main
import (
"log"
"os"
"log"
"os"
//tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
"boteval/src/behx"
"github.com/mojosa-software/got/src/tx"
)
var rootKbd = behx.NewKeyboard(
behx.NewButtonRow(
behx.NewButton(
"Increment",
behx.NewCustomAction(func(c *behx.Context){
counter := c.V["counter"].(*int)
*counter++
c.Sendf("%d", *counter)
}),
),
behx.NewButton(
"Decrement",
behx.NewCustomAction(func(c *behx.Context){
counter := c.V["counter"].(*int)
*counter--
c.Sendf("%d", *counter)
}),
),
),
behx.NewButtonRow(
behx.NewButton("To second screen", behx.NewScreenChange("second")),
),
var navKeyboard = tx.NewKeyboard("nav").Row(
tx.NewButton().WithText("Inc/Dec").ScreenChange("inc/dec"),
).Row(
tx.NewButton().WithText("Upper case").ScreenChange("upper-case"),
tx.NewButton().WithText("Lower case").ScreenChange("lower-case"),
)
var secondKbd = behx.NewKeyboard(
behx.NewButtonRow(
behx.NewButton(
"❤",
behx.NewScreenChange("start"),
),
),
)
var inlineKbd = behx.NewKeyboard(
behx.NewButtonRow(
behx.NewButton(
"INLINE PRESS ME",
behx.NewCustomAction(func(c *behx.Context){
log.Println("INLINE pressed the button!")
}),
),
behx.NewButton("INLINE PRESS ME 2", behx.NewCustomAction(func(c *behx.Context){
log.Println("INLINE pressed another button!")
})),
),
behx.NewButtonRow(
behx.NewButton(
"INLINE PRESS ME 3",
behx.ScreenChange("second"),
),
),
)
var startScreen = behx.NewScreen(
"Hello, World!",
"inline",
"root",
)
var secondScreen = behx.NewScreen(
"Second screen!",
"",
"second",
)
var behaviour = behx.NewBehaviour(
behx.NewCustomAction(func(c *behx.Context){
// This way we provide counter for EACH user.
c.V["counter"] = new(int)
// Do NOT forget to change to some of the screens
// since they are the ones who provide behaviour
// definition.
c.ChangeScreen("start")
var incKeyboard = tx.NewKeyboard("inc/dec").Row(
tx.NewButton().WithText("+").ActionFunc(func(c *tx.Context) {
counter := c.V["counter"].(*int)
*counter++
c.Sendf("%d", *counter)
}),
behx.ScreenMap{
"start": startScreen,
"second": secondScreen,
},
behx.KeyboardMap{
"root": rootKbd,
"inline": inlineKbd,
"second": secondKbd,
},
tx.NewButton().WithText("-").ActionFunc(func(c *tx.Context) {
counter := c.V["counter"].(*int)
*counter--
c.Sendf("%d", *counter)
}),
)
var startScreen = tx.NewScreen("start").
WithText("The bot started!").
Keyboard("nav")
var incScreen = tx.NewScreen("inc/dec").
WithText("The screen shows how user separated data works").
IKeyboard("inc/dec").
Keyboard("nav")
var beh = tx.NewBehaviour().
OnStartFunc(func(c *tx.Context) {
// The function will be called every time
// the bot is started.
c.V["counter"] = new(int)
c.ChangeScreen("start")
}).WithKeyboards(
navKeyboard,
incKeyboard,
).WithScreens(
startScreen,
incScreen,
)
func main() {
token := os.Getenv("BOT_TOKEN")
bot, err := behx.NewBot(token, behaviour, nil)
if err != nil {
log.Panic(err)
}
bot.Debug = true
bot, err := tx.NewBot(token, beh, nil)
if err != nil {
log.Panic(err)
}
log.Printf("Authorized on account %s", bot.Self.UserName)
bot.Run()
bot.Debug = true
log.Printf("Authorized on account %s", bot.Self.UserName)
bot.Run()
}

2
go.mod
View file

@ -1,4 +1,4 @@
module boteval
module github.com/mojosa-software/got
go 1.20

39
src/behx/beh.go
View file

@ -1,39 +0,0 @@
package behx
// The package implements
// behaviour for the Telegram bots.
// The type describes behaviour for the bot.
type Behaviour struct {
Start Action
Screens ScreenMap
Keyboards KeyboardMap
}
func NewBehaviour(
start Action,
screens ScreenMap,
keyboards KeyboardMap,
) *Behaviour {
return &Behaviour{
start, screens, keyboards,
}
}
// Check whether the screen exists in the behaviour.
func (beh *Behaviour) ScreenExists(id ScreenId) bool {
_, ok := beh.Screens[id]
return ok
}
// Returns the screen by it's ID.
func (beh *Behaviour) GetScreen(id ScreenId) *Screen {
if !beh.ScreenExists(id) {
panic(ScreenNotExistErr)
}
screen := beh.Screens[id]
return screen
}

13
src/behx/errors.go
View file

@ -1,13 +0,0 @@
package behx
import (
"errors"
)
var (
ScreenNotExistErr = errors.New("screen does not exist")
SessionNotExistErr = errors.New("session does not exist")
KeyboardNotExistErr = errors.New("keyboard does not exist")
)

22
src/behx/action.go → src/tx/action.go
View file

@ -1,4 +1,4 @@
package behx
package tx
// Implementing the intereface lets you
// provide behaviour for the buttons etc.
@ -7,29 +7,21 @@ type Action interface {
}
// Customized action for the bot.
type CustomAction func(*Context)
type ActionFunc func(*Context)
// The type implements changing screen to the underlying ScreenId
type ScreenChange ScreenId
// Returns new ScreenChange.
func NewScreenChange(screen string) ScreenChange {
return ScreenChange(screen)
}
// Returns new CustomAction.
func NewCustomAction(fn func(*Context)) CustomAction {
return CustomAction(fn)
}
func (sc ScreenChange) Act(c *Context) {
if !c.B.ScreenExist(ScreenId(sc)) {
panic(ScreenNotExistErr)
}
err := c.ChangeScreen(ScreenId(sc))
if err != nil {
panic(err)
}
}
func (ca CustomAction) Act(c *Context) {
ca(c)
func (af ActionFunc) Act(c *Context) {
af(c)
}

86
src/tx/beh.go Normal file
View file

@ -0,0 +1,86 @@
package tx
// The package implements
// behaviour for the Telegram bots.
// The type describes behaviour for the bot.
type Behaviour struct {
Start Action
Screens ScreenMap
Keyboards KeyboardMap
}
// Returns new empty behaviour.
func NewBehaviour() *Behaviour {
return &Behaviour{
Screens: make(ScreenMap),
Keyboards: make(KeyboardMap),
}
}
func (b *Behaviour) WithStart(a Action) *Behaviour {
b.Start = a
return b
}
func (b *Behaviour) OnStartFunc(
fn ActionFunc,
) *Behaviour {
return b.WithStart(fn)
}
func (b *Behaviour) OnStartChangeScreen(
id ScreenId,
) *Behaviour {
return b.WithStart(ScreenChange(id))
}
// The function sets keyboards.
func (b *Behaviour) WithKeyboards(
kbds ...*Keyboard,
) *Behaviour {
for _, kbd := range kbds {
if kbd.Id == "" {
panic("empty keyboard ID")
}
_, ok := b.Keyboards[kbd.Id]
if ok {
panic("duplicate keyboard IDs")
}
b.Keyboards[kbd.Id] = kbd
}
return b
}
// The function sets screens.
func (b *Behaviour) WithScreens(
screens ...*Screen,
) *Behaviour {
for _, screen := range screens {
if screen.Id == "" {
panic("empty screen ID")
}
_, ok := b.Screens[screen.Id]
if ok {
panic("duplicate keyboard IDs")
}
b.Screens[screen.Id] = screen
}
return b
}
// Check whether the screen exists in the behaviour.
func (beh *Behaviour) ScreenExist(id ScreenId) bool {
_, ok := beh.Screens[id]
return ok
}
// Returns the screen by it's ID.
func (beh *Behaviour) GetScreen(id ScreenId) *Screen {
if !beh.ScreenExist(id) {
panic(ScreenNotExistErr)
}
screen := beh.Screens[id]
return screen
}

59
src/behx/bot.go → src/tx/bot.go
View file

@ -1,8 +1,8 @@
package behx
package tx
import (
apix "github.com/go-telegram-bot-api/telegram-bot-api/v5"
//"log"
apix "github.com/go-telegram-bot-api/telegram-bot-api/v5"
//"log"
)
// The wrapper around Telegram API.
@ -14,45 +14,43 @@ type Bot struct {
// Return the new bot for running the Behaviour.
func NewBot(token string, beh *Behaviour, sessions SessionMap) (*Bot, error) {
bot, err := apix.NewBotAPI(token)
if err != nil {
return nil, err
}
// Make new sessions if no current are provided.
if sessions == nil {
sessions = make(SessionMap)
}
return &Bot{
BotAPI: bot,
bot, err := apix.NewBotAPI(token)
if err != nil {
return nil, err
}
// Make new sessions if no current are provided.
if sessions == nil {
sessions = make(SessionMap)
}
return &Bot{
BotAPI: bot,
Behaviour: beh,
sessions: make(SessionMap),
}, nil
sessions: make(SessionMap),
}, nil
}
// Run the bot with the Behaviour.
func (bot *Bot) Run() error {
bot.Debug = true
uc := apix.NewUpdate(0)
uc.Timeout = 60
updates := bot.GetUpdatesChan(uc)
chans := make(map[SessionId] chan *Update)
chans := make(map[SessionId]chan *Update)
for u := range updates {
var sid SessionId
if u.Message != nil {
if u.Message != nil {
// Create new session if the one does not exist
// for this user.
sid = SessionId(u.Message.Chat.ID)
if _, ok := bot.sessions[sid] ; !ok {
if _, ok := bot.sessions[sid]; !ok {
bot.sessions.Add(sid)
}
}
// The "start" command resets the bot
// by executing the Start Action.
if u.Message.IsCommand() {
@ -61,10 +59,10 @@ func (bot *Bot) Run() error {
// Getting current session and context.
session := bot.sessions[sid]
ctx := &Context{
B: bot,
B: bot,
Session: session,
}
chn := make(chan *Update)
chans[sid] = chn
// Starting the goroutine for the user.
@ -80,7 +78,6 @@ func (bot *Bot) Run() error {
chn <- &u
}
}
return nil
}

57
src/behx/button.go → src/tx/button.go
View file

@ -1,42 +1,62 @@
package behx
package tx
import (
apix "github.com/go-telegram-bot-api/telegram-bot-api/v5"
apix "github.com/go-telegram-bot-api/telegram-bot-api/v5"
)
// The type wraps Telegram API's button to provide Action functionality.
type Button struct {
Text string
Data string
Url string
Text string
Data string
Url string
Action Action
}
type ButtonMap map[string] *Button
type ButtonMap map[string]*Button
// Represents the reply button row.
type ButtonRow []*Button
// Returns new button with specified text and action.
func NewButton(text string, action Action) *Button {
return &Button{
Text: text,
Action: action,
}
func NewButton() *Button {
return &Button{}
}
func (btn *Button) WithText(text string) *Button {
btn.Text = text
return btn
}
func (btn *Button) WithUrl(url string) *Button {
btn.Url = url
return btn
}
func (btn *Button) WithAction(a Action) *Button {
btn.Action = a
return btn
}
func (btn *Button) ActionFunc(fn ActionFunc) *Button {
return btn.WithAction(fn)
}
func (btn *Button) ScreenChange(sc ScreenChange) *Button {
return btn.WithAction(sc)
}
func NewButtonData(text string, data string, action Action) *Button {
return &Button{
Text: text,
Data: data,
Text: text,
Data: data,
Action: action,
}
}
func NewButtonUrl(text string, url string, action Action) *Button {
return &Button{
Text: text,
Url: url,
Text: text,
Url: url,
Action: action,
}
}
@ -49,11 +69,11 @@ func (btn *Button) ToTelegramInline() apix.InlineKeyboardButton {
if btn.Data != "" {
return apix.NewInlineKeyboardButtonData(btn.Text, btn.Data)
}
if btn.Url != "" {
return apix.NewInlineKeyboardButtonURL(btn.Text, btn.Url)
}
// If no match then return the data one with data the same as the text.
return apix.NewInlineKeyboardButtonData(btn.Text, btn.Text)
}
@ -63,7 +83,7 @@ func (btn *Button) Key() string {
if btn.Data != "" {
return btn.Data
}
// If no match then return the data one with data the same as the text.
return btn.Text
}
@ -71,4 +91,3 @@ func (btn *Button) Key() string {
func NewButtonRow(btns ...*Button) ButtonRow {
return btns
}

26
src/behx/context.go → src/tx/context.go
View file

@ -1,8 +1,9 @@
package behx
package tx
import (
apix "github.com/go-telegram-bot-api/telegram-bot-api/v5"
"fmt"
apix "github.com/go-telegram-bot-api/telegram-bot-api/v5"
)
// The type represents way to interact with user in
@ -19,24 +20,24 @@ func (ctx *Context) handleUpdateChan(updates chan *Update) {
bot.Start.Act(ctx)
for u := range updates {
screen := bot.Screens[session.CurrentScreenId]
if u.Message != nil {
kbd := bot.Keyboards[screen.KeyboardId]
btns := kbd.buttonMap()
text := u.Message.Text
btn, ok := btns[text]
// Skipping wrong text messages.
if !ok {
continue
}
btn.Action.Act(ctx)
} else if u.CallbackQuery != nil {
cb := apix.NewCallback(u.CallbackQuery.ID, u.CallbackQuery.Data)
data := u.CallbackQuery.Data
_, err := bot.Request(cb)
if err != nil {
panic(err)
@ -55,17 +56,17 @@ func (c *Context) ChangeScreen(screenId ScreenId) error {
if c.CurrentScreenId == screenId {
return nil
}
if !c.B.ScreenExists(screenId) {
if !c.B.ScreenExist(screenId) {
return ScreenNotExistErr
}
screen := c.B.Screens[screenId]
screen.Render(c)
c.Session.ChangeScreen(screenId)
c.KeyboardId = screen.KeyboardId
return nil
}
@ -79,4 +80,3 @@ func (c *Context) Send(text string) error {
func (c *Context) Sendf(format string, v ...any) error {
return c.Send(fmt.Sprintf(format, v...))
}

11
src/tx/errors.go Normal file
View file

@ -0,0 +1,11 @@
package tx
import (
"errors"
)
var (
ScreenNotExistErr = errors.New("screen does not exist")
SessionNotExistErr = errors.New("session does not exist")
KeyboardNotExistErr = errors.New("keyboard does not exist")
)

33
src/behx/keyboard.go → src/tx/keyboard.go
View file

@ -1,8 +1,9 @@
package behx
package tx
import (
apix "github.com/go-telegram-bot-api/telegram-bot-api/v5"
apix "github.com/go-telegram-bot-api/telegram-bot-api/v5"
)
/*
var otherKeyboard = tgbotapi.NewReplyKeyboard(
tgbotapi.NewKeyboardButtonRow(
@ -22,20 +23,27 @@ type KeyboardId string
// The type represents reply keyboard which
// is supposed to be showed on a Screen.
type Keyboard struct {
Id KeyboardId
Rows []ButtonRow
}
type KeyboardMap map[KeyboardId] *Keyboard
type KeyboardMap map[KeyboardId]*Keyboard
// Return the new reply keyboard with rows as specified.
func NewKeyboard(rows ...ButtonRow) *Keyboard {
func NewKeyboard(id KeyboardId) *Keyboard {
return &Keyboard{
Rows: rows,
Id: id,
}
}
// Adds a new button row to the current keyboard.
func (kbd *Keyboard) Row(btns ...*Button) *Keyboard {
kbd.Rows = append(kbd.Rows, btns)
return kbd
}
// Convert the Keyboard to the Telegram API type.
func (kbd *Keyboard) ToTelegram() apix.ReplyKeyboardMarkup {
func (kbd *Keyboard) toTelegram() apix.ReplyKeyboardMarkup {
rows := [][]apix.KeyboardButton{}
for _, row := range kbd.Rows {
buttons := []apix.KeyboardButton{}
@ -43,12 +51,12 @@ func (kbd *Keyboard) ToTelegram() apix.ReplyKeyboardMarkup {
buttons = append(buttons, button.ToTelegram())
}
rows = append(rows, buttons)
}
}
return apix.NewReplyKeyboard(rows...)
}
func (kbd *Keyboard) ToTelegramInline() apix.InlineKeyboardMarkup {
func (kbd *Keyboard) toTelegramInline() apix.InlineKeyboardMarkup {
rows := [][]apix.InlineKeyboardButton{}
for _, row := range kbd.Rows {
buttons := []apix.InlineKeyboardButton{}
@ -56,8 +64,8 @@ func (kbd *Keyboard) ToTelegramInline() apix.InlineKeyboardMarkup {
buttons = append(buttons, button.ToTelegramInline())
}
rows = append(rows, buttons)
}
}
return apix.NewInlineKeyboardMarkup(rows...)
}
@ -69,7 +77,6 @@ func (kbd *Keyboard) buttonMap() ButtonMap {
ret[vj.Key()] = vj
}
}
return ret
}

3
src/behx/main.go → src/tx/main.go
View file

@ -1,5 +1,4 @@
package behx
package tx
// The package implements behaviourial
// definition for the Telegram bots through the API.

57
src/behx/screen.go → src/tx/screen.go
View file

@ -1,4 +1,4 @@
package behx
package tx
import (
apix "github.com/go-telegram-bot-api/telegram-bot-api/v5"
@ -14,28 +14,44 @@ type ScreenText string
// Screen statement of the bot.
// Mostly what buttons to show.
type Screen struct {
Id ScreenId
// Text to be sent to the user when changing to the screen.
Text ScreenText
// The keyboard to be sent in the message part.
InlineKeyboardId KeyboardId
// Keyboard to be displayed on the screen.
KeyboardId KeyboardId
}
// Map structure for the screens.
type ScreenMap map[ScreenId] *Screen
type ScreenMap map[ScreenId]*Screen
// Returns the new screen with specified Text and Keyboard.
func NewScreen(text ScreenText, ikbd KeyboardId, kbd KeyboardId) *Screen {
return &Screen {
Text: text,
InlineKeyboardId: ikbd,
KeyboardId: kbd,
func NewScreen(id ScreenId) *Screen {
return &Screen{
Id: id,
}
}
// Returns the screen with specified text printing on appearing.
func (s *Screen) WithText(text ScreenText) *Screen {
s.Text = text
return s
}
func (s *Screen) IKeyboard(kbdId KeyboardId) *Screen {
s.InlineKeyboardId = kbdId
return s
}
func (s *Screen) Keyboard(kbdId KeyboardId) *Screen {
s.KeyboardId = kbdId
return s
}
// Rendering the screen text to string to be sent or printed.
func (st ScreenText) String() string {
return string(st)
@ -44,44 +60,43 @@ func (st ScreenText) String() string {
// Renders output of the screen only to the side of the user.
func (s *Screen) Render(c *Context) error {
id := c.Id.ToTelegram()
msg := apix.NewMessage(id, s.Text.String())
if s.InlineKeyboardId != "" {
kbd, ok := c.B.Keyboards[s.InlineKeyboardId]
if !ok {
return KeyboardNotExistErr
}
msg.ReplyMarkup = kbd.ToTelegramInline()
msg.ReplyMarkup = kbd.toTelegramInline()
}
_, err := c.B.Send(msg)
if err != nil {
return err
}
msg = apix.NewMessage(id, ">")
// Checking if we need to resend the keyboard.
if s.KeyboardId != c.KeyboardId {
// Remove keyboard by default.
var tkbd any
tkbd = apix.NewRemoveKeyboard(true)
// Replace keyboard with the new one.
if s.KeyboardId != "" {
kbd, ok := c.B.Keyboards[s.KeyboardId]
if !ok {
return KeyboardNotExistErr
}
tkbd = kbd.ToTelegram()
tkbd = kbd.toTelegram()
}
msg.ReplyMarkup = tkbd
if _, err := c.B.Send(msg) ; err != nil {
if _, err := c.B.Send(msg); err != nil {
return err
}
}
}
return nil
}

12
src/behx/session.go → src/tx/session.go
View file

@ -1,4 +1,4 @@
package behx
package tx
import (
apix "github.com/go-telegram-bot-api/telegram-bot-api/v5"
@ -21,20 +21,20 @@ type Session struct {
PreviousScreenId ScreenId
// The currently showed on display keyboard.
KeyboardId KeyboardId
// Custom data for each user.
V map[string] any
V map[string]any
}
// The type represents map of sessions using
// as key.
type SessionMap map[SessionId] *Session
type SessionMap map[SessionId]*Session
// Return new empty session with
// Return new empty session with
func NewSession(id SessionId) *Session {
return &Session{
Id: id,
V: make(map[string] any),
V: make(map[string]any),
}
}