query-orchestration/internal/job/collector/create.go

package collector

import (
	"context"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/server/validation"

	"github.com/google/uuid"
	"github.com/jackc/pgx/v5/pgtype"
)

type CreateParams struct {
	JobID           uuid.UUID
	MinCleanVersion *int32
	MinTextVersion  *int32
	Fields          *map[string]uuid.UUID
}

func (s *Service) Create(ctx context.Context, params *CreateParams) (uuid.UUID, error) {
	dbparams, err := s.getCreateParams(ctx, params)
	if err != nil {
		return uuid.Nil, err
	}

	id, err := s.submitCreate(ctx, dbparams)
	if err != nil {
		return uuid.Nil, err
	}

	return id, nil
}

type dbCreateParams struct {
	JobID           pgtype.UUID
	MinCleanVersion *int32
	MinTextVersion  *int32
	Fields          *map[string]pgtype.UUID
}

type fields struct {
	values *[]uuid.UUID
}

func (f *fields) GetRequiredQueryIDs() *[]uuid.UUID {
	return f.values
}

func (f *fields) SetRequiredQueryIDs(v *[]uuid.UUID) {
	f.values = v
}

func (s *Service) getCreateParams(ctx context.Context, params *CreateParams) (*dbCreateParams, error) {
	minClean := params.MinCleanVersion
	if minClean != nil {
		err := s.svc.Clean.IsValidVersion(*minClean)
		if err != nil {
			return nil, err
		}
	}

	minText := params.MinTextVersion
	if minText != nil {
		err := s.svc.Text.IsValidVersion(*minText)
		if err != nil {
			return nil, err
		}
	}

	fields, err := s.normalizeFieldsToDB(ctx, params.Fields)
	if err != nil {
		return nil, err
	}

	return &dbCreateParams{
		JobID:           database.MustToDBUUID(params.JobID),
		MinCleanVersion: minClean,
		MinTextVersion:  minText,
		Fields:          fields,
	}, nil
}

func (s *Service) submitCreate(ctx context.Context, params *dbCreateParams) (uuid.UUID, error) {
	var dbID pgtype.UUID
	err := database.ExecuteTransaction(ctx, s.db, func(ctx context.Context, qtx *repository.Queries) error {
		dID, err := qtx.CreateCollector(ctx, params.JobID)
		if err != nil {
			return err
		}
		dbID = dID
		latestVersion := int32(1)

		if params.MinCleanVersion != nil || params.MinTextVersion != nil {
			err = qtx.AddCollectorCodeVersion(ctx, &repository.AddCollectorCodeVersionParams{
				Collectorid:     dbID,
				Mincleanversion: validation.GetUpdatedValue(1, params.MinCleanVersion),
				Mintextversion:  validation.GetUpdatedValue(1, params.MinTextVersion),
				Addedversion:    latestVersion,
			})
			if err != nil {
				return err
			}
		}

		if params.Fields != nil {
			for key, field := range *params.Fields {
				err = qtx.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{
					Collectorid:  dbID,
					Name:         key,
					Queryid:      field,
					Addedversion: latestVersion,
				})
				if err != nil {
					return err
				}
			}
		}

		return nil
	})
	if err != nil {
		return uuid.Nil, err
	}

	id, err := database.ToUUID(dbID)
	if err != nil {
		return uuid.Nil, err
	}

	return id, nil
}