package utils import ( "EverythingSuckz/fsb/config" "EverythingSuckz/fsb/internal/cache" "EverythingSuckz/fsb/internal/types" "context" "errors" "fmt" "math/rand" "strings" "github.com/celestix/gotgproto" "github.com/celestix/gotgproto/ext" "github.com/celestix/gotgproto/storage" "github.com/gotd/td/telegram/uploader" "github.com/gotd/td/tg" "go.uber.org/zap" ) // https://stackoverflow.com/a/70802740/15807350 func Contains[T comparable](s []T, e T) bool { for _, v := range s { if v == e { return true } } return false } // IsClientDisconnectError checks if the error is due to client disconnecting // e.g. user seeking in video, stopping playback, or network issues on client side func IsClientDisconnectError(err error) bool { if err == nil { return false } errStr := err.Error() return strings.Contains(errStr, "connection was aborted") || strings.Contains(errStr, "connection reset by peer") || strings.Contains(errStr, "broken pipe") || strings.Contains(errStr, "forcibly closed") } // telegram helper functions // TODO: move these to a separate package if they grow too large func GetTGMessage(ctx context.Context, client *gotgproto.Client, messageID int) (*tg.Message, error) { inputMessageID := tg.InputMessageClass(&tg.InputMessageID{ID: messageID}) channel, err := GetLogChannelPeer(ctx, client.API(), client.PeerStorage) if err != nil { return nil, err } messageRequest := tg.ChannelsGetMessagesRequest{Channel: channel, ID: []tg.InputMessageClass{inputMessageID}} res, err := client.API().ChannelsGetMessages(ctx, &messageRequest) if err != nil { return nil, err } messages := res.(*tg.MessagesChannelMessages) message := messages.Messages[0] if _, ok := message.(*tg.Message); ok { return message.(*tg.Message), nil } else { return nil, fmt.Errorf("this file was deleted") } } func FileFromMedia(media tg.MessageMediaClass) (*types.File, error) { switch media := media.(type) { case *tg.MessageMediaDocument: document, ok := media.Document.AsNotEmpty() if !ok { return nil, fmt.Errorf("unexpected type %T", media) } var fileName string for _, attribute := range document.Attributes { if name, ok := attribute.(*tg.DocumentAttributeFilename); ok { fileName = name.FileName break } } return &types.File{ Location: document.AsInputDocumentFileLocation(), FileSize: document.Size, FileName: fileName, MimeType: document.MimeType, ID: document.ID, }, nil case *tg.MessageMediaPhoto: photo, ok := media.Photo.AsNotEmpty() if !ok { return nil, fmt.Errorf("unexpected type %T", media) } sizes := photo.Sizes if len(sizes) == 0 { return nil, errors.New("photo has no sizes") } photoSize := sizes[len(sizes)-1] size, ok := photoSize.AsNotEmpty() if !ok { return nil, errors.New("photo size is empty") } location := new(tg.InputPhotoFileLocation) location.ID = photo.GetID() location.AccessHash = photo.GetAccessHash() location.FileReference = photo.GetFileReference() location.ThumbSize = size.GetType() return &types.File{ Location: location, FileSize: 0, // caller should judge if this is a photo or not FileName: fmt.Sprintf("photo_%d.jpg", photo.GetID()), MimeType: "image/jpeg", ID: photo.GetID(), }, nil } return nil, fmt.Errorf("unexpected type %T", media) } func FileFromMessage(ctx context.Context, client *gotgproto.Client, messageID int) (*types.File, error) { key := fmt.Sprintf("file:%d:%d", messageID, client.Self.ID) log := Logger.Named("GetMessageMedia") var cachedMedia types.File err := cache.GetCache().Get(key, &cachedMedia) if err == nil { log.Debug("Using cached media message properties", zap.Int("messageID", messageID), zap.Int64("clientID", client.Self.ID)) return &cachedMedia, nil } log.Debug("Fetching file properties from message ID", zap.Int("messageID", messageID), zap.Int64("clientID", client.Self.ID)) message, err := GetTGMessage(ctx, client, messageID) if err != nil { return nil, err } file, err := FileFromMedia(message.Media) if err != nil { return nil, err } err = cache.GetCache().Set( key, file, 3600, ) if err != nil { return nil, err } return file, nil } func GetLogChannelPeer(ctx context.Context, api *tg.Client, peerStorage *storage.PeerStorage) (*tg.InputChannel, error) { cachedInputPeer := peerStorage.GetInputPeerById(config.ValueOf.LogChannelID) switch peer := cachedInputPeer.(type) { case *tg.InputPeerEmpty: break case *tg.InputPeerChannel: return &tg.InputChannel{ ChannelID: peer.ChannelID, AccessHash: peer.AccessHash, }, nil default: return nil, errors.New("unexpected type of input peer") } inputChannel := &tg.InputChannel{ ChannelID: config.ValueOf.LogChannelID, } channels, err := api.ChannelsGetChannels(ctx, []tg.InputChannelClass{inputChannel}) if err != nil { return nil, err } if len(channels.GetChats()) == 0 { return nil, errors.New("no channels found") } channel, ok := channels.GetChats()[0].(*tg.Channel) if !ok { return nil, errors.New("type assertion to *tg.Channel failed") } // Bruh, I literally have to call library internal functions at this point peerStorage.AddPeer(channel.GetID(), channel.AccessHash, storage.TypeChannel, "") return channel.AsInput(), nil } func ForwardMessages(ctx *ext.Context, fromChatId, toChatId int64, messageID int) (*tg.Updates, error) { fromPeer := ctx.PeerStorage.GetInputPeerById(fromChatId) if fromPeer.Zero() { return nil, fmt.Errorf("fromChatId: %d is not a valid peer", fromChatId) } toPeer, err := GetLogChannelPeer(ctx, ctx.Raw, ctx.PeerStorage) if err != nil { return nil, err } update, err := ctx.Raw.MessagesForwardMessages(ctx, &tg.MessagesForwardMessagesRequest{ RandomID: []int64{rand.Int63()}, FromPeer: fromPeer, ID: []int{messageID}, ToPeer: &tg.InputPeerChannel{ChannelID: toPeer.ChannelID, AccessHash: toPeer.AccessHash}, }) if err != nil { return nil, err } return update.(*tg.Updates), nil } // UploadToTG uploads a file to Telegram using MTProto directly and returns error if any. func UploadToTG(ctx *ext.Context, chatID int64, fileData []byte, fileName string) error { u := uploader.NewUploader(ctx.Raw) // uploader.FromBytes handles the chunking and uploading logic via MTProto file, err := u.FromBytes(ctx.Context, fileName, fileData) if err != nil { return fmt.Errorf("failed to upload via MTProto: %v", err) } media := &tg.InputMediaUploadedDocument{ File: file, MimeType: "text/plain", Attributes: []tg.DocumentAttributeClass{ &tg.DocumentAttributeFilename{FileName: fileName}, }, } _, err = ctx.SendMedia(chatID, &tg.MessagesSendMediaRequest{ Media: media, }) if err != nil { return fmt.Errorf("failed to send media via MTProto: %v", err) } return nil }