780 lines
20 KiB
Go
780 lines
20 KiB
Go
// Code generated by ogen, DO NOT EDIT.
|
|
|
|
package api
|
|
|
|
import (
|
|
"context"
|
|
"net/http"
|
|
"time"
|
|
|
|
"github.com/go-faster/errors"
|
|
"go.opentelemetry.io/otel/attribute"
|
|
"go.opentelemetry.io/otel/codes"
|
|
"go.opentelemetry.io/otel/metric"
|
|
semconv "go.opentelemetry.io/otel/semconv/v1.26.0"
|
|
"go.opentelemetry.io/otel/trace"
|
|
|
|
ht "github.com/ogen-go/ogen/http"
|
|
"github.com/ogen-go/ogen/middleware"
|
|
"github.com/ogen-go/ogen/ogenerrors"
|
|
"github.com/ogen-go/ogen/otelogen"
|
|
)
|
|
|
|
// handleCreateSubmissionRequest handles createSubmission operation.
|
|
//
|
|
// Create new submission.
|
|
//
|
|
// POST /submissions
|
|
func (s *Server) handleCreateSubmissionRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("createSubmission"),
|
|
semconv.HTTPRequestMethodKey.String("POST"),
|
|
semconv.HTTPRouteKey.String("/submissions"),
|
|
}
|
|
|
|
// Start a span for this request.
|
|
ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateSubmission",
|
|
trace.WithAttributes(otelAttrs...),
|
|
serverSpanKind,
|
|
)
|
|
defer span.End()
|
|
|
|
// Add Labeler to context.
|
|
labeler := &Labeler{attrs: otelAttrs}
|
|
ctx = contextWithLabeler(ctx, labeler)
|
|
|
|
// Run stopwatch.
|
|
startTime := time.Now()
|
|
defer func() {
|
|
elapsedDuration := time.Since(startTime)
|
|
attrOpt := metric.WithAttributeSet(labeler.AttributeSet())
|
|
|
|
// Increment request counter.
|
|
s.requests.Add(ctx, 1, attrOpt)
|
|
|
|
// Use floating point division here for higher precision (instead of Millisecond method).
|
|
s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), attrOpt)
|
|
}()
|
|
|
|
var (
|
|
recordError = func(stage string, err error) {
|
|
span.RecordError(err)
|
|
span.SetStatus(codes.Error, stage)
|
|
s.errors.Add(ctx, 1, metric.WithAttributeSet(labeler.AttributeSet()))
|
|
}
|
|
err error
|
|
opErrContext = ogenerrors.OperationContext{
|
|
Name: "CreateSubmission",
|
|
ID: "createSubmission",
|
|
}
|
|
)
|
|
request, close, err := s.decodeCreateSubmissionRequest(r)
|
|
if err != nil {
|
|
err = &ogenerrors.DecodeRequestError{
|
|
OperationContext: opErrContext,
|
|
Err: err,
|
|
}
|
|
defer recordError("DecodeRequest", err)
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
defer func() {
|
|
if err := close(); err != nil {
|
|
recordError("CloseRequest", err)
|
|
}
|
|
}()
|
|
|
|
var response *ID
|
|
if m := s.cfg.Middleware; m != nil {
|
|
mreq := middleware.Request{
|
|
Context: ctx,
|
|
OperationName: "CreateSubmission",
|
|
OperationSummary: "Create new submission",
|
|
OperationID: "createSubmission",
|
|
Body: request,
|
|
Params: middleware.Parameters{},
|
|
Raw: r,
|
|
}
|
|
|
|
type (
|
|
Request = OptSubmissionCreate
|
|
Params = struct{}
|
|
Response = *ID
|
|
)
|
|
response, err = middleware.HookMiddleware[
|
|
Request,
|
|
Params,
|
|
Response,
|
|
](
|
|
m,
|
|
mreq,
|
|
nil,
|
|
func(ctx context.Context, request Request, params Params) (response Response, err error) {
|
|
response, err = s.h.CreateSubmission(ctx, request)
|
|
return response, err
|
|
},
|
|
)
|
|
} else {
|
|
response, err = s.h.CreateSubmission(ctx, request)
|
|
}
|
|
if err != nil {
|
|
if errRes, ok := errors.Into[*ErrorStatusCode](err); ok {
|
|
if err := encodeErrorResponse(errRes, w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
if errors.Is(err, ht.ErrNotImplemented) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := encodeCreateSubmissionResponse(response, w, span); err != nil {
|
|
defer recordError("EncodeResponse", err)
|
|
if !errors.Is(err, ht.ErrInternalServerErrorResponse) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
// handleGetSubmissionRequest handles getSubmission operation.
|
|
//
|
|
// Retrieve map with ID.
|
|
//
|
|
// GET /submissions/{SubmissionID}
|
|
func (s *Server) handleGetSubmissionRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("getSubmission"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}"),
|
|
}
|
|
|
|
// Start a span for this request.
|
|
ctx, span := s.cfg.Tracer.Start(r.Context(), "GetSubmission",
|
|
trace.WithAttributes(otelAttrs...),
|
|
serverSpanKind,
|
|
)
|
|
defer span.End()
|
|
|
|
// Add Labeler to context.
|
|
labeler := &Labeler{attrs: otelAttrs}
|
|
ctx = contextWithLabeler(ctx, labeler)
|
|
|
|
// Run stopwatch.
|
|
startTime := time.Now()
|
|
defer func() {
|
|
elapsedDuration := time.Since(startTime)
|
|
attrOpt := metric.WithAttributeSet(labeler.AttributeSet())
|
|
|
|
// Increment request counter.
|
|
s.requests.Add(ctx, 1, attrOpt)
|
|
|
|
// Use floating point division here for higher precision (instead of Millisecond method).
|
|
s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), attrOpt)
|
|
}()
|
|
|
|
var (
|
|
recordError = func(stage string, err error) {
|
|
span.RecordError(err)
|
|
span.SetStatus(codes.Error, stage)
|
|
s.errors.Add(ctx, 1, metric.WithAttributeSet(labeler.AttributeSet()))
|
|
}
|
|
err error
|
|
opErrContext = ogenerrors.OperationContext{
|
|
Name: "GetSubmission",
|
|
ID: "getSubmission",
|
|
}
|
|
)
|
|
params, err := decodeGetSubmissionParams(args, argsEscaped, r)
|
|
if err != nil {
|
|
err = &ogenerrors.DecodeParamsError{
|
|
OperationContext: opErrContext,
|
|
Err: err,
|
|
}
|
|
defer recordError("DecodeParams", err)
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
|
|
var response *Submission
|
|
if m := s.cfg.Middleware; m != nil {
|
|
mreq := middleware.Request{
|
|
Context: ctx,
|
|
OperationName: "GetSubmission",
|
|
OperationSummary: "Retrieve map with ID",
|
|
OperationID: "getSubmission",
|
|
Body: nil,
|
|
Params: middleware.Parameters{
|
|
{
|
|
Name: "SubmissionID",
|
|
In: "path",
|
|
}: params.SubmissionID,
|
|
},
|
|
Raw: r,
|
|
}
|
|
|
|
type (
|
|
Request = struct{}
|
|
Params = GetSubmissionParams
|
|
Response = *Submission
|
|
)
|
|
response, err = middleware.HookMiddleware[
|
|
Request,
|
|
Params,
|
|
Response,
|
|
](
|
|
m,
|
|
mreq,
|
|
unpackGetSubmissionParams,
|
|
func(ctx context.Context, request Request, params Params) (response Response, err error) {
|
|
response, err = s.h.GetSubmission(ctx, params)
|
|
return response, err
|
|
},
|
|
)
|
|
} else {
|
|
response, err = s.h.GetSubmission(ctx, params)
|
|
}
|
|
if err != nil {
|
|
if errRes, ok := errors.Into[*ErrorStatusCode](err); ok {
|
|
if err := encodeErrorResponse(errRes, w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
if errors.Is(err, ht.ErrNotImplemented) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := encodeGetSubmissionResponse(response, w, span); err != nil {
|
|
defer recordError("EncodeResponse", err)
|
|
if !errors.Is(err, ht.ErrInternalServerErrorResponse) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
// handleListSubmissionsRequest handles listSubmissions operation.
|
|
//
|
|
// Get list of submissions.
|
|
//
|
|
// GET /submissions
|
|
func (s *Server) handleListSubmissionsRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("listSubmissions"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.HTTPRouteKey.String("/submissions"),
|
|
}
|
|
|
|
// Start a span for this request.
|
|
ctx, span := s.cfg.Tracer.Start(r.Context(), "ListSubmissions",
|
|
trace.WithAttributes(otelAttrs...),
|
|
serverSpanKind,
|
|
)
|
|
defer span.End()
|
|
|
|
// Add Labeler to context.
|
|
labeler := &Labeler{attrs: otelAttrs}
|
|
ctx = contextWithLabeler(ctx, labeler)
|
|
|
|
// Run stopwatch.
|
|
startTime := time.Now()
|
|
defer func() {
|
|
elapsedDuration := time.Since(startTime)
|
|
attrOpt := metric.WithAttributeSet(labeler.AttributeSet())
|
|
|
|
// Increment request counter.
|
|
s.requests.Add(ctx, 1, attrOpt)
|
|
|
|
// Use floating point division here for higher precision (instead of Millisecond method).
|
|
s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), attrOpt)
|
|
}()
|
|
|
|
var (
|
|
recordError = func(stage string, err error) {
|
|
span.RecordError(err)
|
|
span.SetStatus(codes.Error, stage)
|
|
s.errors.Add(ctx, 1, metric.WithAttributeSet(labeler.AttributeSet()))
|
|
}
|
|
err error
|
|
opErrContext = ogenerrors.OperationContext{
|
|
Name: "ListSubmissions",
|
|
ID: "listSubmissions",
|
|
}
|
|
)
|
|
params, err := decodeListSubmissionsParams(args, argsEscaped, r)
|
|
if err != nil {
|
|
err = &ogenerrors.DecodeParamsError{
|
|
OperationContext: opErrContext,
|
|
Err: err,
|
|
}
|
|
defer recordError("DecodeParams", err)
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
|
|
var response []Submission
|
|
if m := s.cfg.Middleware; m != nil {
|
|
mreq := middleware.Request{
|
|
Context: ctx,
|
|
OperationName: "ListSubmissions",
|
|
OperationSummary: "Get list of submissions",
|
|
OperationID: "listSubmissions",
|
|
Body: nil,
|
|
Params: middleware.Parameters{
|
|
{
|
|
Name: "page",
|
|
In: "query",
|
|
}: params.Page,
|
|
{
|
|
Name: "filter",
|
|
In: "query",
|
|
}: params.Filter,
|
|
},
|
|
Raw: r,
|
|
}
|
|
|
|
type (
|
|
Request = struct{}
|
|
Params = ListSubmissionsParams
|
|
Response = []Submission
|
|
)
|
|
response, err = middleware.HookMiddleware[
|
|
Request,
|
|
Params,
|
|
Response,
|
|
](
|
|
m,
|
|
mreq,
|
|
unpackListSubmissionsParams,
|
|
func(ctx context.Context, request Request, params Params) (response Response, err error) {
|
|
response, err = s.h.ListSubmissions(ctx, params)
|
|
return response, err
|
|
},
|
|
)
|
|
} else {
|
|
response, err = s.h.ListSubmissions(ctx, params)
|
|
}
|
|
if err != nil {
|
|
if errRes, ok := errors.Into[*ErrorStatusCode](err); ok {
|
|
if err := encodeErrorResponse(errRes, w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
if errors.Is(err, ht.ErrNotImplemented) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := encodeListSubmissionsResponse(response, w, span); err != nil {
|
|
defer recordError("EncodeResponse", err)
|
|
if !errors.Is(err, ht.ErrInternalServerErrorResponse) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
// handlePatchSubmissionCompletedRequest handles patchSubmissionCompleted operation.
|
|
//
|
|
// Retrieve map with ID.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/completed
|
|
func (s *Server) handlePatchSubmissionCompletedRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("patchSubmissionCompleted"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/completed"),
|
|
}
|
|
|
|
// Start a span for this request.
|
|
ctx, span := s.cfg.Tracer.Start(r.Context(), "PatchSubmissionCompleted",
|
|
trace.WithAttributes(otelAttrs...),
|
|
serverSpanKind,
|
|
)
|
|
defer span.End()
|
|
|
|
// Add Labeler to context.
|
|
labeler := &Labeler{attrs: otelAttrs}
|
|
ctx = contextWithLabeler(ctx, labeler)
|
|
|
|
// Run stopwatch.
|
|
startTime := time.Now()
|
|
defer func() {
|
|
elapsedDuration := time.Since(startTime)
|
|
attrOpt := metric.WithAttributeSet(labeler.AttributeSet())
|
|
|
|
// Increment request counter.
|
|
s.requests.Add(ctx, 1, attrOpt)
|
|
|
|
// Use floating point division here for higher precision (instead of Millisecond method).
|
|
s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), attrOpt)
|
|
}()
|
|
|
|
var (
|
|
recordError = func(stage string, err error) {
|
|
span.RecordError(err)
|
|
span.SetStatus(codes.Error, stage)
|
|
s.errors.Add(ctx, 1, metric.WithAttributeSet(labeler.AttributeSet()))
|
|
}
|
|
err error
|
|
opErrContext = ogenerrors.OperationContext{
|
|
Name: "PatchSubmissionCompleted",
|
|
ID: "patchSubmissionCompleted",
|
|
}
|
|
)
|
|
params, err := decodePatchSubmissionCompletedParams(args, argsEscaped, r)
|
|
if err != nil {
|
|
err = &ogenerrors.DecodeParamsError{
|
|
OperationContext: opErrContext,
|
|
Err: err,
|
|
}
|
|
defer recordError("DecodeParams", err)
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
|
|
var response *PatchSubmissionCompletedOK
|
|
if m := s.cfg.Middleware; m != nil {
|
|
mreq := middleware.Request{
|
|
Context: ctx,
|
|
OperationName: "PatchSubmissionCompleted",
|
|
OperationSummary: "Retrieve map with ID",
|
|
OperationID: "patchSubmissionCompleted",
|
|
Body: nil,
|
|
Params: middleware.Parameters{
|
|
{
|
|
Name: "SubmissionID",
|
|
In: "path",
|
|
}: params.SubmissionID,
|
|
{
|
|
Name: "Completed",
|
|
In: "query",
|
|
}: params.Completed,
|
|
},
|
|
Raw: r,
|
|
}
|
|
|
|
type (
|
|
Request = struct{}
|
|
Params = PatchSubmissionCompletedParams
|
|
Response = *PatchSubmissionCompletedOK
|
|
)
|
|
response, err = middleware.HookMiddleware[
|
|
Request,
|
|
Params,
|
|
Response,
|
|
](
|
|
m,
|
|
mreq,
|
|
unpackPatchSubmissionCompletedParams,
|
|
func(ctx context.Context, request Request, params Params) (response Response, err error) {
|
|
err = s.h.PatchSubmissionCompleted(ctx, params)
|
|
return response, err
|
|
},
|
|
)
|
|
} else {
|
|
err = s.h.PatchSubmissionCompleted(ctx, params)
|
|
}
|
|
if err != nil {
|
|
if errRes, ok := errors.Into[*ErrorStatusCode](err); ok {
|
|
if err := encodeErrorResponse(errRes, w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
if errors.Is(err, ht.ErrNotImplemented) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := encodePatchSubmissionCompletedResponse(response, w, span); err != nil {
|
|
defer recordError("EncodeResponse", err)
|
|
if !errors.Is(err, ht.ErrInternalServerErrorResponse) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
// handlePatchSubmissionModelRequest handles patchSubmissionModel operation.
|
|
//
|
|
// Update model following role restrictions.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/model
|
|
func (s *Server) handlePatchSubmissionModelRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("patchSubmissionModel"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/model"),
|
|
}
|
|
|
|
// Start a span for this request.
|
|
ctx, span := s.cfg.Tracer.Start(r.Context(), "PatchSubmissionModel",
|
|
trace.WithAttributes(otelAttrs...),
|
|
serverSpanKind,
|
|
)
|
|
defer span.End()
|
|
|
|
// Add Labeler to context.
|
|
labeler := &Labeler{attrs: otelAttrs}
|
|
ctx = contextWithLabeler(ctx, labeler)
|
|
|
|
// Run stopwatch.
|
|
startTime := time.Now()
|
|
defer func() {
|
|
elapsedDuration := time.Since(startTime)
|
|
attrOpt := metric.WithAttributeSet(labeler.AttributeSet())
|
|
|
|
// Increment request counter.
|
|
s.requests.Add(ctx, 1, attrOpt)
|
|
|
|
// Use floating point division here for higher precision (instead of Millisecond method).
|
|
s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), attrOpt)
|
|
}()
|
|
|
|
var (
|
|
recordError = func(stage string, err error) {
|
|
span.RecordError(err)
|
|
span.SetStatus(codes.Error, stage)
|
|
s.errors.Add(ctx, 1, metric.WithAttributeSet(labeler.AttributeSet()))
|
|
}
|
|
err error
|
|
opErrContext = ogenerrors.OperationContext{
|
|
Name: "PatchSubmissionModel",
|
|
ID: "patchSubmissionModel",
|
|
}
|
|
)
|
|
params, err := decodePatchSubmissionModelParams(args, argsEscaped, r)
|
|
if err != nil {
|
|
err = &ogenerrors.DecodeParamsError{
|
|
OperationContext: opErrContext,
|
|
Err: err,
|
|
}
|
|
defer recordError("DecodeParams", err)
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
|
|
var response *PatchSubmissionModelOK
|
|
if m := s.cfg.Middleware; m != nil {
|
|
mreq := middleware.Request{
|
|
Context: ctx,
|
|
OperationName: "PatchSubmissionModel",
|
|
OperationSummary: "Update model following role restrictions",
|
|
OperationID: "patchSubmissionModel",
|
|
Body: nil,
|
|
Params: middleware.Parameters{
|
|
{
|
|
Name: "SubmissionID",
|
|
In: "path",
|
|
}: params.SubmissionID,
|
|
{
|
|
Name: "ModelID",
|
|
In: "query",
|
|
}: params.ModelID,
|
|
{
|
|
Name: "VersionID",
|
|
In: "query",
|
|
}: params.VersionID,
|
|
},
|
|
Raw: r,
|
|
}
|
|
|
|
type (
|
|
Request = struct{}
|
|
Params = PatchSubmissionModelParams
|
|
Response = *PatchSubmissionModelOK
|
|
)
|
|
response, err = middleware.HookMiddleware[
|
|
Request,
|
|
Params,
|
|
Response,
|
|
](
|
|
m,
|
|
mreq,
|
|
unpackPatchSubmissionModelParams,
|
|
func(ctx context.Context, request Request, params Params) (response Response, err error) {
|
|
err = s.h.PatchSubmissionModel(ctx, params)
|
|
return response, err
|
|
},
|
|
)
|
|
} else {
|
|
err = s.h.PatchSubmissionModel(ctx, params)
|
|
}
|
|
if err != nil {
|
|
if errRes, ok := errors.Into[*ErrorStatusCode](err); ok {
|
|
if err := encodeErrorResponse(errRes, w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
if errors.Is(err, ht.ErrNotImplemented) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := encodePatchSubmissionModelResponse(response, w, span); err != nil {
|
|
defer recordError("EncodeResponse", err)
|
|
if !errors.Is(err, ht.ErrInternalServerErrorResponse) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
}
|
|
return
|
|
}
|
|
}
|
|
|
|
// handlePatchSubmissionStatusRequest handles patchSubmissionStatus operation.
|
|
//
|
|
// Update status following role restrictions.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status
|
|
func (s *Server) handlePatchSubmissionStatusRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("patchSubmissionStatus"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status"),
|
|
}
|
|
|
|
// Start a span for this request.
|
|
ctx, span := s.cfg.Tracer.Start(r.Context(), "PatchSubmissionStatus",
|
|
trace.WithAttributes(otelAttrs...),
|
|
serverSpanKind,
|
|
)
|
|
defer span.End()
|
|
|
|
// Add Labeler to context.
|
|
labeler := &Labeler{attrs: otelAttrs}
|
|
ctx = contextWithLabeler(ctx, labeler)
|
|
|
|
// Run stopwatch.
|
|
startTime := time.Now()
|
|
defer func() {
|
|
elapsedDuration := time.Since(startTime)
|
|
attrOpt := metric.WithAttributeSet(labeler.AttributeSet())
|
|
|
|
// Increment request counter.
|
|
s.requests.Add(ctx, 1, attrOpt)
|
|
|
|
// Use floating point division here for higher precision (instead of Millisecond method).
|
|
s.duration.Record(ctx, float64(float64(elapsedDuration)/float64(time.Millisecond)), attrOpt)
|
|
}()
|
|
|
|
var (
|
|
recordError = func(stage string, err error) {
|
|
span.RecordError(err)
|
|
span.SetStatus(codes.Error, stage)
|
|
s.errors.Add(ctx, 1, metric.WithAttributeSet(labeler.AttributeSet()))
|
|
}
|
|
err error
|
|
opErrContext = ogenerrors.OperationContext{
|
|
Name: "PatchSubmissionStatus",
|
|
ID: "patchSubmissionStatus",
|
|
}
|
|
)
|
|
params, err := decodePatchSubmissionStatusParams(args, argsEscaped, r)
|
|
if err != nil {
|
|
err = &ogenerrors.DecodeParamsError{
|
|
OperationContext: opErrContext,
|
|
Err: err,
|
|
}
|
|
defer recordError("DecodeParams", err)
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
|
|
var response *PatchSubmissionStatusOK
|
|
if m := s.cfg.Middleware; m != nil {
|
|
mreq := middleware.Request{
|
|
Context: ctx,
|
|
OperationName: "PatchSubmissionStatus",
|
|
OperationSummary: "Update status following role restrictions",
|
|
OperationID: "patchSubmissionStatus",
|
|
Body: nil,
|
|
Params: middleware.Parameters{
|
|
{
|
|
Name: "SubmissionID",
|
|
In: "path",
|
|
}: params.SubmissionID,
|
|
{
|
|
Name: "Status",
|
|
In: "query",
|
|
}: params.Status,
|
|
},
|
|
Raw: r,
|
|
}
|
|
|
|
type (
|
|
Request = struct{}
|
|
Params = PatchSubmissionStatusParams
|
|
Response = *PatchSubmissionStatusOK
|
|
)
|
|
response, err = middleware.HookMiddleware[
|
|
Request,
|
|
Params,
|
|
Response,
|
|
](
|
|
m,
|
|
mreq,
|
|
unpackPatchSubmissionStatusParams,
|
|
func(ctx context.Context, request Request, params Params) (response Response, err error) {
|
|
err = s.h.PatchSubmissionStatus(ctx, params)
|
|
return response, err
|
|
},
|
|
)
|
|
} else {
|
|
err = s.h.PatchSubmissionStatus(ctx, params)
|
|
}
|
|
if err != nil {
|
|
if errRes, ok := errors.Into[*ErrorStatusCode](err); ok {
|
|
if err := encodeErrorResponse(errRes, w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
if errors.Is(err, ht.ErrNotImplemented) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
return
|
|
}
|
|
if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil {
|
|
defer recordError("Internal", err)
|
|
}
|
|
return
|
|
}
|
|
|
|
if err := encodePatchSubmissionStatusResponse(response, w, span); err != nil {
|
|
defer recordError("EncodeResponse", err)
|
|
if !errors.Is(err, ht.ErrInternalServerErrorResponse) {
|
|
s.cfg.ErrorHandler(ctx, w, r, err)
|
|
}
|
|
return
|
|
}
|
|
}
|