Michael McGuinness
144 lines
3.3 KiB
Go
144 lines
3.3 KiB
Go
package controllers
|
|
|
|
import (
|
|
"context"
|
|
serviceinterfaces "queryorchestration/api/serviceInterfaces"
|
|
"queryorchestration/internal/query"
|
|
queryprocessor "queryorchestration/internal/queryProcessor"
|
|
|
|
"github.com/go-playground/validator/v10"
|
|
"github.com/google/uuid"
|
|
|
|
"google.golang.org/protobuf/types/known/emptypb"
|
|
)
|
|
|
|
type QueryController struct {
|
|
serviceinterfaces.UnimplementedQueryServiceServer
|
|
query query.Service
|
|
validator *validator.Validate
|
|
}
|
|
|
|
func NewQueryController(querySvc query.Service, validator *validator.Validate) *QueryController {
|
|
return &QueryController{
|
|
query: querySvc,
|
|
validator: validator,
|
|
}
|
|
}
|
|
|
|
func (s *QueryController) List(ctx context.Context, req *serviceinterfaces.QueryFilter) (*serviceinterfaces.Queries, error) {
|
|
types := make([]queryprocessor.Type, len(req.GetTypes()))
|
|
for index, t := range req.GetTypes() {
|
|
types[index] = queryprocessor.Type(ParseSpecQueryType(t))
|
|
}
|
|
|
|
filters := query.ListFilters{
|
|
Types: types,
|
|
}
|
|
|
|
queries, err := s.query.List(ctx, filters)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
outQueries := make([]*serviceinterfaces.Query, len(queries))
|
|
for index, query := range queries {
|
|
outQueries[index] = ParseQuery(query)
|
|
}
|
|
|
|
return &serviceinterfaces.Queries{
|
|
Queries: outQueries,
|
|
}, nil
|
|
}
|
|
|
|
func (s *QueryController) Get(ctx context.Context, req *serviceinterfaces.IdMessage) (*serviceinterfaces.Query, error) {
|
|
id, err := uuid.Parse(req.GetId())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
query, err := s.query.Get(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return ParseQuery(query), nil
|
|
}
|
|
|
|
func (s *QueryController) Create(ctx context.Context, req *serviceinterfaces.QueryCreate) (*serviceinterfaces.IdMessage, error) {
|
|
requiredQueryIDs := make([]uuid.UUID, len(req.GetRequiredQueries()))
|
|
for index, id := range req.GetRequiredQueries() {
|
|
parsedID, err := uuid.Parse(id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
requiredQueryIDs[index] = parsedID
|
|
}
|
|
|
|
id, err := s.query.Create(ctx, &queryprocessor.Create{
|
|
Type: ParseSpecQueryType(req.GetType()),
|
|
RequiredQueryIDs: requiredQueryIDs,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &serviceinterfaces.IdMessage{
|
|
Id: id.String(),
|
|
}, nil
|
|
}
|
|
|
|
func (s *QueryController) Update(ctx context.Context, req *serviceinterfaces.QueryUpdate) (*emptypb.Empty, error) {
|
|
id, err := uuid.Parse(req.GetId())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = s.query.Update(ctx, &queryprocessor.Update{
|
|
ID: id,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &emptypb.Empty{}, nil
|
|
}
|
|
|
|
func (s *QueryController) Deprecate(ctx context.Context, req *serviceinterfaces.IdMessage) (*emptypb.Empty, error) {
|
|
id, err := uuid.Parse(req.GetId())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
err = s.query.Deprecate(ctx, id)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &emptypb.Empty{}, nil
|
|
}
|
|
|
|
func (s *QueryController) Test(ctx context.Context, req *serviceinterfaces.QueryTestRequest) (*serviceinterfaces.QueryTestResponse, error) {
|
|
queryId, err := uuid.Parse(req.GetQueryId())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
docId, err := uuid.Parse(req.GetDocumentId())
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
value, err := s.query.Test(ctx, query.Test{
|
|
QueryID: queryId,
|
|
QueryVersion: req.GetQueryVersion(),
|
|
DocumentID: docId,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &serviceinterfaces.QueryTestResponse{
|
|
Value: value,
|
|
}, nil
|
|
}
|