afanasyev.aa/predictor
1
Fork 0
forked from gsn/predictor
Code Pull requests Activity

feat: predictor works

Browse source
This commit is contained in:
Anatoly Antonov 2025-06-26 01:15:37 +03:00
parent 11be8f351f
commit 7a9f81e527
20 changed files with 1357 additions and 1794 deletions
Download patch file Download diff file Expand all files Collapse all files

6
.gitignore vendored
View file

@ -51,4 +51,8 @@ Thumbs.db
# GRIB files
/grib_data/
/grib_data/*
/grib_data/*
# Leaflet WebUI
/leaflet_predictor
/leaflet_predictor/*

120
api/rest/predictor.swagger.yml
View file

@ -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:

1
go.mod
View file

@ -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

2
go.sum
View file

@ -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=

40
internal/pkg/ds/predictor.go
View file

@ -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

4
internal/transport/rest/handler/handler.go
View file

@ -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")
}

10
internal/transport/rest/transport.go
View file

@ -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)
}

270
pkg/rest/oas_client_gen.go
View file

@ -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)

15
pkg/rest/oas_defaults_gen.go
View file

@ -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)
}
}

91
pkg/rest/oas_handlers_gen.go
View file

@ -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 {

518
pkg/rest/oas_json_gen.go
View file

@ -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()

871
pkg/rest/oas_parameters_gen.go
View file

@ -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,
}

94
pkg/rest/oas_request_decoders_gen.go
View file

@ -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)
}
}

29
pkg/rest/oas_request_encoders_gen.go
View file

@ -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
}

8
pkg/rest/oas_router_gen.go
View file

@ -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

347
pkg/rest/oas_schemas_gen.go
View file

@ -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)

6
pkg/rest/oas_server_gen.go
View file

@ -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.

6
pkg/rest/oas_unimplemented_gen.go
View file

@ -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
}

535
pkg/rest/oas_uri_gen.go
View file

@ -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
}

178
pkg/rest/oas_validators_gen.go
View file

@ -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