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