Initial commit

2026-08-05 19:31:35 +03:00
commit a33fa24e99
272 changed files with 40566 additions and 0 deletions
@@ -0,0 +1,427 @@
+package bot
+
+import (
+	"context"
+	"crypto/sha256"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"strings"
+	"sync"
+
+	"github.com/NicoNex/echotron/v3"
+	"github.com/TelegramExchange/tgex-backend/tg_bot/backend"
+	"github.com/rs/zerolog/log"
+)
+
+type exec struct {
+	handled      bool // Событие обработано, дальше не идём
+	transitioned bool // Был SetState
+}
+
+var botUsername string
+
+func SetUsername(username string) { botUsername = username }
+
+func Username() string { return botUsername }
+
+type lastRender struct {
+	textHash string
+	kbHash   string
+	isMedia  bool
+}
+
+type Bot struct {
+	echotron.API
+	mu                   sync.Mutex
+	ChatID               int64
+	exec                 *exec
+	CurrentState         State
+	Session              *Session
+	LastMessageID        int // ID последнего сообщения с inline кнопками
+	lastRender           lastRender
+	commandRouter        func(cmd string) State          // Роутер для команд (например, /start, /help)
+	globalCallbackRouter func(callbackData string) State // Роутер для глобальных callbacks из уведомлений
+	Backend              *backend.Client
+}
+
+func NewBot(chatID int64, token string, commandRouter func(string) State, backendClient *backend.Client, globalCallbackRouter func(string) State) *Bot {
+	if commandRouter == nil {
+		panic("bot: commandRouter cannot be nil")
+	}
+	if globalCallbackRouter == nil {
+		panic("bot: globalCallbackRouter cannot be nil")
+	}
+	if commandRouter("/start") == nil {
+		panic("bot: commandRouter requires /start state answer")
+	}
+	if backendClient == nil {
+		panic("bot: backendClient cannot be nil")
+	}
+
+	api := echotron.NewAPI(token)
+
+	return &Bot{
+		ChatID:               chatID,
+		API:                  api,
+		Session:              &Session{},
+		commandRouter:        commandRouter,
+		Backend:              backendClient,
+		globalCallbackRouter: globalCallbackRouter,
+	}
+}
+
+// GetOrCreateJWT получает JWT токен, передавая актуальные данные пользователя из update
+func (b *Bot) GetOrCreateJWT(u *echotron.Update) error {
+	// Извлекаем данные пользователя из update
+	var user *echotron.User
+	if u.Message != nil && u.Message.From != nil {
+		user = u.Message.From
+	} else if u.CallbackQuery != nil && u.CallbackQuery.From != nil {
+		user = u.CallbackQuery.From
+	}
+
+	var username, firstName, lastName *string
+	if user != nil {
+		if user.Username != "" {
+			username = &user.Username
+		}
+		if user.FirstName != "" {
+			firstName = &user.FirstName
+		}
+		if user.LastName != "" {
+			lastName = &user.LastName
+		}
+	}
+
+	jwt, err := b.Backend.GetJWTByTelegramUser(context.Background(), b.ChatID, username, firstName, lastName)
+	if err != nil {
+		return err
+	}
+
+	b.Session.JWT = jwt
+
+	if firstName != nil {
+		b.Session.FirstName = *firstName
+	}
+
+	return nil
+}
+
+func (b *Bot) SetState(s State, mode RenderMode) {
+	log.Info().Msg(fmt.Sprintf("State transition: %T -> %T", b.CurrentState, s))
+
+	if b.CurrentState != nil {
+		b.CurrentState.Exit()
+	}
+
+	b.CurrentState = s
+
+	if b.exec != nil {
+		b.exec.transitioned = true
+		b.exec.handled = true
+	}
+
+	s.Enter(b, mode)
+}
+
+func (b *Bot) MarkHandled() {
+	if b.exec != nil {
+		b.exec.handled = true
+	}
+}
+
+func isChannelChat(chatType string) bool {
+	return chatType == "channel" || chatType == "supergroup"
+}
+
+func stringPtr(value string) *string {
+	if value == "" {
+		return nil
+	}
+	return &value
+}
+
+func (b *Bot) Render(text string, keyboard echotron.InlineKeyboardMarkup, mode RenderMode) {
+	switch mode {
+	case EditMessage:
+		b.Edit(text, keyboard)
+	case NewMessage:
+		b.SendNew(text, keyboard)
+	default:
+		panic("unknown RenderMode")
+	}
+}
+
+func (b *Bot) SetLastMessageIsMedia(isMedia bool) {
+	b.lastRender.isMedia = isMedia
+}
+
+func (b *Bot) DownloadFileBytes(fileID string) ([]byte, error) {
+	res, err := b.GetFile(fileID)
+	if err != nil {
+		return nil, err
+	}
+	if res.Result == nil || res.Result.FilePath == "" {
+		return nil, fmt.Errorf("telegram file not available")
+	}
+	return b.DownloadFile(res.Result.FilePath)
+}
+
+func (b *Bot) SendNew(text string, keyboard echotron.InlineKeyboardMarkup) {
+	if b.exec != nil {
+		defer func() { b.exec.handled = true }()
+	}
+
+	if b.LastMessageID != 0 {
+		log.Info().Int("cleanup_msg_id", b.LastMessageID).Msg("Cleaning up keyboard before SendNew")
+		b.cleanupKeyboard(b.LastMessageID)
+	}
+
+	res, err := b.SendMessage(text, b.ChatID, &echotron.MessageOptions{
+		ReplyMarkup:        keyboard,
+		ParseMode:          echotron.HTML,
+		LinkPreviewOptions: echotron.LinkPreviewOptions{IsDisabled: true},
+	})
+	if err != nil {
+		log.Error().Err(err).Msg("SendMessage failed")
+		return
+	}
+
+	if res.Result == nil {
+		return
+	}
+
+	b.LastMessageID = res.Result.ID
+	b.lastRender.isMedia = false
+	b.lastRender.textHash = hashString(text)
+	b.lastRender.kbHash = keyboardHash(keyboard)
+	log.Info().Int("new_last_msg_id", b.LastMessageID).Msg("Updated LastMessageID in SendNew")
+}
+
+func (b *Bot) Edit(text string, keyboard echotron.InlineKeyboardMarkup) {
+	if b.exec != nil {
+		defer func() { b.exec.handled = true }()
+	}
+
+	if b.LastMessageID == 0 {
+		b.SendNew(text, keyboard)
+		return
+	}
+
+	newTextHash := hashString(text)
+	newKBHash := keyboardHash(keyboard)
+
+	textChanged := newTextHash != b.lastRender.textHash
+	kbChanged := newKBHash != b.lastRender.kbHash
+
+	if !textChanged && !kbChanged {
+		log.Info().Msg("Edit skipped: message not modified")
+		return
+	}
+
+	var err error
+	msgID := echotron.NewMessageID(b.ChatID, b.LastMessageID)
+
+	if b.lastRender.isMedia {
+		_, err = b.EditMessageCaption(msgID, &echotron.MessageCaptionOptions{
+			Caption:     text,
+			ParseMode:   echotron.HTML,
+			ReplyMarkup: keyboard,
+		})
+	} else {
+		_, err = b.EditMessageText(text, msgID, &echotron.MessageTextOptions{
+			ReplyMarkup:        keyboard,
+			ParseMode:          echotron.HTML,
+			LinkPreviewOptions: echotron.LinkPreviewOptions{IsDisabled: true},
+		})
+	}
+
+	if err == nil {
+		if textChanged {
+			b.lastRender.textHash = newTextHash
+		}
+		if kbChanged {
+			b.lastRender.kbHash = newKBHash
+		}
+		return
+	}
+
+	switch {
+	case strings.Contains(err.Error(), "message is not modified"):
+		log.Err(err).Msg("EditMessageText ignored: message is not modified")
+	case strings.Contains(err.Error(), "no text in the message to edit"):
+		b.lastRender.isMedia = true
+		log.Err(err).Msg("EditMessageText ignored: message has no text")
+	default:
+		log.Error().Err(err).Msg("EditMessageText")
+	}
+
+}
+
+func keyboardHash(kb echotron.InlineKeyboardMarkup) string {
+	b, err := json.Marshal(kb)
+	if err != nil {
+		return ""
+	}
+	sum := sha256.Sum256(b)
+	return hex.EncodeToString(sum[:])
+}
+
+func hashString(v string) string {
+	sum := sha256.Sum256([]byte(v))
+	return hex.EncodeToString(sum[:])
+}
+
+func (b *Bot) Update(u *echotron.Update) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	log.Info().Int64("chat_id", b.ChatID).Msg("Update received")
+
+	// 1. Системные события -> отправляем доменные события в backend
+	if u.ChatJoinRequest != nil || u.ChatMember != nil || u.MyChatMember != nil {
+		go b.forwardSystemEvent(u)
+		return
+	}
+
+	// 2. Игнорируем события не из private чатов
+	chatType := ""
+	switch {
+	case u.Message != nil:
+		chatType = u.Message.Chat.Type
+	case u.CallbackQuery != nil && u.CallbackQuery.Message != nil:
+		chatType = u.CallbackQuery.Message.Chat.Type
+	case u.EditedMessage != nil:
+		chatType = u.EditedMessage.Chat.Type
+	case u.ChannelPost != nil || u.EditedChannelPost != nil:
+		return // Каналы игнорируем сразу
+	}
+	if chatType != "" && chatType != "private" {
+		log.Debug().Str("chat_type", chatType).Msg("Ignoring non-private chat")
+		return
+	}
+
+	// 3. Игнорируем edited messages
+	if u.EditedMessage != nil || u.EditedChannelPost != nil || u.EditedBusinessMessage != nil {
+		log.Debug().Msg("Ignoring edited message")
+		return
+	}
+
+	err := b.GetOrCreateJWT(u)
+	if err != nil || b.Session.JWT == "" {
+		b.Edit(
+			"❌ Ошибка авторизации",
+			echotron.InlineKeyboardMarkup{InlineKeyboard: [][]echotron.InlineKeyboardButton{{{Text: "↻ Обновить", CallbackData: "refresh"}}}},
+		)
+		b.cleanupCallbackUI(u)
+		return
+	}
+
+	e := &exec{}
+	b.exec = e
+	defer func() { b.exec = nil }()
+
+	isStartCommand := u.Message != nil && (u.Message.Text == "/start" ||
+		u.Message.Text == "/start login" ||
+		strings.HasPrefix(u.Message.Text, "/start project_"))
+
+	if b.CurrentState == nil && !isStartCommand {
+		b.Session.WasRestarted = true
+		b.SetState(b.commandRouter("/start"), EditMessage)
+		return
+	}
+
+	// === Обработка входящего события ===
+
+	// 1. Команды (приоритетный маршрут)
+	if u.Message != nil {
+		if strings.HasPrefix(u.Message.Text, "/") {
+			b.SetState(b.commandRouter(u.Message.Text), NewMessage)
+			return
+		}
+
+		b.CurrentState.HandleMessage(b, u)
+		if e.handled || e.transitioned {
+			return
+		}
+	}
+
+	// 2. Callback запросы
+	if u.CallbackQuery != nil {
+		b.cleanupCallbackUI(u)
+
+		switch u.CallbackQuery.Data {
+		case "empty":
+			return
+		case "refresh":
+			if b.CurrentState != nil {
+				b.CurrentState.Enter(b, EditMessage)
+				e.handled = true
+			}
+			return
+		}
+
+		if newState := b.globalCallbackRouter(u.CallbackQuery.Data); newState != nil {
+			b.SetState(newState, NewMessage)
+			return
+		}
+
+		b.CurrentState.HandleCallback(b, u)
+		if e.handled || e.transitioned {
+			return
+		}
+	}
+
+	// 3. Универсальный обработчик состояния (если ничего не подошло)
+	b.CurrentState.Handle(b, u)
+	if e.handled || e.transitioned {
+		return
+	}
+
+	// 4. Fallback - ререндер текущего экрана, чтобы не терять прогресс
+	if b.CurrentState != nil {
+		mode := NewMessage
+		if u.CallbackQuery != nil {
+			mode = EditMessage
+		}
+		b.CurrentState.Enter(b, mode)
+		if e.handled || e.transitioned {
+			return
+		}
+	}
+
+	// 5. Крайний fallback - сброс в начальное состояние
+	b.SetState(b.commandRouter("/start"), NewMessage)
+}
+
+func (b *Bot) cleanupKeyboard(messageID int) {
+	var emptyKeyboard = echotron.InlineKeyboardMarkup{
+		InlineKeyboard: [][]echotron.InlineKeyboardButton{},
+	}
+	_, err := b.EditMessageReplyMarkup(
+		echotron.NewMessageID(b.ChatID, messageID),
+		&echotron.MessageReplyMarkupOptions{ReplyMarkup: emptyKeyboard},
+	)
+	if err != nil {
+		log.Error().Err(err).Int("message_id", messageID).Msg("Failed to remove keyboard")
+	}
+}
+
+func (b *Bot) cleanupCallbackUI(u *echotron.Update) {
+	_, err := b.AnswerCallbackQuery(u.CallbackQuery.ID, nil)
+	if err != nil {
+		log.Error().Err(err).Msg("b.AnswerCallbackQuery error")
+	}
+
+	if u.CallbackQuery.Message != nil {
+		callbackMessageID := u.CallbackQuery.Message.ID
+
+		// Если это сообщение последнее, не удаляем клавиатуру
+		if b.LastMessageID == callbackMessageID {
+			return
+		}
+
+		b.cleanupKeyboard(callbackMessageID)
+	}
+}
@@ -0,0 +1,196 @@
+package bot
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/NicoNex/echotron/v3"
+	"github.com/rs/zerolog/log"
+)
+
+func (b *Bot) forwardSystemEvent(u *echotron.Update) {
+	ctx := context.Background()
+
+	switch {
+	case u.ChatJoinRequest != nil:
+		req := u.ChatJoinRequest
+		if !isChannelChat(req.Chat.Type) {
+			return
+		}
+
+		inviteLink := ""
+		if req.InviteLink != nil {
+			inviteLink = req.InviteLink.InviteLink
+		}
+		if inviteLink == "" {
+			log.Debug().Msg("No invite link in chat join request")
+			return
+		}
+
+		userID := req.From.ID
+		username := stringPtr(req.From.Username)
+		firstName := stringPtr(req.From.FirstName)
+		lastName := stringPtr(req.From.LastName)
+		if userID == 0 && req.UserChatID != 0 {
+			userID = req.UserChatID
+		}
+		if userID == 0 {
+			log.Error().Msg("No user id in chat join request")
+			return
+		}
+
+		payload := map[string]any{
+			"type":             "subscription",
+			"user_telegram_id": userID,
+			"invite_link":      inviteLink,
+			"username":         username,
+			"first_name":       firstName,
+			"last_name":        lastName,
+		}
+		if err := b.Backend.SendEvent(ctx, payload); err != nil {
+			log.Error().Err(err).Msg("Failed to send subscription event")
+		}
+
+	case u.ChatMember != nil:
+		event := u.ChatMember
+		if !isChannelChat(event.Chat.Type) {
+			return
+		}
+
+		memberUser := event.NewChatMember.User
+		if memberUser == nil {
+			log.Error().Msg("No user in chat member update")
+			return
+		}
+
+		oldStatus := event.OldChatMember.Status
+		newStatus := event.NewChatMember.Status
+
+		wasNotMember := oldStatus == "left" || oldStatus == "kicked"
+		isNowMember := newStatus == "member" || newStatus == "administrator" || newStatus == "creator"
+		userJoined := wasNotMember && isNowMember
+
+		wasMember := oldStatus == "member" || oldStatus == "administrator" || oldStatus == "creator" || oldStatus == "restricted"
+		isNowNotMember := newStatus == "left" || newStatus == "kicked"
+		userLeft := wasMember && isNowNotMember
+
+		if userJoined {
+			inviteLink := ""
+			if event.InviteLink != nil {
+				inviteLink = event.InviteLink.InviteLink
+			}
+			if inviteLink == "" {
+				log.Debug().Msg("No invite link in chat member update")
+				return
+			}
+
+			username := stringPtr(memberUser.Username)
+			firstName := stringPtr(memberUser.FirstName)
+			lastName := stringPtr(memberUser.LastName)
+			payload := map[string]any{
+				"type":             "subscription",
+				"user_telegram_id": memberUser.ID,
+				"invite_link":      inviteLink,
+				"username":         username,
+				"first_name":       firstName,
+				"last_name":        lastName,
+			}
+			if err := b.Backend.SendEvent(ctx, payload); err != nil {
+				log.Error().Err(err).Msg("Failed to send subscription event")
+			}
+			return
+		}
+
+		if userLeft {
+			payload := map[string]any{
+				"type":                "unsubscription",
+				"user_telegram_id":    memberUser.ID,
+				"channel_telegram_id": event.Chat.ID,
+			}
+			if err := b.Backend.SendEvent(ctx, payload); err != nil {
+				log.Error().Err(err).Msg("Failed to send unsubscription event")
+			}
+		}
+
+	case u.MyChatMember != nil:
+		event := u.MyChatMember
+		if !isChannelChat(event.Chat.Type) {
+			return
+		}
+
+		actorID := event.From.ID
+		if actorID == 0 {
+			log.Error().Msg("No user in my chat member update")
+			return
+		}
+
+		oldStatus := event.OldChatMember.Status
+		newStatus := event.NewChatMember.Status
+
+		wasMember := oldStatus == "administrator" || oldStatus == "member"
+		isNowNotMember := newStatus == "left" || newStatus == "kicked"
+		botRemoved := wasMember && isNowNotMember
+
+		permissionsChanged := oldStatus == "administrator" && newStatus == "administrator"
+
+		if botRemoved {
+			payload := map[string]any{
+				"type":             "bot_removed",
+				"telegram_id":      event.Chat.ID,
+				"user_telegram_id": actorID,
+			}
+			if err := b.Backend.SendEvent(ctx, payload); err != nil {
+				log.Error().Err(err).Msg("Failed to send bot removed event")
+			}
+			return
+		}
+
+		if permissionsChanged {
+			title := event.Chat.Title
+			if title == "" {
+				title = fmt.Sprintf("Channel %d", event.Chat.ID)
+			}
+			payload := map[string]any{
+				"type":             "bot_permissions",
+				"telegram_id":      event.Chat.ID,
+				"chat_title":       title,
+				"user_telegram_id": actorID,
+				"permissions": map[string]any{
+					"is_admin":             newStatus == "administrator",
+					"can_invite_users":     event.NewChatMember.CanInviteUsers,
+					"can_restrict_members": event.NewChatMember.CanRestrictMembers,
+				},
+			}
+			if err := b.Backend.SendEvent(ctx, payload); err != nil {
+				log.Error().Err(err).Msg("Failed to send bot permissions event")
+			}
+			return
+		}
+
+		wasNotMember := oldStatus == "left" || oldStatus == "kicked"
+		isNowMember := newStatus == "administrator" || newStatus == "member"
+		botAdded := wasNotMember && isNowMember
+
+		if botAdded {
+			title := event.Chat.Title
+			if title == "" {
+				title = fmt.Sprintf("Channel %d", event.Chat.ID)
+			}
+			payload := map[string]any{
+				"type":             "bot_added",
+				"telegram_id":      event.Chat.ID,
+				"title":            title,
+				"username":         stringPtr(event.Chat.Username),
+				"user_telegram_id": actorID,
+				"bot_permissions": map[string]any{
+					"is_admin":             newStatus == "administrator",
+					"can_invite_users":     event.NewChatMember.CanInviteUsers,
+					"can_restrict_members": event.NewChatMember.CanRestrictMembers,
+				},
+			}
+			if err := b.Backend.SendEvent(ctx, payload); err != nil {
+				log.Error().Err(err).Msg("Failed to send bot added event")
+			}
+		}
+	}
+}
@@ -0,0 +1,25 @@
+package bot
+
+import "github.com/NicoNex/echotron/v3"
+
+type RenderMode int
+
+const (
+	NewMessage RenderMode = iota
+	EditMessage
+)
+
+type State interface {
+	Enter(*Bot, RenderMode)
+	HandleCallback(*Bot, *echotron.Update)
+	HandleMessage(*Bot, *echotron.Update)
+	Handle(*Bot, *echotron.Update)
+	Exit() // Вызывается при выходе из состояния для cleanup (например, отмены горутин)
+}
+
+type Session struct {
+	FirstName    string
+	JWT          string
+	WorkspaceID  string
+	WasRestarted bool
+}