tss/telegram/telegram.go

package telegram

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

	"go.balki.me/tss/limiter"
	"go.balki.me/tss/log"
)

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

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

func (ts *telegramSender) SendLink(link, channel, rhash, title string) error {
	if title == "" {
		title = "Link"
	}
	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">%s</a>`, genIVLink(link, rhash), link, title),
		ParseMode: "HTML",
	}
	data, err := json.Marshal(msg)

	if err != nil {
		return err
	}

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

	ts.rateLimiterPerMin.Wait()
	ts.rateLimiterPerSec.Wait()

	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: limiter.NewLimiter((60+15)*time.Second, 20),
		// 1 msg per sec with some buffer
		rateLimiterPerSec: limiter.NewLimiter(1100*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()
}