146 lines
3.0 KiB
Go
146 lines
3.0 KiB
Go
package tgcore
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"strings"
|
|
)
|
|
|
|
var API string
|
|
|
|
func Init(token string) {
|
|
API = "https://api.telegram.org/bot" + token
|
|
}
|
|
|
|
func TG(method string, body interface{}) (map[string]interface{}, error) {
|
|
jsonBody, err := json.Marshal(body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := http.Post(API+"/"+method, "application/json", bytes.NewReader(jsonBody))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
data, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var result map[string]interface{}
|
|
if err := json.Unmarshal(data, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
return result, nil
|
|
}
|
|
|
|
func Allowed(chatID int64, allowedIDs []int64) bool {
|
|
if len(allowedIDs) == 0 {
|
|
return true
|
|
}
|
|
for _, id := range allowedIDs {
|
|
if id == chatID {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func SendMessage(chatID int64, text string, opts map[string]interface{}) error {
|
|
safeText := text
|
|
body := map[string]interface{}{
|
|
"chat_id": chatID,
|
|
"text": safeText,
|
|
"parse_mode": "HTML",
|
|
"disable_web_page_preview": true,
|
|
}
|
|
if opts != nil {
|
|
for k, v := range opts {
|
|
body[k] = v
|
|
}
|
|
}
|
|
|
|
_, err := TG("sendMessage", body)
|
|
if err != nil && (strings.Contains(err.Error(), "parse") || strings.Contains(err.Error(), "HTML")) {
|
|
delete(body, "parse_mode")
|
|
_, err = TG("sendMessage", body)
|
|
}
|
|
return err
|
|
}
|
|
|
|
// TgHandler is the callback handler interface
|
|
type TgHandler interface {
|
|
List(chatID int64, page string)
|
|
Links(chatID int64, page string)
|
|
Feeds(chatID int64, page string)
|
|
// Session callbacks
|
|
SessionCallback(chatID int64, action string)
|
|
MenuCallback(chatID int64, action string)
|
|
}
|
|
|
|
func HandleCallback(chatID int64, queryID string, data string, h TgHandler) {
|
|
if data == "" {
|
|
return
|
|
}
|
|
|
|
// Session callbacks
|
|
if strings.HasPrefix(data, "session_") {
|
|
action := strings.TrimPrefix(data, "session_")
|
|
if h != nil {
|
|
h.SessionCallback(chatID, action)
|
|
}
|
|
TG("answerCallbackQuery", map[string]interface{}{"callback_query_id": queryID})
|
|
return
|
|
}
|
|
|
|
// Menu callbacks
|
|
if strings.HasPrefix(data, "menu_") {
|
|
action := strings.TrimPrefix(data, "menu_")
|
|
if h != nil {
|
|
h.MenuCallback(chatID, action)
|
|
}
|
|
TG("answerCallbackQuery", map[string]interface{}{"callback_query_id": queryID})
|
|
return
|
|
}
|
|
|
|
// Pagination callbacks: list_N, links_N, feeds_N
|
|
parts := strings.SplitN(data, "_", 2)
|
|
if len(parts) == 2 {
|
|
cmd := parts[0]
|
|
page := parts[1]
|
|
if h != nil {
|
|
switch cmd {
|
|
case "list":
|
|
h.List(chatID, page)
|
|
case "links":
|
|
h.Links(chatID, page)
|
|
case "feeds":
|
|
h.Feeds(chatID, page)
|
|
}
|
|
}
|
|
}
|
|
TG("answerCallbackQuery", map[string]interface{}{"callback_query_id": queryID})
|
|
}
|
|
|
|
func GetInt64(m map[string]interface{}, key string) int64 {
|
|
if v, ok := m[key]; ok {
|
|
switch n := v.(type) {
|
|
case float64:
|
|
return int64(n)
|
|
case int64:
|
|
return n
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
func GetString(m map[string]interface{}, key string) string {
|
|
if v, ok := m[key]; ok {
|
|
if s, ok := v.(string); ok {
|
|
return s
|
|
}
|
|
}
|
|
return ""
|
|
}
|