weather_API_Assignment 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 333073786678d1c376cb0027ba05c8c39da196572fd6ca56f5ea546f154c4271
+  data.tar.gz: e9569587183412572dbbcb09ab6e97c7b03be4ea2bf009d34e8fb59dfc35df74
+SHA512:
+  metadata.gz: 9dbdfe3032c4e79dd40a0dbe395de5cd42a48b9436b7c0e609260f7abf6f927231d545f05e48c2ba3277d0328ff1621a1d3b07c9bad3396b559594a0c654c2bd
+  data.tar.gz: 48a62ff715e67df4fed53ead69d385f5adb8444c874fbd5d3bac07c5f75ba81062ed6b6073960c651a0beb3b8ec569bbf473eccf02c0f2d36c9af93c4593850d

data/LICENSE

@@ -0,0 +1,28 @@
+License: 
+========
+The MIT License (MIT)
+http://opensource.org/licenses/MIT
+
+Copyright (c) 2014 - 2016 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,187 @@
+# Getting started
+
+This API will provide latest information of current weather
+
+## How to Build
+
+This client library is a Ruby gem which can be compiled and used in your Ruby and Ruby on Rails project. This library requires a few gems from the RubyGems repository.
+
+1. Open the command line interface or the terminal and navigate to the folder containing the source code.
+2. Run ``` gem build weather_api_assignment.gemspec ``` to build the gem.
+3. Once built, the gem can be installed on the current work environment using ``` gem install weather_api_assignment-1.0.gem ```
+
+![Building Gem](https://apidocs.io/illustration/ruby?step=buildSDK&workspaceFolder=Weather_API-Ruby&workspaceName=Weather_API-Ruby&projectName=weather_api_assignment&gemName=weather_api_assignment&gemVer=1.0)
+
+## How to Use
+
+The following section explains how to use the WeatherApiAssignment Ruby Gem in a new Rails project using RubyMine™. The basic workflow presented here is also applicable if you prefer using a different editor or IDE.
+
+### 1. Starting a new project
+
+Close any existing projects in RubyMine™ by selecting ``` File -> Close Project ```. Next, click on ``` Create New Project ``` to create a new project from scratch.
+
+![Create a new project in RubyMine](https://apidocs.io/illustration/ruby?step=createNewProject0&workspaceFolder=Weather_API-Ruby&workspaceName=WeatherApiAssignment&projectName=weather_api_assignment&gemName=weather_api_assignment&gemVer=1.0)
+
+Next, provide ``` TestApp ``` as the project name, choose ``` Rails Application ``` as the project type, and click ``` OK ```.
+
+![Create a new Rails Application in RubyMine - step 1](https://apidocs.io/illustration/ruby?step=createNewProject1&workspaceFolder=Weather_API-Ruby&workspaceName=WeatherApiAssignment&projectName=weather_api_assignment&gemName=weather_api_assignment&gemVer=1.0)
+
+In the next dialog make sure that correct *Ruby SDK* is being used (minimum 2.0.0) and click ``` OK ```.
+
+![Create a new Rails Application in RubyMine - step 2](https://apidocs.io/illustration/ruby?step=createNewProject2&workspaceFolder=Weather_API-Ruby&workspaceName=WeatherApiAssignment&projectName=weather_api_assignment&gemName=weather_api_assignment&gemVer=1.0)
+
+This will create a new Rails Application project with an existing set of files and folder.
+
+### 2. Add reference of the gem
+
+In order to use the WeatherApiAssignment gem in the new project we must add a gem reference. Locate the ```Gemfile``` in the *Project Explorer* window under the ``` TestApp ``` project node. The file contains references to all gems being used in the project. Here, add the reference to the library gem by adding the following line: ``` gem 'weather_api_assignment', '~> 1.0' ```
+
+![Add references of the Gemfile](https://apidocs.io/illustration/ruby?step=addReference&workspaceFolder=Weather_API-Ruby&workspaceName=WeatherApiAssignment&projectName=weather_api_assignment&gemName=weather_api_assignment&gemVer=1.0)
+
+### 3. Adding a new Rails Controller
+
+Once the ``` TestApp ``` project is created, a folder named ``` controllers ``` will be visible in the *Project Explorer* under the following path: ``` TestApp > app > controllers ```. Right click on this folder and select ``` New -> Run Rails Generator... ```.
+
+![Run Rails Generator on Controllers Folder](https://apidocs.io/illustration/ruby?step=addCode0&workspaceFolder=Weather_API-Ruby&workspaceName=WeatherApiAssignment&projectName=weather_api_assignment&gemName=weather_api_assignment&gemVer=1.0)
+
+Selecting the said option will popup a small window where the generator names are displayed. Here, select the ``` controller ``` template.
+
+![Create a new Controller](https://apidocs.io/illustration/ruby?step=addCode1&workspaceFolder=Weather_API-Ruby&workspaceName=WeatherApiAssignment&projectName=weather_api_assignment&gemName=weather_api_assignment&gemVer=1.0)
+
+Next, a popup window will ask you for a Controller name and included Actions. For controller name provide ``` Hello ``` and include an action named ``` Index ``` and click ``` OK ```.
+
+![Add a new Controller](https://apidocs.io/illustration/ruby?step=addCode2&workspaceFolder=Weather_API-Ruby&workspaceName=WeatherApiAssignment&projectName=weather_api_assignment&gemName=weather_api_assignment&gemVer=1.0)
+
+A new controller class anmed ``` HelloController ``` will be created in a file named ``` hello_controller.rb ``` containing a method named ``` Index ```. In this method, add code for initialization and a sample for its usage.
+
+![Initialize the library](https://apidocs.io/illustration/ruby?step=addCode3&workspaceFolder=Weather_API-Ruby&workspaceName=WeatherApiAssignment&projectName=weather_api_assignment&gemName=weather_api_assignment&gemVer=1.0)
+
+## How to Test
+
+You can test the generated SDK and the server with automatically generated test
+cases as follows:
+
+  1. From terminal/cmd navigate to the root directory of the SDK.
+  2. Invoke: `bundle exec rake`
+
+## Initialization
+
+### Authentication
+In order to setup authentication and initialization of the API client, you need the following information.
+
+| Parameter | Description |
+|-----------|-------------|
+| appid | App key for authentication |
+
+
+
+API client can be initialized as following.
+
+```ruby
+# Configuration parameters and credentials
+appid = '178db63aed00f6e4daaa06009b04438b' # App key for authentication
+
+client = WeatherApiAssignment::WeatherApiAssignmentClient.new(
+  appid: appid
+)
+```
+
+The added initlization code can be debugged by putting a breakpoint in the ``` Index ``` method and running the project in debug mode by selecting ``` Run -> Debug 'Development: TestApp' ```.
+
+![Debug the TestApp](https://apidocs.io/illustration/ruby?step=addCode4&workspaceFolder=Weather_API-Ruby&workspaceName=WeatherApiAssignment&projectName=weather_api_assignment&gemName=weather_api_assignment&gemVer=1.0&initLine=client%2520%253D%2520WeatherApiAssignmentClient.new%2528%2527appid%2527%2529)
+
+
+
+# Class Reference
+
+## <a name="list_of_controllers"></a>List of Controllers
+
+* [WeatherAPIsController](#weather_ap_is_controller)
+
+## <a name="weather_ap_is_controller"></a>![Class: ](https://apidocs.io/img/class.png ".WeatherAPIsController") WeatherAPIsController
+
+### Get singleton instance
+
+The singleton instance of the ``` WeatherAPIsController ``` class can be accessed from the API Client.
+
+```ruby
+weatherAPIs_controller = client.weather_ap_is
+```
+
+### <a name="get_weather_by_city_name"></a>![Method: ](https://apidocs.io/img/method.png ".WeatherAPIsController.get_weather_by_city_name") get_weather_by_city_name
+
+> This is a weather API endpoint which returns the current weather of a location by city name.
+
+
+```ruby
+def get_weather_by_city_name(q,
+                                 mode = nil,
+                                 units = nil,
+                                 lang = nil); end
+```
+
+#### Parameters
+
+| Parameter | Tags | Description |
+|-----------|------|-------------|
+| q |  ``` Required ```  ``` DefaultValue ```  | City name, state code and country code divided by comma, use ISO 3166 country codes. |
+| mode |  ``` Optional ```  | Response format. Possible values are xml and html. If you don't use the mode parameter format is JSON by default. |
+| units |  ``` Optional ```  | Units of measurement. standard, metric and imperial units are available. If you do not use the units parameter, standard units will be applied by default. |
+| lang |  ``` Optional ```  | You can use this parameter to get the output in your language. |
+
+
+#### Example Usage
+
+```ruby
+q = 'London,uk'
+mode = WeatherApiAssignment::MODEEnum::XML
+units = WeatherApiAssignment::UNITSEnum::STANDARD
+lang = WeatherApiAssignment::LANGEnum::AF
+
+result = weatherAPIs_controller.get_weather_by_city_name(q, mode, units, lang)
+
+```
+
+
+### <a name="get_weather_by_latitude_and_longitude"></a>![Method: ](https://apidocs.io/img/method.png ".WeatherAPIsController.get_weather_by_latitude_and_longitude") get_weather_by_latitude_and_longitude
+
+> This is a weather API endpoint which returns the current weather of a location by latitude and longitude.
+
+
+```ruby
+def get_weather_by_latitude_and_longitude(lat,
+                                              lon,
+                                              mode = nil,
+                                              units = nil,
+                                              lang = nil); end
+```
+
+#### Parameters
+
+| Parameter | Tags | Description |
+|-----------|------|-------------|
+| lat |  ``` Required ```  | This field will contain the latitude of city |
+| lon |  ``` Required ```  | This field will contain the longitude of city |
+| mode |  ``` Optional ```  | Response format. Possible values are xml and html. If you don't use the mode parameter format is JSON by default. |
+| units |  ``` Optional ```  | Units of measurement. standard, metric and imperial units are available. If you do not use the units parameter, standard units will be applied by default. |
+| lang |  ``` Optional ```  | You can use this parameter to get the output in your language. |
+
+
+#### Example Usage
+
+```ruby
+lat = 29.0834359890239
+lon = 29.0834359890239
+mode = WeatherApiAssignment::MODEEnum::XML
+units = WeatherApiAssignment::UNITSEnum::STANDARD
+lang = 'lang'
+
+result = weatherAPIs_controller.get_weather_by_latitude_and_longitude(lat, lon, mode, units, lang)
+
+```
+
+
+[Back to List of Controllers](#list_of_controllers)
+
+
+

data/lib/weather_api_assignment.rb

@@ -0,0 +1,46 @@
+# weather_api_assignment
+#
+# This file was automatically generated by APIMATIC
+# v2.0 ( https://apimatic.io ).
+
+require 'date'
+require 'json'
+require 'faraday'
+require 'certifi'
+require 'logging'
+
+require_relative 'weather_api_assignment/api_helper.rb'
+require_relative 'weather_api_assignment/weather_api_assignment_client.rb'
+
+# Http
+require_relative 'weather_api_assignment/http/http_call_back.rb'
+require_relative 'weather_api_assignment/http/http_client.rb'
+require_relative 'weather_api_assignment/http/http_method_enum.rb'
+require_relative 'weather_api_assignment/http/http_request.rb'
+require_relative 'weather_api_assignment/http/http_response.rb'
+require_relative 'weather_api_assignment/http/http_context.rb'
+require_relative 'weather_api_assignment/http/faraday_client.rb'
+require_relative 'weather_api_assignment/http/auth/custom_query_auth.rb'
+
+# Models
+require_relative 'weather_api_assignment/models/base_model.rb'
+require_relative 'weather_api_assignment/models/weather_api_response.rb'
+require_relative 'weather_api_assignment/models/coord.rb'
+require_relative 'weather_api_assignment/models/weather.rb'
+require_relative 'weather_api_assignment/models/main.rb'
+require_relative 'weather_api_assignment/models/wind.rb'
+require_relative 'weather_api_assignment/models/clouds.rb'
+require_relative 'weather_api_assignment/models/sys.rb'
+require_relative 'weather_api_assignment/models/mode_enum.rb'
+require_relative 'weather_api_assignment/models/units_enum.rb'
+require_relative 'weather_api_assignment/models/lang_enum.rb'
+
+# Exceptions
+require_relative 'weather_api_assignment/exceptions/api_exception.rb'
+
+require_relative 'weather_api_assignment/configuration.rb'
+
+# Controllers
+require_relative 'weather_api_assignment/controllers/base_controller.rb'
+require_relative 'weather_api_assignment/controllers/weather_ap_is' \
+                 '_controller.rb'

data/lib/weather_api_assignment/api_helper.rb

@@ -0,0 +1,275 @@
+# weather_api_assignment
+#
+# This file was automatically generated by APIMATIC
+# v2.0 ( https://apimatic.io ).
+
+module WeatherApiAssignment
+  # 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?
+
+      # Iterate and append parameters.
+      parameters.each do |key, value|
+        replace_value = ''
+
+        if value.nil?
+          replace_value = ''
+        elsif value.instance_of? Array
+          value.map! { |element| CGI.escape(element.to_s) }
+          replace_value = value.join('/')
+        else
+          replace_value = CGI.escape(value.to_s)
+        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.
+    # @param [String] The format of array parameter serialization.
+    def self.append_url_with_query_parameters(query_builder, parameters,
+                                              array_serialization: 'indexed')
+      # 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, 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)
+      encoded = {}
+      form_parameters.each do |key, value|
+        encoded.merge!(APIHelper.form_encode(value, key, formatting:
+          Configuration.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)
+            # print retval
+          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 + ']', formatting: formatting))
+        end
+      else
+        retval[instance_name] = obj
+      end
+      retval
+    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
+
+# Extend types to support to_bool.
+module ToBoolean
+  def to_bool
+    return true if self == true || to_s.strip =~ /^(true|yes|y|1)$/i
+    false
+  end
+end
+
+# Extend NilClass type to support to_bool.
+class NilClass; include ToBoolean; end
+# Extend TrueClass type to support to_bool.
+class TrueClass; include ToBoolean; end
+# Extend FalseClass type to support to_bool.
+class FalseClass; include ToBoolean; end
+# Extend Numeric type to support to_bool.
+class Numeric; include ToBoolean; end
+# Extend String type to support to_bool.
+class String; include ToBoolean; end