151 lines
3.4 KiB
Go
151 lines
3.4 KiB
Go
package app
|
|
|
|
import (
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/config"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/db"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/handler"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/handler/iface"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/locale"
|
|
"gitea.neur0tx.site/Neur0toxine/vegapokerbot/internal/logger"
|
|
"github.com/mymmrac/telego"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
type App struct {
|
|
Logger *zap.SugaredLogger
|
|
Telegram *telego.Bot
|
|
BotProfile *telego.User
|
|
Config *config.Config
|
|
Repositories *db.Repositories
|
|
Handlers map[handler.Type]handler.Handler
|
|
}
|
|
|
|
func (a *App) Start() error {
|
|
if err := a.loadConfig(); err != nil {
|
|
return err
|
|
}
|
|
if err := a.initLogger(); err != nil {
|
|
return err
|
|
}
|
|
if a.Config.Debug {
|
|
a.Logger.Debugf("loaded configuration: %+v", a.Config)
|
|
}
|
|
if err := a.migrateDB(); err != nil {
|
|
return err
|
|
}
|
|
if err := a.initDB(); err != nil {
|
|
return err
|
|
}
|
|
if err := a.initTelegram(); err != nil {
|
|
return err
|
|
}
|
|
a.initHandlers()
|
|
a.Logger.Info("Vega Poker Bot is running")
|
|
return a.longPoll()
|
|
}
|
|
|
|
func (a *App) Log() *zap.SugaredLogger {
|
|
return a.Logger
|
|
}
|
|
|
|
func (a *App) TG() *telego.Bot {
|
|
return a.Telegram
|
|
}
|
|
|
|
func (a *App) TGProfile() *telego.User {
|
|
return a.BotProfile
|
|
}
|
|
|
|
func (a *App) Conf() *config.Config {
|
|
return a.Config
|
|
}
|
|
|
|
func (a *App) DB() iface.Repositories {
|
|
return &DBWrapper{a.Repositories}
|
|
}
|
|
|
|
func (a *App) Localizer(lang string) locale.Localizer {
|
|
return locale.For(lang)
|
|
}
|
|
|
|
func (a *App) loadConfig() error {
|
|
config, err := config.LoadConfig()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
a.Config = config
|
|
return nil
|
|
}
|
|
|
|
func (a *App) initLogger() error {
|
|
var err error
|
|
a.Logger, err = logger.NewLogger(a.Config.Debug)
|
|
return err
|
|
}
|
|
|
|
func (a *App) migrateDB() error {
|
|
return db.Migrate(a.Config.PostgresDSN)
|
|
}
|
|
|
|
func (a *App) initDB() error {
|
|
conn, err := db.Connect(a.Config.PostgresDSN)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
a.Repositories = db.InitRepositories(conn)
|
|
return nil
|
|
}
|
|
|
|
func (a *App) initTelegram() error {
|
|
var err error
|
|
a.Telegram, err = telego.NewBot(a.Config.TelegramToken, logger.WrapForTelego(a.Logger, a.Config.Debug))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
a.BotProfile, err = a.Telegram.GetMe()
|
|
return err
|
|
}
|
|
|
|
func (a *App) initHandlers() {
|
|
a.Handlers = map[handler.Type]handler.Handler{
|
|
handler.Noop: handler.NewNoopHandler(a.Logger, a.Config.Debug),
|
|
handler.Message: handler.NewMessageHandler(a),
|
|
handler.ChatMemberUpdated: handler.NewChatMemberUpdatedHandler(a),
|
|
handler.CallbackQuery: handler.NewCallbackQueryHandler(a),
|
|
}
|
|
}
|
|
|
|
func (a *App) handler(update telego.Update) handler.Handler {
|
|
if update.Message != nil {
|
|
return a.Handlers[handler.Message]
|
|
}
|
|
if update.MyChatMember != nil {
|
|
return a.Handlers[handler.ChatMemberUpdated]
|
|
}
|
|
if update.CallbackQuery != nil {
|
|
return a.Handlers[handler.CallbackQuery]
|
|
}
|
|
return a.Handlers[handler.Noop]
|
|
}
|
|
|
|
func (a *App) longPoll() error {
|
|
updates, err := a.Telegram.UpdatesViaLongPolling(nil)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer a.Telegram.StopLongPolling()
|
|
for update := range updates {
|
|
go func() {
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
a.Logger.Errorf("recovered from panic inside the handler: %v", r)
|
|
}
|
|
}()
|
|
if err := a.handler(update).Handle(update); err != nil {
|
|
a.Logger.Errorf("error while handling the update: %s", err)
|
|
}
|
|
}()
|
|
}
|
|
return nil
|
|
}
|