pkg/models/subscription_params.go

   1 // Code generated by go-swagger; DO NOT EDIT.
   2
   3 package models
   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         strfmt "github.com/go-openapi/strfmt"
  10
  11         "github.com/go-openapi/errors"
  12         "github.com/go-openapi/swag"
  13         "github.com/go-openapi/validate"
  14 )
  15
  16 // SubscriptionParams subscription params
  17 // swagger:model SubscriptionParams
  18 type SubscriptionParams struct {
  19
  20         // client endpoint
  21         // Required: true
  22         ClientEndpoint *SubscriptionParamsClientEndpoint `json:"ClientEndpoint"`
  23
  24         // instance Id
  25         // Required: true
  26         // Maximum: 65535
  27         // Minimum: 0
  28         InstanceID *int64 `json:"InstanceId"`
  29
  30         // meid
  31         // Required: true
  32         Meid *string `json:"Meid"`
  33
  34         // r a n function ID
  35         // Required: true
  36         // Maximum: 4095
  37         // Minimum: 0
  38         RANFunctionID *int64 `json:"RANFunctionID"`
  39
  40         // requestor Id
  41         // Required: true
  42         // Maximum: 65535
  43         // Minimum: 0
  44         RequestorID *int64 `json:"RequestorId"`
  45
  46         // subscription details
  47         // Required: true
  48         SubscriptionDetails SubscriptionDetailsList `json:"SubscriptionDetails"`
  49 }
  50
  51 // Validate validates this subscription params
  52 func (m *SubscriptionParams) Validate(formats strfmt.Registry) error {
  53         var res []error
  54
  55         if err := m.validateClientEndpoint(formats); err != nil {
  56                 res = append(res, err)
  57         }
  58
  59         if err := m.validateInstanceID(formats); err != nil {
  60                 res = append(res, err)
  61         }
  62
  63         if err := m.validateMeid(formats); err != nil {
  64                 res = append(res, err)
  65         }
  66
  67         if err := m.validateRANFunctionID(formats); err != nil {
  68                 res = append(res, err)
  69         }
  70
  71         if err := m.validateRequestorID(formats); err != nil {
  72                 res = append(res, err)
  73         }
  74
  75         if err := m.validateSubscriptionDetails(formats); err != nil {
  76                 res = append(res, err)
  77         }
  78
  79         if len(res) > 0 {
  80                 return errors.CompositeValidationError(res...)
  81         }
  82         return nil
  83 }
  84
  85 func (m *SubscriptionParams) validateClientEndpoint(formats strfmt.Registry) error {
  86
  87         if err := validate.Required("ClientEndpoint", "body", m.ClientEndpoint); err != nil {
  88                 return err
  89         }
  90
  91         if m.ClientEndpoint != nil {
  92                 if err := m.ClientEndpoint.Validate(formats); err != nil {
  93                         if ve, ok := err.(*errors.Validation); ok {
  94                                 return ve.ValidateName("ClientEndpoint")
  95                         }
  96                         return err
  97                 }
  98         }
  99
 100         return nil
 101 }
 102
 103 func (m *SubscriptionParams) validateInstanceID(formats strfmt.Registry) error {
 104
 105         if err := validate.Required("InstanceId", "body", m.InstanceID); err != nil {
 106                 return err
 107         }
 108
 109         if err := validate.MinimumInt("InstanceId", "body", int64(*m.InstanceID), 0, false); err != nil {
 110                 return err
 111         }
 112
 113         if err := validate.MaximumInt("InstanceId", "body", int64(*m.InstanceID), 65535, false); err != nil {
 114                 return err
 115         }
 116
 117         return nil
 118 }
 119
 120 func (m *SubscriptionParams) validateMeid(formats strfmt.Registry) error {
 121
 122         if err := validate.Required("Meid", "body", m.Meid); err != nil {
 123                 return err
 124         }
 125
 126         return nil
 127 }
 128
 129 func (m *SubscriptionParams) validateRANFunctionID(formats strfmt.Registry) error {
 130
 131         if err := validate.Required("RANFunctionID", "body", m.RANFunctionID); err != nil {
 132                 return err
 133         }
 134
 135         if err := validate.MinimumInt("RANFunctionID", "body", int64(*m.RANFunctionID), 0, false); err != nil {
 136                 return err
 137         }
 138
 139         if err := validate.MaximumInt("RANFunctionID", "body", int64(*m.RANFunctionID), 4095, false); err != nil {
 140                 return err
 141         }
 142
 143         return nil
 144 }
 145
 146 func (m *SubscriptionParams) validateRequestorID(formats strfmt.Registry) error {
 147
 148         if err := validate.Required("RequestorId", "body", m.RequestorID); err != nil {
 149                 return err
 150         }
 151
 152         if err := validate.MinimumInt("RequestorId", "body", int64(*m.RequestorID), 0, false); err != nil {
 153                 return err
 154         }
 155
 156         if err := validate.MaximumInt("RequestorId", "body", int64(*m.RequestorID), 65535, false); err != nil {
 157                 return err
 158         }
 159
 160         return nil
 161 }
 162
 163 func (m *SubscriptionParams) validateSubscriptionDetails(formats strfmt.Registry) error {
 164
 165         if err := validate.Required("SubscriptionDetails", "body", m.SubscriptionDetails); err != nil {
 166                 return err
 167         }
 168
 169         if err := m.SubscriptionDetails.Validate(formats); err != nil {
 170                 if ve, ok := err.(*errors.Validation); ok {
 171                         return ve.ValidateName("SubscriptionDetails")
 172                 }
 173                 return err
 174         }
 175
 176         return nil
 177 }
 178
 179 // MarshalBinary interface implementation
 180 func (m *SubscriptionParams) MarshalBinary() ([]byte, error) {
 181         if m == nil {
 182                 return nil, nil
 183         }
 184         return swag.WriteJSON(m)
 185 }
 186
 187 // UnmarshalBinary interface implementation
 188 func (m *SubscriptionParams) UnmarshalBinary(b []byte) error {
 189         var res SubscriptionParams
 190         if err := swag.ReadJSON(b, &res); err != nil {
 191                 return err
 192         }
 193         *m = res
 194         return nil
 195 }
 196
 197 // SubscriptionParamsClientEndpoint xApp service address and port
 198 // swagger:model SubscriptionParamsClientEndpoint
 199 type SubscriptionParamsClientEndpoint struct {
 200
 201         // xApp service address port
 202         // Maximum: 65535
 203         // Minimum: 0
 204         Port *int64 `json:"Port,omitempty"`
 205
 206         // xApp service address name like 'service-ricxapp-xappname-http.ricxapp'
 207         ServiceName string `json:"ServiceName,omitempty"`
 208 }
 209
 210 // Validate validates this subscription params client endpoint
 211 func (m *SubscriptionParamsClientEndpoint) Validate(formats strfmt.Registry) error {
 212         var res []error
 213
 214         if err := m.validatePort(formats); err != nil {
 215                 res = append(res, err)
 216         }
 217
 218         if len(res) > 0 {
 219                 return errors.CompositeValidationError(res...)
 220         }
 221         return nil
 222 }
 223
 224 func (m *SubscriptionParamsClientEndpoint) validatePort(formats strfmt.Registry) error {
 225
 226         if swag.IsZero(m.Port) { // not required
 227                 return nil
 228         }
 229
 230         if err := validate.MinimumInt("ClientEndpoint"+"."+"Port", "body", int64(*m.Port), 0, false); err != nil {
 231                 return err
 232         }
 233
 234         if err := validate.MaximumInt("ClientEndpoint"+"."+"Port", "body", int64(*m.Port), 65535, false); err != nil {
 235                 return err
 236         }
 237
 238         return nil
 239 }
 240
 241 // MarshalBinary interface implementation
 242 func (m *SubscriptionParamsClientEndpoint) MarshalBinary() ([]byte, error) {
 243         if m == nil {
 244                 return nil, nil
 245         }
 246         return swag.WriteJSON(m)
 247 }
 248
 249 // UnmarshalBinary interface implementation
 250 func (m *SubscriptionParamsClientEndpoint) UnmarshalBinary(b []byte) error {
 251         var res SubscriptionParamsClientEndpoint
 252         if err := swag.ReadJSON(b, &res); err != nil {
 253                 return err
 254         }
 255         *m = res
 256         return nil
 257 }