bluevia 1.0

data/lib/bluevia/base_client.rb

@@ -0,0 +1,401 @@
+#
+# BlueVia is a global iniciative of Telefonica delivered by Movistar and O2.
+# Please, check out www.bluevia.com and if you need more information
+# contact us at mailto:support@bluevia.com
+
+require 'net/http'
+require 'net/https'
+require 'uri'
+require 'cgi'
+require 'bluevia/utils'
+require 'bluevia/response'
+require 'bluevia/ext/hash'
+require 'bluevia/utils'
+require 'bluevia/errors'
+require 'bluevia/bluevia_logger'
+require 'oauth/client/helper'
+
+module Bluevia
+  #
+  # Abstract class that wraps access to REST services
+  #
+
+  class BaseClient
+    include BlueviaLogger
+
+    attr_accessor :base_uri
+
+    #
+    # REST INTERFACE CONFIGURATION
+    #
+
+    # Base URI to invoke Bluevia API. Production environment
+    BASEURI = "https://api.bluevia.com"
+
+    # Base Path to invoke Bluevia API. Production environment
+    BASEPATH = "/services/REST"
+
+    # Default parameters required to invoke API
+    DEFAULT_PARAMS = {:version => "v1", :alt => "json"}
+    # Endpoint for commercial (either testing or commercial apps)
+    BASEPATH_COMMERCIAL = ""
+    # Endpoint for sandbox (either testing or commercial apps)
+    BASEPATH_SANDBOX    = "_Sandbox"
+
+    # HTTP Proxy is SDK is being used behind a firewall
+    PROXY = nil #"localhost:8888" #, "nube.hi.inet:8080"
+
+    def BaseClient.create_rest_client(uri = nil)
+      @@base_uri = uri.nil? ? BASEURI : uri
+      @@uri = URI.parse(@@base_uri)
+
+      # Set proxy if required
+      unless PROXY.nil?
+        proxy = PROXY.split(":")
+        rest = Net::HTTP::Proxy(proxy[0], proxy[1]).new(@@uri.host, @@uri.port)
+      else
+        rest = Net::HTTP.new(@@uri.host, @@uri.port)
+      end
+      # Set HTTP connection with SSL if required
+      if @@uri.instance_of?(URI::HTTPS)
+        rest.use_ssl = true
+      end
+      rest.read_timeout=(5)
+      rest
+    end
+
+
+    #
+    # Creates basic HTTP client
+    #
+    def initialize(params = nil)
+      @@uri = URI.parse(BASEURI)
+
+      if params.nil?
+        @rest = BaseClient.create_rest_client
+      elsif params.instance_of?(Hash)
+        params.has_key?(:rest) and @rest = params[:rest]
+        params.has_key?(:logger) and logger = params[:logger]
+      else
+        @rest = params
+      end
+
+      logger.debug "Initialized baseClient for service: #{self.class.name}"
+    end
+
+    #
+    # set HTTP client
+    #
+    def set_http_client(rest)
+      @rest = rest
+    end
+
+    #
+    # set the valid timeout for the HTTP requests
+    #
+    def set_timeout(timeout = 5)
+      !timeout.nil? and @rest.read_timeout(timeout)
+    end
+
+    #
+    # Define an instance variable using the default Hash syntax
+    #
+    def []=(key, value)
+      self.instance_variable_set(:"@#{key}", value) unless key.nil?
+    end
+
+    #
+    # Creates a valid path by concat the path received
+    # with the path defined in BASEPATH
+    #
+    def set_path(_path = nil)
+      path = BASEPATH.clone
+      path << _path unless _path.nil?
+    end
+
+    #
+    # Include params in the URI being created to perform a REST call
+    #
+    def include_params(_path, _params)
+      "#{_path}?".
+        concat(
+        _params.collect{
+          |k,v|
+          "#{k}=#{CGI::escape(v.to_s)}"
+        }.reverse.join('&')) unless _params.nil?
+    end
+
+    # Each Bluevia API has a specific basepath. This method gets the specific
+    # service basepath and the path associated to the request (either test or
+    # commercial)
+    def get_basepath
+      begin
+        basepath = self.class.const_get("BASEPATH_API")
+      rescue NameError => e
+        logger.error "Unable to fetch basepath #{e}"
+        basepath = "/#{self.class.to_s.upcase}_"
+      end
+
+      if @commercial
+        path = BASEPATH_COMMERCIAL
+      else
+        path = BASEPATH_SANDBOX
+      end
+      "#{basepath}#{path}"
+    end
+
+    #
+    # Send an Http::Get to the server
+    #
+    def GET(_path = nil, params = nil, headers = nil, field = nil)
+      path = set_path(_path)
+      params = Hash.new if params.nil?
+      params.merge!(DEFAULT_PARAMS) { |key,oldval,newval| oldval }
+
+      path = include_params(path, params)
+
+      logger.debug "GET Request path: " << path
+
+      begin
+        resp = authorized_client.get(path, get_headers(headers))
+      rescue => e
+        logger.error e
+      end
+      return handle_response(create_response(resp), "body", field)
+    end
+
+    #
+    #  Send an Http::Post to the server
+    #
+    def POST(_path = nil, body = nil, headers = nil, files = nil, return_header = nil)
+
+      if files.nil?
+        path = set_path(_path)
+        path = include_params(path, DEFAULT_PARAMS)
+        logger.debug "POST Request path: " << path
+        logger.debug "POST body: " << body
+
+        begin
+          resp = authorized_client.post(path, body, get_headers(headers, true))
+        rescue => e
+          logger.error e
+        end
+        return handle_response(create_response(resp), return_header.nil? ? nil : "headers", return_header)
+      else
+        return POST_MULTIPART(_path, body, headers, files)
+      end
+    end
+
+    #
+    # Send an Http::Delete to the server
+    #
+    def DELETE(_path = nil, headers = nil)
+      path = set_path(_path)
+      path = include_params(path, DEFAULT_PARAMS)
+
+      logger.debug "DELETE Request path: " << path
+
+      resp = authorized_client.delete(path, get_headers(headers, false))
+      return handle_response(create_response(resp))
+    end
+
+    def authorized_client
+      @consumer ||= OAuth::Consumer.new(@consumer_key, @consumer_secret, :site => @@base_uri)
+      @access_token ||= OAuth::AccessToken.new(@consumer, @token, @token_secret)
+      @access_token
+    end
+
+    #
+    # Creates the basic header while creating an HTTP Request
+    #
+    def get_headers(_headers = nil, is_post = false)
+      
+      headers = {
+        "Accept" => "application/json"
+        }
+
+      if is_post
+        headers["Content-Type"] = "application/json"
+      end
+
+      unless _headers.nil?
+        headers.merge!(_headers) { |key,oldval,newval| newval }
+      end
+      logger.debug "HEADERS: "
+      logger.debug headers
+      return headers
+    end
+
+    private
+
+    # Converts an HTTP response to an internal object
+    def create_response(http_response)
+      return nil if http_response.nil?
+
+      response = Response.new
+      response.code    = http_response.code
+      response.message = http_response.message
+
+      # headers
+      response.headers = Hash.new
+
+      http_response.each_header {|key, value|
+        response.headers[key] = value
+      }
+
+      # body
+      begin
+        # Convert JSON
+        if response.headers["content-type"].to_s.start_with?("application/json")
+          unless http_response.body.nil? or http_response.body.empty?
+            response.body = JSON.parse(http_response.body)
+          else
+            response.body = ""
+          end
+        # Convert XML to Hash
+        elsif response.headers["content-type"].to_s.start_with?("application/xml")
+          begin
+            response.body = Hash.from_xml(http_response.body)
+          rescue => e
+            logger.error "Unable to decode response: #{e.to_s}"
+            raise ServerError, "Unable to decode XML response"
+          end
+        # Do nothing
+        else
+          response.body = http_response.body
+        end
+      rescue => e
+        logger.error "Error while converting response"
+        logger.error e
+        raise ServerError, "Error while processing the response"
+      end
+      logger.debug response.to_s
+      return response
+    end
+
+    #
+    # This method is in charge of verify the code retrieved from the server and
+    # handle it properly.
+    # In case of get a field, just this JSON filed is retrieved from the body response
+    #
+    # Examples:
+    #
+    # response.code = 200
+    # response.body = {"name": "foo", "surname": "bar", "age": 32, "address": "Nissim Aloni"}
+    #
+    # handle_response(response, {"name"}) => "foo"
+    # handle_response(response) => {"name": "foo", "surname": "bar", "age": 32, "address": "Nissim Aloni"}
+    # handle_response(response, {"age"}) => 32
+    #
+    def handle_response(response, field_name = nil, field_value = nil)
+      unless response.nil?
+        
+        if !field_name.nil? && field_value.instance_of?(String)
+          field_value = [field_value]
+        end
+
+        # Valid response
+        if response.code =~ /20?/
+          unless field_name.nil?
+            response_field = response[field_name]
+            if field_value.nil?
+              return response_field
+            end
+            unless response_field.nil?
+              if response_field.instance_of?(Hash)
+                unless field_value.nil? || !field_value.instance_of?(Array)
+                  field_value.each{ |key|
+                    unless response_field.has_key?(key)
+                      raise ClientError, "Unable to find the request data: #{key}"
+                    end
+                    response_field = response_field[key]
+                  }
+                end
+                return response_field
+              end
+            else
+              return false
+            end
+          else
+            return response
+          end
+        # Not found
+        elsif response.code.eql?("404")
+          raise NotFoundError, "Unable to find the resource: #{response.message} - #{response.body}"
+        # 40?
+        elsif response.code =~ /40?/
+          raise ClientError, "Error #{response.code} received: #{response.message} - #{response.body}"
+        # Not implemented
+        elsif response.code =~ /501/
+          raise NotImplementedError, "Operation not implemented in server side #{response.message} - #{response.body}"
+        # Server Error
+        elsif response.code =~ /500/
+          raise ServerError, "Server error #{response.message} - #{response.body}"
+        end
+      else
+        raise ServerError, "Unable to connect with endpoint."
+      end
+    end
+
+    #
+    # Send an Http::Post::Multipart to the server
+    #
+    def POST_MULTIPART(_path = nil, body = nil, headers = nil, files = nil)
+      path = set_path(_path)
+      path = include_params(path, DEFAULT_PARAMS)
+      unless files.nil?
+        logger.debug "POST MULTIPART " << path
+        multipart_data = Hash.new
+        #prueba = Utils::Multipart.new
+        unless files.nil?
+          if files.instance_of?(String) or (files.instance_of?(Array) and files.length == 1)
+            if files.instance_of?(Array)
+              files = files[0]
+            end
+            multipart_data["attachments"] = UploadIO.new(files, Utils.get_file_mime_type(files))
+          elsif files.instance_of?(Array)
+            requestbody = String.new
+            mimeboundary = "ABC123Boundary"
+            files.each{|file|
+              requestbody << "\r\n"
+              requestbody << "--#{mimeboundary}\n"
+              requestbody << "\r\n"
+              requestbody << "Content-Disposition: attachment; fileName=\"text.txt\""
+              requestbody << "\r\n"
+              requestbody << "Content-Type: #{Utils.get_file_mime_type(file)}\n"
+              requestbody << "\r\n"
+              content = File.open(file, "rb")
+              requestbody << "#{content.read}\n"
+            }
+            requestbody << "--#{mimeboundary}--\n"
+            multipart_data["attachment"] = UploadIO.new(StringIO.new(requestbody), "multipart/mixed; boundary=#{mimeboundary}", "attachments")
+          elsif files.instance_of?(Hash) && files.has_key?(:text)
+            multipart_data["attachments"] = UploadIO.new(StringIO.new(files[:text]), "text/plain", "text")
+          else
+            logger.error "Not sure about how to send this object: #{files.class.name}"
+          end
+        end
+        multipart_data["message"]     = UploadIO.new(StringIO.new(body), "application/json", "root-field")
+        logger.debug "MULTIPART POST message: #{body}"
+        req = Net::HTTP::Post::Multipart.new(
+          path,
+          multipart_data,
+          get_headers(headers, true)
+        )
+
+        # Set proxy if required
+        unless PROXY.nil?
+          proxy = PROXY.split(":")
+          rest = Net::HTTP::Proxy(proxy[0], proxy[1]).new(@@uri.host,@@uri.port)
+        else
+          rest = Net::HTTP.new(@@uri.host,@@uri.port)
+        end
+        res = rest.start do |http|
+          http.request(req)
+        end
+
+        return create_response(res)
+      end
+    end
+  end
+end

data/lib/bluevia/bluevia_client.rb

@@ -0,0 +1,119 @@
+#
+# BlueVia is a global iniciative of Telefonica delivered by Movistar and O2.
+# Please, check out www.bluevia.com and if you need more information
+# contact us at mailto:support@bluevia.com
+
+require 'rubygems'
+require 'json'
+require 'uri'
+require 'net/http'
+require 'bluevia/directory'
+require 'bluevia/sms'
+require 'bluevia/oauth'
+require 'bluevia/advertising'
+require 'bluevia/bluevia_logger'
+
+module Bluevia
+  #
+  # This class is the main client to access Bluevia API.
+  # It defines a services factory that provides an isolated way to reach
+  # each API. Currently the following APIs are supported:
+  # * oAuth authentication
+  # * SMS
+  # * Advertising
+  # * Directory
+  #
+  # When creating a BlueviaClient instance, basic authentication parameters
+  # can be provided:
+  #
+  # require 'bluevia'
+  #
+  # bc = BlueviaClient.new(
+  #      { :consumer_key => <YOUR_CONSUMER_KEY>,
+  #        :consumer_secret => <YOUR_CONSUMER_SECRET>,
+  #        :token => <OAUTH_TOKEN>,
+  #        :token_secret => <OAUTH_TOKEN_SECRET>
+  #      })
+  #
+
+  class BlueviaClient
+    include BlueviaLogger
+
+    # Constructor
+    def initialize(params = nil)
+
+      unless params.nil? || params[:uri].nil?
+        rest = BaseClient.create_rest_client(params[:uri])
+      else
+        rest = BaseClient.create_rest_client
+      end
+
+      @commercial      = false
+      @consumer_key    = nil
+      @consumer_secret = nil
+
+      unless params.nil?
+        %w(consumer_key consumer_secret token token_secret).each{ |param|
+          self.instance_variable_set(:"@#{param}", params[:"#{param}"]) unless params[:"#{param}"].nil?
+        }
+      end
+      
+      @factory = ServicesFactory.new(rest)
+    end
+
+    # Retrieves a specific service to call any related API
+    # i.e.
+    # sms = bc.get_service(:Sms)
+    def get_service(_service)
+      service = @factory.get(_service)
+      service[:consumer_key]    = @consumer_key   unless @consumer_key.nil?
+      service[:consumer_secret] = @consumer_secret unless @consumer_secret.nil?
+      service[:token]           = @token          unless @token.nil?
+      service[:token_secret]    = @token_secret   unless @token_secret.nil?
+      service[:commercial]      = @commercial
+      return service
+    end
+
+    # Client will get access to commercial APIs
+    def set_commercial
+      @commercial = true
+    end
+
+    # Client will get access to sandbox APIs
+    def set_sandbox
+      @commercial = false
+    end
+
+    # {true|false} if commercial or sandbox client
+    def commercial?
+      return @commercial
+    end
+  end
+
+  # This service factory wraps the initialization of a service
+  class ServicesFactory
+    include BlueviaLogger
+    def initialize(rest = nil)
+      @directory      = Directory.new({:rest =>rest, :logger => logger})
+      @sms            = Sms.new({:rest =>rest, :logger => logger})
+      @advertising    = Advertising.new({:rest =>rest, :logger => logger})
+      @oauth          = Oauth.new({:rest =>rest, :logger => logger})
+    end
+
+    def get(service)
+      case service.to_s.downcase
+        when "directory"
+          return @directory
+        when "sms"
+          return @sms
+        when "oauth"
+          return @oauth
+        when "advertising"
+          return @advertising
+        else
+          raise(SyntaxError, "Service not valid")
+      end
+    end
+
+  end
+end