1803 lines
49 KiB
Go
1803 lines
49 KiB
Go
// Code generated by ogen, DO NOT EDIT.
|
|
|
|
package api
|
|
|
|
import (
|
|
"context"
|
|
"net/url"
|
|
"strings"
|
|
"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"
|
|
|
|
"github.com/ogen-go/ogen/conv"
|
|
ht "github.com/ogen-go/ogen/http"
|
|
"github.com/ogen-go/ogen/ogenerrors"
|
|
"github.com/ogen-go/ogen/otelogen"
|
|
"github.com/ogen-go/ogen/uri"
|
|
)
|
|
|
|
// Invoker invokes operations described by OpenAPI v3 specification.
|
|
type Invoker interface {
|
|
// ActionSubmissionPublish invokes actionSubmissionPublish operation.
|
|
//
|
|
// Role Validator changes status from Publishing -> Published.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/publish
|
|
ActionSubmissionPublish(ctx context.Context, params ActionSubmissionPublishParams) error
|
|
// ActionSubmissionReject invokes actionSubmissionReject operation.
|
|
//
|
|
// Role Reviewer changes status from Submitted -> Rejected.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/reject
|
|
ActionSubmissionReject(ctx context.Context, params ActionSubmissionRejectParams) error
|
|
// ActionSubmissionRequestChanges invokes actionSubmissionRequestChanges operation.
|
|
//
|
|
// Role Reviewer changes status from Validated|Accepted|Submitted -> ChangesRequested.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/request-changes
|
|
ActionSubmissionRequestChanges(ctx context.Context, params ActionSubmissionRequestChangesParams) error
|
|
// ActionSubmissionRevoke invokes actionSubmissionRevoke operation.
|
|
//
|
|
// Role Submitter changes status from Submitted|ChangesRequested -> UnderConstruction.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/revoke
|
|
ActionSubmissionRevoke(ctx context.Context, params ActionSubmissionRevokeParams) error
|
|
// ActionSubmissionSubmit invokes actionSubmissionSubmit operation.
|
|
//
|
|
// Role Submitter changes status from UnderConstruction|ChangesRequested -> Submitted.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/submit
|
|
ActionSubmissionSubmit(ctx context.Context, params ActionSubmissionSubmitParams) error
|
|
// ActionSubmissionTriggerPublish invokes actionSubmissionTriggerPublish operation.
|
|
//
|
|
// Role Admin changes status from Validated -> Publishing.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/trigger-publish
|
|
ActionSubmissionTriggerPublish(ctx context.Context, params ActionSubmissionTriggerPublishParams) error
|
|
// ActionSubmissionTriggerValidate invokes actionSubmissionTriggerValidate operation.
|
|
//
|
|
// Role Reviewer triggers validation and changes status from Submitted|Accepted -> Validating.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/trigger-validate
|
|
ActionSubmissionTriggerValidate(ctx context.Context, params ActionSubmissionTriggerValidateParams) error
|
|
// ActionSubmissionValidate invokes actionSubmissionValidate operation.
|
|
//
|
|
// Role Validator changes status from Validating -> Validated.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/validate
|
|
ActionSubmissionValidate(ctx context.Context, params ActionSubmissionValidateParams) error
|
|
// CreateSubmission invokes createSubmission operation.
|
|
//
|
|
// Create new submission.
|
|
//
|
|
// POST /submissions
|
|
CreateSubmission(ctx context.Context, request OptSubmissionCreate) (*ID, error)
|
|
// GetSubmission invokes getSubmission operation.
|
|
//
|
|
// Retrieve map with ID.
|
|
//
|
|
// GET /submissions/{SubmissionID}
|
|
GetSubmission(ctx context.Context, params GetSubmissionParams) (*Submission, error)
|
|
// ListSubmissions invokes listSubmissions operation.
|
|
//
|
|
// Get list of submissions.
|
|
//
|
|
// GET /submissions
|
|
ListSubmissions(ctx context.Context, params ListSubmissionsParams) ([]Submission, error)
|
|
// PatchSubmissionCompleted invokes patchSubmissionCompleted operation.
|
|
//
|
|
// Retrieve map with ID.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/completed
|
|
PatchSubmissionCompleted(ctx context.Context, params PatchSubmissionCompletedParams) error
|
|
// PatchSubmissionModel invokes patchSubmissionModel operation.
|
|
//
|
|
// Update model following role restrictions.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/model
|
|
PatchSubmissionModel(ctx context.Context, params PatchSubmissionModelParams) error
|
|
}
|
|
|
|
// Client implements OAS client.
|
|
type Client struct {
|
|
serverURL *url.URL
|
|
sec SecuritySource
|
|
baseClient
|
|
}
|
|
type errorHandler interface {
|
|
NewError(ctx context.Context, err error) *ErrorStatusCode
|
|
}
|
|
|
|
var _ Handler = struct {
|
|
errorHandler
|
|
*Client
|
|
}{}
|
|
|
|
func trimTrailingSlashes(u *url.URL) {
|
|
u.Path = strings.TrimRight(u.Path, "/")
|
|
u.RawPath = strings.TrimRight(u.RawPath, "/")
|
|
}
|
|
|
|
// NewClient initializes new Client defined by OAS.
|
|
func NewClient(serverURL string, sec SecuritySource, opts ...ClientOption) (*Client, error) {
|
|
u, err := url.Parse(serverURL)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
trimTrailingSlashes(u)
|
|
|
|
c, err := newClientConfig(opts...).baseClient()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Client{
|
|
serverURL: u,
|
|
sec: sec,
|
|
baseClient: c,
|
|
}, nil
|
|
}
|
|
|
|
type serverURLKey struct{}
|
|
|
|
// WithServerURL sets context key to override server URL.
|
|
func WithServerURL(ctx context.Context, u *url.URL) context.Context {
|
|
return context.WithValue(ctx, serverURLKey{}, u)
|
|
}
|
|
|
|
func (c *Client) requestURL(ctx context.Context) *url.URL {
|
|
u, ok := ctx.Value(serverURLKey{}).(*url.URL)
|
|
if !ok {
|
|
return c.serverURL
|
|
}
|
|
return u
|
|
}
|
|
|
|
// ActionSubmissionPublish invokes actionSubmissionPublish operation.
|
|
//
|
|
// Role Validator changes status from Publishing -> Published.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/publish
|
|
func (c *Client) ActionSubmissionPublish(ctx context.Context, params ActionSubmissionPublishParams) error {
|
|
_, err := c.sendActionSubmissionPublish(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendActionSubmissionPublish(ctx context.Context, params ActionSubmissionPublishParams) (res *ActionSubmissionPublishOK, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("actionSubmissionPublish"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/publish"),
|
|
}
|
|
|
|
// 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(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, ActionSubmissionPublishOperation,
|
|
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/publish"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", 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, ActionSubmissionPublishOperation, 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 := decodeActionSubmissionPublishResponse(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.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/reject
|
|
func (c *Client) ActionSubmissionReject(ctx context.Context, params ActionSubmissionRejectParams) error {
|
|
_, err := c.sendActionSubmissionReject(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendActionSubmissionReject(ctx context.Context, params ActionSubmissionRejectParams) (res *ActionSubmissionRejectOK, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("actionSubmissionReject"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/reject"),
|
|
}
|
|
|
|
// 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(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, ActionSubmissionRejectOperation,
|
|
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/reject"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", 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, ActionSubmissionRejectOperation, 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 := decodeActionSubmissionRejectResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ActionSubmissionRequestChanges invokes actionSubmissionRequestChanges operation.
|
|
//
|
|
// Role Reviewer changes status from Validated|Accepted|Submitted -> ChangesRequested.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/request-changes
|
|
func (c *Client) ActionSubmissionRequestChanges(ctx context.Context, params ActionSubmissionRequestChangesParams) error {
|
|
_, err := c.sendActionSubmissionRequestChanges(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendActionSubmissionRequestChanges(ctx context.Context, params ActionSubmissionRequestChangesParams) (res *ActionSubmissionRequestChangesOK, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("actionSubmissionRequestChanges"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/request-changes"),
|
|
}
|
|
|
|
// 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(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, ActionSubmissionRequestChangesOperation,
|
|
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/request-changes"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", 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, ActionSubmissionRequestChangesOperation, 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 := decodeActionSubmissionRequestChangesResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ActionSubmissionRevoke invokes actionSubmissionRevoke operation.
|
|
//
|
|
// Role Submitter changes status from Submitted|ChangesRequested -> UnderConstruction.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/revoke
|
|
func (c *Client) ActionSubmissionRevoke(ctx context.Context, params ActionSubmissionRevokeParams) error {
|
|
_, err := c.sendActionSubmissionRevoke(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendActionSubmissionRevoke(ctx context.Context, params ActionSubmissionRevokeParams) (res *ActionSubmissionRevokeOK, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("actionSubmissionRevoke"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/revoke"),
|
|
}
|
|
|
|
// 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(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, ActionSubmissionRevokeOperation,
|
|
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/revoke"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", 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, ActionSubmissionRevokeOperation, 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 := decodeActionSubmissionRevokeResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ActionSubmissionSubmit invokes actionSubmissionSubmit operation.
|
|
//
|
|
// Role Submitter changes status from UnderConstruction|ChangesRequested -> Submitted.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/submit
|
|
func (c *Client) ActionSubmissionSubmit(ctx context.Context, params ActionSubmissionSubmitParams) error {
|
|
_, err := c.sendActionSubmissionSubmit(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendActionSubmissionSubmit(ctx context.Context, params ActionSubmissionSubmitParams) (res *ActionSubmissionSubmitOK, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("actionSubmissionSubmit"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/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(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, ActionSubmissionSubmitOperation,
|
|
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/submit"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", 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, ActionSubmissionSubmitOperation, 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 := decodeActionSubmissionSubmitResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ActionSubmissionTriggerPublish invokes actionSubmissionTriggerPublish operation.
|
|
//
|
|
// Role Admin changes status from Validated -> Publishing.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/trigger-publish
|
|
func (c *Client) ActionSubmissionTriggerPublish(ctx context.Context, params ActionSubmissionTriggerPublishParams) error {
|
|
_, err := c.sendActionSubmissionTriggerPublish(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendActionSubmissionTriggerPublish(ctx context.Context, params ActionSubmissionTriggerPublishParams) (res *ActionSubmissionTriggerPublishOK, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("actionSubmissionTriggerPublish"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/trigger-publish"),
|
|
}
|
|
|
|
// 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(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, ActionSubmissionTriggerPublishOperation,
|
|
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/trigger-publish"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", 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, ActionSubmissionTriggerPublishOperation, 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 := decodeActionSubmissionTriggerPublishResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ActionSubmissionTriggerValidate invokes actionSubmissionTriggerValidate operation.
|
|
//
|
|
// Role Reviewer triggers validation and changes status from Submitted|Accepted -> Validating.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/trigger-validate
|
|
func (c *Client) ActionSubmissionTriggerValidate(ctx context.Context, params ActionSubmissionTriggerValidateParams) error {
|
|
_, err := c.sendActionSubmissionTriggerValidate(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendActionSubmissionTriggerValidate(ctx context.Context, params ActionSubmissionTriggerValidateParams) (res *ActionSubmissionTriggerValidateOK, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("actionSubmissionTriggerValidate"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/trigger-validate"),
|
|
}
|
|
|
|
// 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(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, ActionSubmissionTriggerValidateOperation,
|
|
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/trigger-validate"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", 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, ActionSubmissionTriggerValidateOperation, 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 := decodeActionSubmissionTriggerValidateResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ActionSubmissionValidate invokes actionSubmissionValidate operation.
|
|
//
|
|
// Role Validator changes status from Validating -> Validated.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/status/validate
|
|
func (c *Client) ActionSubmissionValidate(ctx context.Context, params ActionSubmissionValidateParams) error {
|
|
_, err := c.sendActionSubmissionValidate(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendActionSubmissionValidate(ctx context.Context, params ActionSubmissionValidateParams) (res *ActionSubmissionValidateOK, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("actionSubmissionValidate"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/status/validate"),
|
|
}
|
|
|
|
// 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(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, ActionSubmissionValidateOperation,
|
|
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/validate"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", 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, ActionSubmissionValidateOperation, 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 := decodeActionSubmissionValidateResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// CreateSubmission invokes createSubmission operation.
|
|
//
|
|
// Create new submission.
|
|
//
|
|
// POST /submissions
|
|
func (c *Client) CreateSubmission(ctx context.Context, request OptSubmissionCreate) (*ID, error) {
|
|
res, err := c.sendCreateSubmission(ctx, request)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendCreateSubmission(ctx context.Context, request OptSubmissionCreate) (res *ID, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("createSubmission"),
|
|
semconv.HTTPRequestMethodKey.String("POST"),
|
|
semconv.HTTPRouteKey.String("/submissions"),
|
|
}
|
|
|
|
// 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(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, CreateSubmissionOperation,
|
|
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 [1]string
|
|
pathParts[0] = "/submissions"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "POST", u)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "create request")
|
|
}
|
|
if err := encodeCreateSubmissionRequest(request, r); err != nil {
|
|
return res, errors.Wrap(err, "encode request")
|
|
}
|
|
|
|
{
|
|
type bitset = [1]uint8
|
|
var satisfied bitset
|
|
{
|
|
stage = "Security:CookieAuth"
|
|
switch err := c.securityCookieAuth(ctx, CreateSubmissionOperation, 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 := decodeCreateSubmissionResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// GetSubmission invokes getSubmission operation.
|
|
//
|
|
// Retrieve map with ID.
|
|
//
|
|
// GET /submissions/{SubmissionID}
|
|
func (c *Client) GetSubmission(ctx context.Context, params GetSubmissionParams) (*Submission, error) {
|
|
res, err := c.sendGetSubmission(ctx, params)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendGetSubmission(ctx context.Context, params GetSubmissionParams) (res *Submission, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("getSubmission"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}"),
|
|
}
|
|
|
|
// 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(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, GetSubmissionOperation,
|
|
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 [2]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
|
|
}
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "GET", 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, GetSubmissionOperation, 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 := decodeGetSubmissionResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// ListSubmissions invokes listSubmissions operation.
|
|
//
|
|
// Get list of submissions.
|
|
//
|
|
// GET /submissions
|
|
func (c *Client) ListSubmissions(ctx context.Context, params ListSubmissionsParams) ([]Submission, error) {
|
|
res, err := c.sendListSubmissions(ctx, params)
|
|
return res, err
|
|
}
|
|
|
|
func (c *Client) sendListSubmissions(ctx context.Context, params ListSubmissionsParams) (res []Submission, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("listSubmissions"),
|
|
semconv.HTTPRequestMethodKey.String("GET"),
|
|
semconv.HTTPRouteKey.String("/submissions"),
|
|
}
|
|
|
|
// 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(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, ListSubmissionsOperation,
|
|
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 [1]string
|
|
pathParts[0] = "/submissions"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeQueryParams"
|
|
q := uri.NewQueryEncoder()
|
|
{
|
|
// Encode "page" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "page",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
return params.Page.EncodeURI(e)
|
|
}); err != nil {
|
|
return res, errors.Wrap(err, "encode query")
|
|
}
|
|
}
|
|
{
|
|
// Encode "filter" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "filter",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
if val, ok := params.Filter.Get(); ok {
|
|
return val.EncodeURI(e)
|
|
}
|
|
return nil
|
|
}); err != nil {
|
|
return res, errors.Wrap(err, "encode query")
|
|
}
|
|
}
|
|
u.RawQuery = q.Values().Encode()
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "GET", 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, ListSubmissionsOperation, 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 := decodeListSubmissionsResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// PatchSubmissionCompleted invokes patchSubmissionCompleted operation.
|
|
//
|
|
// Retrieve map with ID.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/completed
|
|
func (c *Client) PatchSubmissionCompleted(ctx context.Context, params PatchSubmissionCompletedParams) error {
|
|
_, err := c.sendPatchSubmissionCompleted(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendPatchSubmissionCompleted(ctx context.Context, params PatchSubmissionCompletedParams) (res *PatchSubmissionCompletedOK, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("patchSubmissionCompleted"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/completed"),
|
|
}
|
|
|
|
// 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(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, PatchSubmissionCompletedOperation,
|
|
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] = "/completed"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", 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, PatchSubmissionCompletedOperation, 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 := decodePatchSubmissionCompletedResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|
|
|
|
// PatchSubmissionModel invokes patchSubmissionModel operation.
|
|
//
|
|
// Update model following role restrictions.
|
|
//
|
|
// PATCH /submissions/{SubmissionID}/model
|
|
func (c *Client) PatchSubmissionModel(ctx context.Context, params PatchSubmissionModelParams) error {
|
|
_, err := c.sendPatchSubmissionModel(ctx, params)
|
|
return err
|
|
}
|
|
|
|
func (c *Client) sendPatchSubmissionModel(ctx context.Context, params PatchSubmissionModelParams) (res *PatchSubmissionModelOK, err error) {
|
|
otelAttrs := []attribute.KeyValue{
|
|
otelogen.OperationID("patchSubmissionModel"),
|
|
semconv.HTTPRequestMethodKey.String("PATCH"),
|
|
semconv.HTTPRouteKey.String("/submissions/{SubmissionID}/model"),
|
|
}
|
|
|
|
// 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(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, PatchSubmissionModelOperation,
|
|
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] = "/model"
|
|
uri.AddPathParts(u, pathParts[:]...)
|
|
|
|
stage = "EncodeQueryParams"
|
|
q := uri.NewQueryEncoder()
|
|
{
|
|
// Encode "ModelID" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "ModelID",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
return e.EncodeValue(conv.Int64ToString(params.ModelID))
|
|
}); err != nil {
|
|
return res, errors.Wrap(err, "encode query")
|
|
}
|
|
}
|
|
{
|
|
// Encode "VersionID" parameter.
|
|
cfg := uri.QueryParameterEncodingConfig{
|
|
Name: "VersionID",
|
|
Style: uri.QueryStyleForm,
|
|
Explode: true,
|
|
}
|
|
|
|
if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
|
|
return e.EncodeValue(conv.Int64ToString(params.VersionID))
|
|
}); err != nil {
|
|
return res, errors.Wrap(err, "encode query")
|
|
}
|
|
}
|
|
u.RawQuery = q.Values().Encode()
|
|
|
|
stage = "EncodeRequest"
|
|
r, err := ht.NewRequest(ctx, "PATCH", 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, PatchSubmissionModelOperation, 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 := decodePatchSubmissionModelResponse(resp)
|
|
if err != nil {
|
|
return res, errors.Wrap(err, "decode response")
|
|
}
|
|
|
|
return result, nil
|
|
}
|