From 4055ef550e2752d02fc1a7f571466232b61d55e0 Mon Sep 17 00:00:00 2001 From: Quaternions Date: Wed, 4 Jun 2025 17:32:44 -0700 Subject: [PATCH] openapi: generate --- pkg/api/oas_client_gen.go | 260 +++++++++++++++ pkg/api/oas_handlers_gen.go | 390 +++++++++++++++++++++++ pkg/api/oas_operations_gen.go | 2 + pkg/api/oas_parameters_gen.go | 166 ++++++++++ pkg/api/oas_request_decoders_gen.go | 41 ++- pkg/api/oas_response_decoders_gen.go | 120 +++++++ pkg/api/oas_response_encoders_gen.go | 14 + pkg/api/oas_router_gen.go | 92 ++++++ pkg/api/oas_schemas_gen.go | 17 + pkg/api/oas_security_gen.go | 46 +++ pkg/api/oas_server_gen.go | 12 + pkg/api/oas_unimplemented_gen.go | 18 ++ pkg/internal/oas_request_decoders_gen.go | 17 +- 13 files changed, 1165 insertions(+), 30 deletions(-) diff --git a/pkg/api/oas_client_gen.go b/pkg/api/oas_client_gen.go index 79517238..b5fa438f 100644 --- a/pkg/api/oas_client_gen.go +++ b/pkg/api/oas_client_gen.go @@ -35,6 +35,12 @@ type Invoker interface { // // POST /mapfixes/{MapfixID}/status/reset-validating ActionMapfixAccepted(ctx context.Context, params ActionMapfixAcceptedParams) error + // ActionMapfixBypassSubmit invokes actionMapfixBypassSubmit operation. + // + // Role Reviewer changes status from ChangesRequested -> Submitted. + // + // POST /mapfixes/{MapfixID}/status/bypass-submit + ActionMapfixBypassSubmit(ctx context.Context, params ActionMapfixBypassSubmitParams) error // ActionMapfixReject invokes actionMapfixReject operation. // // Role Reviewer changes status from Submitted -> Rejected. @@ -96,6 +102,12 @@ type Invoker interface { // // POST /submissions/{SubmissionID}/status/reset-validating ActionSubmissionAccepted(ctx context.Context, params ActionSubmissionAcceptedParams) error + // ActionSubmissionBypassSubmit invokes actionSubmissionBypassSubmit operation. + // + // Role Reviewer changes status from ChangesRequested -> Submitted. + // + // POST /submissions/{SubmissionID}/status/bypass-submit + ActionSubmissionBypassSubmit(ctx context.Context, params ActionSubmissionBypassSubmitParams) error // ActionSubmissionReject invokes actionSubmissionReject operation. // // Role Reviewer changes status from Submitted -> Rejected. @@ -518,6 +530,130 @@ func (c *Client) sendActionMapfixAccepted(ctx context.Context, params ActionMapf return result, nil } +// ActionMapfixBypassSubmit invokes actionMapfixBypassSubmit operation. +// +// Role Reviewer changes status from ChangesRequested -> Submitted. +// +// POST /mapfixes/{MapfixID}/status/bypass-submit +func (c *Client) ActionMapfixBypassSubmit(ctx context.Context, params ActionMapfixBypassSubmitParams) error { + _, err := c.sendActionMapfixBypassSubmit(ctx, params) + return err +} + +func (c *Client) sendActionMapfixBypassSubmit(ctx context.Context, params ActionMapfixBypassSubmitParams) (res *ActionMapfixBypassSubmitNoContent, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("actionMapfixBypassSubmit"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/mapfixes/{MapfixID}/status/bypass-submit"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, ActionMapfixBypassSubmitOperation, + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/mapfixes/" + { + // Encode "MapfixID" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "MapfixID", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.Int64ToString(params.MapfixID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/status/bypass-submit" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:CookieAuth" + switch err := c.securityCookieAuth(ctx, ActionMapfixBypassSubmitOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"CookieAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeActionMapfixBypassSubmitResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // ActionMapfixReject invokes actionMapfixReject operation. // // Role Reviewer changes status from Submitted -> Rejected. @@ -1759,6 +1895,130 @@ func (c *Client) sendActionSubmissionAccepted(ctx context.Context, params Action return result, nil } +// ActionSubmissionBypassSubmit invokes actionSubmissionBypassSubmit operation. +// +// Role Reviewer changes status from ChangesRequested -> Submitted. +// +// POST /submissions/{SubmissionID}/status/bypass-submit +func (c *Client) ActionSubmissionBypassSubmit(ctx context.Context, params ActionSubmissionBypassSubmitParams) error { + _, err := c.sendActionSubmissionBypassSubmit(ctx, params) + return err +} + +func (c *Client) sendActionSubmissionBypassSubmit(ctx context.Context, params ActionSubmissionBypassSubmitParams) (res *ActionSubmissionBypassSubmitNoContent, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("actionSubmissionBypassSubmit"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/bypass-submit"), + } + + // Run stopwatch. + startTime := time.Now() + defer func() { + // Use floating point division here for higher precision (instead of Millisecond method). + elapsedDuration := time.Since(startTime) + c.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), metric.WithAttributes(otelAttrs...)) + }() + + // Increment request counter. + c.requests.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + + // Start a span for this request. + ctx, span := c.cfg.Tracer.Start(ctx, ActionSubmissionBypassSubmitOperation, + trace.WithAttributes(otelAttrs...), + clientSpanKind, + ) + // Track stage for error reporting. + var stage string + defer func() { + if err != nil { + span.RecordError(err) + span.SetStatus(codes.Error, stage) + c.errors.Add(ctx, 1, metric.WithAttributes(otelAttrs...)) + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/submissions/" + { + // Encode "SubmissionID" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "SubmissionID", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.Int64ToString(params.SubmissionID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[1] = encoded + } + pathParts[2] = "/status/bypass-submit" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "POST", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:CookieAuth" + switch err := c.securityCookieAuth(ctx, ActionSubmissionBypassSubmitOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"CookieAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + defer resp.Body.Close() + + stage = "DecodeResponse" + result, err := decodeActionSubmissionBypassSubmitResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // ActionSubmissionReject invokes actionSubmissionReject operation. // // Role Reviewer changes status from Submitted -> Rejected. diff --git a/pkg/api/oas_handlers_gen.go b/pkg/api/oas_handlers_gen.go index 13081b75..a2677d08 100644 --- a/pkg/api/oas_handlers_gen.go +++ b/pkg/api/oas_handlers_gen.go @@ -225,6 +225,201 @@ func (s *Server) handleActionMapfixAcceptedRequest(args [1]string, argsEscaped b } } +// handleActionMapfixBypassSubmitRequest handles actionMapfixBypassSubmit operation. +// +// Role Reviewer changes status from ChangesRequested -> Submitted. +// +// POST /mapfixes/{MapfixID}/status/bypass-submit +func (s *Server) handleActionMapfixBypassSubmitRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + statusWriter := &codeRecorder{ResponseWriter: w} + w = statusWriter + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("actionMapfixBypassSubmit"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/mapfixes/{MapfixID}/status/bypass-submit"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), ActionMapfixBypassSubmitOperation, + 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) + + attrSet := labeler.AttributeSet() + attrs := attrSet.ToSlice() + code := statusWriter.status + if code != 0 { + codeAttr := semconv.HTTPResponseStatusCode(code) + attrs = append(attrs, codeAttr) + span.SetAttributes(codeAttr) + } + attrOpt := metric.WithAttributes(attrs...) + + // 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(elapsedDuration)/float64(time.Millisecond), attrOpt) + }() + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + + // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status + // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, + // unless there was another error (e.g., network error receiving the response body; or 3xx codes with + // max redirects exceeded), in which case status MUST be set to Error. + code := statusWriter.status + if code >= 100 && code < 500 { + span.SetStatus(codes.Error, stage) + } + + attrSet := labeler.AttributeSet() + attrs := attrSet.ToSlice() + if code != 0 { + attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) + } + + s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: ActionMapfixBypassSubmitOperation, + ID: "actionMapfixBypassSubmit", + } + ) + { + type bitset = [1]uint8 + var satisfied bitset + { + sctx, ok, err := s.securityCookieAuth(ctx, ActionMapfixBypassSubmitOperation, r) + if err != nil { + err = &ogenerrors.SecurityError{ + OperationContext: opErrContext, + Security: "CookieAuth", + Err: err, + } + if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { + defer recordError("Security:CookieAuth", err) + } + return + } + if ok { + satisfied[0] |= 1 << 0 + ctx = sctx + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + err = &ogenerrors.SecurityError{ + OperationContext: opErrContext, + Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, + } + if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { + defer recordError("Security", err) + } + return + } + } + params, err := decodeActionMapfixBypassSubmitParams(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 *ActionMapfixBypassSubmitNoContent + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: ActionMapfixBypassSubmitOperation, + OperationSummary: "Role Reviewer changes status from ChangesRequested -> Submitted", + OperationID: "actionMapfixBypassSubmit", + Body: nil, + Params: middleware.Parameters{ + { + Name: "MapfixID", + In: "path", + }: params.MapfixID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ActionMapfixBypassSubmitParams + Response = *ActionMapfixBypassSubmitNoContent + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackActionMapfixBypassSubmitParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + err = s.h.ActionMapfixBypassSubmit(ctx, params) + return response, err + }, + ) + } else { + err = s.h.ActionMapfixBypassSubmit(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 := encodeActionMapfixBypassSubmitResponse(response, w, span); err != nil { + defer recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + // handleActionMapfixRejectRequest handles actionMapfixReject operation. // // Role Reviewer changes status from Submitted -> Rejected. @@ -2176,6 +2371,201 @@ func (s *Server) handleActionSubmissionAcceptedRequest(args [1]string, argsEscap } } +// handleActionSubmissionBypassSubmitRequest handles actionSubmissionBypassSubmit operation. +// +// Role Reviewer changes status from ChangesRequested -> Submitted. +// +// POST /submissions/{SubmissionID}/status/bypass-submit +func (s *Server) handleActionSubmissionBypassSubmitRequest(args [1]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + statusWriter := &codeRecorder{ResponseWriter: w} + w = statusWriter + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("actionSubmissionBypassSubmit"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/bypass-submit"), + } + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), ActionSubmissionBypassSubmitOperation, + 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) + + attrSet := labeler.AttributeSet() + attrs := attrSet.ToSlice() + code := statusWriter.status + if code != 0 { + codeAttr := semconv.HTTPResponseStatusCode(code) + attrs = append(attrs, codeAttr) + span.SetAttributes(codeAttr) + } + attrOpt := metric.WithAttributes(attrs...) + + // 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(elapsedDuration)/float64(time.Millisecond), attrOpt) + }() + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + + // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status + // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, + // unless there was another error (e.g., network error receiving the response body; or 3xx codes with + // max redirects exceeded), in which case status MUST be set to Error. + code := statusWriter.status + if code >= 100 && code < 500 { + span.SetStatus(codes.Error, stage) + } + + attrSet := labeler.AttributeSet() + attrs := attrSet.ToSlice() + if code != 0 { + attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) + } + + s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: ActionSubmissionBypassSubmitOperation, + ID: "actionSubmissionBypassSubmit", + } + ) + { + type bitset = [1]uint8 + var satisfied bitset + { + sctx, ok, err := s.securityCookieAuth(ctx, ActionSubmissionBypassSubmitOperation, r) + if err != nil { + err = &ogenerrors.SecurityError{ + OperationContext: opErrContext, + Security: "CookieAuth", + Err: err, + } + if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { + defer recordError("Security:CookieAuth", err) + } + return + } + if ok { + satisfied[0] |= 1 << 0 + ctx = sctx + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + err = &ogenerrors.SecurityError{ + OperationContext: opErrContext, + Err: ogenerrors.ErrSecurityRequirementIsNotSatisfied, + } + if encodeErr := encodeErrorResponse(s.h.NewError(ctx, err), w, span); encodeErr != nil { + defer recordError("Security", err) + } + return + } + } + params, err := decodeActionSubmissionBypassSubmitParams(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 *ActionSubmissionBypassSubmitNoContent + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: ActionSubmissionBypassSubmitOperation, + OperationSummary: "Role Reviewer changes status from ChangesRequested -> Submitted", + OperationID: "actionSubmissionBypassSubmit", + Body: nil, + Params: middleware.Parameters{ + { + Name: "SubmissionID", + In: "path", + }: params.SubmissionID, + }, + Raw: r, + } + + type ( + Request = struct{} + Params = ActionSubmissionBypassSubmitParams + Response = *ActionSubmissionBypassSubmitNoContent + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackActionSubmissionBypassSubmitParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + err = s.h.ActionSubmissionBypassSubmit(ctx, params) + return response, err + }, + ) + } else { + err = s.h.ActionSubmissionBypassSubmit(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 := encodeActionSubmissionBypassSubmitResponse(response, w, span); err != nil { + defer recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + // handleActionSubmissionRejectRequest handles actionSubmissionReject operation. // // Role Reviewer changes status from Submitted -> Rejected. diff --git a/pkg/api/oas_operations_gen.go b/pkg/api/oas_operations_gen.go index bb64e959..0ed67d84 100644 --- a/pkg/api/oas_operations_gen.go +++ b/pkg/api/oas_operations_gen.go @@ -7,6 +7,7 @@ type OperationName = string const ( ActionMapfixAcceptedOperation OperationName = "ActionMapfixAccepted" + ActionMapfixBypassSubmitOperation OperationName = "ActionMapfixBypassSubmit" ActionMapfixRejectOperation OperationName = "ActionMapfixReject" ActionMapfixRequestChangesOperation OperationName = "ActionMapfixRequestChanges" ActionMapfixResetSubmittingOperation OperationName = "ActionMapfixResetSubmitting" @@ -17,6 +18,7 @@ const ( ActionMapfixTriggerValidateOperation OperationName = "ActionMapfixTriggerValidate" ActionMapfixValidatedOperation OperationName = "ActionMapfixValidated" ActionSubmissionAcceptedOperation OperationName = "ActionSubmissionAccepted" + ActionSubmissionBypassSubmitOperation OperationName = "ActionSubmissionBypassSubmit" ActionSubmissionRejectOperation OperationName = "ActionSubmissionReject" ActionSubmissionRequestChangesOperation OperationName = "ActionSubmissionRequestChanges" ActionSubmissionResetSubmittingOperation OperationName = "ActionSubmissionResetSubmitting" diff --git a/pkg/api/oas_parameters_gen.go b/pkg/api/oas_parameters_gen.go index f434a5fa..bcfd93df 100644 --- a/pkg/api/oas_parameters_gen.go +++ b/pkg/api/oas_parameters_gen.go @@ -98,6 +98,89 @@ func decodeActionMapfixAcceptedParams(args [1]string, argsEscaped bool, r *http. return params, nil } +// ActionMapfixBypassSubmitParams is parameters of actionMapfixBypassSubmit operation. +type ActionMapfixBypassSubmitParams struct { + // The unique identifier for a mapfix. + MapfixID int64 +} + +func unpackActionMapfixBypassSubmitParams(packed middleware.Parameters) (params ActionMapfixBypassSubmitParams) { + { + key := middleware.ParameterKey{ + Name: "MapfixID", + In: "path", + } + params.MapfixID = packed[key].(int64) + } + return params +} + +func decodeActionMapfixBypassSubmitParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionMapfixBypassSubmitParams, _ error) { + // Decode path: MapfixID. + if err := func() error { + param := args[0] + if argsEscaped { + unescaped, err := url.PathUnescape(args[0]) + if err != nil { + return errors.Wrap(err, "unescape path") + } + param = unescaped + } + if len(param) > 0 { + d := uri.NewPathDecoder(uri.PathDecoderConfig{ + Param: "MapfixID", + Value: param, + Style: uri.PathStyleSimple, + Explode: false, + }) + + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt64(val) + if err != nil { + return err + } + + params.MapfixID = c + return nil + }(); err != nil { + return err + } + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 0, + MaxSet: false, + Max: 0, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + }).Validate(int64(params.MapfixID)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "MapfixID", + In: "path", + Err: err, + } + } + return params, nil +} + // ActionMapfixRejectParams is parameters of actionMapfixReject operation. type ActionMapfixRejectParams struct { // The unique identifier for a mapfix. @@ -928,6 +1011,89 @@ func decodeActionSubmissionAcceptedParams(args [1]string, argsEscaped bool, r *h return params, nil } +// ActionSubmissionBypassSubmitParams is parameters of actionSubmissionBypassSubmit operation. +type ActionSubmissionBypassSubmitParams struct { + // The unique identifier for a submission. + SubmissionID int64 +} + +func unpackActionSubmissionBypassSubmitParams(packed middleware.Parameters) (params ActionSubmissionBypassSubmitParams) { + { + key := middleware.ParameterKey{ + Name: "SubmissionID", + In: "path", + } + params.SubmissionID = packed[key].(int64) + } + return params +} + +func decodeActionSubmissionBypassSubmitParams(args [1]string, argsEscaped bool, r *http.Request) (params ActionSubmissionBypassSubmitParams, _ error) { + // Decode path: SubmissionID. + if err := func() error { + param := args[0] + if argsEscaped { + unescaped, err := url.PathUnescape(args[0]) + if err != nil { + return errors.Wrap(err, "unescape path") + } + param = unescaped + } + if len(param) > 0 { + d := uri.NewPathDecoder(uri.PathDecoderConfig{ + Param: "SubmissionID", + Value: param, + Style: uri.PathStyleSimple, + Explode: false, + }) + + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToInt64(val) + if err != nil { + return err + } + + params.SubmissionID = c + return nil + }(); err != nil { + return err + } + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 0, + MaxSet: false, + Max: 0, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + }).Validate(int64(params.SubmissionID)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + return err + } + } else { + return validate.ErrFieldRequired + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "SubmissionID", + In: "path", + Err: err, + } + } + return params, nil +} + // ActionSubmissionRejectParams is parameters of actionSubmissionReject operation. type ActionSubmissionRejectParams struct { // The unique identifier for a submission. diff --git a/pkg/api/oas_request_decoders_gen.go b/pkg/api/oas_request_decoders_gen.go index a53e8e7a..24ca5bff 100644 --- a/pkg/api/oas_request_decoders_gen.go +++ b/pkg/api/oas_request_decoders_gen.go @@ -10,7 +10,6 @@ import ( "github.com/go-faster/errors" "github.com/go-faster/jx" - "go.uber.org/multierr" "github.com/ogen-go/ogen/ogenerrors" "github.com/ogen-go/ogen/validate" @@ -27,13 +26,13 @@ func (s *Server) decodeCreateMapfixRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -98,13 +97,13 @@ func (s *Server) decodeCreateMapfixAuditCommentRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -132,13 +131,13 @@ func (s *Server) decodeCreateScriptRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -203,13 +202,13 @@ func (s *Server) decodeCreateScriptPolicyRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -274,13 +273,13 @@ func (s *Server) decodeCreateSubmissionRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -345,13 +344,13 @@ func (s *Server) decodeCreateSubmissionAdminRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -416,13 +415,13 @@ func (s *Server) decodeCreateSubmissionAuditCommentRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -450,13 +449,13 @@ func (s *Server) decodeReleaseSubmissionsRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -554,13 +553,13 @@ func (s *Server) decodeUpdateScriptRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -625,13 +624,13 @@ func (s *Server) decodeUpdateScriptPolicyRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) diff --git a/pkg/api/oas_response_decoders_gen.go b/pkg/api/oas_response_decoders_gen.go index a017f830..f1227af2 100644 --- a/pkg/api/oas_response_decoders_gen.go +++ b/pkg/api/oas_response_decoders_gen.go @@ -75,6 +75,66 @@ func decodeActionMapfixAcceptedResponse(resp *http.Response) (res *ActionMapfixA return res, errors.Wrap(defRes, "error") } +func decodeActionMapfixBypassSubmitResponse(resp *http.Response) (res *ActionMapfixBypassSubmitNoContent, _ error) { + switch resp.StatusCode { + case 204: + // Code 204. + return &ActionMapfixBypassSubmitNoContent{}, nil + } + // Convenient error response. + defRes, err := func() (res *ErrorStatusCode, err error) { + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &ErrorStatusCode{ + StatusCode: resp.StatusCode, + Response: response, + }, nil + default: + return res, validate.InvalidContentType(ct) + } + }() + if err != nil { + return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode) + } + return res, errors.Wrap(defRes, "error") +} + func decodeActionMapfixRejectResponse(resp *http.Response) (res *ActionMapfixRejectNoContent, _ error) { switch resp.StatusCode { case 204: @@ -675,6 +735,66 @@ func decodeActionSubmissionAcceptedResponse(resp *http.Response) (res *ActionSub return res, errors.Wrap(defRes, "error") } +func decodeActionSubmissionBypassSubmitResponse(resp *http.Response) (res *ActionSubmissionBypassSubmitNoContent, _ error) { + switch resp.StatusCode { + case 204: + // Code 204. + return &ActionSubmissionBypassSubmitNoContent{}, nil + } + // Convenient error response. + defRes, err := func() (res *ErrorStatusCode, err error) { + ct, _, err := mime.ParseMediaType(resp.Header.Get("Content-Type")) + if err != nil { + return res, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + buf, err := io.ReadAll(resp.Body) + if err != nil { + return res, err + } + d := jx.DecodeBytes(buf) + + var response Error + if err := func() error { + if err := response.Decode(d); err != nil { + return err + } + if err := d.Skip(); err != io.EOF { + return errors.New("unexpected trailing data") + } + return nil + }(); err != nil { + err = &ogenerrors.DecodeBodyError{ + ContentType: ct, + Body: buf, + Err: err, + } + return res, err + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &ErrorStatusCode{ + StatusCode: resp.StatusCode, + Response: response, + }, nil + default: + return res, validate.InvalidContentType(ct) + } + }() + if err != nil { + return res, errors.Wrapf(err, "default (code %d)", resp.StatusCode) + } + return res, errors.Wrap(defRes, "error") +} + func decodeActionSubmissionRejectResponse(resp *http.Response) (res *ActionSubmissionRejectNoContent, _ error) { switch resp.StatusCode { case 204: diff --git a/pkg/api/oas_response_encoders_gen.go b/pkg/api/oas_response_encoders_gen.go index 151b3253..6279a819 100644 --- a/pkg/api/oas_response_encoders_gen.go +++ b/pkg/api/oas_response_encoders_gen.go @@ -20,6 +20,13 @@ func encodeActionMapfixAcceptedResponse(response *ActionMapfixAcceptedNoContent, return nil } +func encodeActionMapfixBypassSubmitResponse(response *ActionMapfixBypassSubmitNoContent, w http.ResponseWriter, span trace.Span) error { + w.WriteHeader(204) + span.SetStatus(codes.Ok, http.StatusText(204)) + + return nil +} + func encodeActionMapfixRejectResponse(response *ActionMapfixRejectNoContent, w http.ResponseWriter, span trace.Span) error { w.WriteHeader(204) span.SetStatus(codes.Ok, http.StatusText(204)) @@ -90,6 +97,13 @@ func encodeActionSubmissionAcceptedResponse(response *ActionSubmissionAcceptedNo return nil } +func encodeActionSubmissionBypassSubmitResponse(response *ActionSubmissionBypassSubmitNoContent, w http.ResponseWriter, span trace.Span) error { + w.WriteHeader(204) + span.SetStatus(codes.Ok, http.StatusText(204)) + + return nil +} + func encodeActionSubmissionRejectResponse(response *ActionSubmissionRejectNoContent, w http.ResponseWriter, span trace.Span) error { w.WriteHeader(204) span.SetStatus(codes.Ok, http.StatusText(204)) diff --git a/pkg/api/oas_router_gen.go b/pkg/api/oas_router_gen.go index 00ff8488..d74b7b59 100644 --- a/pkg/api/oas_router_gen.go +++ b/pkg/api/oas_router_gen.go @@ -250,6 +250,28 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { + case 'b': // Prefix: "bypass-submit" + + if l := len("bypass-submit"); len(elem) >= l && elem[0:l] == "bypass-submit" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleActionMapfixBypassSubmitRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + case 'r': // Prefix: "re" if l := len("re"); len(elem) >= l && elem[0:l] == "re" { @@ -1046,6 +1068,28 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { + case 'b': // Prefix: "bypass-submit" + + if l := len("bypass-submit"); len(elem) >= l && elem[0:l] == "bypass-submit" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleActionSubmissionBypassSubmitRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, "POST") + } + + return + } + case 'r': // Prefix: "re" if l := len("re"); len(elem) >= l && elem[0:l] == "re" { @@ -1621,6 +1665,30 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { + case 'b': // Prefix: "bypass-submit" + + if l := len("bypass-submit"); len(elem) >= l && elem[0:l] == "bypass-submit" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = ActionMapfixBypassSubmitOperation + r.summary = "Role Reviewer changes status from ChangesRequested -> Submitted" + r.operationID = "actionMapfixBypassSubmit" + r.pathPattern = "/mapfixes/{MapfixID}/status/bypass-submit" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + case 'r': // Prefix: "re" if l := len("re"); len(elem) >= l && elem[0:l] == "re" { @@ -2525,6 +2593,30 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { + case 'b': // Prefix: "bypass-submit" + + if l := len("bypass-submit"); len(elem) >= l && elem[0:l] == "bypass-submit" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = ActionSubmissionBypassSubmitOperation + r.summary = "Role Reviewer changes status from ChangesRequested -> Submitted" + r.operationID = "actionSubmissionBypassSubmit" + r.pathPattern = "/submissions/{SubmissionID}/status/bypass-submit" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + case 'r': // Prefix: "re" if l := len("re"); len(elem) >= l && elem[0:l] == "re" { diff --git a/pkg/api/oas_schemas_gen.go b/pkg/api/oas_schemas_gen.go index c55d7b4d..6d355f56 100644 --- a/pkg/api/oas_schemas_gen.go +++ b/pkg/api/oas_schemas_gen.go @@ -17,6 +17,9 @@ func (s *ErrorStatusCode) Error() string { // ActionMapfixAcceptedNoContent is response for ActionMapfixAccepted operation. type ActionMapfixAcceptedNoContent struct{} +// ActionMapfixBypassSubmitNoContent is response for ActionMapfixBypassSubmit operation. +type ActionMapfixBypassSubmitNoContent struct{} + // ActionMapfixRejectNoContent is response for ActionMapfixReject operation. type ActionMapfixRejectNoContent struct{} @@ -47,6 +50,9 @@ type ActionMapfixValidatedNoContent struct{} // ActionSubmissionAcceptedNoContent is response for ActionSubmissionAccepted operation. type ActionSubmissionAcceptedNoContent struct{} +// ActionSubmissionBypassSubmitNoContent is response for ActionSubmissionBypassSubmit operation. +type ActionSubmissionBypassSubmitNoContent struct{} + // ActionSubmissionRejectNoContent is response for ActionSubmissionReject operation. type ActionSubmissionRejectNoContent struct{} @@ -182,6 +188,7 @@ func (s *AuditEventEventData) init() AuditEventEventData { type CookieAuth struct { APIKey string + Roles []string } // GetAPIKey returns the value of APIKey. @@ -189,11 +196,21 @@ func (s *CookieAuth) GetAPIKey() string { return s.APIKey } +// GetRoles returns the value of Roles. +func (s *CookieAuth) GetRoles() []string { + return s.Roles +} + // SetAPIKey sets the value of APIKey. func (s *CookieAuth) SetAPIKey(val string) { s.APIKey = val } +// SetRoles sets the value of Roles. +func (s *CookieAuth) SetRoles(val []string) { + s.Roles = val +} + // CreateMapfixAuditCommentNoContent is response for CreateMapfixAuditComment operation. type CreateMapfixAuditCommentNoContent struct{} diff --git a/pkg/api/oas_security_gen.go b/pkg/api/oas_security_gen.go index 5f1eac33..cb72d81d 100644 --- a/pkg/api/oas_security_gen.go +++ b/pkg/api/oas_security_gen.go @@ -33,6 +33,51 @@ func findAuthorization(h http.Header, prefix string) (string, bool) { return "", false } +var operationRolesCookieAuth = map[string][]string{ + ActionMapfixAcceptedOperation: []string{}, + ActionMapfixBypassSubmitOperation: []string{}, + ActionMapfixRejectOperation: []string{}, + ActionMapfixRequestChangesOperation: []string{}, + ActionMapfixResetSubmittingOperation: []string{}, + ActionMapfixRetryValidateOperation: []string{}, + ActionMapfixRevokeOperation: []string{}, + ActionMapfixTriggerSubmitOperation: []string{}, + ActionMapfixTriggerUploadOperation: []string{}, + ActionMapfixTriggerValidateOperation: []string{}, + ActionMapfixValidatedOperation: []string{}, + ActionSubmissionAcceptedOperation: []string{}, + ActionSubmissionBypassSubmitOperation: []string{}, + ActionSubmissionRejectOperation: []string{}, + ActionSubmissionRequestChangesOperation: []string{}, + ActionSubmissionResetSubmittingOperation: []string{}, + ActionSubmissionRetryValidateOperation: []string{}, + ActionSubmissionRevokeOperation: []string{}, + ActionSubmissionTriggerSubmitOperation: []string{}, + ActionSubmissionTriggerUploadOperation: []string{}, + ActionSubmissionTriggerValidateOperation: []string{}, + ActionSubmissionValidatedOperation: []string{}, + CreateMapfixOperation: []string{}, + CreateMapfixAuditCommentOperation: []string{}, + CreateScriptOperation: []string{}, + CreateScriptPolicyOperation: []string{}, + CreateSubmissionOperation: []string{}, + CreateSubmissionAdminOperation: []string{}, + CreateSubmissionAuditCommentOperation: []string{}, + DeleteScriptOperation: []string{}, + DeleteScriptPolicyOperation: []string{}, + GetOperationOperation: []string{}, + ReleaseSubmissionsOperation: []string{}, + SessionRolesOperation: []string{}, + SessionUserOperation: []string{}, + SessionValidateOperation: []string{}, + SetMapfixCompletedOperation: []string{}, + SetSubmissionCompletedOperation: []string{}, + UpdateMapfixModelOperation: []string{}, + UpdateScriptOperation: []string{}, + UpdateScriptPolicyOperation: []string{}, + UpdateSubmissionModelOperation: []string{}, +} + func (s *Server) securityCookieAuth(ctx context.Context, operationName OperationName, req *http.Request) (context.Context, bool, error) { var t CookieAuth const parameterName = "session_id" @@ -46,6 +91,7 @@ func (s *Server) securityCookieAuth(ctx context.Context, operationName Operation return nil, false, errors.Wrap(err, "get cookie value") } t.APIKey = value + t.Roles = operationRolesCookieAuth[operationName] rctx, err := s.sec.HandleCookieAuth(ctx, operationName, t) if errors.Is(err, ogenerrors.ErrSkipServerSecurity) { return nil, false, nil diff --git a/pkg/api/oas_server_gen.go b/pkg/api/oas_server_gen.go index 08df7497..f2f961b6 100644 --- a/pkg/api/oas_server_gen.go +++ b/pkg/api/oas_server_gen.go @@ -14,6 +14,12 @@ type Handler interface { // // POST /mapfixes/{MapfixID}/status/reset-validating ActionMapfixAccepted(ctx context.Context, params ActionMapfixAcceptedParams) error + // ActionMapfixBypassSubmit implements actionMapfixBypassSubmit operation. + // + // Role Reviewer changes status from ChangesRequested -> Submitted. + // + // POST /mapfixes/{MapfixID}/status/bypass-submit + ActionMapfixBypassSubmit(ctx context.Context, params ActionMapfixBypassSubmitParams) error // ActionMapfixReject implements actionMapfixReject operation. // // Role Reviewer changes status from Submitted -> Rejected. @@ -75,6 +81,12 @@ type Handler interface { // // POST /submissions/{SubmissionID}/status/reset-validating ActionSubmissionAccepted(ctx context.Context, params ActionSubmissionAcceptedParams) error + // ActionSubmissionBypassSubmit implements actionSubmissionBypassSubmit operation. + // + // Role Reviewer changes status from ChangesRequested -> Submitted. + // + // POST /submissions/{SubmissionID}/status/bypass-submit + ActionSubmissionBypassSubmit(ctx context.Context, params ActionSubmissionBypassSubmitParams) error // ActionSubmissionReject implements actionSubmissionReject operation. // // Role Reviewer changes status from Submitted -> Rejected. diff --git a/pkg/api/oas_unimplemented_gen.go b/pkg/api/oas_unimplemented_gen.go index 9f0e8041..5f935ded 100644 --- a/pkg/api/oas_unimplemented_gen.go +++ b/pkg/api/oas_unimplemented_gen.go @@ -22,6 +22,15 @@ func (UnimplementedHandler) ActionMapfixAccepted(ctx context.Context, params Act return ht.ErrNotImplemented } +// ActionMapfixBypassSubmit implements actionMapfixBypassSubmit operation. +// +// Role Reviewer changes status from ChangesRequested -> Submitted. +// +// POST /mapfixes/{MapfixID}/status/bypass-submit +func (UnimplementedHandler) ActionMapfixBypassSubmit(ctx context.Context, params ActionMapfixBypassSubmitParams) error { + return ht.ErrNotImplemented +} + // ActionMapfixReject implements actionMapfixReject operation. // // Role Reviewer changes status from Submitted -> Rejected. @@ -113,6 +122,15 @@ func (UnimplementedHandler) ActionSubmissionAccepted(ctx context.Context, params return ht.ErrNotImplemented } +// ActionSubmissionBypassSubmit implements actionSubmissionBypassSubmit operation. +// +// Role Reviewer changes status from ChangesRequested -> Submitted. +// +// POST /submissions/{SubmissionID}/status/bypass-submit +func (UnimplementedHandler) ActionSubmissionBypassSubmit(ctx context.Context, params ActionSubmissionBypassSubmitParams) error { + return ht.ErrNotImplemented +} + // ActionSubmissionReject implements actionSubmissionReject operation. // // Role Reviewer changes status from Submitted -> Rejected. diff --git a/pkg/internal/oas_request_decoders_gen.go b/pkg/internal/oas_request_decoders_gen.go index a33ac8da..016e05d6 100644 --- a/pkg/internal/oas_request_decoders_gen.go +++ b/pkg/internal/oas_request_decoders_gen.go @@ -9,7 +9,6 @@ import ( "github.com/go-faster/errors" "github.com/go-faster/jx" - "go.uber.org/multierr" "github.com/ogen-go/ogen/ogenerrors" "github.com/ogen-go/ogen/validate" @@ -26,13 +25,13 @@ func (s *Server) decodeCreateMapfixRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -97,13 +96,13 @@ func (s *Server) decodeCreateScriptRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -168,13 +167,13 @@ func (s *Server) decodeCreateScriptPolicyRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) @@ -239,13 +238,13 @@ func (s *Server) decodeCreateSubmissionRequest(r *http.Request) ( // Close in reverse order, to match defer behavior. for i := len(closers) - 1; i >= 0; i-- { c := closers[i] - merr = multierr.Append(merr, c()) + merr = errors.Join(merr, c()) } return merr } defer func() { if rerr != nil { - rerr = multierr.Append(rerr, close()) + rerr = errors.Join(rerr, close()) } }() ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))