Class: SwaggerPetstore::PetController

Inherits:
BaseController show all
Defined in:
lib/swagger_petstore/controllers/pet_controller.rb

Overview

PetController

Constant Summary

Constants inherited from BaseController

BaseController::GLOBAL_ERRORS

Instance Attribute Summary

Attributes inherited from BaseController

#config, #http_call_back

Instance Method Summary collapse

Methods inherited from BaseController

#initialize, #new_api_call_builder, #new_parameter, #new_request_builder, #new_response_handler, user_agent

Constructor Details

This class inherits a constructor from SwaggerPetstore::BaseController

Instance Method Details

#add_pet(body) ⇒ void

This method returns an undefined value.

Add a new pet to the store added to the store

Parameters:

  • body (PetRequest) —

    Required parameter: Pet object that needs to be



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/swagger_petstore/controllers/pet_controller.rb', line 63

def add_pet(body)
  new_api_call_builder
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/pet',
                                 Server::DEFAULT)
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('petstore_auth')))
    .response(new_response_handler
               .is_response_void(true)
               .local_error('405',
                            'Invalid input',
                            APIException))
    .execute
end

#delete_pet(pet_id, api_key: nil) ⇒ void

This method returns an undefined value.

Deletes a pet

Parameters:

  • pet_id (Integer) —

    Required parameter: Pet id to delete

  • api_key (String) (defaults to: nil) —

    Optional parameter: Example:



159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
 
# File 'lib/swagger_petstore/controllers/pet_controller.rb', line 159

def delete_pet(pet_id,
               api_key: nil)
  new_api_call_builder
    .request(new_request_builder(HttpMethodEnum::DELETE,
                                 '/pet/{petId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(pet_id, key: 'petId')
                                .should_encode(true))
               .header_param(new_parameter(api_key, key: 'api_key'))
               .auth(Single.new('petstore_auth')))
    .response(new_response_handler
               .is_response_void(true)
               .local_error('400',
                            'Invalid ID supplied',
                            APIException)
               .local_error('404',
                            'Pet not found',
                            APIException))
    .execute
end

#find_pets_by_status(status) ⇒ Array[Pet]

Multiple status values can be provided with comma separated strings need to be considered for filter

Parameters:

  • status (Array[Status2Enum]) —

    Required parameter: Status values that

Returns:

  • (Array[Pet]) —

    response from the API call



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/swagger_petstore/controllers/pet_controller.rb', line 108

def find_pets_by_status(status)
  new_api_call_builder
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/pet/findByStatus',
                                 Server::DEFAULT)
               .query_param(new_parameter(status, key: 'status'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('petstore_auth')))
    .response(new_response_handler
               .deserializer(APIHelper.method(:custom_type_deserializer))
               .deserialize_into(Pet.method(:from_hash))
               .is_response_array(true)
               .local_error('400',
                            'Invalid status value',
                            APIException))
    .execute
end

#find_pets_by_tags(tags) ⇒ Array[Pet]

Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.

Parameters:

  • tags (Array[String]) —

    Required parameter: Tags to filter by

Returns:

  • (Array[Pet]) —

    response from the API call



13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/swagger_petstore/controllers/pet_controller.rb', line 13

def find_pets_by_tags(tags)
  warn 'Endpoint find_pets_by_tags in PetController is deprecated'
  new_api_call_builder
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/pet/findByTags',
                                 Server::DEFAULT)
               .query_param(new_parameter(tags, key: 'tags'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('petstore_auth')))
    .response(new_response_handler
               .deserializer(APIHelper.method(:custom_type_deserializer))
               .deserialize_into(Pet.method(:from_hash))
               .is_response_array(true)
               .local_error('400',
                            'Invalid tag value',
                            APIException))
    .execute
end

#get_pet_by_id(pet_id) ⇒ Pet

Returns a single pet

Parameters:

  • pet_id (Integer) —

    Required parameter: ID of pet to return

Returns:

  • (Pet) —

    response from the API call



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/swagger_petstore/controllers/pet_controller.rb', line 83

def get_pet_by_id(pet_id)
  new_api_call_builder
    .request(new_request_builder(HttpMethodEnum::GET,
                                 '/pet/{petId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(pet_id, key: 'petId')
                                .should_encode(true))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('api_key')))
    .response(new_response_handler
               .deserializer(APIHelper.method(:custom_type_deserializer))
               .deserialize_into(Pet.method(:from_hash))
               .local_error('400',
                            'Invalid ID supplied',
                            APIException)
               .local_error('404',
                            'Pet not found',
                            APIException))
    .execute
end

#update_pet(body) ⇒ void

This method returns an undefined value.

Update an existing pet added to the store

Parameters:

  • body (PetRequest) —

    Required parameter: Pet object that needs to be



36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/swagger_petstore/controllers/pet_controller.rb', line 36

def update_pet(body)
  new_api_call_builder
    .request(new_request_builder(HttpMethodEnum::PUT,
                                 '/pet',
                                 Server::DEFAULT)
               .header_param(new_parameter('application/json', key: 'Content-Type'))
               .body_param(new_parameter(body))
               .body_serializer(proc do |param| param.to_json unless param.nil? end)
               .auth(Single.new('petstore_auth')))
    .response(new_response_handler
               .is_response_void(true)
               .local_error('400',
                            'Invalid ID supplied',
                            APIException)
               .local_error('404',
                            'Pet not found',
                            APIException)
               .local_error('405',
                            'Validation exception',
                            APIException))
    .execute
end

#update_pet_with_form(pet_id, content_type, name: nil, status: nil) ⇒ void

This method returns an undefined value.

Updates a pet in the store with form data updated

Parameters:

  • pet_id (Integer) —

    Required parameter: ID of pet that needs to be

  • content_type (ContentTypeEnum) —

    Required parameter: Example:

  • name (String) (defaults to: nil) —

    Optional parameter: Updated name of the pet

  • status (String) (defaults to: nil) —

    Optional parameter: Updated status of the pet



133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/swagger_petstore/controllers/pet_controller.rb', line 133

def update_pet_with_form(pet_id,
                         content_type,
                         name: nil,
                         status: nil)
  new_api_call_builder
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/pet/{petId}',
                                 Server::DEFAULT)
               .template_param(new_parameter(pet_id, key: 'petId')
                                .should_encode(true))
               .form_param(new_parameter(name, key: 'name'))
               .form_param(new_parameter(status, key: 'status'))
               .header_param(new_parameter('application/x-www-form-urlencoded', key: 'content-type'))
               .auth(Single.new('petstore_auth')))
    .response(new_response_handler
               .is_response_void(true)
               .local_error('405',
                            'Invalid input',
                            APIException))
    .execute
end

#upload_file(pet_id, additional_metadata: nil, file: nil) ⇒ ApiResponse

uploads an image pass to server

Parameters:

  • pet_id (Integer) —

    Required parameter: ID of pet to update

  • additional_metadata (String) (defaults to: nil) —

    Optional parameter: Additional data to

  • file (File | UploadIO) (defaults to: nil) —

    Optional parameter: file to upload

Returns:



186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
 
# File 'lib/swagger_petstore/controllers/pet_controller.rb', line 186

def upload_file(pet_id,
                additional_metadata: nil,
                file: nil)
  new_api_call_builder
    .request(new_request_builder(HttpMethodEnum::POST,
                                 '/pet/{petId}/uploadImage',
                                 Server::DEFAULT)
               .template_param(new_parameter(pet_id, key: 'petId')
                                .should_encode(true))
               .form_param(new_parameter(additional_metadata, key: 'additionalMetadata'))
               .multipart_param(new_parameter(file, key: 'file')
                                 .default_content_type('application/octet-stream'))
               .header_param(new_parameter('application/json', key: 'accept'))
               .auth(Single.new('petstore_auth')))
    .response(new_response_handler
               .deserializer(APIHelper.method(:custom_type_deserializer))
               .deserialize_into(ApiResponse.method(:from_hash)))
    .execute
end