queuecreation

internal/document/service.go

@@ -2,49 +2,49 @@ package document
 
 import (
 	"context"
+	"gotemplate/internal/collector"
 	"gotemplate/internal/database"
 	"gotemplate/internal/database/repository"
-	"log"
+	"gotemplate/internal/query"
 
 	"github.com/google/uuid"
 )
 
+type Document struct {
+	ID           uuid.UUID `json:"id"`
+	JobID        uuid.UUID `json:"jobId"`
+	Name         string    `json:"name"`
+	CleanVersion int32     `json:"cleanVersion"`
+	TextVersion  int32     `json:"textVersion"`
+}
+
 type Service struct {
 	db *repository.Queries
 }
 
-type Document struct {
-	ID    uuid.UUID `json:"id"`
-	JobID uuid.UUID `json:"jobId"`
-	Name  string    `json:"name"`
-}
-
-type QueryType int
-
-const (
-	QueryTypeJsonExtractor = iota
-)
-
-type query struct {
-	ID              uuid.UUID
-	Type            QueryType
-	RequiredQueryID uuid.UUID
-	Version         int
-}
-
 func New(ctx context.Context, db *repository.Queries) *Service {
 	return &Service{
 		db: db,
 	}
 }
 
-func (s *Service) Sync(ctx context.Context, doc Document) error {
-	queries, err := s.getUnsyncedOrderedQueries(ctx, doc)
+func (s *Service) Sync(ctx context.Context, doc *Document) error {
+	collector, err := collector.NewByJobId(ctx, s.db, doc.JobID)
 	if err != nil {
 		return err
 	}
 
-	err = s.executeQueries(queries)
+	results, err := s.GetResults(ctx, doc.ID, collector)
+	if err != nil {
+		return err
+	}
+
+	queue, err := query.NewQueue(ctx, s.db, collector, results, doc.ID, doc.CleanVersion, doc.TextVersion)
+	if err != nil {
+		return err
+	}
+
+	err = queue.Execute(ctx)
 	if err != nil {
 		return err
 	}
@@ -52,65 +52,33 @@ func (s *Service) Sync(ctx context.Context, doc Document) error {
 	return nil
 }
 
-func (s *Service) getUnsyncedOrderedQueries(ctx context.Context, doc Document) ([]query, error) {
-	jobID, err := database.ToDBUUID(doc.JobID)
-	if err != nil {
-		return nil, err
-	}
-
-	collector, err := s.db.GetCollectorFromJobID(ctx, jobID)
-	if err != nil {
-		return nil, err
-	}
-
-	queries, err := s.db.GetCollectorQueries(ctx, collector.ID)
-	if err != nil {
-		return nil, err
-	}
-
-	docID, err := database.ToDBUUID(doc.ID)
+func (s *Service) GetResults(ctx context.Context, id uuid.UUID, coll *collector.Collector) (*[]query.Result, error) {
+	docID, err := database.ToDBUUID(id)
 	if err != nil {
 		return nil, err
 	}
 
 	results, err := s.db.ListResultsByDocumentID(ctx, repository.ListResultsByDocumentIDParams{
 		Documentid:   docID,
-		Textversion:  collector.Mintextversion,
-		Cleanversion: collector.Mincleanversion,
+		Textversion:  coll.MinTextVersion,
+		Cleanversion: coll.MinCleanVersion,
 	})
 	if err != nil {
 		return nil, err
 	}
 
-	queue := []query{}
-
-	for _, query := range queries {
-		isSynced := false
-		for _, result := range results {
-			if result.Queryid != query.Queryid || int(result.Queryversion) != int(query.Queryversion.Int32) {
-				continue
-			}
-			isSynced = true
-			break
-		}
-		if isSynced {
-			continue
-		}
-		// TODO add query to beginning, add all dependents until one that is already in the queue
+	cleanResults := make([]query.Result, len(results))
+	for index, dbResult := range results {
+		cleanResults[index] = *s.parseResult(&dbResult)
 	}
 
-	return queue, nil
+	return &cleanResults, nil
 }
 
-func (s *Service) executeQueries(queries []query) error {
-	// TODO - get all results?
-
-	for _, query := range queries {
-		log.Print(query)
-		// TODO - get required field
-		// execute query
-		// store result fully
+func (s *Service) parseResult(dbQuery *repository.ListResultsByDocumentIDRow) *query.Result {
+	return &query.Result{
+		ID:           database.MustToUUID(dbQuery.ID),
+		QueryID:      database.MustToUUID(dbQuery.Queryid),
+		QueryVersion: dbQuery.Queryversion,
 	}
-
-	return nil
 }