Enhance document scraper service with AI portal integration and error handling

- Updated the document scraper service to include a new ScrapePortalsProvider interface, allowing for dynamic retrieval of supported scraping portals.
- Modified the ListPendingTenders and GetTenderByNoticeID methods to filter tenders based on document URLs that match the configured portals.
- Introduced new error handling for cases when the scrape portals provider is not configured, returning appropriate service unavailable responses.
- Enhanced API documentation to reflect changes in tender retrieval logic and added error response details for unsupported portal scenarios.

This update improves the document scraping functionality by integrating AI portal support, enhancing the overall reliability and flexibility of the tender management system.

internal/document_scraper/service.go

@@ -3,21 +3,17 @@ package document_scraper
 import (
 	"context"
 	"fmt"
+	"strings"
 	"time"
 	"tm/internal/tender"
+	"tm/pkg/ai_summarizer"
 	"tm/pkg/logger"
 	"tm/pkg/response"
 )
 
-var documentScraperCountryCodes = []string{"SWE", "FIN", "NOR"}
-
-func isDocumentScraperCountry(countryCode string) bool {
-	for _, code := range documentScraperCountryCodes {
-		if countryCode == code {
-			return true
-		}
-	}
-	return false
+// ScrapePortalsProvider fetches supported document scraping portal identifiers.
+type ScrapePortalsProvider interface {
+	GetScrapePortals(ctx context.Context) (*ai_summarizer.ScrapePortalsResponse, error)
 }
 
 // Service defines business logic for the document scraper API
@@ -29,21 +25,49 @@ type Service interface {
 }
 
 type service struct {
-	tenderRepo tender.TenderRepository
-	logger     logger.Logger
+	tenderRepo      tender.TenderRepository
+	portalsProvider ScrapePortalsProvider
+	logger          logger.Logger
 }
 
 // NewService creates a new document scraper service
-func NewService(tenderRepo tender.TenderRepository, logger logger.Logger) Service {
+func NewService(tenderRepo tender.TenderRepository, portalsProvider ScrapePortalsProvider, logger logger.Logger) Service {
 	return &service{
-		tenderRepo: tenderRepo,
-		logger:     logger,
+		tenderRepo:      tenderRepo,
+		portalsProvider: portalsProvider,
+		logger:          logger,
 	}
 }
 
+func (s *service) fetchScrapePortals(ctx context.Context) ([]string, error) {
+	if s.portalsProvider == nil {
+		s.logger.Warn("Scrape portals provider not configured", map[string]interface{}{})
+		return nil, ErrScrapePortalsUnavailable
+	}
+
+	resp, err := s.portalsProvider.GetScrapePortals(ctx)
+	if err != nil {
+		s.logger.Error("Failed to fetch scrape portals", map[string]interface{}{
+			"error": err.Error(),
+		})
+		return nil, fmt.Errorf("fetch scrape portals: %w", err)
+	}
+	if resp == nil {
+		return nil, nil
+	}
+
+	portals := make([]string, 0, len(*resp))
+	for _, portal := range *resp {
+		if p := strings.TrimSpace(portal); p != "" {
+			portals = append(portals, p)
+		}
+	}
+	return portals, nil
+}
+
 // ListPendingTenders retrieves tenders that have not yet been scraped for documents.
-// Only returns tenders from Sweden, Finland, and Norway. By default only tenders with active
-// deadlines are included; set IncludeExpired to include tenders whose deadline has passed.
+// Only returns tenders whose document URL matches a portal supported by the AI service.
+// By default only tenders with active deadlines are included; set IncludeExpired to include expired tenders.
 func (s *service) ListPendingTenders(ctx context.Context, req DocumentScraperListRequest) (*DocumentScraperListResponse, *response.Meta, error) {
 	req.Normalize()
 
@@ -51,16 +75,30 @@ func (s *service) ListPendingTenders(ctx context.Context, req DocumentScraperLis
 		return nil, nil, ErrInvalidDateRange
 	}
 
+	portals, err := s.fetchScrapePortals(ctx)
+	if err != nil {
+		return nil, nil, err
+	}
+	if len(portals) == 0 {
+		s.logger.Info("No scrape portals configured; returning empty pending tender list", map[string]interface{}{})
+		meta := &response.Meta{Total: 0, Limit: req.Limit, Offset: req.Offset, HasMore: false}
+		if meta.Limit > 0 {
+			meta.Page = (req.Offset / meta.Limit) + 1
+		}
+		return &DocumentScraperListResponse{Tenders: []DocumentScraperTenderResponse{}}, meta, nil
+	}
+
 	s.logger.Info("Listing pending tenders for document scraper", map[string]interface{}{
-		"limit":             req.Limit,
-		"offset":            req.Offset,
-		"created_at_from":   req.CreatedAtFrom,
-		"created_at_to":     req.CreatedAtTo,
-		"include_expired":   req.IncludeExpired,
+		"limit":           req.Limit,
+		"offset":          req.Offset,
+		"created_at_from": req.CreatedAtFrom,
+		"created_at_to":   req.CreatedAtTo,
+		"include_expired": req.IncludeExpired,
+		"portal_count":    len(portals),
 	})
 
 	filter := tender.PendingDocumentScrapeFilter{
-		CountryCodes:  documentScraperCountryCodes,
+		Portals:       portals,
 		CreatedAtFrom: req.CreatedAtFrom,
 		CreatedAtTo:   req.CreatedAtTo,
 		Limit:         req.Limit,
@@ -106,12 +144,17 @@ func (s *service) ListPendingTenders(ctx context.Context, req DocumentScraperLis
 }
 
 // GetTenderByNoticeID retrieves a specific tender by its notice publication ID.
-// Only returns tenders from Sweden, Finland, and Norway with active deadlines (deadline not yet reached).
+// Only returns unexpired tenders whose document URL matches a supported scrape portal.
 func (s *service) GetTenderByNoticeID(ctx context.Context, noticeID string) (*DocumentScraperTenderResponse, error) {
 	s.logger.Info("Getting tender by notice ID for document scraper", map[string]interface{}{
 		"notice_id": noticeID,
 	})
 
+	portals, err := s.fetchScrapePortals(ctx)
+	if err != nil {
+		return nil, err
+	}
+
 	t, err := s.tenderRepo.GetByNoticePublicationID(ctx, noticeID)
 	if err != nil {
 		s.logger.Error("Failed to get tender by notice ID", map[string]interface{}{
@@ -126,10 +169,9 @@ func (s *service) GetTenderByNoticeID(ctx context.Context, noticeID string) (*Do
 	}
 
 	now := time.Now().Unix()
-	if !isDocumentScraperCountry(t.CountryCode) || t.TenderDeadline <= now {
-		s.logger.Info("Tender filtered out: unsupported country or deadline passed", map[string]interface{}{
+	if t.TenderDeadline <= now || !matchesScrapePortals(documentURL(t), portals) {
+		s.logger.Info("Tender filtered out: unsupported portal or deadline passed", map[string]interface{}{
 			"notice_id":       noticeID,
-			"country_code":    t.CountryCode,
 			"tender_deadline": t.TenderDeadline,
 			"now":             now,
 		})