allorails 0.3.1

data/Manifest

@@ -0,0 +1,16 @@
+README.md
+Rakefile
+allorails.gemspec
+init.rb
+lib/allorails.rb
+lib/allorails/api/api.rb
+lib/allorails/core.rb
+lib/allorails/errors/errors.rb
+lib/allorails/rails.rb
+lib/allorails/request/request.rb
+lib/allorails/response/model.rb
+lib/allorails/response/response.rb
+test/allorails_spec.rb
+test/test-conf-sample.yml
+test/test-conf.yml
+Manifest

data/README.md

@@ -0,0 +1,7 @@
+*IMPORTANT:* Allorails is still being developed and tested. Use at your own risk ;)
+
+## Allorails
+
+Allorails is a Ruby gem which allows to interact with Allopass's online payment REST API.
+
+It is a Ruby port of the Allopass ApiKit for Python written by Pierre Geoffroy and available [here](http://developer.allopass.com/apidoc/kit/python3.1/index.html). 

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('allorails', '0.3.1') do |p|
+  p.description    = "Ruby client for the Allopass online payment REST API"
+  p.url            = "http://github.com/davb/allorails"
+  p.author         = "Davide Bonapersona"
+  p.email          = "davide@feeligo.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+end
+
+Dir["#{File.dirname(__FILE__)}/tasks/*.rake"].sort.each { |ext| load ext }

data/allorails.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "allorails"
+  s.version = "0.3.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Davide Bonapersona"]
+  s.date = "2012-05-08"
+  s.description = "Ruby client for the Allopass online payment REST API"
+  s.email = "davide@feeligo.com"
+  s.extra_rdoc_files = ["README.md", "lib/allorails.rb", "lib/allorails/api/api.rb", "lib/allorails/core.rb", "lib/allorails/errors/errors.rb", "lib/allorails/rails.rb", "lib/allorails/request/request.rb", "lib/allorails/response/model.rb", "lib/allorails/response/response.rb"]
+  s.files = ["README.md", "Rakefile", "allorails.gemspec", "init.rb", "lib/allorails.rb", "lib/allorails/api/api.rb", "lib/allorails/core.rb", "lib/allorails/errors/errors.rb", "lib/allorails/rails.rb", "lib/allorails/request/request.rb", "lib/allorails/response/model.rb", "lib/allorails/response/response.rb", "test/allorails_spec.rb", "test/test-conf-sample.yml", "test/test-conf.yml", "Manifest"]
+  s.homepage = "http://github.com/davb/allorails"
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Allorails", "--main", "README.md"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = "allorails"
+  s.rubygems_version = "1.8.21"
+  s.summary = "Ruby client for the Allopass online payment REST API"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'allorails'

data/lib/allorails/api/api.rb

@@ -0,0 +1,203 @@
+module Allorails
+  
+  class Api
+    
+    attr_accessor :email
+    
+    ## Constructor
+    #
+    #  @param configuration_email_account (string) Email of the configurated account
+    #  If email is null, the first account is considered
+    def initialize(email = nil)
+      self.email = email
+    end
+ 
+    ## Method performing a onetime pricing request
+    # 
+    #  @param parameters (Hash) Query string parameters of the API call
+    #  @param mapping (boolean) Should the response be an object mapping or a plain response
+    # 
+    #  @return (ApiResponse) The API call response
+    #  Will be a OnetimePricingResponse instance if mapping is true, an ApiResponse if not
+    # 
+    #  @code
+    #  # Make sure the apikit is in your search path
+    #  import allopass_apikit.api
+    #  api = allopass_apikit.api.AllopassAPI()
+    #  response = api.getOnetimePricing({'site_id': 127042, 'country': 'FR'})
+    #  print("{}\n-----".format(response.getWebsite().getName()))
+    #  for country in response.getCountries()
+    #    print("{}\n-----".format(country.getCode()))
+    #    print("{}\n-----".format(country.getName()))
+    #  @endcode
+    def get_onetime_pricing(parameters, mapping = true)
+      Allorails::Request::OnetimePricingRequest.new(parameters, mapping, self.email).call
+    end
+ 
+    ## Method performing a onetime discrete pricing request
+    # 
+    #  @param parameters (array) Query string parameters of the API call
+    #  @param mapping (boolean) Should the response be an object mapping or a plain response
+    # 
+    #  @return (ApiResponse) The API call response
+    #  Will be a OnetimePricingResponse instance if mapping is true, an ApiResponse if not
+    # 
+    #  @code
+    #  # Make sure the apikit is in your search path
+    #  import allopass_apikit.api
+    #  api = allopass_apikit.api.AllopassAPI()
+    #  response = api.getOnetimeDiscretePricing({'site_id': 127042, 'country': 'FR', 'amount': 12})
+    #  print("{}\n-----".format(response.getWebsite().getName()))
+    #  for country in response.getCountries()
+    #    print("{}\n-----".format(country.getCode()))
+    #    print("{}\n-----".format(country.getName()))
+    #  @endcode
+    def get_onetime_discrete_pricing(parameters, mapping = true)
+      Allorails::Request::OnetimeDiscretePricingRequest.new(parameters, mapping, self.email).call
+    end
+ 
+    ## Method performing a onetime validate codes request
+    # 
+    #  @param parameters (array) Query string parameters of the API call
+    #  @param mapping (boolean) Should the response be an object mapping or a plain response
+    # 
+    #  @return (ApiResponse) The API call response
+    #  Will be a OnetimeValidateCodesResponse instance if mapping is true, an ApiResponse if not
+    # 
+    #  @code
+    #  # Make sure the apikit is in your search path
+    #  import allopass_apikit.api
+    #  api = allopass_apikit.api.AllopassAPI()
+    #  response = api.validateCodes({'site_id': 127042, 'product_id': 354926, 'code': ('9M7QU457',)})
+    #  print("{}\n-----".format(response->getStatus()))
+    #  print("{}\n-----".format(response->getStatusDescription()))
+    #  @endcode
+    def validate_codes(parameters, mapping = true)
+      Allorails::Request::OnetimeValidateCodesRequest.new(parameters, mapping, self.email).call
+    end
+ 
+    ## Method performing a onetime button request
+    # 
+    #  @param parameters (array) Query string parameters of the API call
+    #  @param mapping (boolean) Should the response be an object mapping or a plain response
+    # 
+    #  @return (ApiResponse) The API call response
+    #  Will be a OnetimeButtonResponse instance if mapping is true, an ApiResponse if not
+    # 
+    #  @code
+    #  # Make sure the apikit is in your search path
+    #  import allopass_apikit.api
+    #  api = allopass_apikit.api.AllopassAPI()
+    #  response = api.createButton({'site_id': 127042, 'amount': 12.3, 'reference_currency': 'EUR', 'price_mode': 'price', 'price_policy': 'high-only', 'product_name': 'premium sms access', 'forward_url': 'http://product-page.com'})
+    #  print("{}\n-----".format(response.getButtonId()))
+    #  print("{}\n-----".format(response.getBuyUrl()))
+    #  @endcode
+    def create_button(parameters = {}, mapping = true)
+      Allorails::Request::OnetimeButtonRequest.new(parameters, mapping, self.email).call
+    end
+    
+    ## Method performing a onetime discrete button request
+    # 
+    #  @param parameters (array) Query string parameters of the API call
+    #  @param mapping (boolean) Should the response be an object mapping or a plain response
+    # 
+    #  @return (ApiResponse) The API call response
+    #  Will be a OnetimeButtonResponse instance if mapping is true, an ApiResponse if not
+    # 
+    #  @code
+    #  # Make sure the apikit is in your search path
+    #  import allopass_apikit.api
+    #  api = allopass_apikit.api.AllopassAPI()
+    #  response = api.createDiscreteButton({'site_id': 127042, 'amount': 1.1, 'reference_currency': 'EUR', 'price_mode': 'price', 'price_policy': 'high-only', 'product_name': 'premium sms access', 'forward_url': 'http://product-page.com'})
+    #  print("{}\n-----".format(response.getButtonId()))
+    #  print("{}\n-----".format(response.getBuyUrl()))
+    #  @endcode
+    def create_discrete_button(parameters = {}, mapping = true)
+      Allorails::Request::OnetimeDiscreteButtonRequest.new(parameters, mapping, self.email).call
+    end
+ 
+    ## Method performing a product detail request
+    # 
+    #  @param id (integer) The product id
+    #  @param parameters (array) Query string parameters of the API call
+    #  @param mapping (boolean) Should the response be an object mapping or a plain response
+    # 
+    #  @return (ApiResponse) The API call response
+    #  Will be a ProductDetailResponse instance if mapping is true, an ApiResponse if not
+    # 
+    #  @code
+    #  # Make sure the apikit is in your search path
+    #  import allopass_apikit.api
+    #  api = allopass_apikit.api.AllopassAPI()
+    #  response = api.getProduct(354926)
+    #  print({}"\n-----".format(response.getName()))
+    #  @endcode
+    def get_product(id, parameters = {}, mapping = true)
+      Allorails::Request::ProductDetailRequest.new(parameters.merge({'id'=>id}), mapping, self.email).call
+    end
+ 
+    ## Method performing a transaction prepare request
+    # 
+    #  @param parameters (array) Query string parameters of the API call
+    #  @param mapping (boolean) Should the response be an object mapping or a plain response
+    # 
+    #  @return (ApiResponse) The API call response
+    #  Will be a TransactionPrepareResponse instance if mapping is true, an ApiResponse if not
+    # 
+    #  @code
+    #  # Make sure the apikit is in your search path
+    #  import allopass_apikit.api
+    #  api = allopass_apikit.api.AllopassAPI()
+    #  response = api.prepareTransaction({'site_id': 127042, 'pricepoint_id': 2, 'product_name': 'premium calling product', 'forward_url': 'http://product-page.com', 'amount': 15})
+    #  print("{}\n-----".format(response.getBuyUrl()))
+    #  print("{}\n-----".format(response.getCheckoutButton()))
+    #  @endcode
+    def prepareTransaction(parameters, mapping = true)
+      Allorails::Request::TransactionPrepareRequest.new(parameters, mapping, self.email).call
+    end
+ 
+    ## Method performing a transaction detail request based on the transaction id
+    # 
+    #  @param id (string) The transaction id
+    #  @param parameters (array) Query string parameters of the API call
+    #  @param mapping (boolean) Should the response be an object mapping or a plain response
+    # 
+    #  @return (ApiResponse) The API call response
+    #  Will be a TransactionDetailResponse instance if mapping is true, an ApiResponse if not
+    # 
+    #  @code
+    #  # Make sure the apikit is in your search path
+    #  import allopass_apikit.api
+    #  api = allopass_apikit.api.AllopassAPI()
+    #  response = api.getTransaction('3f5506ac-5345-45e4-babb-96570aafdf6a');
+    #  print("{}\n-----".format(response.getPaid().getCurrency()))
+    #  print("{}\n-----".format(response.getPaid().getAmount()))
+    #  @endcode
+    def getTransaction(id, parameters = {}, mapping = true)
+      Allorails::Request::TransactionDetailRequest.new(parameters.merge({'id'=>id}), mapping, self.email).call
+    end
+ 
+    ## Method performing a transaction detail request based on the merchant transaction id
+    # 
+    #  @param id (string) The merchant transaction id
+    #  @param parameters (array) Query string parameters of the API call
+    #  @param mapping (boolean) Should the response be an object mapping or a plain response
+    # 
+    #  @return (ApiResponse) The API call response
+    #  Will be a TransactionDetailResponse instance if mapping is true, an ApiResponse if not
+    # 
+    #  @code
+    #  # Make sure the apikit is in your search path
+    #  import allopass_apikit.api
+    #  api = allopass_apikit.api.AllopassAPI()
+    #  response = api.getTransactionMerchant('TRX20091112134569B8');
+    #  print("{}\n-----".format(response.getPaid().getCurrency()))
+    #  print("{}\n-----".format(response.getPaid().getAmount()))
+    #  @endcode
+    def getTransactionMerchant(id, parameters = {}, mapping = true)
+      Allorails::Request::TransactionMerchantRequest.new(parameters.merge({'id'=>id}), mapping, self.email).call
+    end
+    
+  end
+  
+end

data/lib/allorails/core.rb

@@ -0,0 +1,147 @@
+require 'set'
+
+module Allorails
+  
+  module Core
+    
+    # Holds the configuration options for Allorails
+    #
+    class Configuration
+      
+      # creates a new Configuration object
+      # @param options
+      # @option options
+      def initialize options = {}
+        options.each_pair do |opt_name, value|
+          opt_name = opt_name.to_sym
+          if self.class.accepted_options.include?(opt_name)
+            supplied[opt_name] = value
+          end
+        end
+      end
+      
+      # creates a new Configuration object with the given modifications
+      # does not modify the current object
+      def with options = {}
+        # symbolize option keys
+        options = symbolize_keys options
+        values = supplied.merge(options)
+        
+        if supplied == values
+          self # no changes
+        else
+          self.class.new(values)
+        end
+      end
+      
+      # API key and secret key depend on the account
+      def api_key email = nil
+        account(email)[:api_key]
+      end
+      
+      def private_key email = nil
+        account(email)[:private_key]
+      end
+      
+      
+    protected
+      
+      # symbolize Hash keys
+      def symbolize_keys hash
+        hash.inject({}) {|h, (k,v)| h[k.to_sym] = v.is_a?(Hash) ? symbolize_keys(v) : v; h }
+      end
+    
+    
+      # Returns the account matching a given email
+      # 
+      #  @param email (string) The email identifying the account
+      #  If email is null, the first account is considered
+      # 
+      #  @return (xml.etree.ElementTree.ElementTree) Object representation of the account
+      # 
+      #  @throws ApiConfAccountNotFoundError If an email is provided but can't be found
+      #
+      def account(email = nil)
+        if accounts.length == 0
+          raise Allorails::ApiConfAccountNotFoundError, "No account found in config. You must configure at least one account."
+        else
+          # if email is null, the first account is considered
+          return accounts[accounts.keys.first] if email.nil?
+          # find the account corresponding to the email
+          return accounts[email] if accounts.has_key?(email)
+        end
+        # raise ApiConfAccountNotFoundError if email is provided but can't be found
+        raise Allorails::ApiConfAccountNotFoundError, "Missing configuration for account `#{email}`"
+      end
+    
+      # supplied options
+      def supplied
+        @supplied ||= {}
+      end
+      
+      # class methods
+      class << self
+        
+        # accepted options
+        def accepted_options
+          @options ||= Set.new
+        end
+        
+        # used internally to register a configuration option
+        def add_option name, default_value = nil
+          # marks the option as accepted
+          accepted_options << name
+          # defines an accessor method for the option
+          define_method(name) do
+            if supplied.has_key?(name)
+              supplied[name]
+            else
+              default_value
+            end
+          end
+        end
+        
+        
+      
+      end #-- end class << self
+      
+      # registers configuration options
+      add_option :accounts, {}
+      add_option :default_hash, 'sha1'
+      add_option :default_format, 'json'
+      add_option :network_timeout, 20
+      add_option :network_protocol, 'http'
+      add_option :network_port, 80
+      add_option :host, 'api.allopass.com'
+      
+    end #-- end class Configuration
+    
+  end #-- end module Core
+  
+  class << self
+    
+    @@config = nil
+    
+    # The global configuration for Allorails
+    # generally you would set your configuration options once, after
+    # loading the allorails gem.
+    #
+    #   Allorails.config({
+    #     :accounts => {
+    #       :your@email.com => {
+    #         :api_key => 'API_KEY',
+    #         :private_key => 'PRIVATE_KEY'
+    #       }
+    #     },
+    #     :network_port => PORT
+    #   })
+    #
+    def config options = {}
+      @@config ||= Core::Configuration.new
+      @@config = @@config.with(options) unless options.empty?
+      @@config
+    end
+    
+  end
+  
+end

data/lib/allorails/errors/errors.rb

@@ -0,0 +1,28 @@
+module Allorails
+
+
+  class AllopassApikitError < StandardError
+  end
+
+  class ApiConfAccountNotFoundError < StandardError
+  end
+  class ApiConfFileCorruptedError < StandardError
+  end
+  class ApiConfFileMissingError < StandardError
+  end
+  class ApiConfFileMissingSectionError < StandardError
+  end
+  class ApiFalseResponseSignatureError < StandardError
+  end
+
+  class ApiMissingHashFeatureError < StandardError
+  end
+  class ApiRemoteErrorError < StandardError
+  end
+
+  class ApiUnavailableResourceError < StandardError
+  end
+  class ApiWrongFormatResponseError < StandardError
+  end
+    
+end

data/lib/allorails/rails.rb

@@ -0,0 +1,75 @@
+require 'yaml'
+
+module Allorails
+  
+  if Object.const_defined?(:Rails) and Rails.const_defined?(:Railtie)
+    
+    class Railtie < Rails::Railtie
+      
+      initializer "allorails.initialize" do |app|
+        Allorails::Rails.setup
+      end
+      
+    end
+    
+  end
+  
+  
+  module Rails
+    
+    def self.setup
+      load_yaml_config
+      #log_to_rails_logger
+      nil
+    end
+    
+    # Loads Allorails configuration from +RAILS_ROOT/config/allorails.yml+
+    #
+    # TODO: this configuration file is optional, you can instead use Ruby
+    # to configure Allorails inside an initializer
+    # (e.g. +RAILS_ROOT/config/initializers/allorails.rb)
+    #
+    # If you use the yaml configuration file, it should include one section for
+    # each Rails environment:
+    #
+    #  development:
+    #    api_key: YOUR_API_KEY
+    #    secret_key: YOUR_SECRET_KEY
+    #
+    #  production:
+    #    api_key: YOUR_API_KEY
+    #    secret_key: YOUR_SECRET_KEY
+    # 
+    # ERB tags are allowed inside the yaml file: you can do things like
+    #    api_key: <%= read_from_somewhere_else %>
+    #
+    def self.load_yaml_config
+      path = Pathname.new("#{rails_root}/config/allorails.yml")
+      if File.exists?(path)
+        cfg = YAML::load(ERB.new(File.read(path)).result)
+        unless cfg[rails_env]
+          raise "config/allorails.yml is missing a section for `#{rails_env}`"
+        end
+        Allorails.config(cfg[rails_env])
+      end      
+    end
+    
+  protected
+  
+    def self.rails_env
+      ::Rails.respond_to?(:env) ? ::Rails.env : RAILS_ENV
+    end
+
+    # @private
+    def self.rails_root
+      ::Rails.respond_to?(:root) ? ::Rails.root.to_s : RAILS_ROOT
+    end
+
+    # @private
+    def self.rails_logger
+      ::Rails.respond_to?(:logger) ? ::Rails.logger : ::RAILS_DEFAULT_LOGGER
+    end
+    
+  end
+  
+end