tgbot

go-tgbot

Pure Golang telegram bot API wrapper generated from swagger definition, session-based routing and middlewares.

Usage benefits

1. No need to learn any other library API. You will use methods with payload exactly like it presented on telegram bot API description page. With only couple trade-offs, b/c of telegram bot API is generics a bit.
2. All models and methods are being supported. The models and methods were generated from swagger.yaml description file. So, new entities/methods could be added by describing in the YAML swagger file. This approach allows validating the description, avoid typos and develop fast.
3. ffjson is plugged. So, it's pretty fast.
4. context.Context based HTTP client
5. Session-based routing, not only message text based.

Client

Client package could be used as regular go-swagger client library without using Router. There is the only single additional feature over go-swagger - a possibility to setup token by default. It solved as a custom HTTP transport. Example:

package main

import (
	"context"
	"flag"
	"log"
	"time"

	tgbot "github.com/olebedev/go-tgbot"
	"github.com/olebedev/go-tgbot/client/users"
)

var token *string

func main() {
	token = flag.String("token", "", "telegram bot token")
	flag.Parse()

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	api := tgbot.NewClient(ctx, *token)

	log.Println(api.Users.GetMe(nil))

	// Also, every calls could be done with given token and/or context
	ctx, cancel = context.WithTimeout(ctx, 10*time.Second)
	defer cancel()

	t := "<overwrite default token>"
	_, err := api.Users.GetMe(
		users.NewGetMeParams().
			WithContext(ctx).
			WithToken(&t),
	)

	if err != nil {
		// users.NewGetMeBadRequest()
		if e, ok := err.(*users.GetMeBadRequest); ok {
			log.Println(e.Payload.ErrorCode, e.Payload.Description)
		}
	}
}

Since swagger covers many other platforms/technologies the same libraries could be generated for them too. See the source here - swagger.yaml.

Router

The Router allows binding between kinds of updates and handlers, which are being checked via regexp. router include client API library as embedded struct. Example:

package main

import (
	"context"
	"flag"
	"log"

	tgbot "github.com/olebedev/go-tgbot"
	"github.com/olebedev/go-tgbot/client/messages"
	"github.com/olebedev/go-tgbot/models"
)

var token *string

func main() {
	token = flag.String("token", "", "telegram bot token")
	flag.Parse()

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	r := tgbot.New(&tgbot.Options{
		Context: ctx,
		Token:   *token,
	})

	// setup global middleware
	r.Use(tgbot.Recover)

	// Bind handler
	r.Message("^/start\\sstart$", func(c *tgbot.Context) error {
		log.Println(c.Update.Message.Text)
		// send greeting message back
		message := "hi there what's up"
		resp, err := r.Messages.SendMessage(
			messages.NewSendMessageParams().WithBody(&models.SendMessageBody{
				Text:   &message,
				ChatID: c.Update.Message.Chat.ID,
			}),
		)
		if err != nil {
			return err
		}
		if resp != nil {
			log.Println(resp.Payload.Result.MessageID)
		}
		return nil
	})

	if err := r.Poll(ctx, []models.AllowedUpdate{models.AllowedUpdateMessage}); err != nil {
		log.Fatal(err)
	}
}

Default string representation of any kind of an update could be found here - session.go.

Router implements http.Handler interface to be able to serve HTTP as well. But, it's not recommended because webhooks are much much slower than polling.

Session-based routing

After many bots were developed, the one principal thing could be marked - routing need to be matched with session instead of received message text. So, we should be able to wrap the update into a string representation, to be matched with a handler. For this purpose, Router accepts a GetSession optional argument. It's a function which returns (fmt.Stringer, error), the fmt.Stringer instance will be placed as c.Session during handlers chain call. Example:

package main

import (
	"context"
	"flag"
	"fmt"
	"log"

	tgbot "github.com/olebedev/go-tgbot"
	"github.com/olebedev/go-tgbot/models"

	"app" // you application
)

type Session struct {
	User    *app.User
	Billing *app.UserBillingInfo
	// ... etc
	Route string
}

func (s Session) String() string {
	return s.Route
}

func GetSessionFunc(u *models.Update) (fmt.Stringer, error) {
	sess, err := tgbot.GetSession(u)
	if err != nil {
		return nil, err
	}

	s := &Session{
		Route: "~" + sess.String(),
	}

	s.User, err = app.GetUserByTgID(u.Message.From.ID)
	if err != nil {
		return err
	}
	s.Billing, err = app.GetBillingByID(s.User.ID)
	if err != nil {
		return err
	}

	if !s.Billing.Active {
		s.Route = "/pay" + s.Route
	}

	return s, nil
}

func main() {
	token := flag.String("token", "", "telegram bot token")
	flag.Parse()

	ctx, cancel := context.WithCancel(context.Background())
	defer cancel()

	r := tgbot.New(&tgbot.Options{
		Context:    ctx,
		Token:      *token,
		GetSession: GetSessionFunc,
	})

	// setup global middleware
	r.Use(tgbot.Recover)

	// Bind handlers
	r.Message("^/pay~.*", func(c *tgbot.Context) error {
		s := c.Session.(*Session)
		// TODO handle payment here before say hello
		return r.Route(c.Update)
	})

	r.Message("^~/start\\sstart$", func(c *tgbot.Context) error {
		log.Println(c.Update.Message.Text)
		// send greeting message back
		message := "hi there what's up"
		resp, err := r.Messages.SendMessage(
			messages.NewSendMessageParams().WithBody(&models.SendMessageBody{
				Text:   &message,
				ChatID: c.Update.Message.Chat.ID,
			}),
		)
		if err != nil {
			return err
		}
		if resp != nil {
			log.Println(resp.Payload.MessageID)
		}
		return nil
	})

	if err := r.Poll(ctx, []models.AllowedUpdate{models.AllowedUpdateMessage}); err != nil {
		log.Fatal(err)
	}
}

See the documentation for more details.

LICENSE

http://www.apache.org/licenses/LICENSE-2.0