pkg/clientmodel/subscription_params.go

   1 // Code generated by go-swagger; DO NOT EDIT.
   2
   3 package clientmodel
   4
   5 // This file was generated by the swagger tool.
   6 // Editing this file might prove futile when you re-run the swagger generate command
   7
   8 import (
   9         "github.com/go-openapi/errors"
  10         "github.com/go-openapi/strfmt"
  11         "github.com/go-openapi/swag"
  12         "github.com/go-openapi/validate"
  13 )
  14
  15 // SubscriptionParams subscription params
  16 //
  17 // swagger:model SubscriptionParams
  18 type SubscriptionParams struct {
  19
  20         // client endpoint
  21         // Required: true
  22         ClientEndpoint *SubscriptionParamsClientEndpoint `json:"ClientEndpoint"`
  23
  24         // e2 subscription directives
  25         E2SubscriptionDirectives *SubscriptionParamsE2SubscriptionDirectives `json:"E2SubscriptionDirectives,omitempty"`
  26
  27         // meid
  28         // Required: true
  29         Meid *string `json:"Meid"`
  30
  31         // r a n function ID
  32         // Required: true
  33         // Maximum: 4095
  34         // Minimum: 0
  35         RANFunctionID *int64 `json:"RANFunctionID"`
  36
  37         // subscription details
  38         // Required: true
  39         SubscriptionDetails SubscriptionDetailsList `json:"SubscriptionDetails"`
  40
  41         // Optional subscription ID (Submgr allocates if not given)
  42         SubscriptionID string `json:"SubscriptionId,omitempty"`
  43 }
  44
  45 // Validate validates this subscription params
  46 func (m *SubscriptionParams) Validate(formats strfmt.Registry) error {
  47         var res []error
  48
  49         if err := m.validateClientEndpoint(formats); err != nil {
  50                 res = append(res, err)
  51         }
  52
  53         if err := m.validateE2SubscriptionDirectives(formats); err != nil {
  54                 res = append(res, err)
  55         }
  56
  57         if err := m.validateMeid(formats); err != nil {
  58                 res = append(res, err)
  59         }
  60
  61         if err := m.validateRANFunctionID(formats); err != nil {
  62                 res = append(res, err)
  63         }
  64
  65         if err := m.validateSubscriptionDetails(formats); err != nil {
  66                 res = append(res, err)
  67         }
  68
  69         if len(res) > 0 {
  70                 return errors.CompositeValidationError(res...)
  71         }
  72         return nil
  73 }
  74
  75 func (m *SubscriptionParams) validateClientEndpoint(formats strfmt.Registry) error {
  76
  77         if err := validate.Required("ClientEndpoint", "body", m.ClientEndpoint); err != nil {
  78                 return err
  79         }
  80
  81         if m.ClientEndpoint != nil {
  82                 if err := m.ClientEndpoint.Validate(formats); err != nil {
  83                         if ve, ok := err.(*errors.Validation); ok {
  84                                 return ve.ValidateName("ClientEndpoint")
  85                         }
  86                         return err
  87                 }
  88         }
  89
  90         return nil
  91 }
  92
  93 func (m *SubscriptionParams) validateE2SubscriptionDirectives(formats strfmt.Registry) error {
  94
  95         if swag.IsZero(m.E2SubscriptionDirectives) { // not required
  96                 return nil
  97         }
  98
  99         if m.E2SubscriptionDirectives != nil {
 100                 if err := m.E2SubscriptionDirectives.Validate(formats); err != nil {
 101                         if ve, ok := err.(*errors.Validation); ok {
 102                                 return ve.ValidateName("E2SubscriptionDirectives")
 103                         }
 104                         return err
 105                 }
 106         }
 107
 108         return nil
 109 }
 110
 111 func (m *SubscriptionParams) validateMeid(formats strfmt.Registry) error {
 112
 113         if err := validate.Required("Meid", "body", m.Meid); err != nil {
 114                 return err
 115         }
 116
 117         return nil
 118 }
 119
 120 func (m *SubscriptionParams) validateRANFunctionID(formats strfmt.Registry) error {
 121
 122         if err := validate.Required("RANFunctionID", "body", m.RANFunctionID); err != nil {
 123                 return err
 124         }
 125
 126         if err := validate.MinimumInt("RANFunctionID", "body", int64(*m.RANFunctionID), 0, false); err != nil {
 127                 return err
 128         }
 129
 130         if err := validate.MaximumInt("RANFunctionID", "body", int64(*m.RANFunctionID), 4095, false); err != nil {
 131                 return err
 132         }
 133
 134         return nil
 135 }
 136
 137 func (m *SubscriptionParams) validateSubscriptionDetails(formats strfmt.Registry) error {
 138
 139         if err := validate.Required("SubscriptionDetails", "body", m.SubscriptionDetails); err != nil {
 140                 return err
 141         }
 142
 143         if err := m.SubscriptionDetails.Validate(formats); err != nil {
 144                 if ve, ok := err.(*errors.Validation); ok {
 145                         return ve.ValidateName("SubscriptionDetails")
 146                 }
 147                 return err
 148         }
 149
 150         return nil
 151 }
 152
 153 // MarshalBinary interface implementation
 154 func (m *SubscriptionParams) MarshalBinary() ([]byte, error) {
 155         if m == nil {
 156                 return nil, nil
 157         }
 158         return swag.WriteJSON(m)
 159 }
 160
 161 // UnmarshalBinary interface implementation
 162 func (m *SubscriptionParams) UnmarshalBinary(b []byte) error {
 163         var res SubscriptionParams
 164         if err := swag.ReadJSON(b, &res); err != nil {
 165                 return err
 166         }
 167         *m = res
 168         return nil
 169 }
 170
 171 // SubscriptionParamsClientEndpoint xApp service address and port
 172 //
 173 // swagger:model SubscriptionParamsClientEndpoint
 174 type SubscriptionParamsClientEndpoint struct {
 175
 176         // xApp HTTP service address port
 177         // Maximum: 65535
 178         // Minimum: 0
 179         HTTPPort *int64 `json:"HTTPPort,omitempty"`
 180
 181         // xApp service address name like 'service-ricxapp-xappname-http.ricxapp'
 182         Host string `json:"Host,omitempty"`
 183
 184         // xApp RMR service address port
 185         // Maximum: 65535
 186         // Minimum: 0
 187         RMRPort *int64 `json:"RMRPort,omitempty"`
 188 }
 189
 190 // Validate validates this subscription params client endpoint
 191 func (m *SubscriptionParamsClientEndpoint) Validate(formats strfmt.Registry) error {
 192         var res []error
 193
 194         if err := m.validateHTTPPort(formats); err != nil {
 195                 res = append(res, err)
 196         }
 197
 198         if err := m.validateRMRPort(formats); err != nil {
 199                 res = append(res, err)
 200         }
 201
 202         if len(res) > 0 {
 203                 return errors.CompositeValidationError(res...)
 204         }
 205         return nil
 206 }
 207
 208 func (m *SubscriptionParamsClientEndpoint) validateHTTPPort(formats strfmt.Registry) error {
 209
 210         if swag.IsZero(m.HTTPPort) { // not required
 211                 return nil
 212         }
 213
 214         if err := validate.MinimumInt("ClientEndpoint"+"."+"HTTPPort", "body", int64(*m.HTTPPort), 0, false); err != nil {
 215                 return err
 216         }
 217
 218         if err := validate.MaximumInt("ClientEndpoint"+"."+"HTTPPort", "body", int64(*m.HTTPPort), 65535, false); err != nil {
 219                 return err
 220         }
 221
 222         return nil
 223 }
 224
 225 func (m *SubscriptionParamsClientEndpoint) validateRMRPort(formats strfmt.Registry) error {
 226
 227         if swag.IsZero(m.RMRPort) { // not required
 228                 return nil
 229         }
 230
 231         if err := validate.MinimumInt("ClientEndpoint"+"."+"RMRPort", "body", int64(*m.RMRPort), 0, false); err != nil {
 232                 return err
 233         }
 234
 235         if err := validate.MaximumInt("ClientEndpoint"+"."+"RMRPort", "body", int64(*m.RMRPort), 65535, false); err != nil {
 236                 return err
 237         }
 238
 239         return nil
 240 }
 241
 242 // MarshalBinary interface implementation
 243 func (m *SubscriptionParamsClientEndpoint) MarshalBinary() ([]byte, error) {
 244         if m == nil {
 245                 return nil, nil
 246         }
 247         return swag.WriteJSON(m)
 248 }
 249
 250 // UnmarshalBinary interface implementation
 251 func (m *SubscriptionParamsClientEndpoint) UnmarshalBinary(b []byte) error {
 252         var res SubscriptionParamsClientEndpoint
 253         if err := swag.ReadJSON(b, &res); err != nil {
 254                 return err
 255         }
 256         *m = res
 257         return nil
 258 }
 259
 260 // SubscriptionParamsE2SubscriptionDirectives Optional. If not set Submgr uses its default values
 261 //
 262 // swagger:model SubscriptionParamsE2SubscriptionDirectives
 263 type SubscriptionParamsE2SubscriptionDirectives struct {
 264
 265         // How many times E2 subscription request is retried
 266         // Maximum: 10
 267         // Minimum: 0
 268         E2RetryCount *int64 `json:"E2RetryCount,omitempty"`
 269
 270         // How long time response is waited from E2 node
 271         // Maximum: 10
 272         // Minimum: 1
 273         E2TimeoutTimerValue int64 `json:"E2TimeoutTimerValue,omitempty"`
 274
 275         // Subscription needs RMR route from E2Term to xApp
 276         RMRRoutingNeeded bool `json:"RMRRoutingNeeded,omitempty"`
 277 }
 278
 279 // Validate validates this subscription params e2 subscription directives
 280 func (m *SubscriptionParamsE2SubscriptionDirectives) Validate(formats strfmt.Registry) error {
 281         var res []error
 282
 283         if err := m.validateE2RetryCount(formats); err != nil {
 284                 res = append(res, err)
 285         }
 286
 287         if err := m.validateE2TimeoutTimerValue(formats); err != nil {
 288                 res = append(res, err)
 289         }
 290
 291         if len(res) > 0 {
 292                 return errors.CompositeValidationError(res...)
 293         }
 294         return nil
 295 }
 296
 297 func (m *SubscriptionParamsE2SubscriptionDirectives) validateE2RetryCount(formats strfmt.Registry) error {
 298
 299         if swag.IsZero(m.E2RetryCount) { // not required
 300                 return nil
 301         }
 302
 303         if err := validate.MinimumInt("E2SubscriptionDirectives"+"."+"E2RetryCount", "body", int64(*m.E2RetryCount), 0, false); err != nil {
 304                 return err
 305         }
 306
 307         if err := validate.MaximumInt("E2SubscriptionDirectives"+"."+"E2RetryCount", "body", int64(*m.E2RetryCount), 10, false); err != nil {
 308                 return err
 309         }
 310
 311         return nil
 312 }
 313
 314 func (m *SubscriptionParamsE2SubscriptionDirectives) validateE2TimeoutTimerValue(formats strfmt.Registry) error {
 315
 316         if swag.IsZero(m.E2TimeoutTimerValue) { // not required
 317                 return nil
 318         }
 319
 320         if err := validate.MinimumInt("E2SubscriptionDirectives"+"."+"E2TimeoutTimerValue", "body", int64(m.E2TimeoutTimerValue), 1, false); err != nil {
 321                 return err
 322         }
 323
 324         if err := validate.MaximumInt("E2SubscriptionDirectives"+"."+"E2TimeoutTimerValue", "body", int64(m.E2TimeoutTimerValue), 10, false); err != nil {
 325                 return err
 326         }
 327
 328         return nil
 329 }
 330
 331 // MarshalBinary interface implementation
 332 func (m *SubscriptionParamsE2SubscriptionDirectives) MarshalBinary() ([]byte, error) {
 333         if m == nil {
 334                 return nil, nil
 335         }
 336         return swag.WriteJSON(m)
 337 }
 338
 339 // UnmarshalBinary interface implementation
 340 func (m *SubscriptionParamsE2SubscriptionDirectives) UnmarshalBinary(b []byte) error {
 341         var res SubscriptionParamsE2SubscriptionDirectives
 342         if err := swag.ReadJSON(b, &res); err != nil {
 343                 return err
 344         }
 345         *m = res
 346         return nil
 347 }