capifcore/internal/eventsapi/eventsapi-server.gen.go

   1 // Package eventsapi provides primitives to interact with the openapi HTTP API.
   2 //
   3 // Code generated by github.com/deepmap/oapi-codegen version v1.10.1 DO NOT EDIT.
   4 package eventsapi
   5
   6 import (
   7         "bytes"
   8         "compress/gzip"
   9         "encoding/base64"
  10         "fmt"
  11         "net/http"
  12         "net/url"
  13         "path"
  14         "strings"
  15
  16         "github.com/deepmap/oapi-codegen/pkg/runtime"
  17         "github.com/getkin/kin-openapi/openapi3"
  18         "github.com/labstack/echo/v4"
  19         externalRef0 "oransc.org/nonrtric/capifcore/internal/accesscontrolpolicyapi"
  20         externalRef1 "oransc.org/nonrtric/capifcore/internal/common"
  21         externalRef2 "oransc.org/nonrtric/capifcore/internal/common29122"
  22         externalRef3 "oransc.org/nonrtric/capifcore/internal/common29571"
  23         externalRef4 "oransc.org/nonrtric/capifcore/internal/loggingapi"
  24         externalRef5 "oransc.org/nonrtric/capifcore/internal/publishserviceapi"
  25         externalRef6 "oransc.org/nonrtric/capifcore/internal/routinginfoapi"
  26 )
  27
  28 // ServerInterface represents all server handlers.
  29 type ServerInterface interface {
  30
  31         // (POST /{subscriberId}/subscriptions)
  32         PostSubscriberIdSubscriptions(ctx echo.Context, subscriberId string) error
  33
  34         // (DELETE /{subscriberId}/subscriptions/{subscriptionId})
  35         DeleteSubscriberIdSubscriptionsSubscriptionId(ctx echo.Context, subscriberId string, subscriptionId string) error
  36 }
  37
  38 // ServerInterfaceWrapper converts echo contexts to parameters.
  39 type ServerInterfaceWrapper struct {
  40         Handler ServerInterface
  41 }
  42
  43 // PostSubscriberIdSubscriptions converts echo context to params.
  44 func (w *ServerInterfaceWrapper) PostSubscriberIdSubscriptions(ctx echo.Context) error {
  45         var err error
  46         // ------------- Path parameter "subscriberId" -------------
  47         var subscriberId string
  48
  49         err = runtime.BindStyledParameterWithLocation("simple", false, "subscriberId", runtime.ParamLocationPath, ctx.Param("subscriberId"), &subscriberId)
  50         if err != nil {
  51                 return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subscriberId: %s", err))
  52         }
  53
  54         // Invoke the callback with all the unmarshalled arguments
  55         err = w.Handler.PostSubscriberIdSubscriptions(ctx, subscriberId)
  56         return err
  57 }
  58
  59 // DeleteSubscriberIdSubscriptionsSubscriptionId converts echo context to params.
  60 func (w *ServerInterfaceWrapper) DeleteSubscriberIdSubscriptionsSubscriptionId(ctx echo.Context) error {
  61         var err error
  62         // ------------- Path parameter "subscriberId" -------------
  63         var subscriberId string
  64
  65         err = runtime.BindStyledParameterWithLocation("simple", false, "subscriberId", runtime.ParamLocationPath, ctx.Param("subscriberId"), &subscriberId)
  66         if err != nil {
  67                 return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subscriberId: %s", err))
  68         }
  69
  70         // ------------- Path parameter "subscriptionId" -------------
  71         var subscriptionId string
  72
  73         err = runtime.BindStyledParameterWithLocation("simple", false, "subscriptionId", runtime.ParamLocationPath, ctx.Param("subscriptionId"), &subscriptionId)
  74         if err != nil {
  75                 return echo.NewHTTPError(http.StatusBadRequest, fmt.Sprintf("Invalid format for parameter subscriptionId: %s", err))
  76         }
  77
  78         // Invoke the callback with all the unmarshalled arguments
  79         err = w.Handler.DeleteSubscriberIdSubscriptionsSubscriptionId(ctx, subscriberId, subscriptionId)
  80         return err
  81 }
  82
  83 // This is a simple interface which specifies echo.Route addition functions which
  84 // are present on both echo.Echo and echo.Group, since we want to allow using
  85 // either of them for path registration
  86 type EchoRouter interface {
  87         CONNECT(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
  88         DELETE(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
  89         GET(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
  90         HEAD(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
  91         OPTIONS(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
  92         PATCH(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
  93         POST(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
  94         PUT(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
  95         TRACE(path string, h echo.HandlerFunc, m ...echo.MiddlewareFunc) *echo.Route
  96 }
  97
  98 // RegisterHandlers adds each server route to the EchoRouter.
  99 func RegisterHandlers(router EchoRouter, si ServerInterface) {
 100         RegisterHandlersWithBaseURL(router, si, "")
 101 }
 102
 103 // Registers handlers, and prepends BaseURL to the paths, so that the paths
 104 // can be served under a prefix.
 105 func RegisterHandlersWithBaseURL(router EchoRouter, si ServerInterface, baseURL string) {
 106
 107         wrapper := ServerInterfaceWrapper{
 108                 Handler: si,
 109         }
 110
 111         router.POST(baseURL+"/:subscriberId/subscriptions", wrapper.PostSubscriberIdSubscriptions)
 112         router.DELETE(baseURL+"/:subscriberId/subscriptions/:subscriptionId", wrapper.DeleteSubscriberIdSubscriptionsSubscriptionId)
 113
 114 }
 115
 116 // Base64 encoded, gzipped, json marshaled Swagger object
 117 var swaggerSpec = []string{
 118
 119         "H4sIAAAAAAAC/+xZ4Y7iOPJ/Fcv7/zAjZaFhpv+zzbcM0DPRoQYRek57sy1kkgp4J9hZ26GbayHdO9xT",
 120         "3Gvco9yTnGyHEEICdHMrre5mtdptOa5fVbmqflU2zzjgy4QzYErizjOWwQKWxPzpBgFI2eVMCR6PeEyD",
 121         "9YBK1X9S+iuJ42GEO1+f8f8JiHAHT/z2TbvdnnbdkXc7tcLTTHpqxafuyGusyTL+obnT2sxUNmv04Y3z",
 122         "jBPBExCKgrGMJNQL9R9qnQDuYKkEZXO82TjbFT77FQKFNw8ODkEGgiaKcoY7eAyJAKn1IrUABE8KmKSc",
 123         "oYgLRIwFKLAmoETbQEE2sIMF/JZSASHufM3UP2wcbHztr4CZI9nXNOJS0lkMaEXiFCQiAjq/sB+R3x9/",
 124         "8bp9fRZT94vrDdyPg34HGRSJBMREQYgUN/aRFaExmdGYqjXiEZIgVjQA5I48iUikQJht+8sCUJLOYioX",
 125         "EDbKKu/vTipN2WvVpuyI4lHPnVTqDBaEzQFRVgRElEVcLIk+TYOlMby7L8M/9cfT4d3HoTvu9XtVcFZ4",
 126         "xb+BQJzNOBGh/WCidYh1e3suWBRt0SLBlwW8op8at+tOvOHd1L/vdvu+X3fOMjX5FqWxUREYX8vHfQz/",
 127         "1vUG9+PaOEaExhCewnaNjdPu8G4yHg6mo+HA6/58JFomQ5KQKDA1Y7K0om7WB96eqfg1+XmBEYVMcO8n",
 128         "n4dj7y/2cMd9vdqrM0JA8VSNAalacEH/mi8WckdqsczCk3bYsz+ZjongEY23wajI8MlwNBwMP/08/ez1",
 129         "vLtP0+64X4erbQoEZKaLbYAzz7RWxRMe8/kaLWhI2bxYntttryOnKktffPb/YQv3eQw7GFi61NRfSd7Y",
 130         "wTUMW/5iAosdXMll5fWcl0oohwRTvyFjCA19pMzrP++5crJWSnuyPM5Wa7Kx5usW8cEpN/li1+2BIjQ+",
 131         "7L2FLk9sUSDQ+1FoBExHL40UQdBVQo8dZubo5GPNS0YVPRptHDsfyEOrvBCYohE1raSceNjBVMFSVow1",
 132         "Dl5S5tmPrfw8iBBkvVVnKeGI1h1PFijkIp0TnvDPNIRTZzXJyvKzqUotvGtIAz6vsnjXsGI+N8HKzawc",
 133         "Ngd8PqdsbpM/Fz4+bXpFI076mwXKHXm9nakVphe+VsQYEbkjPzRbZ/G4Pe3hyEpNfQt23DW/ytgTLh6O",
 134         "zsU6u6WxAvGCOouMQEWZQXRmaejjgqeES03lUcoCs/OiIvmvrsmqAJrY3XHtn0314xFkiLKQrmiYkjiL",
 135         "pkFArABxGFPYZ+JjXHDA3BvHisvzJU05prPcCXsTPBnVggQSIHkqAtDzxOOCBguzpegloruh419/+3t2",
 136         "GrkczfHNdHB4DS1eF0vG5h4/1EXMLwi8MmJ+lbs1obPFXZGlGcgMwr2qlhVsdSJmGX+cqhqjZQy/FYC7",
 137         "fLnkrEcUqee7MSRcKMrm3m7i28+s4369wqGTrhSTqQdSUZYXYIHgW5rgz/DwXlCcZRVINQF5oqp9UGZW",
 138         "FinoNpM7LPRqhmJy3uZMwAXkHKu3SGAhIkjpbXtlQSQKIaLMXCv1v0FMUgnoQ+P/GyjTGpFYgr5E8CVV",
 139         "uoC4WoB4pBIaxWqZcR4DYbacEx1BCG+BqFRAuQ9ef2iddUz+Ac7GwY8wkzz4Zg6sy1lE568Mwp8Pgcql",
 140         "nqdTXfirar40IB0reHP54anOdSTSGGT5kkOK7aui/dY8nDk4Qx1rUL3h+DgytrunuuCOzyLjHe7pBnb4",
 141         "yFYy7PD4tBg8KRCMxD0eVFT7u0+jEZr4qH3TaLfb6EvrQ+O6cYVsxE3nvRVkCY9cfDMPGmb/HRdqMeMp",
 142         "C82lEDs4FTHu4IVSiew0m4+Pj4138yRpcDFvRipp+gkEsklEsKAraLZvphIEBdm0Wpt27I34oXnaAK3W",
 143         "Muxem1oSRuawBKYaCP3C/vkP1L5qtx1r4VDMCcseG0iMRkQoBkKiN+7Y++ggd+L5Dup2fddB/YnvOWji",
 144         "98z/Jq7+T/etwXTjGAk6X5g7tk6d7YVXURXrc7bxttfwqR2JViCktb3VaDeutGs8AUYSqk+7cdW40nlH",
 145         "1MIEo/ksc/bxwk2z6KHZkHB73wpIHM9I8M0sHqHP54y/GjMern9o1uzcFKEziY88XBtNnKnsyZYkSZwJ",
 146         "N3+VVoFN3VO94HC22uynsCZfsyATzqStqvbV+8MMuOOoay1CbwpPgkXH3upDfnf14YXMletualkD8dMF",
 147         "ED9piPdXV6+G0LIGonUBRMtCvLsA4p2FeH8BxHsD0brAkZZ1pHWBIy3rSOv6AohrA9G+eT1E+0ZDXF+Q",
 148         "F9c2L64vCOq1DWoIEUlj9WqYrfzG/FP+8agrgCjQd10Gj+eM3roD6/5LthcVPOJS+QVC9PfoUPOmbkZ2",
 149         "Hv96+lqzg9IzrN6jiVcPIGRpGnxBFS6zk1OguvIV5sH5/Vhz735zFmu2fm8DquIcojf+jo53r+PRXpd+",
 150         "ix28ABJmN6gBr5vJNccTyuwQdz/2tiFk8BivLTyE+V3NQSQIuDAP2dvfLpRIAz3WomeS0DHnatMMSEKj",
 151         "H+3Y2Vy1jjbb/GN2E92YRn9+Smy+s/939v+fYX8Hv6yYbMHHoKDqVVivn/tec9g0rHxt2/DLD0x/lCbi",
 152         "HNe9fxzZT3173HzMnJ27L+xqp+bxyQJqwrRvHVoSFSwMQZceGL0QUYlsNpj71Pfp/Y/I399pr2Lotb91",
 153         "banDvnrUzhvYwSsiKJnF+fuS3mdrKjMqfzOBJ7JMYmgEfInLE1cmWHpfzB8XrzVd7D/kaGsfNv8OAAD/",
 154         "//oDEyW/JgAA",
 155 }
 156
 157 // GetSwagger returns the content of the embedded swagger specification file
 158 // or error if failed to decode
 159 func decodeSpec() ([]byte, error) {
 160         zipped, err := base64.StdEncoding.DecodeString(strings.Join(swaggerSpec, ""))
 161         if err != nil {
 162                 return nil, fmt.Errorf("error base64 decoding spec: %s", err)
 163         }
 164         zr, err := gzip.NewReader(bytes.NewReader(zipped))
 165         if err != nil {
 166                 return nil, fmt.Errorf("error decompressing spec: %s", err)
 167         }
 168         var buf bytes.Buffer
 169         _, err = buf.ReadFrom(zr)
 170         if err != nil {
 171                 return nil, fmt.Errorf("error decompressing spec: %s", err)
 172         }
 173
 174         return buf.Bytes(), nil
 175 }
 176
 177 var rawSpec = decodeSpecCached()
 178
 179 // a naive cached of a decoded swagger spec
 180 func decodeSpecCached() func() ([]byte, error) {
 181         data, err := decodeSpec()
 182         return func() ([]byte, error) {
 183                 return data, err
 184         }
 185 }
 186
 187 // Constructs a synthetic filesystem for resolving external references when loading openapi specifications.
 188 func PathToRawSpec(pathToFile string) map[string]func() ([]byte, error) {
 189         var res = make(map[string]func() ([]byte, error))
 190         if len(pathToFile) > 0 {
 191                 res[pathToFile] = rawSpec
 192         }
 193
 194         pathPrefix := path.Dir(pathToFile)
 195
 196         for rawPath, rawFunc := range externalRef1.PathToRawSpec(path.Join(pathPrefix, "CommonData.yaml")) {
 197                 if _, ok := res[rawPath]; ok {
 198                         // it is not possible to compare functions in golang, so always overwrite the old value
 199                 }
 200                 res[rawPath] = rawFunc
 201         }
 202         for rawPath, rawFunc := range externalRef2.PathToRawSpec(path.Join(pathPrefix, "TS29122_CommonData.yaml")) {
 203                 if _, ok := res[rawPath]; ok {
 204                         // it is not possible to compare functions in golang, so always overwrite the old value
 205                 }
 206                 res[rawPath] = rawFunc
 207         }
 208         for rawPath, rawFunc := range externalRef0.PathToRawSpec(path.Join(pathPrefix, "TS29222_CAPIF_Access_Control_Policy_API.yaml")) {
 209                 if _, ok := res[rawPath]; ok {
 210                         // it is not possible to compare functions in golang, so always overwrite the old value
 211                 }
 212                 res[rawPath] = rawFunc
 213         }
 214         for rawPath, rawFunc := range externalRef4.PathToRawSpec(path.Join(pathPrefix, "TS29222_CAPIF_Logging_API_Invocation_API.yaml")) {
 215                 if _, ok := res[rawPath]; ok {
 216                         // it is not possible to compare functions in golang, so always overwrite the old value
 217                 }
 218                 res[rawPath] = rawFunc
 219         }
 220         for rawPath, rawFunc := range externalRef5.PathToRawSpec(path.Join(pathPrefix, "TS29222_CAPIF_Publish_Service_API.yaml")) {
 221                 if _, ok := res[rawPath]; ok {
 222                         // it is not possible to compare functions in golang, so always overwrite the old value
 223                 }
 224                 res[rawPath] = rawFunc
 225         }
 226         for rawPath, rawFunc := range externalRef6.PathToRawSpec(path.Join(pathPrefix, "TS29222_CAPIF_Routing_Info_API.yaml")) {
 227                 if _, ok := res[rawPath]; ok {
 228                         // it is not possible to compare functions in golang, so always overwrite the old value
 229                 }
 230                 res[rawPath] = rawFunc
 231         }
 232         for rawPath, rawFunc := range externalRef3.PathToRawSpec(path.Join(pathPrefix, "TS29571_CommonData.yaml")) {
 233                 if _, ok := res[rawPath]; ok {
 234                         // it is not possible to compare functions in golang, so always overwrite the old value
 235                 }
 236                 res[rawPath] = rawFunc
 237         }
 238         return res
 239 }
 240
 241 // GetSwagger returns the Swagger specification corresponding to the generated code
 242 // in this file. The external references of Swagger specification are resolved.
 243 // The logic of resolving external references is tightly connected to "import-mapping" feature.
 244 // Externally referenced files must be embedded in the corresponding golang packages.
 245 // Urls can be supported but this task was out of the scope.
 246 func GetSwagger() (swagger *openapi3.T, err error) {
 247         var resolvePath = PathToRawSpec("")
 248
 249         loader := openapi3.NewLoader()
 250         loader.IsExternalRefsAllowed = true
 251         loader.ReadFromURIFunc = func(loader *openapi3.Loader, url *url.URL) ([]byte, error) {
 252                 var pathToFile = url.String()
 253                 pathToFile = path.Clean(pathToFile)
 254                 getSpec, ok := resolvePath[pathToFile]
 255                 if !ok {
 256                         err1 := fmt.Errorf("path not found: %s", pathToFile)
 257                         return nil, err1
 258                 }
 259                 return getSpec()
 260         }
 261         var specData []byte
 262         specData, err = rawSpec()
 263         if err != nil {
 264                 return
 265         }
 266         swagger, err = loader.LoadFromData(specData)
 267         if err != nil {
 268                 return
 269         }
 270         return
 271 }