2230 lines
53 KiB
Go
2230 lines
53 KiB
Go
// Code generated by ogen, DO NOT EDIT.
|
|
|
|
package gen
|
|
|
|
import (
|
|
"net/http"
|
|
|
|
"github.com/go-faster/errors"
|
|
"github.com/go-faster/jx"
|
|
"go.opentelemetry.io/otel/codes"
|
|
"go.opentelemetry.io/otel/trace"
|
|
)
|
|
|
|
func encodeDealsDealIDGetResponse(response DealsDealIDGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *SafeDeal:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *NotFound:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(404)
|
|
span.SetStatus(codes.Error, http.StatusText(404))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *DealsDealIDGetTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *DealsDealIDGetInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeDealsGetResponse(response DealsGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *DealsGetOK:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *NotFound:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(404)
|
|
span.SetStatus(codes.Error, http.StatusText(404))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *DealsGetTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *DealsGetInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeDealsPostResponse(response DealsPostRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *SafeDeal:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *DealsPostTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *DealsPostInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeMeGetResponse(response MeGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Me:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePaymentMethodsPaymentMethodIDGetResponse(response PaymentMethodsPaymentMethodIDGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *PaymentMethodsPaymentMethodIDGetOK:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *NotFound:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(404)
|
|
span.SetStatus(codes.Error, http.StatusText(404))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PaymentMethodsPaymentMethodIDGetTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PaymentMethodsPaymentMethodIDGetInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePaymentMethodsPostResponse(response PaymentMethodsPostRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *PaymentMethodsPostOK:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PaymentMethodsPostTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PaymentMethodsPostInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePaymentsGetResponse(response PaymentsGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *PaymentList:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePaymentsPaymentIDCancelPostResponse(response PaymentsPaymentIDCancelPostRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Payment:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePaymentsPaymentIDCapturePostResponse(response PaymentsPaymentIDCapturePostRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Payment:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePaymentsPaymentIDGetResponse(response PaymentsPaymentIDGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Payment:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *NotFound:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(404)
|
|
span.SetStatus(codes.Error, http.StatusText(404))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePaymentsPostResponse(response PaymentsPostRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Payment:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePayoutsGetResponse(response PayoutsGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *PayoutsList:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *NotFound:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(404)
|
|
span.SetStatus(codes.Error, http.StatusText(404))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PayoutsGetTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PayoutsGetInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePayoutsPayoutIDGetResponse(response PayoutsPayoutIDGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Payout:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *NotFound:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(404)
|
|
span.SetStatus(codes.Error, http.StatusText(404))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PayoutsPayoutIDGetTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PayoutsPayoutIDGetInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePayoutsPostResponse(response PayoutsPostRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Payout:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PayoutsPostTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PayoutsPostInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePayoutsSearchGetResponse(response PayoutsSearchGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *PayoutsList:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *NotFound:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(404)
|
|
span.SetStatus(codes.Error, http.StatusText(404))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PayoutsSearchGetTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PayoutsSearchGetInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePersonalDataPersonalDataIDGetResponse(response PersonalDataPersonalDataIDGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *PersonalData:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *NotFound:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(404)
|
|
span.SetStatus(codes.Error, http.StatusText(404))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PersonalDataPersonalDataIDGetTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PersonalDataPersonalDataIDGetInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodePersonalDataPostResponse(response PersonalDataPostRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *PersonalData:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PersonalDataPostTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *PersonalDataPostInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeReceiptsGetResponse(response ReceiptsGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *ReceiptsGetOK:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeReceiptsPostResponse(response ReceiptsPostRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Receipt:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeReceiptsReceiptIDGetResponse(response ReceiptsReceiptIDGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Receipt:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeRefundsGetResponse(response RefundsGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *RefundList:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeRefundsPostResponse(response RefundsPostRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Refund:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeRefundsRefundIDGetResponse(response RefundsRefundIDGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Refund:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *NotFound:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(404)
|
|
span.SetStatus(codes.Error, http.StatusText(404))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeSbpBanksGetResponse(response SbpBanksGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *SbpBanksGetOK:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *NotFound:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(404)
|
|
span.SetStatus(codes.Error, http.StatusText(404))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *SbpBanksGetTooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(429)
|
|
span.SetStatus(codes.Error, http.StatusText(429))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *SbpBanksGetInternalServerError:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeWebhooksGetResponse(response WebhooksGetRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *WebhookList:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeWebhooksPostResponse(response WebhooksPostRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *Webhook:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|
|
|
|
func encodeWebhooksWebhookIDDeleteResponse(response WebhooksWebhookIDDeleteRes, w http.ResponseWriter, span trace.Span) error {
|
|
switch response := response.(type) {
|
|
case *WebhooksWebhookIDDeleteOK:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(200)
|
|
span.SetStatus(codes.Ok, http.StatusText(200))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *BadRequest:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(400)
|
|
span.SetStatus(codes.Error, http.StatusText(400))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *InvalidCredentials:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(401)
|
|
span.SetStatus(codes.Error, http.StatusText(401))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *Forbidden:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(403)
|
|
span.SetStatus(codes.Error, http.StatusText(403))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
case *TooManyRequests:
|
|
w.Header().Set("Content-Type", "application/json; charset=utf-8")
|
|
w.WriteHeader(500)
|
|
span.SetStatus(codes.Error, http.StatusText(500))
|
|
|
|
e := new(jx.Encoder)
|
|
response.Encode(e)
|
|
if _, err := e.WriteTo(w); err != nil {
|
|
return errors.Wrap(err, "write")
|
|
}
|
|
|
|
return nil
|
|
|
|
default:
|
|
return errors.Errorf("unexpected response type: %T", response)
|
|
}
|
|
}
|