tss/telegram/telegram.go

package telegram

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"time"

	"go.balki.me/tss/log"
	"golang.org/x/time/rate"
)

type TelegramSender interface {
	SendLink(link, channel, rhash string) error
}

type telegramSender struct {
	client            *http.Client
	authToken         string
	rateLimiterPerMin *rate.Limiter
	rateLimiterPerSec *rate.Limiter
}

func (ts *telegramSender) SendLink(link string, channel string, rhash string) error {
	msg := struct {
		ChatID    string `json:"chat_id"`
		Text      string `json:"text"`
		ParseMode string `json:"parse_mode"`
	}{
		ChatID:    channel,
		Text:      fmt.Sprintf(`<a href="%s">➢</a> <a href="%s">Link</a>`, genIVLink(link, rhash), link),
		ParseMode: "HTML",
	}
	data, err := json.Marshal(msg)

	if err != nil {
		return err
	}

	apiUrl := fmt.Sprintf("https://api.telegram.org/bot%s/sendMessage", ts.authToken)

	err = ts.rateLimiterPerMin.Wait(context.TODO())
	if err != nil {
		return err
	}

	err = ts.rateLimiterPerSec.Wait(context.TODO())
	if err != nil {
		return err
	}

	res, err := ts.client.Post(apiUrl, "application/json", bytes.NewReader(data))
	if err != nil {
		return err
	}
	defer res.Body.Close()
	responseText, err := io.ReadAll(res.Body)
	if err != nil {
		return err
	}
	if res.StatusCode != http.StatusOK {
		log.Error("telegram send failed", "status", res.Status, "request", data, "response", responseText)
		return errors.New("telegram send failed")
	}
	log.Info("sent message on telegram", "link", link, "channel", channel, "response", responseText)
	return nil
}

func NewTelegramSender(transport http.RoundTripper, authToken string) TelegramSender {
	return &telegramSender{
		client:    &http.Client{Transport: transport},
		authToken: authToken,
		// 20 requests per min with some buffer
		rateLimiterPerMin: rate.NewLimiter(rate.Every(65*time.Second), 20),
		// 1 msg per sec with some buffer
		rateLimiterPerSec: rate.NewLimiter(rate.Every(1050*time.Millisecond), 1),
	}
}

func genIVLink(link, rhash string) string {
	if rhash == "" {
		return link
	}
	query := url.Values{}
	query.Set("url", link)
	query.Set("rhash", rhash)
	u := url.URL{
		Scheme:   "https",
		Host:     "t.me",
		Path:     "iv",
		RawQuery: query.Encode(),
	}
	return u.String()
}