Mazyar
128 lines
3.8 KiB
Go
128 lines
3.8 KiB
Go
package document_scraper
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"time"
|
|
"tm/internal/tender"
|
|
"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
|
|
}
|
|
|
|
// Service defines business logic for the document scraper API
|
|
type Service interface {
|
|
// ListPendingTenders retrieves tenders that need document scraping
|
|
ListPendingTenders(ctx context.Context, limit, offset int) (*DocumentScraperListResponse, *response.Meta, error)
|
|
// GetTenderByNoticeID retrieves a specific tender by its notice publication ID
|
|
GetTenderByNoticeID(ctx context.Context, noticeID string) (*DocumentScraperTenderResponse, error)
|
|
}
|
|
|
|
type service struct {
|
|
tenderRepo tender.TenderRepository
|
|
logger logger.Logger
|
|
}
|
|
|
|
// NewService creates a new document scraper service
|
|
func NewService(tenderRepo tender.TenderRepository, logger logger.Logger) Service {
|
|
return &service{
|
|
tenderRepo: tenderRepo,
|
|
logger: logger,
|
|
}
|
|
}
|
|
|
|
// ListPendingTenders retrieves tenders that have not yet been scraped for documents.
|
|
// Only returns tenders from Sweden, Finland, and Norway with active deadlines (deadline not yet reached).
|
|
func (s *service) ListPendingTenders(ctx context.Context, limit, offset int) (*DocumentScraperListResponse, *response.Meta, error) {
|
|
s.logger.Info("Listing pending tenders for document scraper", map[string]interface{}{
|
|
"limit": limit,
|
|
"offset": offset,
|
|
})
|
|
|
|
now := time.Now().Unix()
|
|
|
|
tenders, hasMore, err := s.tenderRepo.GetPendingDocumentScrapeTenders(ctx, documentScraperCountryCodes, now, limit, offset)
|
|
if err != nil {
|
|
s.logger.Error("Failed to list pending tenders", map[string]interface{}{
|
|
"error": err.Error(),
|
|
})
|
|
return nil, nil, fmt.Errorf("failed to list pending tenders: %w", err)
|
|
}
|
|
|
|
result := &DocumentScraperListResponse{
|
|
Tenders: make([]DocumentScraperTenderResponse, len(tenders)),
|
|
}
|
|
|
|
for i := range tenders {
|
|
result.Tenders[i] = *BuildDocumentScraperTenderResponse(&tenders[i])
|
|
}
|
|
|
|
meta := &response.Meta{
|
|
Total: len(tenders),
|
|
Limit: limit,
|
|
Offset: offset,
|
|
HasMore: hasMore,
|
|
}
|
|
if meta.Limit > 0 {
|
|
meta.Page = (offset / meta.Limit) + 1
|
|
}
|
|
|
|
s.logger.Info("Pending tenders retrieved successfully", map[string]interface{}{
|
|
"count": len(tenders),
|
|
"has_more": hasMore,
|
|
})
|
|
|
|
return result, meta, nil
|
|
}
|
|
|
|
// 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).
|
|
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,
|
|
})
|
|
|
|
t, err := s.tenderRepo.GetByNoticePublicationID(ctx, noticeID)
|
|
if err != nil {
|
|
s.logger.Error("Failed to get tender by notice ID", map[string]interface{}{
|
|
"notice_id": noticeID,
|
|
"error": err.Error(),
|
|
})
|
|
return nil, fmt.Errorf("failed to get tender: %w", err)
|
|
}
|
|
|
|
if t == nil {
|
|
return nil, fmt.Errorf("tender not found")
|
|
}
|
|
|
|
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{}{
|
|
"notice_id": noticeID,
|
|
"country_code": t.CountryCode,
|
|
"tender_deadline": t.TenderDeadline,
|
|
"now": now,
|
|
})
|
|
return nil, fmt.Errorf("tender not found")
|
|
}
|
|
|
|
result := BuildDocumentScraperTenderResponse(t)
|
|
|
|
s.logger.Info("Tender retrieved successfully for document scraper", map[string]interface{}{
|
|
"notice_id": noticeID,
|
|
"tender_id": t.ID.Hex(),
|
|
})
|
|
|
|
return result, nil
|
|
}
|