query-orchestration/internal/query/result/processor/parse.go

package resultprocessor

import (
	"fmt"

	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"

	"github.com/google/uuid"
)

func ParseDBNullType(qType repository.NullQuerytype) (Type, error) {
	if !qType.Valid {
		return TypeJsonExtractor, fmt.Errorf("invalid database query type")
	}

	return ParseDBType(qType.Querytype)
}

func ParseDBType(qType repository.Querytype) (Type, error) {
	switch qType {
	case repository.QuerytypeJsonExtractor:
		return TypeJsonExtractor, nil
	case repository.QuerytypeContextFull:
		return TypeContextFull, nil
	default:
		return TypeJsonExtractor, fmt.Errorf("invalid database query type")
	}
}

func ToDBQueryType(t Type) (repository.Querytype, error) {
	var dbType repository.Querytype

	switch t {
	case TypeJsonExtractor:
		dbType = repository.QuerytypeJsonExtractor
	case TypeContextFull:
		dbType = repository.QuerytypeContextFull
	default:
		return repository.QuerytypeContextFull, fmt.Errorf("invalid database query type")
	}

	return dbType, nil
}

func ToDBQueryTypeArray(t []Type) ([]repository.Querytype, error) {
	arr := make([]repository.Querytype, len(t))
	for index, value := range t {
		v, err := ToDBQueryType(value)
		if err != nil {
			return nil, err
		}

		arr[index] = v
	}

	return arr, nil
}

func ToDBNullQueryType(t Type) (repository.NullQuerytype, error) {
	dbType, err := ToDBQueryType(t)
	if err != nil {
		return repository.NullQuerytype{}, err
	}

	return repository.NullQuerytype{Querytype: dbType, Valid: true}, nil
}

func ParseDBCollectorQuery(q *repository.Collectorquerydependencytree) (*Query, error) {
	var reqQueryIDs *[]uuid.UUID
	if len(q.Requiredids) > 0 {
		ids := database.MustToUUIDArray(q.Requiredids)
		reqQueryIDs = &ids
	}

	qType, err := ParseDBType(q.Type)
	if err != nil {
		return nil, err
	}

	return &Query{
		ID:               database.MustToUUID(q.Queryid),
		Version:          q.Queryversion,
		Type:             qType,
		RequiredQueryIDs: reqQueryIDs,
	}, nil
}

func ParseFullQuery(qs *repository.Fullactivequery) (*Query, error) {
	if qs == nil {
		return nil, nil
	}

	qt, err := ParseDBType(qs.Type)
	if err != nil {
		return nil, err
	}

	var rids *[]uuid.UUID
	if len(qs.Requiredids) > 0 {
		r := database.MustToUUIDArray(qs.Requiredids)
		rids = &r
	}

	var cfg *string
	if qs.Config != nil {
		c := string(qs.Config)
		cfg = &c
	}

	return &Query{
		ID:               database.MustToUUID(qs.ID),
		Type:             qt,
		Version:          qs.Activeversion,
		RequiredQueryIDs: rids,
		Config:           cfg,
	}, nil
}

func ParseFullQueryArray(qs []*repository.Fullactivequery) ([]*Query, error) {
	parsed := make([]*Query, len(qs))
	for i, q := range qs {
		p, err := ParseFullQuery(q)
		if err != nil {
			return nil, err
		}

		parsed[i] = p
	}

	return parsed, nil
}