layout

package
v0.0.0-...-234a4bc Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 18, 2024 License: MIT Imports: 16 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Button 

type Button struct {
	tele.Btn `yaml:",inline"`
	Data     interface{} `yaml:"data"`
	IsReply  bool        `yaml:"reply"`
}

Button is a shortcut for tele.Btn.

type Config 

type Config struct {
	// contains filtered or unexported fields
}

Config represents typed map interface related to the "config" section in layout.

func (*Config) Bool 

func (c *Config) Bool(k string) bool

Bool returns a field casted to the bool.

func (*Config) ChatID 

func (c *Config) ChatID(k string) tele.ChatID

ChatID returns a field casted to the ChatID. The value must be an integer.

func (*Config) Duration 

func (c *Config) Duration(k string) time.Duration

Duration returns a field casted to the time.Duration. Accepts number-represented duration or a string in 0nsuµmh format.

func (*Config) Float 

func (c *Config) Float(k string) float64

Float returns a field casted to the float64.

func (*Config) Floats 

func (c *Config) Floats(k string) (floats []float64)

Floats returns a field casted to the float slice.

func (*Config) Get 

func (c *Config) Get(k string) *Config

Get returns a child map field wrapped into Config. If the field isn't a map, returns nil.

func (*Config) Int 

func (c *Config) Int(k string) int

Int returns a field casted to the int.

func (*Config) Int64 

func (c *Config) Int64(k string) int64

Int64 returns a field casted to the int64.

func (*Config) Int64s 

func (c *Config) Int64s(k string) (ints []int64)

Int64s returns a field casted to the int64 slice.

func (*Config) Ints 

func (c *Config) Ints(k string) []int

Ints returns a field casted to the int slice.

func (*Config) Slice 

func (c *Config) Slice(k string) (slice []*Config)

Slice returns a child slice of objects wrapped into Config. If the field isn't a slice, returns nil.

func (*Config) String 

func (c *Config) String(k string) string

String returns a field casted to the string.

func (*Config) Strings 

func (c *Config) Strings(k string) []string

Strings returns a field casted to the string slice.

func (*Config) Unmarshal 

func (c *Config) Unmarshal(v interface{}) error

Unmarshal parses the whole config into the out value. It's useful when you want to describe and to pre-define the fields in your custom configuration struct.

func (*Config) UnmarshalKey 

func (c *Config) UnmarshalKey(k string, v interface{}) error

UnmarshalKey parses the specific key in the config into the out value.

type Layout 

type Layout struct {
	Config
	// contains filtered or unexported fields
}

Layout provides an interface to interact with the layout, parsed from the config file and locales.

func New 

func New(path string, funcs ...template.FuncMap) (*Layout, error)

New parses the given layout file.

func NewFromFS 

func NewFromFS(fsys fs.FS, path string, funcs ...template.FuncMap) (*Layout, error)

NewFromFS parses the layout from the given fs.FS. It allows to read layout from the go:embed filesystem.

func (*Layout) Button 

func (lt *Layout) Button(c tele.Context, k string, args ...interface{}) *tele.Btn

Button returns a button, which locale is dependent on the context. The given optional argument will be passed to the template engine. 

buttons:
	item:
		unique: item
		callback_data: {{.ID}}
		text: Item #{{.Number}}

Usage: 

btns := make([]tele.Btn, len(items))
for i, item := range items {
	btns[i] = lt.Button(c, "item", struct {
		Number int
		Item   Item
	}{
		Number: i,
		Item:   item,
	})
}

m := b.NewMarkup()
m.Inline(m.Row(btns...))
// Your generated markup is ready.

func (*Layout) ButtonLocale 

func (lt *Layout) ButtonLocale(locale, k string, args ...interface{}) *tele.Btn

ButtonLocale returns a localized button processed with text/template engine. See Button for more details.

func (*Layout) Callback 

func (lt *Layout) Callback(k string) tele.CallbackEndpoint

Callback returns a callback endpoint used to handle buttons.

Example: 

// Handling settings button
b.Handle(lt.Callback("settings"), onSettings)

func (*Layout) Commands 

func (lt *Layout) Commands() (cmds []tele.Command)

Commands returns a list of telebot commands, which can be used in b.SetCommands later.

func (*Layout) CommandsLocale 

func (lt *Layout) CommandsLocale(locale string, args ...interface{}) (cmds []tele.Command)

CommandsLocale returns a list of telebot commands and localized description, which can be used in b.SetCommands later.

Example of bot.yml: 

commands:
  /start: '{{ text `cmdStart` }}'

en.yml: 

cmdStart: Start the bot

ru.yml: 

cmdStart: Запуск бота

Usage: 

b.SetCommands(lt.CommandsLocale("en"), "en")
b.SetCommands(lt.CommandsLocale("ru"), "ru")

func (*Layout) Locale 

func (lt *Layout) Locale(c tele.Context) (string, bool)

Locale returns the context locale.

func (*Layout) Locales 

func (lt *Layout) Locales() []string

Locales returns all presented locales.

func (*Layout) Markup 

func (lt *Layout) Markup(c tele.Context, k string, args ...interface{}) *tele.ReplyMarkup

Markup returns a markup, which locale is dependent on the context. The given optional argument will be passed to the template engine. 

buttons:
	settings: 'Settings'
markups:
	menu:
	- [settings]

Usage: 

func onStart(c tele.Context) error {
	return c.Send(
		lt.Text(c, "start"),
		lt.Markup(c, "menu"),
	)
}

func (*Layout) MarkupLocale 

func (lt *Layout) MarkupLocale(locale, k string, args ...interface{}) *tele.ReplyMarkup

MarkupLocale returns a localized markup processed with text/template engine. See Markup for more details.

func (*Layout) Middleware 

func (lt *Layout) Middleware(defaultLocale string, localeFunc ...LocaleFunc) tele.MiddlewareFunc

func (*Layout) Result 

func (lt *Layout) Result(c tele.Context, k string, args ...interface{}) tele.Result

Result returns an inline result, which locale is dependent on the context. The given optional argument will be passed to the template engine. 

results:
	article:
		type: article
		id: '{{ .ID }}'
		title: '{{ .Title }}'
		description: '{{ .Description }}'
		message_text: '{{ .Content }}'
		thumb_url: '{{ .PreviewURL }}'

Usage: 

func onQuery(c tele.Context) error {
	results := make(tele.Results, len(articles))
	for i, article := range articles {
		results[i] = lt.Result(c, "article", article)
	}
	return c.Answer(&tele.QueryResponse{
		Results:   results,
		CacheTime: 100,
	})
}

func (*Layout) ResultLocale 

func (lt *Layout) ResultLocale(locale, k string, args ...interface{}) tele.Result

ResultLocale returns a localized result processed with text/template engine. See Result for more details.

func (*Layout) SetLocale 

func (lt *Layout) SetLocale(c tele.Context, locale string)

SetLocale allows you to change a locale for the passed context.

func (*Layout) Settings 

func (lt *Layout) Settings() tele.Settings

Settings returns built telebot Settings required for bot initializing. 

settings:
	url: (custom url if needed)
	token: (not recommended)
	updates: (chan capacity)
	locales_dir: (optional)
	token_env: (token env var name, example: TOKEN)
	parse_mode: (default parse mode)
	long_poller: (long poller settings)
	webhook: (or webhook settings)

Usage: 

lt, err := layout.New("bot.yml")
b, err := tele.NewBot(lt.Settings())
// That's all!

func (*Layout) Text 

func (lt *Layout) Text(c tele.Context, k string, args ...interface{}) string

Text returns a text, which locale is dependent on the context. The given optional argument will be passed to the template engine.

Example of en.yml: 

start: Hi, {{.FirstName}}!

Usage: 

func onStart(c tele.Context) error {
	return c.Send(lt.Text(c, "start", c.Sender()))
}

func (*Layout) TextLocale 

func (lt *Layout) TextLocale(locale, k string, args ...interface{}) string

TextLocale returns a localized text processed with text/template engine. See Text for more details.

func (*Layout) UnmarshalYAML 

func (lt *Layout) UnmarshalYAML(data []byte) error

type LocaleFunc 

type LocaleFunc func(*tele.User) string

type Markup 

type Markup struct {
	ResizeKeyboard  *bool `yaml:"resize_keyboard,omitempty"` // nil == true
	ForceReply      bool  `yaml:"force_reply,omitempty"`
	OneTimeKeyboard bool  `yaml:"one_time_keyboard,omitempty"`
	RemoveKeyboard  bool  `yaml:"remove_keyboard,omitempty"`
	Selective       bool  `yaml:"selective,omitempty"`
	// contains filtered or unexported fields
}

Markup represents layout-specific markup to be parsed.

type Result 

type Result struct {
	tele.ResultBase `yaml:",inline"`
	Content         ResultContent `yaml:"content"`
	Markup          string        `yaml:"markup"`
	// contains filtered or unexported fields
}

Result represents layout-specific result to be parsed.

type ResultBase 

type ResultBase struct {
	tele.ResultBase `yaml:",inline"`
	Content         ResultContent `yaml:"content"`
}

ResultBase represents layout-specific result's base to be parsed.

type ResultContent 

type ResultContent map[string]interface{}

ResultContent represents any kind of InputMessageContent and implements it.

func (ResultContent) IsInputMessageContent 

func (ResultContent) IsInputMessageContent() bool

IsInputMessageContent implements telebot.InputMessageContent.

type Settings 

type Settings struct {
	URL     string
	Token   string
	Updates int

	LocalesDir string `yaml:"locales_dir"`
	TokenEnv   string `yaml:"token_env"`
	ParseMode  string `yaml:"parse_mode"`

	Webhook    *tele.Webhook    `yaml:"webhook"`
	LongPoller *tele.LongPoller `yaml:"long_poller"`
}

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.