Revision control
Copy as Markdown
/*
* Operation Parameters Test
*
* This specification is intended for testing purposes. It demonstrates a wide range of combinations of the `style` and `explode` attributes for parameters in various locations: query, path, header, and cookie. The goal is to verify correct path and parameter generation for each case.
*
* API version: 1.0.0
*/
package openapi
import (
"fmt"
"math"
"net/http"
"net/url"
"strconv"
"strings"
"github.com/gin-gonic/gin"
)
type TestAPI struct {
}
// Post /v2/query/anytype/deepObject-explode/deepObjectExplodeAnytype
// deepObject style with explode=true for query Anytype parameter.
func (api *TestAPI) DeepObjectExplodeAnytype(c *gin.Context) {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/cookie/anytype/form-explode/cookieExplodeAnytype
// form anytype explode
func (api *TestAPI) CookieExplodeAnytype(c *gin.Context) {
_, err := c.Request.Cookie("anytypeParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/array/form-explode/cookieExplodeArray
// form array explode
func (api *TestAPI) CookieExplodeArray(c *gin.Context) {
_, err := c.Request.Cookie("arrayParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/int/form-explode/cookieExplodeInt
// Form style with explode set to true for integer query parameter.
func (api *TestAPI) CookieExplodeInt(c *gin.Context) {
_, err := c.Request.Cookie("intParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/object/form-explode/cookieExplodeObject
// form object explode
func (api *TestAPI) CookieExplodeObject(c *gin.Context) {
_, err := c.Request.Cookie("objectParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/string/form-explode/cookieExplodeString/:pathParam
// form style with explode set to true for string query parameter.
func (api *TestAPI) CookieExplodeString(c *gin.Context) {
_, err := c.Request.Cookie("stringParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/map/string-mapping/form-explode/cookieExplodeMap
// Form style with explode=true for query map parameter of string values.
func (api *TestAPI) CookieExplodeStringMap(c *gin.Context) {
_, err := c.Request.Cookie("mapParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/anytype/form-not-explode/cookieNotExplodeAnytype
// form anytype not explode
func (api *TestAPI) CookieNotExplodeAnytype(c *gin.Context) {
_, err := c.Request.Cookie("anytypeParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/array/form-not-explode/cookieNotExplodeArray
// form array not explode
func (api *TestAPI) CookieNotExplodeArray(c *gin.Context) {
_, err := c.Request.Cookie("arrayParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/int/form-not-explode/cookieNotExplodeInt
// Form style with explode set to false for integer query parameter.
func (api *TestAPI) CookieNotExplodeInt(c *gin.Context) {
_, err := c.Request.Cookie("intParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/object/form-not-explode/cookieNotExplodeObject
// form object not explode
func (api *TestAPI) CookieNotExplodeObject(c *gin.Context) {
_, err := c.Request.Cookie("objectParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/string/form-not-explode/cookieNotExplodeString/:pathParam
// form style with explode set to false for string query parameter.
func (api *TestAPI) CookieNotExplodeString(c *gin.Context) {
_, err := c.Request.Cookie("stringParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/string/invalid-simple-not-explode/cookieNotExplodeStringInvalidStyle
// simple style with explode set to false - fallback to form.
func (api *TestAPI) CookieNotExplodeStringInvalidStyle(c *gin.Context) {
_, err := c.Request.Cookie("stringParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/map/string-mapping/form-not-explode/cookieNotExplodeMap
// Form style with explode=false for query map parameter of string values.
func (api *TestAPI) CookieNotExplodeStringMap(c *gin.Context) {
_, err := c.Request.Cookie("mapParameter")
if err != nil {
c.JSON(200, gin.H{"header": c.Request.Header, "error": err.Error()})
} else {
c.JSON(200, gin.H{"header": c.Request.Header})
}
}
// Post /v2/cookie/several-cookies/form-explode/severalExplodeCookies
func (api *TestAPI) SeveralExplodeCookies(c *gin.Context) {
cookie1, err1 := c.Request.Cookie("mapParameter")
cookie2, err2 := c.Request.Cookie("intParameter")
if err1 != nil && err2 != nil {
c.JSON(400, gin.H{"status": "No-cookies"})
} else if err1 != nil {
c.JSON(200, gin.H{"cookie1": "", "cookie2": cookie2.Value, "size": len(c.Request.Cookies())})
} else if err2 != nil {
c.JSON(200, gin.H{"cookie1": cookie1.Value, "cookie2": "", "size": len(c.Request.Cookies())})
} else {
c.JSON(200, gin.H{"cookie1": cookie1.Value, "cookie2": cookie2.Value, "size": len(c.Request.Cookies())})
}
}
// Post /v2/cookie/several-cookies/form-not-explode/severalNotExplodeCookies
func (api *TestAPI) SeveralNotExplodeCookies(c *gin.Context) {
cookie1, err1 := c.Request.Cookie("mapParameter")
cookie2, err2 := c.Request.Cookie("intParameter")
if err1 != nil || err2 != nil {
c.JSON(400, gin.H{"status": "No-cookies"})
} else {
c.JSON(200, gin.H{"cookie1": cookie1.Value, "cookie2": cookie2.Value, "size": len(c.Request.Cookies())})
}
}
// Post /v2/query/map/model-mapping/deepObject-explode/deepObjectExplodeMap
// deepObject style with explode=true for query map parameter of model values.
func (api *TestAPI) DeepObjectExplodeModelMap(c *gin.Context) {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/object/deepObject-explode/deepObjectExplodeObject
// deepObject object explode
func (api *TestAPI) DeepObjectExplodeObject(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil || m.Get("objectParameter[name]") == "" || m.Get("objectParameter[status]") == "" {
fmt.Println(" ====== QUERY ====== deepObject object explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
}
// Post /v2/query/map/string-mapping/deepObject-explode/deepObjectExplodeMap
// deepObject style with explode=true for query map parameter of string values.
func (api *TestAPI) DeepObjectExplodeStringMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/object/deepObject-not-explode/deepObjectNotExplodeObject
// deepObject object not explode
func (api *TestAPI) DeepObjectNotExplodeObject(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil || m.Get("objectParameter[name]") == "" || m.Get("objectParameter[status]") == "" {
fmt.Println(" ====== QUERY ====== deepObject object explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
}
// Post /v2/query/anytype/form-explode/formExplodeAnytype
// form anytype explode
func (api *TestAPI) FormExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/array/form-explode/formExplodeArray
// form array explode
func (api *TestAPI) FormExplodeArray(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil || m.Get("arrayParameter") == "" {
fmt.Println(" ====== QUERY ====== form array explode URI error:", err, m)
}
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/strings/form-explode/formExplodeDifferentOptions
// style-form, explode=true
func (api *TestAPI) FormExplodeDifferentOptions(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil {
fmt.Println(" ====== formExplodeDifferentOptions ====== query parsing error:", err, m)
}
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/query/double/form-explode/formExplodeDouble
// Form style with explode set to true for double query parameter.
func (api *TestAPI) FormExplodeDouble(c *gin.Context) {
doubleParam := c.Query("doubleParameter")
if doubleParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing doubleParameter"})
return
}
f64, err := strconv.ParseFloat(doubleParam, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid doubleParameter"})
return
}
resp := DoubleResponse{
StringValue: c.Request.RequestURI,
Value: f64,
}
c.JSON(http.StatusOK, resp)
}
// Post /v2/query/float/form-explode/formExplodeFloat
// Form style with explode set to true for float query parameter.
func (api *TestAPI) FormExplodeFloat(c *gin.Context) {
floatParam := c.Query("floatParameter")
if floatParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing floatParameter"})
return
}
f64, err := strconv.ParseFloat(floatParam, 32)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid floatParameter"})
return
}
f32 := float32(f64)
// JSON does not support Inf and NaN values. Therefore, we cannot return these
// values as FloatResponse.Value. Instead, set the FloatResponse value to 0.
// We anyway do not need to compare them with the expected value.
// The RequestURI is enough for tests.
if math.IsNaN(f64) || math.IsInf(f64, 0) {
f32 = 0.0
}
resp := FloatResponse{
StringValue: c.Request.RequestURI,
Value: f32,
}
c.JSON(http.StatusOK, resp)
}
// Post /v2/query/int/form-explode/formExplodeInt
// Form style with explode set to true for integer query parameter.
func (api *TestAPI) FormExplodeInt(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/map/model-mapping/form-explode/formExplodeMap
// Form style with explode=true for query map parameter of model values.
func (api *TestAPI) FormExplodeModelMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/object/form-explode/formExplodeObject
// form object explode
func (api *TestAPI) FormExplodeObject(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil || m.Get("name") == "" {
fmt.Println(" ====== QUERY ====== form object explode URI error:", err, m)
}
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/path/string/form-explode/formExplodeString
// form style with explode set to true for string query parameter.
func (api *TestAPI) FormExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/strings/form-explode/formExplodeStringOptions
// style-form, explode=true
func (api *TestAPI) FormExplodeStringOptions(c *gin.Context) {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/map/string-mapping/form-explode/formExplodeMap
// Form style with explode=true for query map parameter of string values.
func (api *TestAPI) FormExplodeStringMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/anytype/form-not-explode/formNotExplodeAnytype
// form anytype not explode
func (api *TestAPI) FormNotExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/array/form-not-explode/formNotExplodeArray
// form array not explode
func (api *TestAPI) FormNotExplodeArray(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil || m.Get("arrayParameter") == "" {
fmt.Println(" ====== QUERY ====== form array not explode URI error:", err, m)
}
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/double/form-not-explode/formNotExplodeDouble
// Form style with explode set to false for double query parameter.
func (api *TestAPI) FormNotExplodeDouble(c *gin.Context) {
doubleParam := c.Query("doubleParameter")
if doubleParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing doubleParameter"})
return
}
f64, err := strconv.ParseFloat(doubleParam, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid doubleParameter"})
return
}
resp := DoubleResponse{
StringValue: c.Request.RequestURI,
Value: f64,
}
c.JSON(http.StatusOK, resp)
}
// Post /v2/query/float/form-not-explode/formNotExplodeFloat
// Form style with explode set to false for float query parameter.
func (api *TestAPI) FormNotExplodeFloat(c *gin.Context) {
floatParam := c.Query("floatParameter")
if floatParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing floatParameter"})
return
}
f64, err := strconv.ParseFloat(floatParam, 32)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid floatParameter"})
return
}
f32 := float32(f64)
// JSON does not support Inf and NaN values. Therefore, we cannot return these
// values as FloatResponse.Value. Instead, set the FloatResponse value to 0.
// We anyway do not need to compare them with the expected value.
// The RequestURI is enough for tests.
if math.IsNaN(f64) || math.IsInf(f64, 0) {
f32 = 0.0
}
resp := FloatResponse{
StringValue: c.Request.RequestURI,
Value: f32,
}
c.JSON(http.StatusOK, resp)
}
// Post /v2/query/int/form-not-explode/formNotExplodeInt
// Form style with explode set to false for integer query parameter.
func (api *TestAPI) FormNotExplodeInt(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/map/model-mapping/form-not-explode/formNotExplodeMap
// Form style with explode=false for query map parameter of model values.
func (api *TestAPI) FormNotExplodeModelMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/object/form-not-explode/formNotExplodeObject
// form object not explode
func (api *TestAPI) FormNotExplodeObject(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil || m.Get("objectParameter") == "" {
fmt.Println(" ====== QUERY ====== form object not explode URI error:", err, m)
}
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/string/form-not-explode/formNotExplodeString
// form style with explode set to false for string query parameter.
func (api *TestAPI) FormNotExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/map/string-mapping/form-not-explode/formNotExplodeMap
// Form style with explode=false for query map parameter of string values.
func (api *TestAPI) FormNotExplodeStringMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/array/invalid-deepObject-not-explode/deepObjectNotExplodeArray
// invalid deepObject style with explode=false for query array parameter
func (api *TestAPI) InvalidDeepObjectNotExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/string/invalid-deepObject-not-explode/deepObjectNotExplodeString
// invalid deepObject style with explode=false for query string parameter
func (api *TestAPI) InvalidDeepObjectNotExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/path/string/invalid-form-explode/formExplodeString/:stringParameter
// invalid form style for path string parameter with explode=true
func (api *TestAPI) InvalidFormExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/query/string/invalid-matrix-explode/matrixExplodeString
// invalid matrix style for query string parameter with explode=true
func (api *TestAPI) InvalidMatrixExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/path/string/invalid-form-explode/:stringParameter/query/array/invalid-label-explode
// invalid form style for path string parameter and invalid label style for query array parameter
func (api *TestAPI) InvalidStylesQueryPathParams(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/anytype/label-explode/:anytypeParameter
// label anytype explode
func (api *TestAPI) LabelExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/array/label-explode/:arrayParameter
// label array explode
func (api *TestAPI) LabelExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/double/label-explode/:doubleParameter
// Label style with explode set to true for double path parameter.
func (api *TestAPI) LabelExplodeDouble(c *gin.Context) {
doubleParam := c.Param("doubleParameter")
if doubleParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing doubleParameter"})
return
}
doubleParam = strings.TrimPrefix(doubleParam, ".")
f64, err := strconv.ParseFloat(doubleParam, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid doubleParameter"})
return
}
resp := DoubleResponse{
StringValue: c.Request.RequestURI,
Value: f64,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/float/label-explode/:floatParameter
// Label style with explode set to true for float path parameter.
func (api *TestAPI) LabelExplodeFloat(c *gin.Context) {
floatParam := c.Param("floatParameter")
if floatParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing floatParameter"})
return
}
floatParam = strings.TrimPrefix(floatParam, ".")
f64, err := strconv.ParseFloat(floatParam, 32)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid floatParameter"})
return
}
f32 := float32(f64)
// JSON does not support Inf and NaN values. Therefore, we cannot return these
// values as FloatResponse.Value. Instead, set the FloatResponse value to 0.
// We anyway do not need to compare them with the expected value.
// The RequestURI is enough for tests.
if math.IsNaN(f64) || math.IsInf(f64, 0) {
f32 = 0.0
}
resp := FloatResponse{
StringValue: c.Request.RequestURI,
Value: f32,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/int/label-explode/:intParameter
// Label style with explode set to true for integer path parameter.
func (api *TestAPI) LabelExplodeInt(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/model-mapping/label-explode/:mapParameter
// label style with explode=true for path map parameter of model values.
func (api *TestAPI) LabelExplodeModelMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Get /v2/path/object/label-explode/:objectParameter
// label object explode
func (api *TestAPI) LabelExplodeObject(c *gin.Context) {
m, err := url.ParseRequestURI(c.Request.URL.Path)
if err != nil {
fmt.Println(" ====== PATH ====== label object explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.URL.Path})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
}
// Get /v2/path/string/label-explode/:stringParameter
// label style with explode set to true for string path parameter.
func (api *TestAPI) LabelExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/string-mapping/label-explode/:mapParameter
// label style with explode=true for path map parameter of string values.
func (api *TestAPI) LabelExplodeStringMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/anytype/label-not-explode/:anytypeParameter
// label anytype not explode
func (api *TestAPI) LabelNotExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/array/label-not-explode/:arrayParameter
// label array not explode
func (api *TestAPI) LabelNotExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/double/label-not-explode/:doubleParameter
// Label style with explode set to false for double path parameter.
func (api *TestAPI) LabelNotExplodeDouble(c *gin.Context) {
doubleParam := c.Param("doubleParameter")
if doubleParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing doubleParameter"})
return
}
doubleParam = strings.TrimPrefix(doubleParam, ".")
f64, err := strconv.ParseFloat(doubleParam, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid doubleParameter"})
return
}
resp := DoubleResponse{
StringValue: c.Request.RequestURI,
Value: f64,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/float/label-not-explode/:floatParameter
// Label style with explode set to false for float path parameter.
func (api *TestAPI) LabelNotExplodeFloat(c *gin.Context) {
floatParam := c.Param("floatParameter")
if floatParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing floatParameter"})
return
}
floatParam = strings.TrimPrefix(floatParam, ".")
f64, err := strconv.ParseFloat(floatParam, 32)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid floatParameter"})
return
}
f32 := float32(f64)
// JSON does not support Inf and NaN values. Therefore, we cannot return these
// values as FloatResponse.Value. Instead, set the FloatResponse value to 0.
// We anyway do not need to compare them with the expected value.
// The RequestURI is enough for tests.
if math.IsNaN(f64) || math.IsInf(f64, 0) {
f32 = 0.0
}
resp := FloatResponse{
StringValue: c.Request.RequestURI,
Value: f32,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/int/label-not-explode/:intParameter
// Label style with explode set to false for integer path parameter.
func (api *TestAPI) LabelNotExplodeInt(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/model-mapping/label-not-explode/:mapParameter
// label style with explode=false for path map parameter of model values.
func (api *TestAPI) LabelNotExplodeModelMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/path/object/label-not-explode/:objectParameter
// label object not explode
func (api *TestAPI) LabelNotExplodeObject(c *gin.Context) {
m, err := url.ParseRequestURI(c.Request.URL.Path)
if err != nil {
fmt.Println(" ====== PATH ====== label object not explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.URL.Path})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
}
// Get /v2/path/string/label-not-explode/:stringParameter
// label style with explode set to false for string path parameter.
func (api *TestAPI) LabelNotExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/string-mapping/label-not-explode/:mapParameter
// label style with explode=false for path map parameter of string values.
func (api *TestAPI) LabelNotExplodeStringMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/string/label-not-explode/array/matrix-not-explode/:stringParameter/:arrayParameter
// label style with explode set to false for string path parameter and matrix style with explode set to false for array path parameter.
func (api *TestAPI) LabelStringMatrixArrayNotExplode(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/anytype/matrix-explode/:anytypeParameter
// matrix anytype explode
func (api *TestAPI) MatrixExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/array/matrix-explode/:arrayParameter
// matrix array explode
func (api *TestAPI) MatrixExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/double/matrix-explode/:doubleParameter
// Matrix style with explode set to true for double path parameter.
func (api *TestAPI) MatrixExplodeDouble(c *gin.Context) {
doubleParam := c.Param("doubleParameter")
if doubleParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing doubleParameter"})
return
}
doubleParam = strings.TrimPrefix(doubleParam, ";doubleParameter=")
f64, err := strconv.ParseFloat(doubleParam, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid doubleParameter"})
return
}
resp := DoubleResponse{
StringValue: c.Request.RequestURI,
Value: f64,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/float/matrix-explode/:floatParameter
// Matrix style with explode set to true for float path parameter.
func (api *TestAPI) MatrixExplodeFloat(c *gin.Context) {
floatParam := c.Param("floatParameter")
if floatParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing floatParameter"})
return
}
floatParam = strings.TrimPrefix(floatParam, ";floatParameter=")
f64, err := strconv.ParseFloat(floatParam, 32)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid floatParameter"})
return
}
f32 := float32(f64)
// JSON does not support Inf and NaN values. Therefore, we cannot return these
// values as FloatResponse.Value. Instead, set the FloatResponse value to 0.
// We anyway do not need to compare them with the expected value.
// The RequestURI is enough for tests.
if math.IsNaN(f64) || math.IsInf(f64, 0) {
f32 = 0.0
}
resp := FloatResponse{
StringValue: c.Request.RequestURI,
Value: f32,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/int/matrix-explode/:intParameter
// Matrix style with explode set to true for integer path parameter.
func (api *TestAPI) MatrixExplodeInt(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/model-mapping/matrix-explode/:mapParameter
// matrix style with explode=true for path map parameter of model values.
func (api *TestAPI) MatrixExplodeModelMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Get /v2/path/object/matrix-explode/:objectParameter
// matrix object explode
func (api *TestAPI) MatrixExplodeObject(c *gin.Context) {
m, err := url.ParseRequestURI(c.Request.URL.Path)
if err != nil {
fmt.Println(" ====== PATH ====== object explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.URL.Path})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
}
// Get /v2/path/string/matrix-explode/:stringParameter
// matrix style with explode set to true for string path parameter.
func (api *TestAPI) MatrixExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/string-mapping/matrix-explode/:mapParameter
// matrix style with explode=true for path map parameter of string values.
func (api *TestAPI) MatrixExplodeStringMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/anytype/matrix-not-explode/:anytypeParameter
// matrix anytype not explode
func (api *TestAPI) MatrixNotExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/array/matrix-not-explode/:arrayParameter
// matrix array not explode
func (api *TestAPI) MatrixNotExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/double/matrix-not-explode/:doubleParameter
// Matrix style with explode set to false for double path parameter.
func (api *TestAPI) MatrixNotExplodeDouble(c *gin.Context) {
doubleParam := c.Param("doubleParameter")
if doubleParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing doubleParameter"})
return
}
doubleParam = strings.TrimPrefix(doubleParam, ";doubleParameter=")
f64, err := strconv.ParseFloat(doubleParam, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid doubleParameter"})
return
}
resp := DoubleResponse{
StringValue: c.Request.RequestURI,
Value: f64,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/float/matrix-not-explode/:floatParameter
// Matrix style with explode set to false for float path parameter.
func (api *TestAPI) MatrixNotExplodeFloat(c *gin.Context) {
floatParam := c.Param("floatParameter")
if floatParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing floatParameter"})
return
}
floatParam = strings.TrimPrefix(floatParam, ";floatParameter=")
f64, err := strconv.ParseFloat(floatParam, 32)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid floatParameter"})
return
}
f32 := float32(f64)
// JSON does not support Inf and NaN values. Therefore, we cannot return these
// values as FloatResponse.Value. Instead, set the FloatResponse value to 0.
// We anyway do not need to compare them with the expected value.
// The RequestURI is enough for tests.
if math.IsNaN(f64) || math.IsInf(f64, 0) {
f32 = 0.0
}
resp := FloatResponse{
StringValue: c.Request.RequestURI,
Value: f32,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/int/matrix-not-explode/:intParameter
// Matrix style with explode set to false for integer path parameter.
func (api *TestAPI) MatrixNotExplodeInt(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/model-mapping/matrix-not-explode/:mapParameter
// matrix style with explode=false for path map parameter of model values.
func (api *TestAPI) MatrixNotExplodeModelMap(c *gin.Context) {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Get /v2/path/object/matrix-not-explode/:objectParameter
// matrix object not explode
func (api *TestAPI) MatrixNotExplodeObject(c *gin.Context) {
m, err := url.ParseRequestURI(c.Request.URL.Path)
if err != nil {
fmt.Println(" ====== PATH ====== matrix object not explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.URL.Path})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
}
// Get /v2/path/string/matrix-not-explode/:stringParameter
// matrix style with explode set to false for string path parameter.
func (api *TestAPI) MatrixNotExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/string-mapping/matrix-not-explode/:mapParameter
// matrix style with explode=false for path map parameter of string values.
func (api *TestAPI) MatrixNotExplodeStringMap(c *gin.Context) {
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/query/anytype/pipeDelimited-explode/pipeDelimitedExplodeAnytype
// pipeDelimited anytype explode
func (api *TestAPI) PipeDelimitedExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/query/array/pipeDelimited-explode/pipeDelimitedExplodeArray
// pipeDelimited array explode
func (api *TestAPI) PipeDelimitedExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/object/pipeDelimited-explode/pipeDelimitedExplodeObject
// pipeDelimited object explode
func (api *TestAPI) PipeDelimitedExplodeObject(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil || m.Get("objectParameter") == "" {
fmt.Println(" ====== QUERY ====== pipeDelimited object explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
}
// Post /v2/query/anytype/pipeDelimited-not-explode/pipeDelimitedNotExplodeAnytype
// pipeDelimited anytype not explode
func (api *TestAPI) PipeDelimitedNotExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/array/pipeDelimited-not-explode/pipeDelimitedNotExplodeArray
// pipeDelimited array not explode
func (api *TestAPI) PipeDelimitedNotExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/map/model-mapping/pipeDelimited-not-explode/pipeDelimitedNotExplodeMap
// pipeDelimited style with explode=false for query map parameter of model values.
func (api *TestAPI) PipeDelimitedNotExplodeModelMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/object/pipeDelimited-not-explode/pipeDelimitedNotExplodeObject
// pipeDelimited object not explode
func (api *TestAPI) PipeDelimitedNotExplodeObject(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil || m.Get("objectParameter") == "" {
fmt.Println(" ====== QUERY ====== pipeDelimited object not explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
}
// Post /v2/query/map/string-mapping/pipeDelimited-not-explode/pipeDelimitedNotExplodeMap
// pipeDelimited style with explode=false for query map parameter of string values.
func (api *TestAPI) PipeDelimitedNotExplodeStringMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/path/string/matrix-explode/:stringParameter/query/array/spaceDelimited-not-explode
// matrix style for path string parameter with explode=true and spaceDelimited style for query array parameter with explode=false
func (api *TestAPI) QueryAndPathParams(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/anytype/simple-explode/:anytypeParameter
// simple anytype explode
func (api *TestAPI) SimpleExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/array/simple-explode/:arrayParameter
// simple array explode
func (api *TestAPI) SimpleExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/double/simple-explode/:doubleParameter
// Simple style with explode set to true for double path parameter.
func (api *TestAPI) SimpleExplodeDouble(c *gin.Context) {
doubleParam := c.Param("doubleParameter")
if doubleParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing doubleParameter"})
return
}
f64, err := strconv.ParseFloat(doubleParam, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid doubleParameter"})
return
}
resp := DoubleResponse{
StringValue: c.Request.RequestURI,
Value: f64,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/float/simple-explode/:floatParameter
// Simple style with explode set to true for float path parameter.
func (api *TestAPI) SimpleExplodeFloat(c *gin.Context) {
floatParam := c.Param("floatParameter")
if floatParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing floatParameter"})
return
}
f64, err := strconv.ParseFloat(floatParam, 32)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid floatParameter"})
return
}
f32 := float32(f64)
// JSON does not support Inf and NaN values. Therefore, we cannot return these
// values as FloatResponse.Value. Instead, set the FloatResponse value to 0.
// We anyway do not need to compare them with the expected value.
// The RequestURI is enough for tests.
if math.IsNaN(f64) || math.IsInf(f64, 0) {
f32 = 0.0
}
resp := FloatResponse{
StringValue: c.Request.RequestURI,
Value: f32,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/int/simple-explode/:intParameter
// Simple style with explode set to true for integer path parameter.
func (api *TestAPI) SimpleExplodeInt(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/model-mapping/simple-explode/:mapParameter
// simple style with explode=true for path map parameter of model values.
func (api *TestAPI) SimpleExplodeModelMap(c *gin.Context) {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Get /v2/path/object/simple-explode/:objectParameter
// simple object explode
func (api *TestAPI) SimpleExplodeObject(c *gin.Context) {
m, err := url.ParseRequestURI(c.Request.URL.Path)
if err != nil {
fmt.Println(" ====== PATH ====== simple object explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.URL.Path})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
}
// Get /v2/path/string/simple-explode/:stringParameter
// Simple style with explode set to true for string path parameter.
func (api *TestAPI) SimpleExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/string-mapping/simple-explode/:mapParameter
// simple style with explode=true for path map parameter of string values.
func (api *TestAPI) SimpleExplodeStringMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/strings/simple-explode/:stringParameter1/:stringParameter2
// Simple style with explode set to true for two string path parameters.
func (api *TestAPI) SimpleExplodeStrings(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/anytype/simple-not-explode/:anytypeParameter
// simple anytype not explode
func (api *TestAPI) SimpleNotExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/array/simple-not-explode/:arrayParameter
// simple array not explode
func (api *TestAPI) SimpleNotExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Get /v2/path/double/simple-not-explode/:doubleParameter
// Simple style with explode set to false for double path parameter.
func (api *TestAPI) SimpleNotExplodeDouble(c *gin.Context) {
doubleParam := c.Param("doubleParameter")
if doubleParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing doubleParameter"})
return
}
f64, err := strconv.ParseFloat(doubleParam, 64)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid doubleParameter"})
return
}
resp := DoubleResponse{
StringValue: c.Request.RequestURI,
Value: f64,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/float/simple-not-explode/:floatParameter
// Simple style with explode set to false for float path parameter.
func (api *TestAPI) SimpleNotExplodeFloat(c *gin.Context) {
floatParam := c.Param("floatParameter")
if floatParam == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "missing floatParameter"})
return
}
f64, err := strconv.ParseFloat(floatParam, 32)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid floatParameter"})
return
}
f32 := float32(f64)
// JSON does not support Inf and NaN values. Therefore, we cannot return these
// values as FloatResponse.Value. Instead, set the FloatResponse value to 0.
// We anyway do not need to compare them with the expected value.
// The RequestURI is enough for tests.
if math.IsNaN(f64) || math.IsInf(f64, 0) {
f32 = 0.0
}
resp := FloatResponse{
StringValue: c.Request.RequestURI,
Value: f32,
}
c.JSON(http.StatusOK, resp)
}
// Get /v2/path/int/simple-not-explode/:intParameter
// Simple style with explode set to false for string path parameter.
func (api *TestAPI) SimpleNotExplodeInt(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/model-mapping/simple-not-explode/:mapParameter
// simple style with explode=false for path map parameter of model values.
func (api *TestAPI) SimpleNotExplodeModelMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Get /v2/path/object/simple-not-explode/:objectParameter
// simple object not explode
func (api *TestAPI) SimpleNotExplodeObject(c *gin.Context) {
m, err := url.ParseRequestURI(c.Request.URL.Path)
if err != nil {
fmt.Println(" ====== PATH ====== simple object not explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.URL.Path})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
}
// Get /v2/path/string/simple-not-explode/:stringParameter
// Simple style with explode set to false for string path parameter.
func (api *TestAPI) SimpleNotExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/path/map/string-mapping/simple-not-explode/:mapParameter
// simple style with explode=false for path map parameter of string values.
func (api *TestAPI) SimpleNotExplodeStringMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/query/anytype/spaceDelimited-explode/spaceDelimitedExplodeAnytype
// spaceDelimited anytype explode
func (api *TestAPI) SpaceDelimitedExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI})
}
// Post /v2/query/array/spaceDelimited-explode/spaceDelimitedExplodeArray
// spaceDelimited array explode
func (api *TestAPI) SpaceDelimitedExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/object/spaceDelimited-explode/spaceDelimitedExplodeObject
// spaceDelimited object explode
func (api *TestAPI) SpaceDelimitedExplodeObject(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil || m.Get("objectParameter") == "" {
fmt.Println(" ====== QUERY ====== spaceDelimited object explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
}
// Post /v2/query/anytype/spaceDelimited-not-explode/spaceDelimitedNotExplodeAnytype
// spaceDelimited anytype not explode
func (api *TestAPI) SpaceDelimitedNotExplodeAnytype(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/array/spaceDelimited-not-explode/spaceDelimitedNotExplodeArray
// spaceDelimited array not explode
func (api *TestAPI) SpaceDelimitedNotExplodeArray(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/map/model-mapping/spaceDelimited-not-explode/spaceDelimitedNotExplodeMap
// spaceDelimited style with explode=false for query map parameter of model values.
func (api *TestAPI) SpaceDelimitedNotExplodeModelMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/object/spaceDelimited-not-explode/spaceDelimitedNotExplodeObject
// spaceDelimited object not explode
func (api *TestAPI) SpaceDelimitedNotExplodeObject(c *gin.Context) {
m, err := url.ParseQuery(c.Request.URL.RawQuery)
if err != nil || m.Get("objectParameter") == "" {
fmt.Println(" ====== QUERY ====== spaceDelimited object not explode URI error:", err, m)
c.JSON(400, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
} else {
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
}
// Post /v2/query/string/spaceDelimited-not-explode/spaceDelimitedNotExplodeString
// spaceDelimited style with explode=false for query string parameter.
func (api *TestAPI) SpaceDelimitedNotExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Post /v2/query/map/string-mapping/spaceDelimited-not-explode/spaceDelimitedNotExplodeMap
// spaceDelimited style with explode=false for query map parameter of string values.
func (api *TestAPI) SpaceDelimitedNotExplodeStringMap(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"status": c.Request.RequestURI, "header": c.Request.Header})
}
// Get /v2/header/anytype/simple-explode/anytypeParameter
// simple anytype explode
func (api *TestAPI) HeaderSimpleExplodeAnytype(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Get /v2/header/array/simple-explode/arrayParameter
// simple array explode
func (api *TestAPI) HeaderSimpleExplodeArray(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Get /v2/header/object/simple-explode/objectParameter
// simple object explode
func (api *TestAPI) HeaderSimpleExplodeObject(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Get /v2/header/string/simple-explode/stringParameter
// Simple style with explode true.
func (api *TestAPI) HeaderSimpleExplodeString(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Get /v2/header/anytype/simple-not-explode/anytypeParameter
// simple anytype not explode
func (api *TestAPI) HeaderSimpleNotExplodeAnytype(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Post /v2/header/array/simple-not-explode/arrayParameter
// simple array not explode
func (api *TestAPI) HeaderSimpleNotExplodeArray(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Post /v2/header/object/simple-not-explode/objectParameter
// simple object not explode
func (api *TestAPI) HeaderSimpleNotExplodeObject(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Get /v2/header/string/simple-not-explode/stringParameter
// Simple style with explode false.
func (api *TestAPI) HeaderSimpleNotExplodeString(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Get /v2/header/string/invalid-label-not-explode/stringParameter
// Invalid label style with explode false, replaced to simple.
func (api *TestAPI) HeaderInvalidLabelNotExplodeString(c *gin.Context) {
// Your handler implementation
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Post /v2/header/map/simple-explode/mapParameter
// simple map explode
func (api *TestAPI) HeaderSimpleExplodeMap(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Get /v2/header/map/simple-not-explode/mapParameter
// simple map not explode
func (api *TestAPI) HeaderSimpleNotExplodeMap(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Get /v2/header/bad-header-name/simple-not-explode/operatoinParameter
// simple not explode
func (api *TestAPI) HeaderSimpleNotExplodeContentType(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Get /v2/header/string-custom-devided/simple-not-explode/stringParameter
// Simple style with explode false.
func (api *TestAPI) HeaderSimpleNotExplodeCustomDevidedString(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}
// Post /v2/header/several-headers/simple/severalHeaderParameters
func (api *TestAPI) SeveralHeaderParametersOp(c *gin.Context) {
c.JSON(200, gin.H{"header": c.Request.Header})
}