My-first-api-matic 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0b28501632ae5cc4d873ce37d49e309bbfb8be5340862b7be8dacb577918410e
+  data.tar.gz: 71016bf84c15fb98c866a1ea395c83310045e9fddd584436b75bb6f5fb9c9568
+SHA512:
+  metadata.gz: f46eb878e55aef173f2835f90defaee50f8b8fc77b804a1cb53a89dad146e028600b3c3af6c7e65172a79d626a4bba82f3e29ac1d75d5cb9a0fc18e6c5f73a3d
+  data.tar.gz: c688d55de8d81c5e60de67294c0cc470f9bc1cbe61621163c6437faa6c0e9d363a66e333ffc4a9797dd559bd524cebc3702013d6597fca0e4b3a8a955a5bc3c2

data/LICENSE

@@ -0,0 +1,28 @@
+License: 
+========
+The MIT License (MIT)
+http://opensource.org/licenses/MIT
+
+Copyright (c) 2014 - 2020 APIMATIC Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+Trade Mark:
+==========
+APIMATIC is a trade mark for APIMATIC Limited

data/README.md

@@ -0,0 +1,317 @@
+# Getting Started with Youtube
+
+## Getting Started
+
+### Install the Package
+
+Install the gem from the command line:
+
+```ruby
+gem install My-first-api-matic -v 1.0
+```
+
+Or add the gem to your Gemfile and run `bundle`:
+
+```ruby
+gem 'My-first-api-matic', '1.0'
+```
+
+For additional gem details, see the [RubyGems page for the My-first-api-matic gem](https://rubygems.org/gems/My-first-api-matic/versions/1.0).
+
+### Initialize the API Client
+
+The following parameters are configurable for the API Client:
+
+| Parameter | Type | Description |
+|  --- | --- | --- |
+| `timeout` | `Float` | The value to use for connection timeout. <br> **Default: 60** |
+| `max_retries` | `Integer` | The number of times to retry an endpoint call if it fails. <br> **Default: 0** |
+| `retry_interval` | `Float` | Pause in seconds between retries. <br> **Default: 1** |
+| `backoff_factor` | `Float` | The amount to multiply each successive retry's interval amount by in order to provide backoff. <br> **Default: 2** |
+| `retry_statuses` | `Array` | A list of HTTP statuses to retry. <br> **Default: [408, 413, 429, 500, 502, 503, 504, 521, 522, 524]** |
+| `retry_methods` | `Array` | A list of HTTP methods to retry. <br> **Default: %i[get put]** |
+
+The API client can be initialized as follows:
+
+```ruby
+client = Youtube::Client.new(
+)
+```
+
+### API Errors
+
+Here is the list of errors that the API might throw.
+
+| HTTP Status Code | Error Description | Exception Class |
+|  --- | --- | --- |
+| 401 | dfgdfgdfgdfgdsfg | [`ProblemDetailsException`](#problem-details) |
+
+## Client Class Documentation
+
+### Youtube Client
+
+The gateway for the SDK. This class acts as a factory for the Controllers and also holds the configuration of the SDK.
+
+### Controllers
+
+| Name | Description |
+|  --- | --- |
+| api | Gets APIController |
+
+## API Reference
+
+### List of APIs
+
+* [API](#api)
+
+### API
+
+#### Overview
+
+##### Get instance
+
+An instance of the `APIController` class can be accessed from the API Client.
+
+```
+client_controller = client.client
+```
+
+#### Get Forcast
+
+get list of 5 random forcasts
+
+:information_source: **Note** This endpoint does not require authentication.
+
+```ruby
+def get_forcast(param: 'String.Empty')
+```
+
+##### Parameters
+
+| Parameter | Type | Tags | Description |
+|  --- | --- | --- | --- |
+| `param` | `String` | Query, Optional | default string parameter<br>**Default**: `'String.Empty'` |
+
+##### Server
+
+`Server::DEFAULT`
+
+##### Response Type
+
+`Mixed`
+
+##### Example Usage
+
+```ruby
+param = 'my value for error'
+result = client_controller.get_forcast(param: param)
+```
+
+##### Example Response
+
+```
+[
+  {
+    "date": "2021-05-27T10:33:06.7728939+05:00",
+    "temperatureC": -7,
+    "temperatureF": 20,
+    "summary": "Scorching"
+  },
+  {
+    "date": "2021-05-28T10:33:06.7729006+05:00",
+    "temperatureC": 6,
+    "temperatureF": 42,
+    "summary": "Bracing"
+  }
+]
+```
+
+##### Errors
+
+| HTTP Status Code | Error Description | Exception Class |
+|  --- | --- | --- |
+| 400 | Test error message | [`ProblemDetailsException`](#problem-details) |
+| 404 | not found | `APIException` |
+
+## Model Reference
+
+### Structures
+
+* [Weather Forecast](#weather-forecast)
+* [Weather Forcase Json Imported](#weather-forcase-json-imported)
+* [Field Parameter Validator](#field-parameter-validator)
+
+#### Weather Forecast
+
+##### Class Name
+
+`WeatherForecast`
+
+##### Fields
+
+| Name | Type | Tags | Description |
+|  --- | --- | --- | --- |
+| `date` | `DateTime` | Required | The time when forecast was taken |
+| `temperature_c` | `Integer` | Required | the value of temperature in Centigrade |
+| `temperature_f` | `Integer` | Required, Constant | the value of temperature in Fahrenheit |
+| `summary` | `String` | Required, Constant | - |
+
+##### Example (as JSON)
+
+```json
+{
+  "date": "2021-05-27T10:33:06.7728939+05:00",
+  "temperatureC": -7,
+  "temperatureF": 20,
+  "summary": "Scorching"
+}
+```
+
+#### Weather Forcase Json Imported
+
+##### Class Name
+
+`WeatherForcaseJsonImported`
+
+##### Fields
+
+| Name | Type | Tags | Description |
+|  --- | --- | --- | --- |
+| `date` | `String` | Required | - |
+| `temperature_c` | `Integer` | Required | - |
+| `temperature_f` | `Integer` | Required | - |
+| `summary` | `String` | Required | - |
+
+##### Example (as JSON)
+
+```json
+{
+  "date": "2021-05-27T10:33:06.7728939+05:00",
+  "temperatureC": -7,
+  "temperatureF": 20,
+  "summary": "Scorching"
+}
+```
+
+#### Field Parameter Validator
+
+##### Class Name
+
+`FieldParameterValidator`
+
+##### Fields
+
+| Name | Type | Tags | Description |
+|  --- | --- | --- | --- |
+| `precision` | `Float` | Required | **Constraints**: `> 0`, `< 600`, *Multiple Of*: `10`, *Total Digits*: `1000`, *Fraction Digits*: `2` |
+| `string` | `Array<String>` | Optional, Constant | **Constraints**: *Minimum Items*: `5`, *Maximum Items*: `200`, *Minimum Length*: `3`, *Maximum Length*: `10`, *Pattern*: `/^[A-Z]+$/i` |
+| `unix_format_date_time` | `DateTime` | Required | - |
+| `object` | `Object` | Required | - |
+| `int_64` | `Long` | Required | **Constraints**: `> 23`, `< 23`, *Multiple Of*: `3`, *Total Digits*: `23`, *Fraction Digits*: `23`, *Pattern*: `2` |
+
+##### Example (as JSON)
+
+```json
+{
+  "Precision": 229.08,
+  "UnixFormatDateTime": 1480809600,
+  "Object": {
+    "key1": "val1",
+    "key2": "val2"
+  },
+  "Int64": 10
+}
+```
+
+### Enumerations
+
+* [Test Enum](#test-enum)
+
+#### Test Enum
+
+This is the test description of enum00
+
+##### Class Name
+
+`TestEnum`
+
+##### Fields
+
+| Name | Description |
+|  --- | --- |
+| `FIRSTFILED` | Test description of first filed |
+| `SECONDFIELD` | Test description of Second filed |
+| `THIRD_VALUE` |  |
+
+### Exceptions
+
+* [Problem Details](#problem-details)
+
+#### Problem Details
+
+##### Class Name
+
+`ProblemDetailsException`
+
+##### Fields
+
+| Name | Type | Tags | Description |
+|  --- | --- | --- | --- |
+| `type` | `String` | Required, Constant | - |
+| `title` | `String` | Required, Constant | - |
+| `status` | `Integer` | Required, Constant | - |
+| `trace_id` | `String` | Required, Constant | - |
+
+##### Example (as JSON)
+
+```json
+{
+  "type": "https://tools.ietf.org/html/rfc7231#section-6.5.1",
+  "title": "Bad Request",
+  "status": 400,
+  "traceId": "00-3dd0a6221d0ccd48ad5eb89a9cf3df71-91763b2e58fa4742-00"
+}
+```
+
+## Utility Classes Documentation
+
+### ApiHelper Class
+
+API utility class.
+
+### Methods
+
+| Name | Return Type | Description |
+|  --- | --- | --- |
+| json_deserialize | Hash | Deserializes a JSON string to a Ruby Hash. |
+| rfc3339 | DateTime | Safely converts a string into an RFC3339 DateTime object. |
+
+## Common Code Documentation
+
+### HttpResponse
+
+Http response received.
+
+#### Properties
+
+| Name | Type | Description |
+|  --- | --- | --- |
+| status_code | Integer | The status code returned by the server. |
+| reason_phrase | String | The reason phrase returned by the server. |
+| headers | Hash | Response headers. |
+| raw_body | String | Response body. |
+| request | HttpRequest | The request that resulted in this response. |
+
+### HttpRequest
+
+Represents a single Http Request.
+
+#### Properties
+
+| Name | Type | Tag | Description |
+|  --- | --- | --- | --- |
+| http_method | HttpMethodEnum |  | The HTTP method of the request. |
+| query_url | String |  | The endpoint URL for the API request. |
+| headers | Hash | Optional | Request headers. |
+| parameters | Hash | Optional | Request body. |
+

data/lib/youtube.rb

@@ -0,0 +1,41 @@
+# youtube
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+require 'date'
+require 'json'
+require 'faraday'
+require 'certifi'
+require 'logging'
+
+require_relative 'youtube/api_helper.rb'
+require_relative 'youtube/client.rb'
+
+# Utilities
+require_relative 'youtube/utilities/file_wrapper.rb'
+
+# Http
+require_relative 'youtube/http/http_call_back.rb'
+require_relative 'youtube/http/http_client.rb'
+require_relative 'youtube/http/faraday_client.rb'
+require_relative 'youtube/http/http_method_enum.rb'
+require_relative 'youtube/http/http_request.rb'
+require_relative 'youtube/http/http_response.rb'
+
+# Models
+require_relative 'youtube/models/base_model.rb'
+require_relative 'youtube/models/weather_forecast.rb'
+require_relative 'youtube/models/weather_forcase_json_imported.rb'
+require_relative 'youtube/models/field_parameter_validator.rb'
+require_relative 'youtube/models/test_enum.rb'
+
+# Exceptions
+require_relative 'youtube/exceptions/api_exception.rb'
+require_relative 'youtube/exceptions/problem_details_exception.rb'
+
+require_relative 'youtube/configuration.rb'
+
+# Controllers
+require_relative 'youtube/controllers/base_controller.rb'
+require_relative 'youtube/controllers/api_controller.rb'

data/lib/youtube/api_helper.rb

@@ -0,0 +1,289 @@
+# youtube
+#
+# This file was automatically generated by APIMATIC v2.0
+# ( https://apimatic.io ).
+
+module Youtube
+  # API utility class
+  class APIHelper
+    # Serializes an array parameter (creates key value pairs).
+    # @param [String] The name of the parameter.
+    # @param [Array] The value of the parameter.
+    # @param [String] The format of the serialization.
+    def self.serialize_array(key, array, formatting: 'indexed')
+      tuples = []
+
+      if formatting == 'unindexed'
+        tuples += array.map { |element| ["#{key}[]", element] }
+      elsif formatting == 'indexed'
+        tuples += array.map.with_index do |element, index|
+          ["#{key}[#{index}]", element]
+        end
+      elsif formatting == 'plain'
+        tuples += array.map { |element| [key, element] }
+      else
+        raise ArgumentError, 'Invalid format provided.'
+      end
+      tuples
+    end
+
+    # Replaces template parameters in the given url.
+    # @param [String] The query string builder to replace the template
+    # parameters.
+    # @param [Hash] The parameters to replace in the url.
+    def self.append_url_with_template_parameters(query_builder, parameters)
+      # perform parameter validation
+      unless query_builder.instance_of? String
+        raise ArgumentError, 'Given value for parameter \"query_builder\" is
+          invalid.'
+      end
+
+      # Return if there are no parameters to replace.
+      return query_builder if parameters.nil?
+
+      parameters.each do |key, val|
+        if val.nil?
+          replace_value = ''
+        elsif val['value'].instance_of? Array
+          if val['encode'] == true
+            val['value'].map! { |element| CGI.escape(element.to_s) }
+          else
+            val['value'].map!(&:to_s)
+          end
+          replace_value = val['value'].join('/')
+        else
+          replace_value = if val['encode'] == true
+                            CGI.escape(val['value'].to_s)
+                          else
+                            val['value'].to_s
+                          end
+        end
+
+        # Find the template parameter and replace it with its value.
+        query_builder = query_builder.gsub('{' + key.to_s + '}', replace_value)
+      end
+      query_builder
+    end
+
+    # Appends the given set of parameters to the given query string.
+    # @param [String] The query string builder to add the query parameters to.
+    # @param [Hash] The parameters to append.
+    def self.append_url_with_query_parameters(query_builder, parameters)
+      # Perform parameter validation.
+      unless query_builder.instance_of? String
+        raise ArgumentError, 'Given value for parameter \"query_builder\"
+          is invalid.'
+      end
+
+      # Return if there are no parameters to replace.
+      return query_builder if parameters.nil?
+
+      array_serialization = 'indexed'
+
+      parameters.each do |key, value|
+        seperator = query_builder.include?('?') ? '&' : '?'
+        unless value.nil?
+          if value.instance_of? Array
+            value.compact!
+            query_builder += if array_serialization == 'csv'
+                               "#{seperator}#{key}=#{value.map do |element|
+                                 CGI.escape(element.to_s)
+                               end.join(',')}"
+                             elsif array_serialization == 'psv'
+                               "#{seperator}#{key}=#{value.map do |element|
+                                 CGI.escape(element.to_s)
+                               end.join('|')}"
+                             elsif array_serialization == 'tsv'
+                               "#{seperator}#{key}=#{value.map do |element|
+                                 CGI.escape(element.to_s)
+                               end.join("\t")}"
+                             else
+                               "#{seperator}#{APIHelper.serialize_array(
+                                 key, value, formatting: array_serialization
+                               ).map { |k, v| "#{k}=#{CGI.escape(v.to_s)}" }
+                               .join('&')}"
+                             end
+          else
+            query_builder += "#{seperator}#{key}=#{CGI.escape(value.to_s)}"
+          end
+        end
+      end
+      query_builder
+    end
+
+    # Validates and processes the given Url.
+    # @param [String] The given Url to process.
+    # @return [String] Pre-processed Url as string.
+    def self.clean_url(url)
+      # Perform parameter validation.
+      raise ArgumentError, 'Invalid Url.' unless url.instance_of? String
+
+      # Ensure that the urls are absolute.
+      matches = url.match(%r{^(https?:\/\/[^\/]+)})
+      raise ArgumentError, 'Invalid Url format.' if matches.nil?
+
+      # Get the http protocol match.
+      protocol = matches[1]
+
+      # Check if parameters exist.
+      index = url.index('?')
+
+      # Remove redundant forward slashes.
+      query = url[protocol.length...(!index.nil? ? index : url.length)]
+      query.gsub!(%r{\/\/+}, '/')
+
+      # Get the parameters.
+      parameters = !index.nil? ? url[url.index('?')...url.length] : ''
+
+      # Return processed url.
+      protocol + query + parameters
+    end
+
+    # Parses JSON string.
+    # @param [String] A JSON string.
+    def self.json_deserialize(json)
+      return JSON.parse(json)
+    rescue StandardError
+      raise TypeError, 'Server responded with invalid JSON.'
+    end
+
+    # Removes elements with empty values from a hash.
+    # @param [Hash] The hash to clean.
+    def self.clean_hash(hash)
+      hash.delete_if { |_key, value| value.to_s.strip.empty? }
+    end
+
+    # Form encodes a hash of parameters.
+    # @param [Hash] The hash of parameters to encode.
+    # @return [Hash] A hash with the same parameters form encoded.
+    def self.form_encode_parameters(form_parameters)
+      array_serialization = 'indexed'
+      encoded = {}
+      form_parameters.each do |key, value|
+        encoded.merge!(APIHelper.form_encode(value, key, formatting:
+          array_serialization))
+      end
+      encoded
+    end
+
+    def self.custom_merge(a, b)
+      x = {}
+      a.each do |key, value_a|
+        b.each do |k, value_b|
+          next unless key == k
+          x[k] = []
+          if value_a.instance_of? Array
+            value_a.each do |v|
+              x[k].push(v)
+            end
+          else
+            x[k].push(value_a)
+          end
+          if value_b.instance_of? Array
+            value_b.each do |v|
+              x[k].push(v)
+            end
+          else
+            x[k].push(value_b)
+          end
+          a.delete(k)
+          b.delete(k)
+        end
+      end
+      x.merge!(a)
+      x.merge!(b)
+      x
+    end
+
+    # Form encodes an object.
+    # @param [Dynamic] An object to form encode.
+    # @param [String] The name of the object.
+    # @return [Hash] A form encoded representation of the object in the form
+    # of a hash.
+    def self.form_encode(obj, instance_name, formatting: 'indexed')
+      retval = {}
+
+      serializable_types = [String, Numeric, TrueClass,
+                            FalseClass, Date, DateTime]
+
+      # If this is a structure, resolve it's field names.
+      obj = obj.to_hash if obj.is_a? BaseModel
+
+      # Create a form encoded hash for this object.
+      if obj.nil?
+        nil
+      elsif obj.instance_of? Array
+        if formatting == 'indexed'
+          obj.each_with_index do |value, index|
+            retval.merge!(APIHelper.form_encode(value, instance_name + '[' +
+              index.to_s + ']'))
+          end
+        elsif serializable_types.map { |x| obj[0].is_a? x }.any?
+          obj.each do |value|
+            abc = if formatting == 'unindexed'
+                    APIHelper.form_encode(value, instance_name + '[]',
+                                          formatting: formatting)
+                  else
+                    APIHelper.form_encode(value, instance_name,
+                                          formatting: formatting)
+                  end
+            retval = APIHelper.custom_merge(retval, abc)
+          end
+        else
+          obj.each_with_index do |value, index|
+            retval.merge!(APIHelper.form_encode(value, instance_name + '[' +
+              index.to_s + ']', formatting: formatting))
+          end
+        end
+      elsif obj.instance_of? Hash
+        obj.each do |key, value|
+          retval.merge!(APIHelper.form_encode(value, instance_name + '[' +
+            key.to_s + ']', formatting: formatting))
+        end
+      elsif obj.instance_of? File
+        retval[instance_name] = UploadIO.new(
+          obj, 'application/octet-stream', File.basename(obj.path)
+        )
+      else
+        retval[instance_name] = obj
+      end
+      retval
+    end
+
+    # Retrieves a field from a Hash/Array based on an Array of keys/indexes
+    # @param [Hash, Array] The hash to extract data from
+    # @param [Array<String, Integer>] The keys/indexes to use
+    # @return [Object] The extracted value
+    def self.map_response(obj, keys)
+      val = obj
+      begin
+        keys.each do |key|
+          val = if val.is_a? Array
+                  if key.to_i.to_s == key
+                    val[key.to_i]
+                  else
+                    val = nil
+                  end
+                else
+                  val.fetch(key.to_sym)
+                end
+        end
+      rescue NoMethodError, TypeError, IndexError
+        val = nil
+      end
+      val
+    end
+
+    # Safely converts a string into an rfc3339 DateTime object
+    # @param [String] The datetime string
+    # @return [DateTime] A DateTime object of rfc3339 format
+    def self.rfc3339(date_time)
+      # missing timezone information
+      if date_time.end_with?('Z') || date_time.index('+')
+        DateTime.rfc3339(date_time)
+      else
+        DateTime.rfc3339(date_time + 'Z')
+      end
+    end
+  end
+end