парсер

tg_parser/internal/usecase/fetch_channel_meta.go

@@ -0,0 +1,11 @@
+package usecase
+
+import (
+	"context"
+
+	"github.com/TelegramExchange/tgex-parser/internal/domain"
+)
+
+func (uc *UseCase) FetchChannelMeta(ctx context.Context, username string) (domain.Channel, error) {
+	return uc.telegram.ParseChannelMeta(ctx, username)
+}

tg_parser/internal/usecase/fetch_channels.go

@@ -0,0 +1,112 @@
+package usecase
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/TelegramExchange/tgex-parser/pkg/transaction"
+	"github.com/rs/zerolog/log"
+
+	"github.com/TelegramExchange/tgex-parser/internal/domain"
+)
+
+func (uc *UseCase) FetchChannels(ctx context.Context) error {
+	channels := uc.database.GetChannels(ctx)
+
+	for _, c := range channels {
+		if c.Pts == 0 {
+			updatedChannel, err := uc.initializeChannel(ctx, c)
+			if err != nil {
+				return fmt.Errorf("uc.initializeChannel: %w", err)
+			}
+
+			c = updatedChannel
+		}
+
+		err := uc.processChannel(ctx, c)
+		if err != nil {
+			return fmt.Errorf("uc.processChannel: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func (uc *UseCase) processChannel(ctx context.Context, channel domain.Channel) error {
+	diff, err := uc.telegram.GetChannelDiff(ctx, channel, 20)
+	if err != nil {
+		return fmt.Errorf("telegram.GetChannelDiff: %w", err)
+	}
+
+	for _, p := range diff.NewPosts {
+		log.Info().Msgf("New post: %s - Views: %d, Text: %.10s...", p.Link, p.Views, p.Text)
+
+		err = uc.database.CreatePost(ctx, p)
+		if err != nil {
+			return fmt.Errorf("database.CreatePost: %w", err)
+		}
+	}
+
+	for _, p := range diff.DeletedPosts {
+		log.Info().Msgf("Deleted post: %s - Views: %d", p.Link, p.Views)
+
+		err = uc.database.DeletePost(ctx, p)
+		if err != nil {
+			return fmt.Errorf("database.DeletePost: %w", err)
+		}
+	}
+
+	// Update channel metadata if changed
+	if diff.UpdatedChannel != nil {
+		diff.UpdatedChannel.Pts = diff.NewPts
+		err = uc.database.UpdateChannel(ctx, *diff.UpdatedChannel)
+		if err != nil {
+			return fmt.Errorf("database.UpdateChannel: %w", err)
+		}
+	} else {
+		channel.Pts = diff.NewPts
+		err = uc.database.UpdateChannel(ctx, channel)
+		if err != nil {
+			return fmt.Errorf("database.UpdateChannel: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func (uc *UseCase) initializeChannel(ctx context.Context, channel domain.Channel) (domain.Channel, error) {
+	c, err := uc.telegram.ParseChannelMeta(ctx, channel.Username)
+	if err != nil {
+		return domain.Channel{}, fmt.Errorf("telegram.ParseChannelMeta: %w", err)
+	}
+
+	// Preserve persistent channel ID from the database so foreign keys remain valid.
+	c.ID = channel.ID
+
+	posts, err := uc.telegram.GetChannelHistory(ctx, c, 20)
+	if err != nil {
+		return domain.Channel{}, fmt.Errorf("telegram.GetChannelHistory: %w", err)
+	}
+
+	err = transaction.Wrap(ctx, func(ctx context.Context) error {
+		err = uc.database.UpdateChannel(ctx, c)
+		if err != nil {
+			return fmt.Errorf("database.UpdateChannel: %w", err)
+		}
+
+		for _, p := range posts {
+			log.Info().Msgf("New post (init): %s - Views: %d", p.Link, p.Views)
+
+			err = uc.database.CreatePost(ctx, p)
+			if err != nil {
+				return fmt.Errorf("database.CreatePost: %w", err)
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return domain.Channel{}, fmt.Errorf("transaction.Wrap: %w", err)
+	}
+
+	return c, nil
+}

tg_parser/internal/usecase/fetch_views.go

@@ -0,0 +1,46 @@
+package usecase
+
+import (
+	"context"
+	"time"
+
+	"github.com/rs/zerolog/log"
+
+	"github.com/TelegramExchange/tgex-parser/internal/domain"
+)
+
+func (uc *UseCase) FetchViews(ctx context.Context) error {
+	channels, err := uc.database.GetChannelsWithTrackedPosts(ctx)
+	if err != nil {
+		return err
+	}
+
+	for _, channel := range channels {
+		posts, err := uc.database.GetTrackedPosts(ctx, channel)
+		if err != nil {
+			return err
+		}
+
+		err = uc.telegram.UpdatePostsViews(ctx, channel, posts)
+		if err != nil {
+			return err
+		}
+
+		for _, p := range posts {
+			v := domain.ViewsSnapshot{
+				ViewsCount: p.Views,
+				FetchedAt:  time.Now().UTC(),
+				PostID:     p.ID,
+			}
+
+			err = uc.database.CreateViewsSnapshot(ctx, v)
+			if err != nil {
+				return err
+			}
+
+			log.Info().Msgf("New ViewsSnapshot: %s - Post ID: %d, Views: %d", p.Link, p.MessageID, p.Views)
+		}
+	}
+
+	return nil
+}

tg_parser/internal/usecase/usecase.go

@@ -0,0 +1,38 @@
+package usecase
+
+import (
+	"context"
+
+	"github.com/TelegramExchange/tgex-parser/internal/domain"
+)
+
+type Telegram interface {
+	ParseChannelMeta(ctx context.Context, username string) (domain.Channel, error)
+	GetChannelHistory(ctx context.Context, channel domain.Channel, limit int) ([]domain.Post, error)
+	GetChannelDiff(ctx context.Context, channel domain.Channel, limit int) (domain.ChannelDiff, error)
+	UpdatePostsViews(ctx context.Context, channel domain.Channel, posts []domain.Post) error
+}
+
+type Database interface {
+	CreatePost(ctx context.Context, post domain.Post) error
+
+	CreateViewsSnapshot(ctx context.Context, snapshot domain.ViewsSnapshot) error
+
+	GetChannels(ctx context.Context) []domain.Channel
+	UpdateChannel(ctx context.Context, channel domain.Channel) error
+	GetChannelsWithTrackedPosts(ctx context.Context) ([]domain.Channel, error)
+	GetTrackedPosts(ctx context.Context, channel domain.Channel) ([]domain.Post, error)
+	DeletePost(ctx context.Context, p domain.Post) error
+}
+
+type UseCase struct {
+	telegram Telegram
+	database Database
+}
+
+func New(telegram Telegram, database Database) *UseCase {
+	return &UseCase{
+		telegram: telegram,
+		database: database,
+	}
+}