smartfocus 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8eac52d54c0b68c2544736e196208f5197772123
+  data.tar.gz: d84d9da100cae9d4ed3fd9b7b0dc987d58004c83
+SHA512:
+  metadata.gz: 45ae22b51f28b0f7e39684f7ff170535d8ca4a41e2044c9eb51ee12e6063a7ced9e037a0eb1b9912428f41ba5a4eb54be1fc13e88238c4cff257ff97c8b473b4
+  data.tar.gz: d0c8255336649508e0a83e3156810b9e01030cb3fc1150a885e38e5f127ee6948f0a2a1b29a79d576f844c914a048853ea408aa529e6246ed8cd63e0f8fb6e04

data/lib/generators/install.rb

@@ -0,0 +1,15 @@
+require 'rails/generators'
+
+module Smartfocus
+  module Generators
+    class Install < Rails::Generators::Base
+      
+      source_root File.expand_path('../templates', __FILE__)
+
+      def generate_config        
+        copy_file "smartfocus.yml", "config/smartfocus.yml" unless File.exist?("config/smartfocus.yml")
+      end
+
+    end    
+  end
+end

data/lib/generators/templates/smartfocus.yml

@@ -0,0 +1,15 @@
+development:
+    server_name:
+    login: 
+    password: 
+    key: 
+production:
+    server_name: 
+    login: 
+    password: 
+    key: 
+test:
+    server_name: 
+    login: 
+    password: 
+    key:

data/lib/smartfocus.rb

@@ -0,0 +1,27 @@
+require 'crack/xml'
+require 'httparty'
+require 'active_support/inflector'
+require 'logger'
+require 'builder'
+
+# Smartfocus API wrapper
+#
+module Smartfocus
+  autoload :Api, 'smartfocus/api'
+  autoload :Exception, 'smartfocus/exception'
+  autoload :Logger, 'smartfocus/logger'
+  autoload :MalformedResponse, 'smartfocus/malformed_response'
+  autoload :Relation, 'smartfocus/relation'
+  autoload :Request, 'smartfocus/request'
+  autoload :RequestError, 'smartfocus/request_error'
+  autoload :Response, 'smartfocus/response'
+  autoload :SessionError, 'smartfocus/session_error'
+  autoload :Tools, 'smartfocus/tools'
+  autoload :Notification, 'smartfocus/notification'
+  autoload :Version, 'smartfocus/version'
+
+  if defined?(Rails)
+    require 'smartfocus/railtie'
+    require 'generators/install'
+  end
+end

data/lib/smartfocus/api.rb

@@ -0,0 +1,173 @@
+module Smartfocus
+
+  # This is where the communication with the API is made.
+  #
+  class Api
+    include HTTParty
+    default_timeout 30
+    format :xml
+    headers 'Content-Type' => 'text/xml'
+
+    # HTTP verbs allowed to trigger a call-chain
+    HTTP_VERBS = [:get, :post].freeze
+    ATTRIBUTES = [:token, :server_name, :endpoint, :login, :password, :key, :debug].freeze
+
+    # Attributes
+    class << self
+      attr_accessor *ATTRIBUTES
+    end
+    attr_accessor *ATTRIBUTES
+
+    # Initialize
+    #
+    # @param [Hash] Instance attributes to assign
+    # @yield Freshly-created instance (optionnal)
+    #
+    def initialize(params = {})
+      yield(self) if block_given?
+      assign_attributes(params)
+    end
+
+    # ----------------- BEGIN Pre-configured methods -----------------
+
+    # Reset session
+    #
+    # Useful when the session has expired.
+    #
+    def reset_session
+      close_connection
+      open_connection
+    end
+
+    # Login to Smartfocus API
+    #
+    # @return [Boolean] true if the connection has been established.
+    #
+    def open_connection
+      return false if connected?
+      self.token = get.connect.open.call :login => @login, :password => @password, :key => @key
+      connected?
+    end
+
+    # Logout from Smartfocus API
+    #
+    # @return [Boolean] true if the connection has been destroyed
+    #
+    def close_connection
+      if connected?
+        get.connect.close.call
+      else
+        return false
+      end
+    rescue Smartfocus::Exception => e
+    ensure
+      invalidate_token!
+      not connected?
+    end
+
+    # Check whether the connection has been established or not
+    #
+    # @return [Boolean] true if the connection has been establshed
+    #
+    def connected?
+      !token.nil?
+    end
+
+    # When a token is no longer valid, this method can be called.
+    # The #connected? method will return false
+    #
+    def invalidate_token!
+      self.token = nil
+    end
+    # ----------------- END Pre-configured methods -----------------    
+
+    # Perform an API call
+    #
+    # @param [Smartfocus::Request] Request to perform
+    #
+    def call(request)
+      # == Check presence of these essential attributes ==
+      unless server_name and endpoint
+        raise Smartfocus::Exception, "Cannot make an API call without a server name and an endpoint !"
+      end
+
+      with_retries do
+        logger.send "#{request.uri} with query : #{request.parameters} and body : #{request.body}"
+
+        response = perform_request(request)
+
+        Smartfocus::Response.new(response, logger).extract
+      end
+    end
+
+    # Set a new token
+    #
+    # @param [String] new token
+    #
+    def token=(value)
+      @token = value
+    end
+
+    # Change API endpoint.
+    # This will close the connection to the current endpoint
+    #
+    # @param [String] new endpoint (apimember, apiccmd, apitransactional, ...)
+    #
+    def endpoint=(value)
+      close_connection
+      @endpoint = value
+    end
+
+    # Base uri
+    #
+    def base_uri
+      "http://#{server_name}/#{endpoint}/services/rest/"
+    end
+
+    # Generate call-chain triggers
+    HTTP_VERBS.each do |http_verb|
+      define_method(http_verb) do
+        Smartfocus::Relation.new(self, build_request(http_verb))
+      end
+    end
+
+    private
+
+    def build_request(http_verb)
+      Smartfocus::Request.new(http_verb, token, server_name, endpoint)
+    end
+
+    def perform_request(request)
+      self.class.send request.http_verb, base_uri + request.uri, :query => request.parameters, :body => request.body, :timeout => 30
+    end
+
+    def assign_attributes(parameters)
+      parameters or return
+      ATTRIBUTES.each do |attribute|
+        public_send("#{attribute}=", (parameters[attribute] || self.class.public_send(attribute)))
+      end
+    end
+
+    def with_retries
+      retries = 3
+      begin
+        yield
+      rescue Errno::ECONNRESET, Timeout::Error => e
+        if ((retries -= 1) > 0)
+          retry
+        else
+          raise e
+        end
+      end
+    end
+
+    def logger
+      if @logger.nil?
+        @logger = Smartfocus::Logger.new(STDOUT)
+        @logger.level = (debug ? Logger::DEBUG : Logger::WARN)
+      end
+      @logger
+    end
+
+  end
+end

data/lib/smartfocus/exception.rb

@@ -0,0 +1,8 @@
+module Smartfocus
+  
+  # API default exception
+  #
+  class Exception < ::StandardError
+
+  end
+end

data/lib/smartfocus/logger.rb

@@ -0,0 +1,29 @@
+module Smartfocus
+  
+  # API logger class
+  #
+  class Logger < ::Logger
+
+    attr_accessor :debug
+
+    def initializer(*args)
+      debug = false
+      super args
+    end
+
+    # Log a message sent to smartfocus
+    #
+    # @param [String] message
+    def send(message)
+      info("[Smartfocus] Send -> #{message}")
+    end
+
+    # Log a message received from smartfocus
+    #
+    # @param [String] message    
+    def receive(message)
+      info("[Smartfocus] Receive -> #{message}")
+    end
+
+  end
+end

data/lib/smartfocus/malformed_response.rb

@@ -0,0 +1,10 @@
+module Smartfocus
+
+  # Malformed response
+  #
+  # This error is raised when the response from Smartfocus
+  # cannot be parsed.
+  class MalformedResponse < Exception
+  end
+
+end

data/lib/smartfocus/notification.rb

@@ -0,0 +1,48 @@
+module Smartfocus
+  class Notification
+    include HTTParty
+    default_timeout 30
+    format :xml
+    headers 'Content-Type' => 'application/xml;charset=utf-8', 'encoding' => 'UTF-8', 'Accept' => '*/*'
+
+    class << self
+      attr_accessor :debug
+    end
+    attr_accessor :debug
+
+    def initialize(params = {})
+      yield(self) if block_given?
+
+      self.debug ||= params[:debug] || self.class.debug
+    end
+
+    def send(body, params = {})
+      # == Processing body ==
+      body_xml = Smartocus::Tools.to_xml_as_is body
+
+      # == Send request ==
+      logger.send "#{base_uri} with body : #{body_xml}"
+      response = self.class.send :post, base_uri, :body => body_xml
+      logger.receive "#{base_uri} with status : #{response.header.inspect}"
+
+      # == Check result ==
+      response.header.code == '200'
+    end
+
+    # Base uri
+    def base_uri
+      'http://api.notificationmessaging.com/NMSXML'
+    end
+
+    private
+
+    def logger
+      if @logger.nil?
+        @logger = Smartocus::Logger.new(STDOUT)
+        @logger.level = (debug ? Logger::DEBUG : Logger::WARN)
+      end
+      @logger
+    end
+
+  end
+end

data/lib/smartfocus/railtie.rb

@@ -0,0 +1,24 @@
+require 'rails'
+
+module Smartocus
+  class Railtie < Rails::Railtie
+
+    generators do
+      require 'generators/install'
+    end
+
+    config.to_prepare do  
+      file = "#{Rails.root}/config/smartfocus.yml"
+      if File.exist?(file)
+        config = YAML.load_file(file)[Rails.env] || {}
+        Smartfocus::Api.server_name    = config['server_name']
+        Smartfocus::Api.endpoint       = config['endpoint']
+        Smartfocus::Api.login          = config['login']
+        Smartfocus::Api.password       = config['password']
+        Smartfocus::Api.key            = config['key']
+        Smartfocus::Api.debug          = config['debug']
+        Smartfocus::Notification.debug = config['debug']
+      end
+    end
+  end
+end

data/lib/smartfocus/relation.rb

@@ -0,0 +1,40 @@
+module Smartfocus
+
+  # Relation is used for API-chained call
+  # 
+  # e.g. emv.get.campaign.last(:limit => 5).call
+  # 
+  class Relation
+
+    def initialize(instance, request)
+      @instance = instance
+      @request = request
+      @uri = []
+      @options = {}
+    end
+
+    # Trigger the API call
+    #
+    # @param [Object] parameters
+    # @return [Object] data returned from Smartfocus
+    #
+    def call(*args)
+      @options.merge! extract_args(args)
+      @request.prepare(@uri.join('/'), @options)
+      @instance.call(@request)
+    end
+
+    def method_missing(method, *args)
+      @uri << method.to_s.camelize(:lower)
+      @options.merge! extract_args(args)
+      self
+    end
+
+    private
+
+    def extract_args(args)
+      (args[0] and args[0].kind_of? Hash) ? args[0] : {}
+    end
+
+  end
+end

data/lib/smartfocus/request.rb

@@ -0,0 +1,67 @@
+module Smartfocus
+
+  # Request object
+  #
+  # This class aims to format the request for Smartfocus
+  #
+  class Request
+
+    attr_reader(
+        :http_verb,
+        :token,
+        :server_name,
+        :endpoint,
+        :uri,
+        :body,
+        :parameters
+    )
+
+    def initialize(http_verb, token, server_name, endpoint)
+      @http_verb = http_verb
+      @token = token
+      @server_name = server_name
+      @endpoint = endpoint
+    end
+
+    def prepare(uri, parameters)
+      @uri = uri
+      @parameters = parameters || {}
+
+      @uri = prepare_uri
+      @body = prepare_body
+    end
+
+    private
+
+    def prepare_uri
+      uri = @uri
+      if parameters[:uri]
+        uri += token ? "/#{token}/" : '/'
+        uri += (parameters[:uri].respond_to?(:join) ? parameters[:uri] : [parameters[:uri]]).compact.join '/'
+        parameters.delete :uri
+      elsif parameters[:body]
+        uri += token ? "/#{token}/" : '/'
+      else
+        parameters[:token] = token
+      end
+      uri
+    end
+
+    def prepare_body
+      body = parameters[:body] || {}
+      parameters.delete :body
+      # 2. Camelize all keys
+      body = Smartfocus::Tools.r_camelize body
+      # 3. Convert to xml
+      Smartfocus::Tools.to_xml_as_is body
+    end
+
+    def assign_attributes(attibutes)
+      attibutes or return
+      attibutes.each do |attribute, value|
+        public_send("#{attribute}=", value)
+      end
+    end
+
+  end
+end

data/lib/smartfocus/request_error.rb

@@ -0,0 +1,11 @@
+module Smartfocus
+
+  # Malformed response
+  #
+  # This error is raised when the response from Smartfocus
+  # cannot be parsed.
+  class RequestError < Exception
+
+  end
+
+end

data/lib/smartfocus/response.rb

@@ -0,0 +1,52 @@
+module Smartfocus
+
+  # Response object
+  # 
+  # This class aims to extract the response from Smartfocus
+  #
+  class Response
+
+    attr_reader :response, :logger
+
+    def initialize(response, logger)
+      @response = response
+      @logger = logger
+    end
+
+    def extract
+      logger.receive(content.inspect)
+
+      if succeed?
+        response = content["response"]["result"] || content["response"]
+      else
+        handle_errors
+      end
+    rescue MultiXml::ParseError, REXML::ParseException => error
+      wrapped_error = Smartfocus::MalformedResponse.new(error)
+      raise wrapped_error, "Error when parsing response body"
+    end
+
+    private
+
+    def succeed?
+      (http_code == "200") and (content and content["response"])
+    end
+
+    def handle_errors
+      if content =~ /Your session has expired/ or content =~ /The maximum number of connection allowed per session has been reached/
+        raise Smartfocus::SessionError, content
+      else
+        raise Smartfocus::RequestError, content
+      end
+    end
+
+    def content
+      @content ||= Crack::XML.parse(response.body)
+    end
+
+    def http_code
+      response.header.code
+    end
+
+  end
+end

data/lib/smartfocus/session_error.rb

@@ -0,0 +1,10 @@
+module Smartfocus
+
+  # Session  Error
+  #
+  # This error is raised when the token has expired
+  # or the number of connections has been reached
+  class SessionError < Exception
+  end
+
+end

data/lib/smartfocus/tools.rb

@@ -0,0 +1,130 @@
+module Smartfocus
+  
+  # Toolbox for the API
+  # This class is mainly used to convert data
+  #  
+  class Tools
+
+    # Sanitize values from a Hash
+    #
+    # @param [Hash] hash to sanitize
+    # @return [Hash] sanitized hash
+    #
+    def self.sanitize_parameters(parameters)
+      r_each(parameters) do |value|
+        if value.kind_of?(DateTime) or value.kind_of?(Time)
+          date_time_format(value.to_datetime)
+        elsif value.kind_of?(Date)
+          date_format(value.to_date)
+        else
+          value
+        end
+      end
+    end
+
+    def self.date_time_format(datetime)
+      datetime.strftime("%Y-%m-%dT%H:%M:%S")
+    end
+
+    def self.date_format(date)
+      date.strftime('%d/%m/%Y')
+    end
+
+    # Convert hash keys to camel case
+    #
+    # @param [Object] structure to camelize
+    # @return [Object] structure with keys camelized (if any)
+    #
+    def self.r_camelize(obj)
+      if obj.is_a?(Hash)
+        new_obj = {}
+        obj.each do |key, value|
+          new_obj[key.to_s.camelize(:lower).to_sym] = r_camelize value
+        end
+        new_obj
+      elsif obj.is_a?(Array)
+        new_obj = []
+        obj.each_with_index do |item, index|
+          new_obj[index] = r_camelize item
+        end
+        new_obj
+      else
+        obj
+      end
+    end
+
+    # Convert data structure to XML
+    #
+    # @param [Object] structure to convert
+    # @return [String] XML structure
+    #
+    def self.to_xml_as_is(obj)
+      obj_xml = ""
+
+      unless obj.nil? or obj.empty?
+        xml = ::Builder::XmlMarkup.new(:target=> obj_xml)
+        xml.instruct! :xml, :version=> "1.0"
+        tag_obj xml, obj
+      end
+
+      obj_xml
+    end
+
+    # Iterate throught a Hash recursively
+    #
+    # @param [Hash] structure to iterate
+    # @yield called for each data
+    #
+    def self.r_each(hash, &block)
+      return enum_for(:dfs, hash) unless block
+ 
+      result = {}
+      if hash.is_a?(Hash)
+        hash.map do |k,v|
+          result[k] = if v.is_a? Array
+            v.map do |elm|
+              r_each(elm, &block)
+            end
+          elsif v.is_a? Hash
+            r_each(v, &block)
+          else
+            yield(v)
+          end
+        end
+      else
+        result = yield(hash)
+      end
+
+      result
+    end
+
+    private
+
+      def self.tag_obj(xml, obj)
+        if obj.is_a? Hash
+          obj.each do |key, value|
+            if value.is_a?(Hash)
+              eval(%{
+                xml.#{key} do
+                  tag_obj(xml, value)
+                end
+              })
+            elsif value.is_a?(Array)
+              value.each do |item|
+                eval(%{
+                  xml.#{key} do
+                    tag_obj(xml, item)
+                  end
+                })
+              end
+            else
+              eval %{xml.#{key}(%{#{value}})}
+            end
+          end
+        else
+          obj
+        end
+      end
+
+  end
+end

data/lib/smartfocus/version.rb

@@ -0,0 +1,3 @@
+module Smartfocus
+  Version = VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: smartfocus
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- '''Bastien'
+- Gysler',
+- '''eboutic.ch'''
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+- !ruby/object:Gem::Dependency
+  name: crack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+description: REST API wrapper interacting with Smartfocus (ex Emailvision)
+email:
+- '''basgys@gmail.com'','
+- '''tech@eboutic.ch'''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/generators/install.rb
+- lib/generators/templates/smartfocus.yml
+- lib/smartfocus/api.rb
+- lib/smartfocus/exception.rb
+- lib/smartfocus/logger.rb
+- lib/smartfocus/malformed_response.rb
+- lib/smartfocus/notification.rb
+- lib/smartfocus/railtie.rb
+- lib/smartfocus/relation.rb
+- lib/smartfocus/request.rb
+- lib/smartfocus/request_error.rb
+- lib/smartfocus/response.rb
+- lib/smartfocus/session_error.rb
+- lib/smartfocus/tools.rb
+- lib/smartfocus/version.rb
+- lib/smartfocus.rb
+homepage: https://github.com/eboutic/smartfocus
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.1.9
+signing_key: 
+specification_version: 4
+summary: Smartfocus
+test_files: []
+has_rdoc: