messagemedia_lookups_sdk 1.0.0

data/lib/message_media_lookups/configuration.rb

@@ -0,0 +1,35 @@
+
+module MessageMediaLookups
+
+  Logging.logger.root.appenders = Logging.appenders.stdout
+  Logging.logger.root.level = :info
+
+  # All configuration including auth info and base URI for the API access
+  # are configured in this class.
+  class Configuration
+    # The base Uri for API calls
+    @base_uri = 'https://api.messagemedia.com'
+
+    # The username to use with basic authentication
+    @basic_auth_user_name = 'TODO: Replace'
+
+    # The password to use with basic authentication
+    @basic_auth_password = 'TODO: Replace'
+
+    # The username to use with HMAC authentication
+    @hmac_auth_user_name = nil
+
+    # The password to use with HMAC authentication
+    @hmac_auth_password = nil
+
+    # The attribute accessors for public properties.
+    class << self
+      attr_accessor :array_serialization
+      attr_accessor :base_uri
+      attr_accessor :basic_auth_user_name
+      attr_accessor :basic_auth_password
+      attr_accessor :hmac_auth_user_name
+      attr_accessor :hmac_auth_password
+    end
+  end
+end

data/lib/message_media_lookups/controllers/base_controller.rb

@@ -0,0 +1,63 @@
+
+module MessageMediaLookups
+  # Base controller.
+  class BaseController
+    attr_accessor :http_client, :http_call_back
+
+    def initialize(http_client: nil, http_call_back: nil)
+      @http_client = http_client || FaradayClient.new
+      @http_call_back = http_call_back
+
+      @global_headers = {
+        'user-agent' => 'messagemedia-lookups-ruby-sdk-1.0.0'
+      }
+      @logger = Logging.logger[self]
+      @logger.info("Instantiated controller class.")
+    end
+
+    def validate_parameters(args)
+      args.each do |_name, value|
+        if value.nil?
+          raise ArgumentError, "Required parameter #{_name} cannot be nil."
+        end
+      end
+    end
+
+    def apply_authentication(request, url, body=nil)
+      if Configuration.hmac_auth_user_name == nil or Configuration.hmac_auth_password == nil
+        BasicAuth.apply(request)
+      else
+        HmacAuth.apply(request, url, body)
+      end
+    end
+
+    def execute_request(request, binary: false, name: nil)
+      @logger.info("Calling the on_before_request method of http_call_back for #{name}.") if @http_call_back
+      @http_call_back.on_before_request(request) if @http_call_back
+
+      @logger.info("Merging global headers with endpoint headers for #{name}.")
+      APIHelper.clean_hash(request.headers)
+      request.headers = @global_headers.clone.merge(request.headers)
+
+      @logger.debug("Raw request for #{name} is: #{request.inspect}")
+      response = if binary
+                   @http_client.execute_as_binary(request)
+                 else
+                   @http_client.execute_as_string(request)
+                 end
+      @logger.debug("Raw response for #{name} is: #{response.inspect}")
+      @logger.info("Wrapping request and response in a context object for #{name}.")
+      context = HttpContext.new(request, response)
+
+      @logger.info("Calling on_after_response method of http_call_back for #{name}.") if @http_call_back
+      @http_call_back.on_after_response(context) if @http_call_back
+
+      context
+    end
+
+    def validate_response(context)
+      raise APIException.new 'HTTP Response Not OK', context unless
+        context.response.status_code.between?(200, 208) # [200,208] = HTTP OK
+    end
+  end
+end

data/lib/message_media_lookups/controllers/lookups_controller.rb

@@ -0,0 +1,121 @@
+
+module MessageMediaLookups
+  # LookupsController
+  class LookupsController < BaseController
+    @instance = LookupsController.new
+
+    class << self
+      attr_accessor :instance
+    end
+
+    def instance
+      self.class.instance
+    end
+
+    # Use the Lookups API to find information about a phone number.
+    # A request to the lookups API has the following format:
+    # ```/v1/lookups/phone/{phone_number}?options={carrier,type}```
+    # The `{phone_number}` parameter is a required field and should be set to
+    # the phone number to be looked up.
+    # The options query parameter can also be used to request additional
+    # information about the phone number.
+    # By default, a request will only return the `country_code` and
+    # `phone_number` properties in the response.
+    # To request details about the the carrier, include `carrier` as a value of
+    # the options parameter.
+    # To request details about the type, include `type` as a value of the
+    # options parameter. To pass multiple values
+    # to the options parameter, use a comma separated list, i.e. `carrier,type`.
+    # A successful request to the lookups endpoint will return a response body
+    # as follows:
+    # ```json
+    # {
+    #   "country_code": "AU",
+    #   "phone_number": "+61491570156",
+    #   "type": "mobile",
+    #   "carrier": {
+    #     "name": "Telstra"
+    #   }
+    # }
+    # ```
+    # Each property in the response body is defined as follows:
+    # - ```country_code``` ISO ALPHA 2 country code of the phone number
+    # - ```phone_number``` E.164 formatted phone number
+    # - ```type``` The type of number. This can be ```"mobile"``` or
+    # ```"landline"```
+    # - ```carrier``` Holds information about the specific carrier (if
+    # available)
+    #   - ```name``` The carrier's name as reported by the network
+    # @param [String] phone_number Required parameter: The phone number to be
+    # looked up
+    # @param [String] options Optional parameter: Example:
+    # @return LookupAPhoneNumberResponse response from the API call
+    def get_lookup_a_phone_number(phone_number,
+                                  options = nil)
+      begin
+        @logger.info("get_lookup_a_phone_number called.")
+
+        request_url = '/v1/lookups/phone/{phone_number}'
+        request_url = APIHelper.append_url_with_template_parameters(
+            request_url,
+            'phone_number' => phone_number
+        )
+
+        # Prepare query url.
+        @logger.info("Preparing query URL for get_lookup_a_phone_number.")
+        _query_builder = Configuration.base_uri.dup
+        _query_builder << '/v1/lookups/phone/{phone_number}'
+        _query_builder = APIHelper.append_url_with_template_parameters(
+          _query_builder,
+          'phone_number' => phone_number
+        )
+        _query_builder = APIHelper.append_url_with_query_parameters(
+          _query_builder,
+          {
+            'options' => options
+          },
+          array_serialization: Configuration.array_serialization
+        )
+        _query_url = APIHelper.clean_url _query_builder
+
+        # Prepare headers.
+        @logger.info("Preparing headers for get_lookup_a_phone_number.")
+        _headers = {
+          'accept' => 'application/json',
+          'user-agent' => 'messagemedia-lookups-ruby-sdk-1.1.0'
+        }
+
+        # Prepare and execute HttpRequest.
+        @logger.info('Preparing and executing HttpRequest for get_lookup_a_phone_number.')
+        _request = @http_client.get(
+          _query_url,
+          headers: _headers
+        )
+
+        apply_authentication(_request, request_url)
+        # BasicAuth.apply(_request)
+
+        _context = execute_request(_request, name: 'get_lookup_a_phone_number')
+
+        # Validate response against endpoint and global error codes.
+        @logger.info("Validating response for get_lookup_a_phone_number.")
+        if _context.response.status_code == 404
+          raise APIException.new(
+            'Number was invalid',
+            _context
+          )
+        end
+        validate_response(_context)
+
+        # Return appropriate response type.
+        @logger.info("Returning response for get_lookup_a_phone_number.")
+        decoded = APIHelper.json_deserialize(_context.response.raw_body)
+        LookupAPhoneNumberResponse.from_hash(decoded)
+
+      rescue Exception => e
+        @logger.error(e)
+        raise e
+      end
+    end
+  end
+end

data/lib/message_media_lookups/exceptions/api_exception.rb

@@ -0,0 +1,16 @@
+
+module MessageMediaLookups
+  # Class for exceptions when there is a network error, status code error, etc.
+  class APIException < StandardError
+    attr_reader :context, :response_code
+
+    # The constructor.
+    # @param [String] The reason for raising an exception.
+    # @param [HttpContext] The HttpContext of the API call.
+    def initialize(reason, context)
+      super(reason)
+      @context = context
+      @response_code = context.response.status_code
+    end
+  end
+end

data/lib/message_media_lookups/http/auth/basic_auth.rb

@@ -0,0 +1,21 @@
+
+require 'base64'
+
+module MessageMediaLookups
+  # Utility class for basic authorization.
+  class BasicAuth
+    # Add basic authentication to the request.
+    # @param [HttpRequest] The HttpRequest object to which authentication will
+    # be added.
+    def self.apply(http_request)
+      username = Configuration.basic_auth_user_name
+      password = Configuration.basic_auth_password
+      if(username.length != 20 || password.length != 30)
+        puts("~~~~~ It appears as though your REST API Keys are invalid. Please check and make sure they are correct. (Invalid Length) ~~~~~")
+      end
+      value = Base64.strict_encode64("#{username}:#{password}")
+      header_value = "Basic #{value}"
+      http_request.headers['Authorization'] = header_value
+    end
+  end
+end

data/lib/message_media_lookups/http/auth/hmac_auth.rb

@@ -0,0 +1,52 @@
+
+require 'base64'
+
+module MessageMediaMessages
+  # Utility class for basic authorization.
+  class HmacAuth
+    def self.create_signature(date, content_signature, url, body=nil)
+      request_type = "GET"
+
+      if body != nil
+        request_type = "POST"
+      end
+
+      signing_string = "date: #{date}\n#{content_signature}#{request_type} #{url} HTTP/1.1"
+      hmac = OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha1'), Configuration.hmac_auth_password.encode("ASCII"), signing_string.encode("ASCII"))
+
+      return Base64.encode64(hmac).chomp
+    end
+
+    # Add basic authentication to the request.
+    # @param [HttpRequest] The HttpRequest object to which authentication will
+    # be added.
+    def self.apply(http_request, url=nil, body=nil)
+      username = Configuration.hmac_auth_user_name
+
+      content_signature = ""
+      content_header = ""
+
+      now = DateTime.now.new_offset(0).to_time.strftime("%a, %d %b %Y %H:%M:%S GMT")
+
+      date_header = now
+
+      if body != nil
+        md5 = Digest::MD5.new
+        md5.update(body)
+
+        content_hash = md5.hexdigest
+        content_signature = "x-Content-MD5: #{content_hash}\n"
+        content_header = "x-Content-MD5 "
+        http_request.headers["x-Content-MD5"] = content_hash
+      end
+
+      http_request.headers["date"] = date_header
+
+      hmac_signature = HmacAuth.create_signature(date_header, content_signature, url, body)
+
+      joined = "username=\"#{username}\", algorithm=\"hmac-sha1\", headers=\"date #{content_header}request-line\", signature=\"#{hmac_signature}\""
+      header_value = "hmac #{joined}"
+      http_request.headers["Authorization"] = header_value
+    end
+  end
+end

data/lib/message_media_lookups/http/faraday_client.rb

@@ -0,0 +1,54 @@
+
+require 'faraday/http_cache'
+
+module MessageMediaLookups
+  # An implementation of HttpClient.
+  class FaradayClient < HttpClient
+    # The constructor.
+    def initialize(timeout: nil, cache: false,
+                   max_retries: nil, retry_interval: nil)
+      @connection = Faraday.new do |faraday|
+        faraday.use Faraday::HttpCache, serializer: Marshal if cache
+        faraday.request :multipart
+        faraday.request :url_encoded
+        faraday.ssl[:ca_file] = Certifi.where
+        faraday.adapter Faraday.default_adapter
+        faraday.options[:params_encoder] = Faraday::FlatParamsEncoder
+        faraday.options[:open_timeout] = timeout if timeout
+        faraday.request :retry, max: max_retries, interval: if max_retries &&
+                                                               retry_interval
+                                                              retry_interval
+                                                            end
+      end
+    end
+
+    # Method overridden from HttpClient.
+    def execute_as_string(http_request)
+      response = @connection.send(
+        http_request.http_method.downcase,
+        http_request.query_url
+      ) do |request|
+        request.headers = http_request.headers
+        request.body = http_request.parameters
+      end
+      convert_response(response)
+    end
+
+    # Method overridden from HttpClient.
+    def execute_as_binary(http_request)
+      response = @connection.send(
+        http_request.http_method.downcase,
+        http_request.query_url
+      ) do |request|
+        request.headers = http_request.headers
+        request.body = http_request.parameters
+      end
+      convert_response(response)
+    end
+
+    # Method overridden from HttpClient.
+    def convert_response(response)
+      HttpResponse.new(response.status, response.headers, response.body)
+    end
+  end
+end

data/lib/message_media_lookups/http/http_call_back.rb

@@ -0,0 +1,20 @@
+
+module MessageMediaLookups
+  # HttpCallBack allows defining callables for pre and post API calls.
+  class HttpCallBack
+    # A controller will call this method before making an HTTP Request.
+    # @param [HttpRequest] The HttpRequest object which the HttpClient
+    # will execute.
+    def on_before_request(_http_request)
+      raise NotImplementedError, 'This method needs
+        to be implemented in a child class.'
+    end
+
+    # A controller will call this method after making an HTTP Request.
+    # @param [HttpContext] The HttpContext of the API call.
+    def on_after_response(_http_context)
+      raise NotImplementedError, 'This method needs
+        to be implemented in a child class.'
+    end
+  end
+end

data/lib/message_media_lookups/http/http_client.rb

@@ -0,0 +1,90 @@
+
+module MessageMediaLookups
+  # An interface for the methods that an HTTP Client must implement.
+  #
+  # This class should not be instantiated but should be used as a base class
+  # for HTTP Client classes.
+  class HttpClient
+    # Execute an HttpRequest when the response is expected to be a string.
+    # @param [HttpRequest] The HttpRequest to be executed.
+    def execute_as_string(_http_request)
+      raise NotImplementedError, 'This method needs
+        to be implemented in a child class.'
+    end
+
+    # Execute an HttpRequest when the response is expected to be binary.
+    # @param [HttpRequest] The HttpRequest to be executed.
+    def execute_as_binary(_http_request)
+      raise NotImplementedError, 'This method needs
+        to be implemented in a child class.'
+    end
+
+    # Converts the HTTP Response from the client to an HttpResponse object.
+    # @param [Dynamic] The response object received from the client.
+    def convert_response(_response)
+      raise NotImplementedError, 'This method needs
+        to be implemented in a child class.'
+    end
+
+    # Get a GET HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    def get(query_url,
+            headers: {})
+      HttpRequest.new(HttpMethodEnum::GET,
+                      query_url,
+                      headers: headers)
+    end
+
+    # Get a POST HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    # @param [Hash, Optional] The parameters for the HTTP Request.
+    def post(query_url,
+             headers: {},
+             parameters: {})
+      HttpRequest.new(HttpMethodEnum::POST,
+                      query_url,
+                      headers: headers,
+                      parameters: parameters)
+    end
+
+    # Get a PUT HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    # @param [Hash, Optional] The parameters for the HTTP Request.
+    def put(query_url,
+            headers: {},
+            parameters: {})
+      HttpRequest.new(HttpMethodEnum::PUT,
+                      query_url,
+                      headers: headers,
+                      parameters: parameters)
+    end
+
+    # Get a PATCH HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    # @param [Hash, Optional] The parameters for the HTTP Request.
+    def patch(query_url,
+              headers: {},
+              parameters: {})
+      HttpRequest.new(HttpMethodEnum::PATCH,
+                      query_url,
+                      headers: headers,
+                      parameters: parameters)
+    end
+
+    # Get a DELETE HttpRequest object.
+    # @param [String] The URL to send the request to.
+    # @param [Hash, Optional] The headers for the HTTP Request.
+    def delete(query_url,
+               headers: {},
+               parameters: {})
+      HttpRequest.new(HttpMethodEnum::DELETE,
+                      query_url,
+                      headers: headers,
+                      parameters: parameters)
+    end
+  end
+end