Mazyar
432 lines
13 KiB
Go
432 lines
13 KiB
Go
package tender
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"strings"
|
|
"time"
|
|
"tm/internal/company"
|
|
"tm/internal/customer"
|
|
"tm/pkg/logger"
|
|
"tm/pkg/response"
|
|
)
|
|
|
|
// TenderService interface defines tender business logic operations
|
|
type Service interface {
|
|
// Tender operations
|
|
GetByID(ctx context.Context, id string) (*TenderResponse, error)
|
|
Update(ctx context.Context, req UpdateTenderRequest) (*TenderResponse, error)
|
|
Delete(ctx context.Context, id string) error
|
|
Search(ctx context.Context, req *SearchForm, pagination *response.Pagination) (*SearchResponse, error)
|
|
Recommend(ctx context.Context, form *SearchForm, pagination *response.Pagination) (*SearchResponse, error)
|
|
GetDocumentSummaries(ctx context.Context, id string) ([]DocumentSummary, error)
|
|
|
|
// Maintenance operations
|
|
UpdateExpiredTenders(ctx context.Context) error
|
|
CleanupOldData(ctx context.Context, olderThan time.Duration, pagination *response.Pagination) error
|
|
}
|
|
|
|
// tenderService implements TenderService interface
|
|
type tenderService struct {
|
|
repository TenderRepository
|
|
companyService company.Service
|
|
customerService customer.Service
|
|
logger logger.Logger
|
|
}
|
|
|
|
// NewService creates a new tender service
|
|
func NewService(repository TenderRepository, companyService company.Service, customerService customer.Service, logger logger.Logger) Service {
|
|
return &tenderService{
|
|
repository: repository,
|
|
companyService: companyService,
|
|
customerService: customerService,
|
|
logger: logger,
|
|
}
|
|
}
|
|
|
|
// GetTenderByID retrieves a tender by ID
|
|
func (s *tenderService) GetByID(ctx context.Context, id string) (*TenderResponse, error) {
|
|
s.logger.Info("Retrieving tender by ID", map[string]interface{}{
|
|
"tender_id": id,
|
|
})
|
|
|
|
tender, err := s.repository.GetByID(ctx, id)
|
|
if err != nil {
|
|
s.logger.Error("Failed to retrieve tender", map[string]interface{}{
|
|
"tender_id": id,
|
|
"error": err.Error(),
|
|
})
|
|
return nil, fmt.Errorf("failed to retrieve tender: %w", err)
|
|
}
|
|
|
|
return tender.ToResponse(), nil
|
|
}
|
|
|
|
// UpdateTender updates an existing tender
|
|
func (s *tenderService) Update(ctx context.Context, req UpdateTenderRequest) (*TenderResponse, error) {
|
|
s.logger.Info("Updating tender", map[string]interface{}{
|
|
"tender_id": req.ID,
|
|
})
|
|
|
|
// Get existing tender
|
|
tender, err := s.repository.GetByID(ctx, req.ID)
|
|
if err != nil {
|
|
s.logger.Error("Failed to find tender for update", map[string]interface{}{
|
|
"tender_id": req.ID,
|
|
"error": err.Error(),
|
|
})
|
|
return nil, fmt.Errorf("failed to find tender: %w", err)
|
|
}
|
|
|
|
// Update fields if provided
|
|
if req.Title != nil {
|
|
tender.Title = *req.Title
|
|
}
|
|
if req.Description != nil {
|
|
tender.Description = *req.Description
|
|
}
|
|
if req.Status != nil {
|
|
tender.Status = *req.Status
|
|
}
|
|
if req.EstimatedValue != nil {
|
|
tender.EstimatedValue = *req.EstimatedValue
|
|
}
|
|
if req.Currency != nil {
|
|
tender.Currency = *req.Currency
|
|
}
|
|
if req.TenderDeadline != nil {
|
|
tender.TenderDeadline = *req.TenderDeadline
|
|
}
|
|
|
|
if err := s.repository.Update(ctx, tender); err != nil {
|
|
s.logger.Error("Failed to update tender", map[string]interface{}{
|
|
"tender_id": req.ID,
|
|
"error": err.Error(),
|
|
})
|
|
return nil, fmt.Errorf("failed to update tender: %w", err)
|
|
}
|
|
|
|
s.logger.Info("Tender updated successfully", map[string]interface{}{
|
|
"tender_id": tender.ID,
|
|
})
|
|
|
|
return tender.ToResponse(), nil
|
|
}
|
|
|
|
// Delete deletes a tender
|
|
func (s *tenderService) Delete(ctx context.Context, id string) error {
|
|
s.logger.Info("Deleting tender", map[string]interface{}{
|
|
"tender_id": id,
|
|
})
|
|
|
|
if err := s.repository.Delete(ctx, id); err != nil {
|
|
s.logger.Error("Failed to delete tender", map[string]interface{}{
|
|
"tender_id": id,
|
|
"error": err.Error(),
|
|
})
|
|
return fmt.Errorf("failed to delete tender: %w", err)
|
|
}
|
|
|
|
s.logger.Info("Tender deleted successfully", map[string]interface{}{
|
|
"tender_id": id,
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
// GetDocumentSummaries retrieves document summaries for a specific tender
|
|
func (s *tenderService) GetDocumentSummaries(ctx context.Context, id string) ([]DocumentSummary, error) {
|
|
if id == "" {
|
|
return nil, fmt.Errorf("tender ID cannot be empty")
|
|
}
|
|
|
|
// Get tender from repository
|
|
tender, err := s.repository.GetByID(ctx, id)
|
|
if err != nil {
|
|
s.logger.Error("Failed to get tender for document summaries", map[string]interface{}{
|
|
"tender_id": id,
|
|
"error": err.Error(),
|
|
})
|
|
return nil, fmt.Errorf("failed to get tender: %w", err)
|
|
}
|
|
|
|
if tender == nil {
|
|
return nil, fmt.Errorf("tender not found")
|
|
}
|
|
|
|
// Return document summaries (empty slice if none exist)
|
|
if tender.DocumentSummaries == nil {
|
|
return []DocumentSummary{}, nil
|
|
}
|
|
|
|
s.logger.Info("Retrieved document summaries for tender", map[string]interface{}{
|
|
"tender_id": id,
|
|
"summaries_count": len(tender.DocumentSummaries),
|
|
})
|
|
|
|
return tender.DocumentSummaries, nil
|
|
}
|
|
|
|
// ListTenders retrieves tenders with pagination and filtering
|
|
func (s *tenderService) Search(ctx context.Context, form *SearchForm, pagination *response.Pagination) (*SearchResponse, error) {
|
|
s.logger.Info("Listing tenders", map[string]interface{}{
|
|
"limit": pagination.Limit,
|
|
"offset": pagination.Offset,
|
|
"company_id": form.CompanyID,
|
|
"customer_id": form.CustomerID,
|
|
"from": form.DeadlineFrom,
|
|
"to": form.DeadlineTo,
|
|
})
|
|
|
|
// If customer ID is provided, get customer keywords and add to search
|
|
if form.CustomerID != nil && *form.CustomerID != "" {
|
|
customerResp, err := s.customerService.GetByID(ctx, *form.CustomerID)
|
|
if err == nil && customerResp != nil {
|
|
// Only use keywords if status is ready
|
|
if customerResp.KeywordsStatus == "ready" && len(customerResp.Keywords) > 0 {
|
|
// Combine customer keywords with existing search query
|
|
keywordsQuery := strings.Join(customerResp.Keywords, " ")
|
|
if form.Search != nil && *form.Search != "" {
|
|
combinedSearch := *form.Search + " " + keywordsQuery
|
|
form.Search = &combinedSearch
|
|
} else {
|
|
form.Search = &keywordsQuery
|
|
}
|
|
s.logger.Info("Using customer keywords for search", map[string]interface{}{
|
|
"customer_id": *form.CustomerID,
|
|
"keywords": customerResp.Keywords,
|
|
})
|
|
} else {
|
|
s.logger.Info("Customer keywords not ready, skipping keyword-based search", map[string]interface{}{
|
|
"customer_id": *form.CustomerID,
|
|
"keywords_status": customerResp.KeywordsStatus,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
tenders, total, err := s.repository.Search(ctx, form, pagination)
|
|
if err != nil {
|
|
s.logger.Error("Failed to list tenders", map[string]interface{}{
|
|
"error": err.Error(),
|
|
})
|
|
return nil, fmt.Errorf("failed to list tenders: %w", err)
|
|
}
|
|
|
|
// If no company ID provided, return tenders without match percentage
|
|
if form.CompanyID == nil || *form.CompanyID == "" {
|
|
tenderResponses := make([]TenderResponse, 0, len(tenders))
|
|
for _, tender := range tenders {
|
|
tenderResponses = append(tenderResponses, *tender.ToResponse())
|
|
}
|
|
|
|
return &SearchResponse{
|
|
Tenders: tenderResponses,
|
|
Metadata: pagination.Response(total),
|
|
}, nil
|
|
}
|
|
|
|
// Get company CPV codes for match calculation
|
|
comp, err := s.companyService.GetByID(ctx, *form.CompanyID)
|
|
if err != nil {
|
|
s.logger.Error("Failed to get company for match calculation", map[string]interface{}{
|
|
"company_id": *form.CompanyID,
|
|
"error": err.Error(),
|
|
})
|
|
// Continue without match percentage if company not found
|
|
tenderResponses := make([]TenderResponse, 0, len(tenders))
|
|
for _, tender := range tenders {
|
|
tenderResponses = append(tenderResponses, *tender.ToResponse())
|
|
}
|
|
|
|
return &SearchResponse{
|
|
Tenders: tenderResponses,
|
|
Metadata: pagination.Response(total),
|
|
},
|
|
nil
|
|
}
|
|
|
|
var companyCPVCodes []string
|
|
if comp.Tags != nil && comp.Tags.CPVCodes != nil {
|
|
companyCPVCodes = comp.Tags.CPVCodes
|
|
}
|
|
|
|
s.logger.Info("Tenders sorted by match percentage", map[string]interface{}{
|
|
"company_id": *form.CompanyID,
|
|
"company_cpv_codes": len(companyCPVCodes),
|
|
"total_tenders": len(tenders),
|
|
})
|
|
|
|
tenderResponses := make([]TenderResponse, 0, len(tenders))
|
|
for _, tender := range tenders {
|
|
tenderResponses = append(tenderResponses, *tender.ToResponse())
|
|
}
|
|
|
|
return &SearchResponse{
|
|
Tenders: tenderResponses,
|
|
Metadata: pagination.Response(total),
|
|
},
|
|
nil
|
|
}
|
|
|
|
// Recommend retrieves tenders with pagination and filtering
|
|
func (s *tenderService) Recommend(ctx context.Context, form *SearchForm, pagination *response.Pagination) (*SearchResponse, error) {
|
|
s.logger.Info("Recommend tenders", map[string]interface{}{
|
|
"company_id": form.CompanyID,
|
|
"customer_id": form.CustomerID,
|
|
})
|
|
|
|
form.Status = []string{string(TenderStatusActive)}
|
|
|
|
// Priority: Use customer keywords if available, otherwise use company CPV codes
|
|
if form.CustomerID != nil && *form.CustomerID != "" {
|
|
customerResp, err := s.customerService.GetByID(ctx, *form.CustomerID)
|
|
if err == nil && customerResp != nil {
|
|
// Only use keywords if status is ready
|
|
if customerResp.KeywordsStatus == "ready" && len(customerResp.Keywords) > 0 {
|
|
// Use customer keywords for recommendation
|
|
keywordsQuery := strings.Join(customerResp.Keywords, " ")
|
|
form.Search = &keywordsQuery
|
|
s.logger.Info("Using customer keywords for recommendation", map[string]interface{}{
|
|
"customer_id": *form.CustomerID,
|
|
"keywords": customerResp.Keywords,
|
|
})
|
|
} else {
|
|
s.logger.Info("Customer keywords not ready, falling back to company CPV codes", map[string]interface{}{
|
|
"customer_id": *form.CustomerID,
|
|
"keywords_status": customerResp.KeywordsStatus,
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// Fallback to company CPV codes if no customer keywords
|
|
if form.Search == nil || *form.Search == "" {
|
|
if form.CompanyID != nil && *form.CompanyID != "" {
|
|
company, err := s.companyService.GetByID(ctx, *form.CompanyID)
|
|
if err != nil {
|
|
s.logger.Error("Failed to get company", map[string]interface{}{
|
|
"company_id": form.CompanyID,
|
|
"error": err.Error(),
|
|
})
|
|
return nil, fmt.Errorf("failed to get company: %w", err)
|
|
}
|
|
if company.Tags != nil && len(company.Tags.CPVCodes) > 0 {
|
|
form.Classifications = company.Tags.CPVCodes
|
|
}
|
|
}
|
|
}
|
|
|
|
tenders, total, err := s.repository.Search(ctx, form, pagination)
|
|
if err != nil {
|
|
s.logger.Error("Failed to list tenders", map[string]interface{}{
|
|
"error": err.Error(),
|
|
})
|
|
return nil, fmt.Errorf("failed to list tenders: %w", err)
|
|
}
|
|
|
|
tenderResponses := make([]TenderResponse, 0, len(tenders))
|
|
for _, tender := range tenders {
|
|
tenderResponses = append(tenderResponses, *tender.ToResponse())
|
|
}
|
|
|
|
return &SearchResponse{
|
|
Tenders: tenderResponses,
|
|
Metadata: pagination.Response(total),
|
|
}, nil
|
|
}
|
|
|
|
// Delete deletes a tender
|
|
|
|
// GetTenderStatistics retrieves tender statistics
|
|
func (s *tenderService) GetTenderStatistics(ctx context.Context) (*TenderStatistics, error) {
|
|
s.logger.Info("Retrieving tender statistics", map[string]interface{}{})
|
|
|
|
stats, err := s.repository.GetStatistics(ctx)
|
|
if err != nil {
|
|
s.logger.Error("Failed to retrieve tender statistics", map[string]interface{}{
|
|
"error": err.Error(),
|
|
})
|
|
return nil, fmt.Errorf("failed to retrieve statistics: %w", err)
|
|
}
|
|
|
|
return stats, nil
|
|
}
|
|
|
|
// UpdateExpiredTenders updates status of expired tenders
|
|
func (s *tenderService) UpdateExpiredTenders(ctx context.Context) error {
|
|
s.logger.Info("Updating expired tenders", map[string]interface{}{})
|
|
|
|
// Get tenders that should be expired
|
|
expiredTenders, err := s.repository.GetExpiredTenders(ctx, time.Now().Unix())
|
|
if err != nil {
|
|
s.logger.Error("Failed to get expired tenders", map[string]interface{}{
|
|
"error": err.Error(),
|
|
})
|
|
return fmt.Errorf("failed to get expired tenders: %w", err)
|
|
}
|
|
|
|
updatedCount := 0
|
|
for _, tender := range expiredTenders {
|
|
if tender.Status != TenderStatusExpired {
|
|
tender.UpdateStatus(TenderStatusExpired)
|
|
if err := s.repository.Update(ctx, &tender); err != nil {
|
|
s.logger.Error("Failed to update expired tender", map[string]interface{}{
|
|
"tender_id": tender.ID,
|
|
"error": err.Error(),
|
|
})
|
|
continue
|
|
}
|
|
updatedCount++
|
|
}
|
|
}
|
|
|
|
s.logger.Info("Expired tenders updated", map[string]interface{}{
|
|
"total_expired": len(expiredTenders),
|
|
"updated": updatedCount,
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
// CleanupOldData removes old data based on retention policy
|
|
func (s *tenderService) CleanupOldData(ctx context.Context, olderThan time.Duration, pagination *response.Pagination) error {
|
|
s.logger.Info("Cleaning up old data", map[string]interface{}{
|
|
"older_than": olderThan.String(),
|
|
"limit": pagination.Limit,
|
|
"offset": pagination.Offset,
|
|
})
|
|
|
|
cutoffTime := time.Now().Add(-olderThan).Unix()
|
|
|
|
// For now, we'll just log what would be cleaned up
|
|
// In production, you might want to actually delete old data
|
|
form := &SearchForm{
|
|
Status: []string{string(TenderStatusExpired), string(TenderStatusCancelled), string(TenderStatusAwarded)},
|
|
}
|
|
|
|
oldTenders, _, err := s.repository.Search(ctx, form, pagination)
|
|
if err != nil {
|
|
s.logger.Error("Failed to find old tenders for cleanup", map[string]interface{}{
|
|
"error": err.Error(),
|
|
})
|
|
return fmt.Errorf("failed to find old tenders: %w", err)
|
|
}
|
|
|
|
cleanupCount := 0
|
|
for _, tender := range oldTenders {
|
|
if tender.CreatedAt < cutoffTime {
|
|
cleanupCount++
|
|
// Here you would delete the tender if implementing actual cleanup
|
|
// s.repository.Delete(ctx, tender.ID)
|
|
}
|
|
}
|
|
|
|
s.logger.Info("Old data cleanup completed", map[string]interface{}{
|
|
"found_old_tenders": cleanupCount,
|
|
"cutoff_time": cutoffTime,
|
|
})
|
|
|
|
return nil
|
|
}
|