From 7a9f81e527eccbe0024c513f8d77294223df8f69 Mon Sep 17 00:00:00 2001 From: "a.antonov" Date: Thu, 26 Jun 2025 01:15:37 +0300 Subject: [PATCH] feat: predictor works --- .gitignore | 6 +- api/rest/predictor.swagger.yml | 120 +-- go.mod | 1 + go.sum | 2 + internal/pkg/ds/predictor.go | 40 +- internal/transport/rest/handler/handler.go | 4 +- internal/transport/rest/transport.go | 10 +- pkg/rest/oas_client_gen.go | 270 ++++++- pkg/rest/oas_defaults_gen.go | 15 - pkg/rest/oas_handlers_gen.go | 91 ++- pkg/rest/oas_json_gen.go | 518 ------------ pkg/rest/oas_parameters_gen.go | 871 ++++++++++++++++++++- pkg/rest/oas_request_decoders_gen.go | 94 --- pkg/rest/oas_request_encoders_gen.go | 29 - pkg/rest/oas_router_gen.go | 8 +- pkg/rest/oas_schemas_gen.go | 347 ++------ pkg/rest/oas_server_gen.go | 6 +- pkg/rest/oas_unimplemented_gen.go | 6 +- pkg/rest/oas_uri_gen.go | 535 ------------- pkg/rest/oas_validators_gen.go | 178 +---- 20 files changed, 1357 insertions(+), 1794 deletions(-) delete mode 100644 pkg/rest/oas_defaults_gen.go delete mode 100644 pkg/rest/oas_uri_gen.go diff --git a/.gitignore b/.gitignore index b58d008..07ba6b1 100644 --- a/.gitignore +++ b/.gitignore @@ -51,4 +51,8 @@ Thumbs.db # GRIB files /grib_data/ -/grib_data/* \ No newline at end of file +/grib_data/* + +# Leaflet WebUI +/leaflet_predictor +/leaflet_predictor/* \ No newline at end of file diff --git a/api/rest/predictor.swagger.yml b/api/rest/predictor.swagger.yml index 282bec4..73e3381 100644 --- a/api/rest/predictor.swagger.yml +++ b/api/rest/predictor.swagger.yml @@ -4,25 +4,77 @@ info: version: 0.0.1 paths: /api/v1/prediction: - post: + get: tags: - Prediction - summary: Perform preidction + summary: Perform prediction operationId: performPrediction parameters: - in: query - name: parameters - required: false + name: launch_latitude schema: - $ref: '#/components/schemas/PredictionParameters' - style: form - explode: true - requestBody: - required: false - content: - application/json: - schema: - $ref: '#/components/schemas/PredictionParameters' + type: number + - in: query + name: launch_longitude + schema: + type: number + - in: query + name: launch_datetime + schema: + type: string + format: date-time + - in: query + name: launch_altitude + schema: + type: number + - in: query + name: profile + schema: + type: string + enum: [standard_profile, float_profile, reverse_profile, custom_profile] + - in: query + name: ascent_rate + schema: + type: number + - in: query + name: burst_altitude + schema: + type: number + - in: query + name: descent_rate + schema: + type: number + - in: query + name: float_altitude + schema: + type: number + - in: query + name: stop_datetime + schema: + type: string + format: date-time + - in: query + name: ascent_curve + schema: + type: string + - in: query + name: descent_curve + schema: + type: string + - in: query + name: interpolate + schema: + type: boolean + - in: query + name: format + schema: + type: string + enum: [json] + - in: query + name: dataset + schema: + type: string + format: date-time responses: "200": description: "Prediction response" @@ -67,48 +119,6 @@ components: type: string details: type: string - PredictionParameters: - type: object - properties: - launch_latitude: # TODO: altitude not required with fallback to https://github.com/priyeshpatel/ruaumoko Go analog - type: number - launch_longitude: - type: number - launch_datetime: - type: string - format: date-time - launch_altitude: - type: number - profile: - type: string - enum: ["standard_profile", "float_profile", "reverse_profile", "custom_profile"] - ascent_rate: - type: number - burst_altitude: - type: number - descent_rate: - type: number - float_altitude: - type: number - stop_datetime: - type: string - format: date-time - ascent_curve: - type: string - description: "Base64 encoded ascent curve" - descent_curve: - type: string - description: "Base64 encoded descent curve" - interpolate: - type: boolean - default: false - format: # TODO: custom output format (csv, kml) with json as default - type: string - enum: ["json"] - default: json - dataset: - type: string - format: date-time PredictionResult: type: object required: diff --git a/go.mod b/go.mod index d63646d..96b2e87 100644 --- a/go.mod +++ b/go.mod @@ -32,6 +32,7 @@ require ( github.com/mattn/go-isatty v0.0.20 // indirect github.com/redis/go-redis/v9 v9.10.0 // indirect github.com/robfig/cron/v3 v3.0.1 // indirect + github.com/rs/cors v1.11.1 // indirect github.com/segmentio/asm v1.2.0 // indirect go.opentelemetry.io/auto/sdk v1.1.0 // indirect go.uber.org/atomic v1.9.0 // indirect diff --git a/go.sum b/go.sum index 0480917..235c0e7 100644 --- a/go.sum +++ b/go.sum @@ -65,6 +65,8 @@ github.com/rogpeppe/go-internal v1.6.1/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTE github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o= github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII= github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o= +github.com/rs/cors v1.11.1 h1:eU3gRzXLRK57F5rKMGMZURNdIG4EoAmX8k94r9wXWHA= +github.com/rs/cors v1.11.1/go.mod h1:XyqrcTp5zjWr1wsJ8PIRZssZ8b/WMcMf71DJnit4EMU= github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys= github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= diff --git a/internal/pkg/ds/predictor.go b/internal/pkg/ds/predictor.go index 1ea5e44..753b0b2 100644 --- a/internal/pkg/ds/predictor.go +++ b/internal/pkg/ds/predictor.go @@ -35,60 +35,54 @@ type PredicitonResult struct { // Add other result fields as needed } -// ConvertOptPredictionParameters converts ogen's OptPredictionParameters to the internal pointer-based model. -// Returns nil if the input is not set. -func ConvertOptPredictionParameters(opt api.OptPredictionParameters) *PredictionParameters { - if !opt.Set { - return nil - } - in := opt.Value +// Converts flat ogen params to internal pointer-based model +func ConvertFlatPredictionParams(params api.PerformPredictionParams) *PredictionParameters { out := &PredictionParameters{} - - if v, ok := in.LaunchLatitude.Get(); ok { + if v, ok := params.LaunchLatitude.Get(); ok { out.LaunchLatitude = &v } - if v, ok := in.LaunchLongitude.Get(); ok { + if v, ok := params.LaunchLongitude.Get(); ok { out.LaunchLongitude = &v } - if v, ok := in.LaunchDatetime.Get(); ok { + if v, ok := params.LaunchDatetime.Get(); ok { out.LaunchDatetime = &v } - if v, ok := in.LaunchAltitude.Get(); ok { + if v, ok := params.LaunchAltitude.Get(); ok { out.LaunchAltitude = &v } - if v, ok := in.Profile.Get(); ok { + if v, ok := params.Profile.Get(); ok { s := string(v) out.Profile = &s } - if v, ok := in.AscentRate.Get(); ok { + if v, ok := params.AscentRate.Get(); ok { out.AscentRate = &v } - if v, ok := in.BurstAltitude.Get(); ok { + if v, ok := params.BurstAltitude.Get(); ok { out.BurstAltitude = &v } - if v, ok := in.DescentRate.Get(); ok { + if v, ok := params.DescentRate.Get(); ok { out.DescentRate = &v } - if v, ok := in.FloatAltitude.Get(); ok { + if v, ok := params.FloatAltitude.Get(); ok { out.FloatAltitude = &v } - if v, ok := in.StopDatetime.Get(); ok { + if v, ok := params.StopDatetime.Get(); ok { out.StopDatetime = &v } - if v, ok := in.AscentCurve.Get(); ok { + if v, ok := params.AscentCurve.Get(); ok { out.AscentCurve = &v } - if v, ok := in.DescentCurve.Get(); ok { + if v, ok := params.DescentCurve.Get(); ok { out.DescentCurve = &v } - if v, ok := in.Interpolate.Get(); ok { + if v, ok := params.Interpolate.Get(); ok { out.Interpolate = &v } - if v, ok := in.Format.Get(); ok { + if v, ok := params.Format.Get(); ok { s := string(v) out.Format = &s } - if v, ok := in.Dataset.Get(); ok { + if v, ok := params.Dataset.Get(); ok { out.Dataset = &v } return out diff --git a/internal/transport/rest/handler/handler.go b/internal/transport/rest/handler/handler.go index f10b09d..5b7141d 100644 --- a/internal/transport/rest/handler/handler.go +++ b/internal/transport/rest/handler/handler.go @@ -24,8 +24,8 @@ func New(svc Service) *Handler { } } -func (h *Handler) PerformPrediction(ctx context.Context, req api.OptPredictionParameters, params api.PerformPredictionParams) (*api.PredictionResult, error) { - internalParams := ds.ConvertOptPredictionParameters(req) +func (h *Handler) PerformPrediction(ctx context.Context, params api.PerformPredictionParams) (*api.PredictionResult, error) { + internalParams := ds.ConvertFlatPredictionParams(params) if internalParams == nil { return nil, errcodes.New(http.StatusBadRequest, "invalid or missing parameters") } diff --git a/internal/transport/rest/transport.go b/internal/transport/rest/transport.go index 8534caa..c89cf8f 100644 --- a/internal/transport/rest/transport.go +++ b/internal/transport/rest/transport.go @@ -9,6 +9,7 @@ import ( "git.intra.yksa.space/gsn/predictor/internal/transport/middleware" handler "git.intra.yksa.space/gsn/predictor/internal/transport/rest/handler" api "git.intra.yksa.space/gsn/predictor/pkg/rest" + "github.com/rs/cors" ) type Transport struct { @@ -18,7 +19,10 @@ type Transport struct { } func New(handler *handler.Handler, cfg *Config) (*Transport, error) { - srv, err := api.NewServer(handler, api.WithMiddleware(middleware.Logging())) + srv, err := api.NewServer( + handler, + api.WithMiddleware(middleware.Logging()), + ) if err != nil { return nil, err } @@ -33,6 +37,10 @@ func New(handler *handler.Handler, cfg *Config) (*Transport, error) { func (t *Transport) Run() { log.Ctx(context.Background()).Info("started") + mux := http.NewServeMux() + mux.Handle("/", t.srv) + cors.AllowAll().Handler(mux) + if err := http.ListenAndServe(fmt.Sprintf(":%d", t.cfg.Port), t.srv); err != nil { panic(err) } diff --git a/pkg/rest/oas_client_gen.go b/pkg/rest/oas_client_gen.go index 754b03d..19822e8 100644 --- a/pkg/rest/oas_client_gen.go +++ b/pkg/rest/oas_client_gen.go @@ -15,6 +15,7 @@ import ( 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/otelogen" "github.com/ogen-go/ogen/uri" @@ -29,10 +30,10 @@ func trimTrailingSlashes(u *url.URL) { type Invoker interface { // PerformPrediction invokes performPrediction operation. // - // Perform preidction. + // Perform prediction. // - // POST /api/v1/prediction - PerformPrediction(ctx context.Context, request OptPredictionParameters, params PerformPredictionParams) (*PredictionResult, error) + // GET /api/v1/prediction + PerformPrediction(ctx context.Context, params PerformPredictionParams) (*PredictionResult, error) // ReadinessCheck invokes readinessCheck operation. // // Readiness check. @@ -90,18 +91,18 @@ func (c *Client) requestURL(ctx context.Context) *url.URL { // PerformPrediction invokes performPrediction operation. // -// Perform preidction. +// Perform prediction. // -// POST /api/v1/prediction -func (c *Client) PerformPrediction(ctx context.Context, request OptPredictionParameters, params PerformPredictionParams) (*PredictionResult, error) { - res, err := c.sendPerformPrediction(ctx, request, params) +// GET /api/v1/prediction +func (c *Client) PerformPrediction(ctx context.Context, params PerformPredictionParams) (*PredictionResult, error) { + res, err := c.sendPerformPrediction(ctx, params) return res, err } -func (c *Client) sendPerformPrediction(ctx context.Context, request OptPredictionParameters, params PerformPredictionParams) (res *PredictionResult, err error) { +func (c *Client) sendPerformPrediction(ctx context.Context, params PerformPredictionParams) (res *PredictionResult, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("performPrediction"), - semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/api/v1/prediction"), } @@ -141,16 +142,254 @@ func (c *Client) sendPerformPrediction(ctx context.Context, request OptPredictio stage = "EncodeQueryParams" q := uri.NewQueryEncoder() { - // Encode "parameters" parameter. + // Encode "launch_latitude" parameter. cfg := uri.QueryParameterEncodingConfig{ - Name: "parameters", + Name: "launch_latitude", Style: uri.QueryStyleForm, Explode: true, } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Parameters.Get(); ok { - return val.EncodeURI(e) + if val, ok := params.LaunchLatitude.Get(); ok { + return e.EncodeValue(conv.Float64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "launch_longitude" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "launch_longitude", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.LaunchLongitude.Get(); ok { + return e.EncodeValue(conv.Float64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "launch_datetime" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "launch_datetime", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.LaunchDatetime.Get(); ok { + return e.EncodeValue(conv.DateTimeToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "launch_altitude" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "launch_altitude", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.LaunchAltitude.Get(); ok { + return e.EncodeValue(conv.Float64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "profile" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "profile", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Profile.Get(); ok { + return e.EncodeValue(conv.StringToString(string(val))) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "ascent_rate" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "ascent_rate", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.AscentRate.Get(); ok { + return e.EncodeValue(conv.Float64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "burst_altitude" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "burst_altitude", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.BurstAltitude.Get(); ok { + return e.EncodeValue(conv.Float64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "descent_rate" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "descent_rate", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.DescentRate.Get(); ok { + return e.EncodeValue(conv.Float64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "float_altitude" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "float_altitude", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.FloatAltitude.Get(); ok { + return e.EncodeValue(conv.Float64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "stop_datetime" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "stop_datetime", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.StopDatetime.Get(); ok { + return e.EncodeValue(conv.DateTimeToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "ascent_curve" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "ascent_curve", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.AscentCurve.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "descent_curve" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "descent_curve", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.DescentCurve.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "interpolate" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "interpolate", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Interpolate.Get(); ok { + return e.EncodeValue(conv.BoolToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "format" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "format", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Format.Get(); ok { + return e.EncodeValue(conv.StringToString(string(val))) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "dataset" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "dataset", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Dataset.Get(); ok { + return e.EncodeValue(conv.DateTimeToString(val)) } return nil }); err != nil { @@ -160,13 +399,10 @@ func (c *Client) sendPerformPrediction(ctx context.Context, request OptPredictio u.RawQuery = q.Values().Encode() stage = "EncodeRequest" - r, err := ht.NewRequest(ctx, "POST", u) + r, err := ht.NewRequest(ctx, "GET", u) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodePerformPredictionRequest(request, r); err != nil { - return res, errors.Wrap(err, "encode request") - } stage = "SendRequest" resp, err := c.cfg.Client.Do(r) diff --git a/pkg/rest/oas_defaults_gen.go b/pkg/rest/oas_defaults_gen.go deleted file mode 100644 index 4cccade..0000000 --- a/pkg/rest/oas_defaults_gen.go +++ /dev/null @@ -1,15 +0,0 @@ -// Code generated by ogen, DO NOT EDIT. - -package gsn - -// setDefaults set default value of fields. -func (s *PredictionParameters) setDefaults() { - { - val := bool(false) - s.Interpolate.SetTo(val) - } - { - val := PredictionParametersFormat("json") - s.Format.SetTo(val) - } -} diff --git a/pkg/rest/oas_handlers_gen.go b/pkg/rest/oas_handlers_gen.go index 1d88103..76ab8ad 100644 --- a/pkg/rest/oas_handlers_gen.go +++ b/pkg/rest/oas_handlers_gen.go @@ -32,15 +32,15 @@ func (c *codeRecorder) WriteHeader(status int) { // handlePerformPredictionRequest handles performPrediction operation. // -// Perform preidction. +// Perform prediction. // -// POST /api/v1/prediction +// GET /api/v1/prediction func (s *Server) handlePerformPredictionRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { statusWriter := &codeRecorder{ResponseWriter: w} w = statusWriter otelAttrs := []attribute.KeyValue{ otelogen.OperationID("performPrediction"), - semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/api/v1/prediction"), } @@ -114,41 +114,82 @@ func (s *Server) handlePerformPredictionRequest(args [0]string, argsEscaped bool s.cfg.ErrorHandler(ctx, w, r, err) return } - request, close, err := s.decodePerformPredictionRequest(r) - if err != nil { - err = &ogenerrors.DecodeRequestError{ - OperationContext: opErrContext, - Err: err, - } - defer recordError("DecodeRequest", err) - s.cfg.ErrorHandler(ctx, w, r, err) - return - } - defer func() { - if err := close(); err != nil { - recordError("CloseRequest", err) - } - }() var response *PredictionResult if m := s.cfg.Middleware; m != nil { mreq := middleware.Request{ Context: ctx, OperationName: PerformPredictionOperation, - OperationSummary: "Perform preidction", + OperationSummary: "Perform prediction", OperationID: "performPrediction", - Body: request, + Body: nil, Params: middleware.Parameters{ { - Name: "parameters", + Name: "launch_latitude", In: "query", - }: params.Parameters, + }: params.LaunchLatitude, + { + Name: "launch_longitude", + In: "query", + }: params.LaunchLongitude, + { + Name: "launch_datetime", + In: "query", + }: params.LaunchDatetime, + { + Name: "launch_altitude", + In: "query", + }: params.LaunchAltitude, + { + Name: "profile", + In: "query", + }: params.Profile, + { + Name: "ascent_rate", + In: "query", + }: params.AscentRate, + { + Name: "burst_altitude", + In: "query", + }: params.BurstAltitude, + { + Name: "descent_rate", + In: "query", + }: params.DescentRate, + { + Name: "float_altitude", + In: "query", + }: params.FloatAltitude, + { + Name: "stop_datetime", + In: "query", + }: params.StopDatetime, + { + Name: "ascent_curve", + In: "query", + }: params.AscentCurve, + { + Name: "descent_curve", + In: "query", + }: params.DescentCurve, + { + Name: "interpolate", + In: "query", + }: params.Interpolate, + { + Name: "format", + In: "query", + }: params.Format, + { + Name: "dataset", + In: "query", + }: params.Dataset, }, Raw: r, } type ( - Request = OptPredictionParameters + Request = struct{} Params = PerformPredictionParams Response = *PredictionResult ) @@ -161,12 +202,12 @@ func (s *Server) handlePerformPredictionRequest(args [0]string, argsEscaped bool mreq, unpackPerformPredictionParams, func(ctx context.Context, request Request, params Params) (response Response, err error) { - response, err = s.h.PerformPrediction(ctx, request, params) + response, err = s.h.PerformPrediction(ctx, params) return response, err }, ) } else { - response, err = s.h.PerformPrediction(ctx, request, params) + response, err = s.h.PerformPrediction(ctx, params) } if err != nil { if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { diff --git a/pkg/rest/oas_json_gen.go b/pkg/rest/oas_json_gen.go index 2621d55..ea3d61c 100644 --- a/pkg/rest/oas_json_gen.go +++ b/pkg/rest/oas_json_gen.go @@ -197,140 +197,6 @@ func (s *OptDateTime) UnmarshalJSON(data []byte) error { return s.Decode(d, json.DecodeDateTime) } -// Encode encodes float64 as json. -func (o OptFloat64) Encode(e *jx.Encoder) { - if !o.Set { - return - } - e.Float64(float64(o.Value)) -} - -// Decode decodes float64 from json. -func (o *OptFloat64) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptFloat64 to nil") - } - o.Set = true - v, err := d.Float64() - if err != nil { - return err - } - o.Value = float64(v) - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s OptFloat64) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptFloat64) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes PredictionParameters as json. -func (o OptPredictionParameters) Encode(e *jx.Encoder) { - if !o.Set { - return - } - o.Value.Encode(e) -} - -// Decode decodes PredictionParameters from json. -func (o *OptPredictionParameters) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptPredictionParameters to nil") - } - o.Set = true - if err := o.Value.Decode(d); err != nil { - return err - } - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s OptPredictionParameters) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptPredictionParameters) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes PredictionParametersFormat as json. -func (o OptPredictionParametersFormat) Encode(e *jx.Encoder) { - if !o.Set { - return - } - e.Str(string(o.Value)) -} - -// Decode decodes PredictionParametersFormat from json. -func (o *OptPredictionParametersFormat) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptPredictionParametersFormat to nil") - } - o.Set = true - if err := o.Value.Decode(d); err != nil { - return err - } - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s OptPredictionParametersFormat) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptPredictionParametersFormat) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes PredictionParametersProfile as json. -func (o OptPredictionParametersProfile) Encode(e *jx.Encoder) { - if !o.Set { - return - } - e.Str(string(o.Value)) -} - -// Decode decodes PredictionParametersProfile from json. -func (o *OptPredictionParametersProfile) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptPredictionParametersProfile to nil") - } - o.Set = true - if err := o.Value.Decode(d); err != nil { - return err - } - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s OptPredictionParametersProfile) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptPredictionParametersProfile) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - // Encode encodes string as json. func (o OptString) Encode(e *jx.Encoder) { if !o.Set { @@ -366,390 +232,6 @@ func (s *OptString) UnmarshalJSON(data []byte) error { return s.Decode(d) } -// Encode implements json.Marshaler. -func (s *PredictionParameters) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *PredictionParameters) encodeFields(e *jx.Encoder) { - { - if s.LaunchLatitude.Set { - e.FieldStart("launch_latitude") - s.LaunchLatitude.Encode(e) - } - } - { - if s.LaunchLongitude.Set { - e.FieldStart("launch_longitude") - s.LaunchLongitude.Encode(e) - } - } - { - if s.LaunchDatetime.Set { - e.FieldStart("launch_datetime") - s.LaunchDatetime.Encode(e, json.EncodeDateTime) - } - } - { - if s.LaunchAltitude.Set { - e.FieldStart("launch_altitude") - s.LaunchAltitude.Encode(e) - } - } - { - if s.Profile.Set { - e.FieldStart("profile") - s.Profile.Encode(e) - } - } - { - if s.AscentRate.Set { - e.FieldStart("ascent_rate") - s.AscentRate.Encode(e) - } - } - { - if s.BurstAltitude.Set { - e.FieldStart("burst_altitude") - s.BurstAltitude.Encode(e) - } - } - { - if s.DescentRate.Set { - e.FieldStart("descent_rate") - s.DescentRate.Encode(e) - } - } - { - if s.FloatAltitude.Set { - e.FieldStart("float_altitude") - s.FloatAltitude.Encode(e) - } - } - { - if s.StopDatetime.Set { - e.FieldStart("stop_datetime") - s.StopDatetime.Encode(e, json.EncodeDateTime) - } - } - { - if s.AscentCurve.Set { - e.FieldStart("ascent_curve") - s.AscentCurve.Encode(e) - } - } - { - if s.DescentCurve.Set { - e.FieldStart("descent_curve") - s.DescentCurve.Encode(e) - } - } - { - if s.Interpolate.Set { - e.FieldStart("interpolate") - s.Interpolate.Encode(e) - } - } - { - if s.Format.Set { - e.FieldStart("format") - s.Format.Encode(e) - } - } - { - if s.Dataset.Set { - e.FieldStart("dataset") - s.Dataset.Encode(e, json.EncodeDateTime) - } - } -} - -var jsonFieldsNameOfPredictionParameters = [15]string{ - 0: "launch_latitude", - 1: "launch_longitude", - 2: "launch_datetime", - 3: "launch_altitude", - 4: "profile", - 5: "ascent_rate", - 6: "burst_altitude", - 7: "descent_rate", - 8: "float_altitude", - 9: "stop_datetime", - 10: "ascent_curve", - 11: "descent_curve", - 12: "interpolate", - 13: "format", - 14: "dataset", -} - -// Decode decodes PredictionParameters from json. -func (s *PredictionParameters) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode PredictionParameters to nil") - } - s.setDefaults() - - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - switch string(k) { - case "launch_latitude": - if err := func() error { - s.LaunchLatitude.Reset() - if err := s.LaunchLatitude.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"launch_latitude\"") - } - case "launch_longitude": - if err := func() error { - s.LaunchLongitude.Reset() - if err := s.LaunchLongitude.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"launch_longitude\"") - } - case "launch_datetime": - if err := func() error { - s.LaunchDatetime.Reset() - if err := s.LaunchDatetime.Decode(d, json.DecodeDateTime); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"launch_datetime\"") - } - case "launch_altitude": - if err := func() error { - s.LaunchAltitude.Reset() - if err := s.LaunchAltitude.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"launch_altitude\"") - } - case "profile": - if err := func() error { - s.Profile.Reset() - if err := s.Profile.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"profile\"") - } - case "ascent_rate": - if err := func() error { - s.AscentRate.Reset() - if err := s.AscentRate.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"ascent_rate\"") - } - case "burst_altitude": - if err := func() error { - s.BurstAltitude.Reset() - if err := s.BurstAltitude.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"burst_altitude\"") - } - case "descent_rate": - if err := func() error { - s.DescentRate.Reset() - if err := s.DescentRate.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"descent_rate\"") - } - case "float_altitude": - if err := func() error { - s.FloatAltitude.Reset() - if err := s.FloatAltitude.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"float_altitude\"") - } - case "stop_datetime": - if err := func() error { - s.StopDatetime.Reset() - if err := s.StopDatetime.Decode(d, json.DecodeDateTime); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"stop_datetime\"") - } - case "ascent_curve": - if err := func() error { - s.AscentCurve.Reset() - if err := s.AscentCurve.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"ascent_curve\"") - } - case "descent_curve": - if err := func() error { - s.DescentCurve.Reset() - if err := s.DescentCurve.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"descent_curve\"") - } - case "interpolate": - if err := func() error { - s.Interpolate.Reset() - if err := s.Interpolate.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"interpolate\"") - } - case "format": - if err := func() error { - s.Format.Reset() - if err := s.Format.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"format\"") - } - case "dataset": - if err := func() error { - s.Dataset.Reset() - if err := s.Dataset.Decode(d, json.DecodeDateTime); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"dataset\"") - } - default: - return d.Skip() - } - return nil - }); err != nil { - return errors.Wrap(err, "decode PredictionParameters") - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s *PredictionParameters) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *PredictionParameters) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes PredictionParametersFormat as json. -func (s PredictionParametersFormat) Encode(e *jx.Encoder) { - e.Str(string(s)) -} - -// Decode decodes PredictionParametersFormat from json. -func (s *PredictionParametersFormat) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode PredictionParametersFormat to nil") - } - v, err := d.StrBytes() - if err != nil { - return err - } - // Try to use constant string. - switch PredictionParametersFormat(v) { - case PredictionParametersFormatJSON: - *s = PredictionParametersFormatJSON - default: - *s = PredictionParametersFormat(v) - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s PredictionParametersFormat) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *PredictionParametersFormat) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes PredictionParametersProfile as json. -func (s PredictionParametersProfile) Encode(e *jx.Encoder) { - e.Str(string(s)) -} - -// Decode decodes PredictionParametersProfile from json. -func (s *PredictionParametersProfile) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode PredictionParametersProfile to nil") - } - v, err := d.StrBytes() - if err != nil { - return err - } - // Try to use constant string. - switch PredictionParametersProfile(v) { - case PredictionParametersProfileStandardProfile: - *s = PredictionParametersProfileStandardProfile - case PredictionParametersProfileFloatProfile: - *s = PredictionParametersProfileFloatProfile - case PredictionParametersProfileReverseProfile: - *s = PredictionParametersProfileReverseProfile - case PredictionParametersProfileCustomProfile: - *s = PredictionParametersProfileCustomProfile - default: - *s = PredictionParametersProfile(v) - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s PredictionParametersProfile) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *PredictionParametersProfile) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - // Encode implements json.Marshaler. func (s *PredictionResult) Encode(e *jx.Encoder) { e.ObjStart() diff --git a/pkg/rest/oas_parameters_gen.go b/pkg/rest/oas_parameters_gen.go index 6c3b0d7..23cc5d8 100644 --- a/pkg/rest/oas_parameters_gen.go +++ b/pkg/rest/oas_parameters_gen.go @@ -4,25 +4,170 @@ package gsn import ( "net/http" + "time" + "github.com/go-faster/errors" + + "github.com/ogen-go/ogen/conv" "github.com/ogen-go/ogen/middleware" "github.com/ogen-go/ogen/ogenerrors" "github.com/ogen-go/ogen/uri" + "github.com/ogen-go/ogen/validate" ) // PerformPredictionParams is parameters of performPrediction operation. type PerformPredictionParams struct { - Parameters OptPredictionParameters + LaunchLatitude OptFloat64 + LaunchLongitude OptFloat64 + LaunchDatetime OptDateTime + LaunchAltitude OptFloat64 + Profile OptPerformPredictionProfile + AscentRate OptFloat64 + BurstAltitude OptFloat64 + DescentRate OptFloat64 + FloatAltitude OptFloat64 + StopDatetime OptDateTime + AscentCurve OptString + DescentCurve OptString + Interpolate OptBool + Format OptPerformPredictionFormat + Dataset OptDateTime } func unpackPerformPredictionParams(packed middleware.Parameters) (params PerformPredictionParams) { { key := middleware.ParameterKey{ - Name: "parameters", + Name: "launch_latitude", In: "query", } if v, ok := packed[key]; ok { - params.Parameters = v.(OptPredictionParameters) + params.LaunchLatitude = v.(OptFloat64) + } + } + { + key := middleware.ParameterKey{ + Name: "launch_longitude", + In: "query", + } + if v, ok := packed[key]; ok { + params.LaunchLongitude = v.(OptFloat64) + } + } + { + key := middleware.ParameterKey{ + Name: "launch_datetime", + In: "query", + } + if v, ok := packed[key]; ok { + params.LaunchDatetime = v.(OptDateTime) + } + } + { + key := middleware.ParameterKey{ + Name: "launch_altitude", + In: "query", + } + if v, ok := packed[key]; ok { + params.LaunchAltitude = v.(OptFloat64) + } + } + { + key := middleware.ParameterKey{ + Name: "profile", + In: "query", + } + if v, ok := packed[key]; ok { + params.Profile = v.(OptPerformPredictionProfile) + } + } + { + key := middleware.ParameterKey{ + Name: "ascent_rate", + In: "query", + } + if v, ok := packed[key]; ok { + params.AscentRate = v.(OptFloat64) + } + } + { + key := middleware.ParameterKey{ + Name: "burst_altitude", + In: "query", + } + if v, ok := packed[key]; ok { + params.BurstAltitude = v.(OptFloat64) + } + } + { + key := middleware.ParameterKey{ + Name: "descent_rate", + In: "query", + } + if v, ok := packed[key]; ok { + params.DescentRate = v.(OptFloat64) + } + } + { + key := middleware.ParameterKey{ + Name: "float_altitude", + In: "query", + } + if v, ok := packed[key]; ok { + params.FloatAltitude = v.(OptFloat64) + } + } + { + key := middleware.ParameterKey{ + Name: "stop_datetime", + In: "query", + } + if v, ok := packed[key]; ok { + params.StopDatetime = v.(OptDateTime) + } + } + { + key := middleware.ParameterKey{ + Name: "ascent_curve", + In: "query", + } + if v, ok := packed[key]; ok { + params.AscentCurve = v.(OptString) + } + } + { + key := middleware.ParameterKey{ + Name: "descent_curve", + In: "query", + } + if v, ok := packed[key]; ok { + params.DescentCurve = v.(OptString) + } + } + { + key := middleware.ParameterKey{ + Name: "interpolate", + In: "query", + } + if v, ok := packed[key]; ok { + params.Interpolate = v.(OptBool) + } + } + { + key := middleware.ParameterKey{ + Name: "format", + In: "query", + } + if v, ok := packed[key]; ok { + params.Format = v.(OptPerformPredictionFormat) + } + } + { + key := middleware.ParameterKey{ + Name: "dataset", + In: "query", + } + if v, ok := packed[key]; ok { + params.Dataset = v.(OptDateTime) } } return params @@ -30,30 +175,249 @@ func unpackPerformPredictionParams(packed middleware.Parameters) (params Perform func decodePerformPredictionParams(args [0]string, argsEscaped bool, r *http.Request) (params PerformPredictionParams, _ error) { q := uri.NewQueryDecoder(r.URL.Query()) - // Decode query: parameters. + // Decode query: launch_latitude. if err := func() error { cfg := uri.QueryParameterDecodingConfig{ - Name: "parameters", + Name: "launch_latitude", Style: uri.QueryStyleForm, Explode: true, - Fields: []uri.QueryParameterObjectField{{Name: "launch_latitude", Required: false}, {Name: "launch_longitude", Required: false}, {Name: "launch_datetime", Required: false}, {Name: "launch_altitude", Required: false}, {Name: "profile", Required: false}, {Name: "ascent_rate", Required: false}, {Name: "burst_altitude", Required: false}, {Name: "descent_rate", Required: false}, {Name: "float_altitude", Required: false}, {Name: "stop_datetime", Required: false}, {Name: "ascent_curve", Required: false}, {Name: "descent_curve", Required: false}, {Name: "interpolate", Required: false}, {Name: "format", Required: false}, {Name: "dataset", Required: false}}, } if err := q.HasParam(cfg); err == nil { if err := q.DecodeParam(cfg, func(d uri.Decoder) error { - var paramsDotParametersVal PredictionParameters + var paramsDotLaunchLatitudeVal float64 if err := func() error { - return paramsDotParametersVal.DecodeURI(d) + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToFloat64(val) + if err != nil { + return err + } + + paramsDotLaunchLatitudeVal = c + return nil }(); err != nil { return err } - params.Parameters.SetTo(paramsDotParametersVal) + params.LaunchLatitude.SetTo(paramsDotLaunchLatitudeVal) return nil }); err != nil { return err } if err := func() error { - if value, ok := params.Parameters.Get(); ok { + if value, ok := params.LaunchLatitude.Get(); ok { + if err := func() error { + if err := (validate.Float{}).Validate(float64(value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "launch_latitude", + In: "query", + Err: err, + } + } + // Decode query: launch_longitude. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "launch_longitude", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotLaunchLongitudeVal float64 + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToFloat64(val) + if err != nil { + return err + } + + paramsDotLaunchLongitudeVal = c + return nil + }(); err != nil { + return err + } + params.LaunchLongitude.SetTo(paramsDotLaunchLongitudeVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if value, ok := params.LaunchLongitude.Get(); ok { + if err := func() error { + if err := (validate.Float{}).Validate(float64(value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "launch_longitude", + In: "query", + Err: err, + } + } + // Decode query: launch_datetime. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "launch_datetime", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotLaunchDatetimeVal time.Time + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToDateTime(val) + if err != nil { + return err + } + + paramsDotLaunchDatetimeVal = c + return nil + }(); err != nil { + return err + } + params.LaunchDatetime.SetTo(paramsDotLaunchDatetimeVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "launch_datetime", + In: "query", + Err: err, + } + } + // Decode query: launch_altitude. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "launch_altitude", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotLaunchAltitudeVal float64 + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToFloat64(val) + if err != nil { + return err + } + + paramsDotLaunchAltitudeVal = c + return nil + }(); err != nil { + return err + } + params.LaunchAltitude.SetTo(paramsDotLaunchAltitudeVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if value, ok := params.LaunchAltitude.Get(); ok { + if err := func() error { + if err := (validate.Float{}).Validate(float64(value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "launch_altitude", + In: "query", + Err: err, + } + } + // Decode query: profile. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "profile", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotProfileVal PerformPredictionProfile + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToString(val) + if err != nil { + return err + } + + paramsDotProfileVal = PerformPredictionProfile(c) + return nil + }(); err != nil { + return err + } + params.Profile.SetTo(paramsDotProfileVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if value, ok := params.Profile.Get(); ok { if err := func() error { if err := value.Validate(); err != nil { return err @@ -71,7 +435,492 @@ func decodePerformPredictionParams(args [0]string, argsEscaped bool, r *http.Req return nil }(); err != nil { return params, &ogenerrors.DecodeParamError{ - Name: "parameters", + Name: "profile", + In: "query", + Err: err, + } + } + // Decode query: ascent_rate. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "ascent_rate", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotAscentRateVal float64 + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToFloat64(val) + if err != nil { + return err + } + + paramsDotAscentRateVal = c + return nil + }(); err != nil { + return err + } + params.AscentRate.SetTo(paramsDotAscentRateVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if value, ok := params.AscentRate.Get(); ok { + if err := func() error { + if err := (validate.Float{}).Validate(float64(value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "ascent_rate", + In: "query", + Err: err, + } + } + // Decode query: burst_altitude. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "burst_altitude", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotBurstAltitudeVal float64 + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToFloat64(val) + if err != nil { + return err + } + + paramsDotBurstAltitudeVal = c + return nil + }(); err != nil { + return err + } + params.BurstAltitude.SetTo(paramsDotBurstAltitudeVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if value, ok := params.BurstAltitude.Get(); ok { + if err := func() error { + if err := (validate.Float{}).Validate(float64(value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "burst_altitude", + In: "query", + Err: err, + } + } + // Decode query: descent_rate. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "descent_rate", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotDescentRateVal float64 + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToFloat64(val) + if err != nil { + return err + } + + paramsDotDescentRateVal = c + return nil + }(); err != nil { + return err + } + params.DescentRate.SetTo(paramsDotDescentRateVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if value, ok := params.DescentRate.Get(); ok { + if err := func() error { + if err := (validate.Float{}).Validate(float64(value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "descent_rate", + In: "query", + Err: err, + } + } + // Decode query: float_altitude. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "float_altitude", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotFloatAltitudeVal float64 + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToFloat64(val) + if err != nil { + return err + } + + paramsDotFloatAltitudeVal = c + return nil + }(); err != nil { + return err + } + params.FloatAltitude.SetTo(paramsDotFloatAltitudeVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if value, ok := params.FloatAltitude.Get(); ok { + if err := func() error { + if err := (validate.Float{}).Validate(float64(value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "float_altitude", + In: "query", + Err: err, + } + } + // Decode query: stop_datetime. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "stop_datetime", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotStopDatetimeVal time.Time + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToDateTime(val) + if err != nil { + return err + } + + paramsDotStopDatetimeVal = c + return nil + }(); err != nil { + return err + } + params.StopDatetime.SetTo(paramsDotStopDatetimeVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "stop_datetime", + In: "query", + Err: err, + } + } + // Decode query: ascent_curve. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "ascent_curve", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotAscentCurveVal string + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToString(val) + if err != nil { + return err + } + + paramsDotAscentCurveVal = c + return nil + }(); err != nil { + return err + } + params.AscentCurve.SetTo(paramsDotAscentCurveVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "ascent_curve", + In: "query", + Err: err, + } + } + // Decode query: descent_curve. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "descent_curve", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotDescentCurveVal string + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToString(val) + if err != nil { + return err + } + + paramsDotDescentCurveVal = c + return nil + }(); err != nil { + return err + } + params.DescentCurve.SetTo(paramsDotDescentCurveVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "descent_curve", + In: "query", + Err: err, + } + } + // Decode query: interpolate. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "interpolate", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotInterpolateVal bool + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToBool(val) + if err != nil { + return err + } + + paramsDotInterpolateVal = c + return nil + }(); err != nil { + return err + } + params.Interpolate.SetTo(paramsDotInterpolateVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "interpolate", + In: "query", + Err: err, + } + } + // Decode query: format. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "format", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotFormatVal PerformPredictionFormat + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToString(val) + if err != nil { + return err + } + + paramsDotFormatVal = PerformPredictionFormat(c) + return nil + }(); err != nil { + return err + } + params.Format.SetTo(paramsDotFormatVal) + return nil + }); err != nil { + return err + } + if err := func() error { + if value, ok := params.Format.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "format", + In: "query", + Err: err, + } + } + // Decode query: dataset. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "dataset", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotDatasetVal time.Time + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToDateTime(val) + if err != nil { + return err + } + + paramsDotDatasetVal = c + return nil + }(); err != nil { + return err + } + params.Dataset.SetTo(paramsDotDatasetVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "dataset", In: "query", Err: err, } diff --git a/pkg/rest/oas_request_decoders_gen.go b/pkg/rest/oas_request_decoders_gen.go index 1a68a60..d99e2f0 100644 --- a/pkg/rest/oas_request_decoders_gen.go +++ b/pkg/rest/oas_request_decoders_gen.go @@ -1,97 +1,3 @@ // Code generated by ogen, DO NOT EDIT. package gsn - -import ( - "io" - "mime" - "net/http" - - "github.com/go-faster/errors" - "github.com/go-faster/jx" - - "github.com/ogen-go/ogen/ogenerrors" - "github.com/ogen-go/ogen/validate" -) - -func (s *Server) decodePerformPredictionRequest(r *http.Request) ( - req OptPredictionParameters, - close func() error, - rerr error, -) { - var closers []func() error - close = func() error { - var merr error - // Close in reverse order, to match defer behavior. - for i := len(closers) - 1; i >= 0; i-- { - c := closers[i] - merr = errors.Join(merr, c()) - } - return merr - } - defer func() { - if rerr != nil { - rerr = errors.Join(rerr, close()) - } - }() - if _, ok := r.Header["Content-Type"]; !ok && r.ContentLength == 0 { - return req, close, nil - } - ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) - if err != nil { - return req, close, errors.Wrap(err, "parse media type") - } - switch { - case ct == "application/json": - if r.ContentLength == 0 { - return req, close, nil - } - buf, err := io.ReadAll(r.Body) - if err != nil { - return req, close, err - } - - if len(buf) == 0 { - return req, close, nil - } - - d := jx.DecodeBytes(buf) - - var request OptPredictionParameters - if err := func() error { - request.Reset() - if err := request.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 req, close, err - } - if err := func() error { - if value, ok := request.Get(); ok { - if err := func() error { - if err := value.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - return req, close, errors.Wrap(err, "validate") - } - return request, close, nil - default: - return req, close, validate.InvalidContentType(ct) - } -} diff --git a/pkg/rest/oas_request_encoders_gen.go b/pkg/rest/oas_request_encoders_gen.go index a387ab8..d99e2f0 100644 --- a/pkg/rest/oas_request_encoders_gen.go +++ b/pkg/rest/oas_request_encoders_gen.go @@ -1,32 +1,3 @@ // Code generated by ogen, DO NOT EDIT. package gsn - -import ( - "bytes" - "net/http" - - "github.com/go-faster/jx" - - ht "github.com/ogen-go/ogen/http" -) - -func encodePerformPredictionRequest( - req OptPredictionParameters, - r *http.Request, -) error { - const contentType = "application/json" - if !req.Set { - // Keep request with empty body if value is not set. - return nil - } - e := new(jx.Encoder) - { - if req.Set { - req.Encode(e) - } - } - encoded := e.Bytes() - ht.SetBody(r, bytes.NewReader(encoded), contentType) - return nil -} diff --git a/pkg/rest/oas_router_gen.go b/pkg/rest/oas_router_gen.go index 68d502b..1eea998 100644 --- a/pkg/rest/oas_router_gen.go +++ b/pkg/rest/oas_router_gen.go @@ -71,10 +71,10 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { // Leaf node. switch r.Method { - case "POST": + case "GET": s.handlePerformPredictionRequest([0]string{}, elemIsEscaped, w, r) default: - s.notAllowed(w, r, "POST") + s.notAllowed(w, r, "GET") } return @@ -205,9 +205,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { if len(elem) == 0 { // Leaf node. switch method { - case "POST": + case "GET": r.name = PerformPredictionOperation - r.summary = "Perform preidction" + r.summary = "Perform prediction" r.operationID = "performPrediction" r.pathPattern = "/api/v1/prediction" r.args = args diff --git a/pkg/rest/oas_schemas_gen.go b/pkg/rest/oas_schemas_gen.go index ba8ffb6..26808cc 100644 --- a/pkg/rest/oas_schemas_gen.go +++ b/pkg/rest/oas_schemas_gen.go @@ -203,38 +203,38 @@ func (o OptFloat64) Or(d float64) float64 { return d } -// NewOptPredictionParameters returns new OptPredictionParameters with value set to v. -func NewOptPredictionParameters(v PredictionParameters) OptPredictionParameters { - return OptPredictionParameters{ +// NewOptPerformPredictionFormat returns new OptPerformPredictionFormat with value set to v. +func NewOptPerformPredictionFormat(v PerformPredictionFormat) OptPerformPredictionFormat { + return OptPerformPredictionFormat{ Value: v, Set: true, } } -// OptPredictionParameters is optional PredictionParameters. -type OptPredictionParameters struct { - Value PredictionParameters +// OptPerformPredictionFormat is optional PerformPredictionFormat. +type OptPerformPredictionFormat struct { + Value PerformPredictionFormat Set bool } -// IsSet returns true if OptPredictionParameters was set. -func (o OptPredictionParameters) IsSet() bool { return o.Set } +// IsSet returns true if OptPerformPredictionFormat was set. +func (o OptPerformPredictionFormat) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptPredictionParameters) Reset() { - var v PredictionParameters +func (o *OptPerformPredictionFormat) Reset() { + var v PerformPredictionFormat o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptPredictionParameters) SetTo(v PredictionParameters) { +func (o *OptPerformPredictionFormat) SetTo(v PerformPredictionFormat) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptPredictionParameters) Get() (v PredictionParameters, ok bool) { +func (o OptPerformPredictionFormat) Get() (v PerformPredictionFormat, ok bool) { if !o.Set { return v, false } @@ -242,45 +242,45 @@ func (o OptPredictionParameters) Get() (v PredictionParameters, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptPredictionParameters) Or(d PredictionParameters) PredictionParameters { +func (o OptPerformPredictionFormat) Or(d PerformPredictionFormat) PerformPredictionFormat { if v, ok := o.Get(); ok { return v } return d } -// NewOptPredictionParametersFormat returns new OptPredictionParametersFormat with value set to v. -func NewOptPredictionParametersFormat(v PredictionParametersFormat) OptPredictionParametersFormat { - return OptPredictionParametersFormat{ +// NewOptPerformPredictionProfile returns new OptPerformPredictionProfile with value set to v. +func NewOptPerformPredictionProfile(v PerformPredictionProfile) OptPerformPredictionProfile { + return OptPerformPredictionProfile{ Value: v, Set: true, } } -// OptPredictionParametersFormat is optional PredictionParametersFormat. -type OptPredictionParametersFormat struct { - Value PredictionParametersFormat +// OptPerformPredictionProfile is optional PerformPredictionProfile. +type OptPerformPredictionProfile struct { + Value PerformPredictionProfile Set bool } -// IsSet returns true if OptPredictionParametersFormat was set. -func (o OptPredictionParametersFormat) IsSet() bool { return o.Set } +// IsSet returns true if OptPerformPredictionProfile was set. +func (o OptPerformPredictionProfile) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptPredictionParametersFormat) Reset() { - var v PredictionParametersFormat +func (o *OptPerformPredictionProfile) Reset() { + var v PerformPredictionProfile o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptPredictionParametersFormat) SetTo(v PredictionParametersFormat) { +func (o *OptPerformPredictionProfile) SetTo(v PerformPredictionProfile) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptPredictionParametersFormat) Get() (v PredictionParametersFormat, ok bool) { +func (o OptPerformPredictionProfile) Get() (v PerformPredictionProfile, ok bool) { if !o.Set { return v, false } @@ -288,53 +288,7 @@ func (o OptPredictionParametersFormat) Get() (v PredictionParametersFormat, ok b } // Or returns value if set, or given parameter if does not. -func (o OptPredictionParametersFormat) Or(d PredictionParametersFormat) PredictionParametersFormat { - if v, ok := o.Get(); ok { - return v - } - return d -} - -// NewOptPredictionParametersProfile returns new OptPredictionParametersProfile with value set to v. -func NewOptPredictionParametersProfile(v PredictionParametersProfile) OptPredictionParametersProfile { - return OptPredictionParametersProfile{ - Value: v, - Set: true, - } -} - -// OptPredictionParametersProfile is optional PredictionParametersProfile. -type OptPredictionParametersProfile struct { - Value PredictionParametersProfile - Set bool -} - -// IsSet returns true if OptPredictionParametersProfile was set. -func (o OptPredictionParametersProfile) IsSet() bool { return o.Set } - -// Reset unsets value. -func (o *OptPredictionParametersProfile) Reset() { - var v PredictionParametersProfile - o.Value = v - o.Set = false -} - -// SetTo sets value to v. -func (o *OptPredictionParametersProfile) SetTo(v PredictionParametersProfile) { - o.Set = true - o.Value = v -} - -// Get returns value and boolean that denotes whether value was set. -func (o OptPredictionParametersProfile) Get() (v PredictionParametersProfile, ok bool) { - if !o.Set { - return v, false - } - return o.Value, true -} - -// Or returns value if set, or given parameter if does not. -func (o OptPredictionParametersProfile) Or(d PredictionParametersProfile) PredictionParametersProfile { +func (o OptPerformPredictionProfile) Or(d PerformPredictionProfile) PerformPredictionProfile { if v, ok := o.Get(); ok { return v } @@ -387,194 +341,23 @@ func (o OptString) Or(d string) string { return d } -// Ref: #/components/schemas/PredictionParameters -type PredictionParameters struct { - LaunchLatitude OptFloat64 `json:"launch_latitude"` - LaunchLongitude OptFloat64 `json:"launch_longitude"` - LaunchDatetime OptDateTime `json:"launch_datetime"` - LaunchAltitude OptFloat64 `json:"launch_altitude"` - Profile OptPredictionParametersProfile `json:"profile"` - AscentRate OptFloat64 `json:"ascent_rate"` - BurstAltitude OptFloat64 `json:"burst_altitude"` - DescentRate OptFloat64 `json:"descent_rate"` - FloatAltitude OptFloat64 `json:"float_altitude"` - StopDatetime OptDateTime `json:"stop_datetime"` - // Base64 encoded ascent curve. - AscentCurve OptString `json:"ascent_curve"` - // Base64 encoded descent curve. - DescentCurve OptString `json:"descent_curve"` - Interpolate OptBool `json:"interpolate"` - Format OptPredictionParametersFormat `json:"format"` - Dataset OptDateTime `json:"dataset"` -} - -// GetLaunchLatitude returns the value of LaunchLatitude. -func (s *PredictionParameters) GetLaunchLatitude() OptFloat64 { - return s.LaunchLatitude -} - -// GetLaunchLongitude returns the value of LaunchLongitude. -func (s *PredictionParameters) GetLaunchLongitude() OptFloat64 { - return s.LaunchLongitude -} - -// GetLaunchDatetime returns the value of LaunchDatetime. -func (s *PredictionParameters) GetLaunchDatetime() OptDateTime { - return s.LaunchDatetime -} - -// GetLaunchAltitude returns the value of LaunchAltitude. -func (s *PredictionParameters) GetLaunchAltitude() OptFloat64 { - return s.LaunchAltitude -} - -// GetProfile returns the value of Profile. -func (s *PredictionParameters) GetProfile() OptPredictionParametersProfile { - return s.Profile -} - -// GetAscentRate returns the value of AscentRate. -func (s *PredictionParameters) GetAscentRate() OptFloat64 { - return s.AscentRate -} - -// GetBurstAltitude returns the value of BurstAltitude. -func (s *PredictionParameters) GetBurstAltitude() OptFloat64 { - return s.BurstAltitude -} - -// GetDescentRate returns the value of DescentRate. -func (s *PredictionParameters) GetDescentRate() OptFloat64 { - return s.DescentRate -} - -// GetFloatAltitude returns the value of FloatAltitude. -func (s *PredictionParameters) GetFloatAltitude() OptFloat64 { - return s.FloatAltitude -} - -// GetStopDatetime returns the value of StopDatetime. -func (s *PredictionParameters) GetStopDatetime() OptDateTime { - return s.StopDatetime -} - -// GetAscentCurve returns the value of AscentCurve. -func (s *PredictionParameters) GetAscentCurve() OptString { - return s.AscentCurve -} - -// GetDescentCurve returns the value of DescentCurve. -func (s *PredictionParameters) GetDescentCurve() OptString { - return s.DescentCurve -} - -// GetInterpolate returns the value of Interpolate. -func (s *PredictionParameters) GetInterpolate() OptBool { - return s.Interpolate -} - -// GetFormat returns the value of Format. -func (s *PredictionParameters) GetFormat() OptPredictionParametersFormat { - return s.Format -} - -// GetDataset returns the value of Dataset. -func (s *PredictionParameters) GetDataset() OptDateTime { - return s.Dataset -} - -// SetLaunchLatitude sets the value of LaunchLatitude. -func (s *PredictionParameters) SetLaunchLatitude(val OptFloat64) { - s.LaunchLatitude = val -} - -// SetLaunchLongitude sets the value of LaunchLongitude. -func (s *PredictionParameters) SetLaunchLongitude(val OptFloat64) { - s.LaunchLongitude = val -} - -// SetLaunchDatetime sets the value of LaunchDatetime. -func (s *PredictionParameters) SetLaunchDatetime(val OptDateTime) { - s.LaunchDatetime = val -} - -// SetLaunchAltitude sets the value of LaunchAltitude. -func (s *PredictionParameters) SetLaunchAltitude(val OptFloat64) { - s.LaunchAltitude = val -} - -// SetProfile sets the value of Profile. -func (s *PredictionParameters) SetProfile(val OptPredictionParametersProfile) { - s.Profile = val -} - -// SetAscentRate sets the value of AscentRate. -func (s *PredictionParameters) SetAscentRate(val OptFloat64) { - s.AscentRate = val -} - -// SetBurstAltitude sets the value of BurstAltitude. -func (s *PredictionParameters) SetBurstAltitude(val OptFloat64) { - s.BurstAltitude = val -} - -// SetDescentRate sets the value of DescentRate. -func (s *PredictionParameters) SetDescentRate(val OptFloat64) { - s.DescentRate = val -} - -// SetFloatAltitude sets the value of FloatAltitude. -func (s *PredictionParameters) SetFloatAltitude(val OptFloat64) { - s.FloatAltitude = val -} - -// SetStopDatetime sets the value of StopDatetime. -func (s *PredictionParameters) SetStopDatetime(val OptDateTime) { - s.StopDatetime = val -} - -// SetAscentCurve sets the value of AscentCurve. -func (s *PredictionParameters) SetAscentCurve(val OptString) { - s.AscentCurve = val -} - -// SetDescentCurve sets the value of DescentCurve. -func (s *PredictionParameters) SetDescentCurve(val OptString) { - s.DescentCurve = val -} - -// SetInterpolate sets the value of Interpolate. -func (s *PredictionParameters) SetInterpolate(val OptBool) { - s.Interpolate = val -} - -// SetFormat sets the value of Format. -func (s *PredictionParameters) SetFormat(val OptPredictionParametersFormat) { - s.Format = val -} - -// SetDataset sets the value of Dataset. -func (s *PredictionParameters) SetDataset(val OptDateTime) { - s.Dataset = val -} - -type PredictionParametersFormat string +type PerformPredictionFormat string const ( - PredictionParametersFormatJSON PredictionParametersFormat = "json" + PerformPredictionFormatJSON PerformPredictionFormat = "json" ) -// AllValues returns all PredictionParametersFormat values. -func (PredictionParametersFormat) AllValues() []PredictionParametersFormat { - return []PredictionParametersFormat{ - PredictionParametersFormatJSON, +// AllValues returns all PerformPredictionFormat values. +func (PerformPredictionFormat) AllValues() []PerformPredictionFormat { + return []PerformPredictionFormat{ + PerformPredictionFormatJSON, } } // MarshalText implements encoding.TextMarshaler. -func (s PredictionParametersFormat) MarshalText() ([]byte, error) { +func (s PerformPredictionFormat) MarshalText() ([]byte, error) { switch s { - case PredictionParametersFormatJSON: + case PerformPredictionFormatJSON: return []byte(s), nil default: return nil, errors.Errorf("invalid value: %q", s) @@ -582,45 +365,45 @@ func (s PredictionParametersFormat) MarshalText() ([]byte, error) { } // UnmarshalText implements encoding.TextUnmarshaler. -func (s *PredictionParametersFormat) UnmarshalText(data []byte) error { - switch PredictionParametersFormat(data) { - case PredictionParametersFormatJSON: - *s = PredictionParametersFormatJSON +func (s *PerformPredictionFormat) UnmarshalText(data []byte) error { + switch PerformPredictionFormat(data) { + case PerformPredictionFormatJSON: + *s = PerformPredictionFormatJSON return nil default: return errors.Errorf("invalid value: %q", data) } } -type PredictionParametersProfile string +type PerformPredictionProfile string const ( - PredictionParametersProfileStandardProfile PredictionParametersProfile = "standard_profile" - PredictionParametersProfileFloatProfile PredictionParametersProfile = "float_profile" - PredictionParametersProfileReverseProfile PredictionParametersProfile = "reverse_profile" - PredictionParametersProfileCustomProfile PredictionParametersProfile = "custom_profile" + PerformPredictionProfileStandardProfile PerformPredictionProfile = "standard_profile" + PerformPredictionProfileFloatProfile PerformPredictionProfile = "float_profile" + PerformPredictionProfileReverseProfile PerformPredictionProfile = "reverse_profile" + PerformPredictionProfileCustomProfile PerformPredictionProfile = "custom_profile" ) -// AllValues returns all PredictionParametersProfile values. -func (PredictionParametersProfile) AllValues() []PredictionParametersProfile { - return []PredictionParametersProfile{ - PredictionParametersProfileStandardProfile, - PredictionParametersProfileFloatProfile, - PredictionParametersProfileReverseProfile, - PredictionParametersProfileCustomProfile, +// AllValues returns all PerformPredictionProfile values. +func (PerformPredictionProfile) AllValues() []PerformPredictionProfile { + return []PerformPredictionProfile{ + PerformPredictionProfileStandardProfile, + PerformPredictionProfileFloatProfile, + PerformPredictionProfileReverseProfile, + PerformPredictionProfileCustomProfile, } } // MarshalText implements encoding.TextMarshaler. -func (s PredictionParametersProfile) MarshalText() ([]byte, error) { +func (s PerformPredictionProfile) MarshalText() ([]byte, error) { switch s { - case PredictionParametersProfileStandardProfile: + case PerformPredictionProfileStandardProfile: return []byte(s), nil - case PredictionParametersProfileFloatProfile: + case PerformPredictionProfileFloatProfile: return []byte(s), nil - case PredictionParametersProfileReverseProfile: + case PerformPredictionProfileReverseProfile: return []byte(s), nil - case PredictionParametersProfileCustomProfile: + case PerformPredictionProfileCustomProfile: return []byte(s), nil default: return nil, errors.Errorf("invalid value: %q", s) @@ -628,19 +411,19 @@ func (s PredictionParametersProfile) MarshalText() ([]byte, error) { } // UnmarshalText implements encoding.TextUnmarshaler. -func (s *PredictionParametersProfile) UnmarshalText(data []byte) error { - switch PredictionParametersProfile(data) { - case PredictionParametersProfileStandardProfile: - *s = PredictionParametersProfileStandardProfile +func (s *PerformPredictionProfile) UnmarshalText(data []byte) error { + switch PerformPredictionProfile(data) { + case PerformPredictionProfileStandardProfile: + *s = PerformPredictionProfileStandardProfile return nil - case PredictionParametersProfileFloatProfile: - *s = PredictionParametersProfileFloatProfile + case PerformPredictionProfileFloatProfile: + *s = PerformPredictionProfileFloatProfile return nil - case PredictionParametersProfileReverseProfile: - *s = PredictionParametersProfileReverseProfile + case PerformPredictionProfileReverseProfile: + *s = PerformPredictionProfileReverseProfile return nil - case PredictionParametersProfileCustomProfile: - *s = PredictionParametersProfileCustomProfile + case PerformPredictionProfileCustomProfile: + *s = PerformPredictionProfileCustomProfile return nil default: return errors.Errorf("invalid value: %q", data) diff --git a/pkg/rest/oas_server_gen.go b/pkg/rest/oas_server_gen.go index f246bc7..9ef451e 100644 --- a/pkg/rest/oas_server_gen.go +++ b/pkg/rest/oas_server_gen.go @@ -10,10 +10,10 @@ import ( type Handler interface { // PerformPrediction implements performPrediction operation. // - // Perform preidction. + // Perform prediction. // - // POST /api/v1/prediction - PerformPrediction(ctx context.Context, req OptPredictionParameters, params PerformPredictionParams) (*PredictionResult, error) + // GET /api/v1/prediction + PerformPrediction(ctx context.Context, params PerformPredictionParams) (*PredictionResult, error) // ReadinessCheck implements readinessCheck operation. // // Readiness check. diff --git a/pkg/rest/oas_unimplemented_gen.go b/pkg/rest/oas_unimplemented_gen.go index 6582495..9662197 100644 --- a/pkg/rest/oas_unimplemented_gen.go +++ b/pkg/rest/oas_unimplemented_gen.go @@ -15,10 +15,10 @@ var _ Handler = UnimplementedHandler{} // PerformPrediction implements performPrediction operation. // -// Perform preidction. +// Perform prediction. // -// POST /api/v1/prediction -func (UnimplementedHandler) PerformPrediction(ctx context.Context, req OptPredictionParameters, params PerformPredictionParams) (r *PredictionResult, _ error) { +// GET /api/v1/prediction +func (UnimplementedHandler) PerformPrediction(ctx context.Context, params PerformPredictionParams) (r *PredictionResult, _ error) { return r, ht.ErrNotImplemented } diff --git a/pkg/rest/oas_uri_gen.go b/pkg/rest/oas_uri_gen.go deleted file mode 100644 index 7990aa4..0000000 --- a/pkg/rest/oas_uri_gen.go +++ /dev/null @@ -1,535 +0,0 @@ -// Code generated by ogen, DO NOT EDIT. - -package gsn - -import ( - "time" - - "github.com/go-faster/errors" - - "github.com/ogen-go/ogen/conv" - "github.com/ogen-go/ogen/uri" -) - -// EncodeURI encodes PredictionParameters as URI form. -func (s *PredictionParameters) EncodeURI(e uri.Encoder) error { - if err := e.EncodeField("launch_latitude", func(e uri.Encoder) error { - if val, ok := s.LaunchLatitude.Get(); ok { - return e.EncodeValue(conv.Float64ToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"launch_latitude\"") - } - if err := e.EncodeField("launch_longitude", func(e uri.Encoder) error { - if val, ok := s.LaunchLongitude.Get(); ok { - return e.EncodeValue(conv.Float64ToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"launch_longitude\"") - } - if err := e.EncodeField("launch_datetime", func(e uri.Encoder) error { - if val, ok := s.LaunchDatetime.Get(); ok { - return e.EncodeValue(conv.DateTimeToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"launch_datetime\"") - } - if err := e.EncodeField("launch_altitude", func(e uri.Encoder) error { - if val, ok := s.LaunchAltitude.Get(); ok { - return e.EncodeValue(conv.Float64ToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"launch_altitude\"") - } - if err := e.EncodeField("profile", func(e uri.Encoder) error { - if val, ok := s.Profile.Get(); ok { - return e.EncodeValue(conv.StringToString(string(val))) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"profile\"") - } - if err := e.EncodeField("ascent_rate", func(e uri.Encoder) error { - if val, ok := s.AscentRate.Get(); ok { - return e.EncodeValue(conv.Float64ToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"ascent_rate\"") - } - if err := e.EncodeField("burst_altitude", func(e uri.Encoder) error { - if val, ok := s.BurstAltitude.Get(); ok { - return e.EncodeValue(conv.Float64ToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"burst_altitude\"") - } - if err := e.EncodeField("descent_rate", func(e uri.Encoder) error { - if val, ok := s.DescentRate.Get(); ok { - return e.EncodeValue(conv.Float64ToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"descent_rate\"") - } - if err := e.EncodeField("float_altitude", func(e uri.Encoder) error { - if val, ok := s.FloatAltitude.Get(); ok { - return e.EncodeValue(conv.Float64ToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"float_altitude\"") - } - if err := e.EncodeField("stop_datetime", func(e uri.Encoder) error { - if val, ok := s.StopDatetime.Get(); ok { - return e.EncodeValue(conv.DateTimeToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"stop_datetime\"") - } - if err := e.EncodeField("ascent_curve", func(e uri.Encoder) error { - if val, ok := s.AscentCurve.Get(); ok { - return e.EncodeValue(conv.StringToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"ascent_curve\"") - } - if err := e.EncodeField("descent_curve", func(e uri.Encoder) error { - if val, ok := s.DescentCurve.Get(); ok { - return e.EncodeValue(conv.StringToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"descent_curve\"") - } - if err := e.EncodeField("interpolate", func(e uri.Encoder) error { - if val, ok := s.Interpolate.Get(); ok { - return e.EncodeValue(conv.BoolToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"interpolate\"") - } - if err := e.EncodeField("format", func(e uri.Encoder) error { - if val, ok := s.Format.Get(); ok { - return e.EncodeValue(conv.StringToString(string(val))) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"format\"") - } - if err := e.EncodeField("dataset", func(e uri.Encoder) error { - if val, ok := s.Dataset.Get(); ok { - return e.EncodeValue(conv.DateTimeToString(val)) - } - return nil - }); err != nil { - return errors.Wrap(err, "encode field \"dataset\"") - } - return nil -} - -var uriFieldsNameOfPredictionParameters = [15]string{ - 0: "launch_latitude", - 1: "launch_longitude", - 2: "launch_datetime", - 3: "launch_altitude", - 4: "profile", - 5: "ascent_rate", - 6: "burst_altitude", - 7: "descent_rate", - 8: "float_altitude", - 9: "stop_datetime", - 10: "ascent_curve", - 11: "descent_curve", - 12: "interpolate", - 13: "format", - 14: "dataset", -} - -// DecodeURI decodes PredictionParameters from URI form. -func (s *PredictionParameters) DecodeURI(d uri.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode PredictionParameters to nil") - } - s.setDefaults() - - if err := d.DecodeFields(func(k string, d uri.Decoder) error { - switch k { - case "launch_latitude": - if err := func() error { - var sDotLaunchLatitudeVal float64 - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToFloat64(val) - if err != nil { - return err - } - - sDotLaunchLatitudeVal = c - return nil - }(); err != nil { - return err - } - s.LaunchLatitude.SetTo(sDotLaunchLatitudeVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"launch_latitude\"") - } - case "launch_longitude": - if err := func() error { - var sDotLaunchLongitudeVal float64 - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToFloat64(val) - if err != nil { - return err - } - - sDotLaunchLongitudeVal = c - return nil - }(); err != nil { - return err - } - s.LaunchLongitude.SetTo(sDotLaunchLongitudeVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"launch_longitude\"") - } - case "launch_datetime": - if err := func() error { - var sDotLaunchDatetimeVal time.Time - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToDateTime(val) - if err != nil { - return err - } - - sDotLaunchDatetimeVal = c - return nil - }(); err != nil { - return err - } - s.LaunchDatetime.SetTo(sDotLaunchDatetimeVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"launch_datetime\"") - } - case "launch_altitude": - if err := func() error { - var sDotLaunchAltitudeVal float64 - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToFloat64(val) - if err != nil { - return err - } - - sDotLaunchAltitudeVal = c - return nil - }(); err != nil { - return err - } - s.LaunchAltitude.SetTo(sDotLaunchAltitudeVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"launch_altitude\"") - } - case "profile": - if err := func() error { - var sDotProfileVal PredictionParametersProfile - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToString(val) - if err != nil { - return err - } - - sDotProfileVal = PredictionParametersProfile(c) - return nil - }(); err != nil { - return err - } - s.Profile.SetTo(sDotProfileVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"profile\"") - } - case "ascent_rate": - if err := func() error { - var sDotAscentRateVal float64 - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToFloat64(val) - if err != nil { - return err - } - - sDotAscentRateVal = c - return nil - }(); err != nil { - return err - } - s.AscentRate.SetTo(sDotAscentRateVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"ascent_rate\"") - } - case "burst_altitude": - if err := func() error { - var sDotBurstAltitudeVal float64 - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToFloat64(val) - if err != nil { - return err - } - - sDotBurstAltitudeVal = c - return nil - }(); err != nil { - return err - } - s.BurstAltitude.SetTo(sDotBurstAltitudeVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"burst_altitude\"") - } - case "descent_rate": - if err := func() error { - var sDotDescentRateVal float64 - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToFloat64(val) - if err != nil { - return err - } - - sDotDescentRateVal = c - return nil - }(); err != nil { - return err - } - s.DescentRate.SetTo(sDotDescentRateVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"descent_rate\"") - } - case "float_altitude": - if err := func() error { - var sDotFloatAltitudeVal float64 - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToFloat64(val) - if err != nil { - return err - } - - sDotFloatAltitudeVal = c - return nil - }(); err != nil { - return err - } - s.FloatAltitude.SetTo(sDotFloatAltitudeVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"float_altitude\"") - } - case "stop_datetime": - if err := func() error { - var sDotStopDatetimeVal time.Time - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToDateTime(val) - if err != nil { - return err - } - - sDotStopDatetimeVal = c - return nil - }(); err != nil { - return err - } - s.StopDatetime.SetTo(sDotStopDatetimeVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"stop_datetime\"") - } - case "ascent_curve": - if err := func() error { - var sDotAscentCurveVal string - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToString(val) - if err != nil { - return err - } - - sDotAscentCurveVal = c - return nil - }(); err != nil { - return err - } - s.AscentCurve.SetTo(sDotAscentCurveVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"ascent_curve\"") - } - case "descent_curve": - if err := func() error { - var sDotDescentCurveVal string - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToString(val) - if err != nil { - return err - } - - sDotDescentCurveVal = c - return nil - }(); err != nil { - return err - } - s.DescentCurve.SetTo(sDotDescentCurveVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"descent_curve\"") - } - case "interpolate": - if err := func() error { - var sDotInterpolateVal bool - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToBool(val) - if err != nil { - return err - } - - sDotInterpolateVal = c - return nil - }(); err != nil { - return err - } - s.Interpolate.SetTo(sDotInterpolateVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"interpolate\"") - } - case "format": - if err := func() error { - var sDotFormatVal PredictionParametersFormat - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToString(val) - if err != nil { - return err - } - - sDotFormatVal = PredictionParametersFormat(c) - return nil - }(); err != nil { - return err - } - s.Format.SetTo(sDotFormatVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"format\"") - } - case "dataset": - if err := func() error { - var sDotDatasetVal time.Time - if err := func() error { - val, err := d.DecodeValue() - if err != nil { - return err - } - - c, err := conv.ToDateTime(val) - if err != nil { - return err - } - - sDotDatasetVal = c - return nil - }(); err != nil { - return err - } - s.Dataset.SetTo(sDotDatasetVal) - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"dataset\"") - } - default: - return nil - } - return nil - }); err != nil { - return errors.Wrap(err, "decode PredictionParameters") - } - - return nil -} diff --git a/pkg/rest/oas_validators_gen.go b/pkg/rest/oas_validators_gen.go index d25fbcd..0cd02b6 100644 --- a/pkg/rest/oas_validators_gen.go +++ b/pkg/rest/oas_validators_gen.go @@ -10,181 +10,7 @@ import ( "github.com/ogen-go/ogen/validate" ) -func (s *PredictionParameters) Validate() error { - if s == nil { - return validate.ErrNilPointer - } - - var failures []validate.FieldError - if err := func() error { - if value, ok := s.LaunchLatitude.Get(); ok { - if err := func() error { - if err := (validate.Float{}).Validate(float64(value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "launch_latitude", - Error: err, - }) - } - if err := func() error { - if value, ok := s.LaunchLongitude.Get(); ok { - if err := func() error { - if err := (validate.Float{}).Validate(float64(value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "launch_longitude", - Error: err, - }) - } - if err := func() error { - if value, ok := s.LaunchAltitude.Get(); ok { - if err := func() error { - if err := (validate.Float{}).Validate(float64(value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "launch_altitude", - Error: err, - }) - } - if err := func() error { - if value, ok := s.Profile.Get(); ok { - if err := func() error { - if err := value.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "profile", - Error: err, - }) - } - if err := func() error { - if value, ok := s.AscentRate.Get(); ok { - if err := func() error { - if err := (validate.Float{}).Validate(float64(value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "ascent_rate", - Error: err, - }) - } - if err := func() error { - if value, ok := s.BurstAltitude.Get(); ok { - if err := func() error { - if err := (validate.Float{}).Validate(float64(value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "burst_altitude", - Error: err, - }) - } - if err := func() error { - if value, ok := s.DescentRate.Get(); ok { - if err := func() error { - if err := (validate.Float{}).Validate(float64(value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "descent_rate", - Error: err, - }) - } - if err := func() error { - if value, ok := s.FloatAltitude.Get(); ok { - if err := func() error { - if err := (validate.Float{}).Validate(float64(value)); err != nil { - return errors.Wrap(err, "float") - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "float_altitude", - Error: err, - }) - } - if err := func() error { - if value, ok := s.Format.Get(); ok { - if err := func() error { - if err := value.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - return err - } - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "format", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil -} - -func (s PredictionParametersFormat) Validate() error { +func (s PerformPredictionFormat) Validate() error { switch s { case "json": return nil @@ -193,7 +19,7 @@ func (s PredictionParametersFormat) Validate() error { } } -func (s PredictionParametersProfile) Validate() error { +func (s PerformPredictionProfile) Validate() error { switch s { case "standard_profile": return nil