query-orchestration/internal/document/sync/sync.go

package documentsync

import (
	"context"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/job/collector"
	queryqueue "queryorchestration/internal/query/queue"
	"queryorchestration/internal/query/result"

	"github.com/google/uuid"
)

func (s *Service) Sync(ctx context.Context, doc *Document) error {
	coll, err := s.svc.Collector.GetByJobID(ctx, doc.JobID)
	if err != nil {
		return err
	}

	results, err := s.getResults(ctx, doc.ID, coll)
	if err != nil {
		return err
	}

	queue, err := queryqueue.New(ctx, &queryqueue.NewConfig{
		DB:           s.db,
		Collector:    coll,
		Results:      results,
		DocumentID:   doc.ID,
		CleanVersion: doc.CleanVersion,
		TextVersion:  doc.TextVersion,
	})
	if err != nil {
		return err
	}

	err = queue.Execute(ctx)
	if err != nil {
		return err
	}

	return nil
}

func (s *Service) getResults(ctx context.Context, id uuid.UUID, coll *collector.Collector) ([]*result.Result, error) {
	docID := database.MustToDBUUID(id)

	results, err := s.db.Queries.ListResultsByDocumentID(ctx, &repository.ListResultsByDocumentIDParams{
		Documentid:   docID,
		Textversion:  coll.MinTextVersion,
		Cleanversion: coll.MinCleanVersion,
	})
	if err != nil {
		return nil, err
	}

	cleanResults := make([]*result.Result, len(results))
	for index, dbResult := range results {
		cleanResults[index] = result.Parse(dbResult)
	}

	return cleanResults, nil
}