wirecardmapper 0.8.0 → 0.9.0

data/README.rdoc

@@ -2,6 +2,44 @@
 
 A Ruby Object Mapper for Wirecard XML interface
 
+== Compatibility
+
+wirecardmapper is tested against Ruby 1.9.2 .
+
+{<img src="http://travis-ci.org/aklaiber/wirecardmapper.png" />}[http://travis-ci.org/aklaiber/wirecardmapper]
+
+== Install
+
+ $ gem install wirecardmapper
+
+or add the following line to Gemfile:
+
+ gem 'wirecardmapper'
+
+and run bundle install from your shell.
+
+== Examples
+
+=== Config
+
+    WirecardMapper::Config.server_uri = "https://c3-test.wirecard.com/issuer/client"
+    WirecardMapper::Config.server_port = 443
+    WirecardMapper::Config.login = "login"
+    WirecardMapper::Config.password = "password"
+    WirecardMapper::Config.mode = "live"
+    WirecardMapper::Config.entity_id = "entity_id"
+    WirecardMapper::Config.product_id = 11
+
+=== How to use
+
+    WirecardMapper.create_card
+    WirecardMapper.card_info(:card_id => '47ae07020a010018157db66065da6e5c')
+    WirecardMapper.update_card_info(:card_id => '47ae07020a010018157db66065da6e5c')
+    WirecardMapper.submit_payment(:card_id => '47ae07020a010018157db66065da6e5c', :amount => 10, :payment_comment => "Test Comment")
+    WirecardMapper.submit_payment(:card_id => '47ae07020a010018157db66065da6e5c', :amount => -10, :payment_comment => "Test Comment")
+    WirecardMapper.payment_info(:card_id => '47ae07020a010018157db66065da6e5c', :from => Time.now - (24 * 3600), :to => Time.now)
+    WirecardMapper.change_card_status(:card_id => '47ae07020a010018157db66065da6e5c', :status_code => 'cancelled')
+
 == Note on Patches/Pull Requests
 
 * Fork the project.
@@ -10,14 +48,25 @@ A Ruby Object Mapper for Wirecard XML interface
 * Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself in another branch so I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
-== Install
-
- $ gem install wirecardmapper
+== Copyright
 
-== Port Tunnel
+Copyright (c) 2010 Alexander Klaiber
 
-ssh tunnelserver1 -L localhost:8080:wirecardserver:443
+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:
 
-== Copyright
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
 
-See LICENSE for details.
+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.

data/Rakefile

@@ -1,24 +1,21 @@
-require 'rubygems'
-
-require 'rake'
-require 'rake/rdoctask'
-
+require 'bundler'
 require "rspec"
-require "rspec/core/rake_task"
+require 'rspec/core/rake_task'
 
-require File.expand_path('../lib/wirecardmapper/version', __FILE__)
+Bundler::GemHelper.install_tasks
 
-Rake::RDocTask.new do |rdoc|
-  files =['README.rdoc', 'LICENSE', 'lib/**/*.rb']
-  rdoc.rdoc_files.add(files)
-  rdoc.main = "README.rdoc" # page to start on
-  rdoc.title = "wirecardmapper Docs"
-  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
-  rdoc.options << '--line-numbers'
-end
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :spec do
+  desc "Run the code examples in spec/unit"
+  RSpec::Core::RakeTask.new('unit') do |t|
+    t.pattern = 'spec/unit/**/*_spec.rb'
+  end
 
-Rspec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = "spec/**/*_spec.rb"
+  desc "Run the code examples in spec/functional"
+  RSpec::Core::RakeTask.new('functional') do |t|
+    t.pattern = 'spec/functional/*_spec.rb'
+  end
 end
 
 namespace :wirecard do
@@ -27,16 +24,3 @@ namespace :wirecard do
     sh "ssh test.freecent.com -L localhost:8080:c3-test.wirecard.com:443"
   end
 end
-
-desc 'Builds the gem'
-task :build do
-  sh "gem build wirecardmapper.gemspec"
-end
-
-desc 'Tags version, pushes to remote, and pushes gem'
-task :release => [:spec, :build] do
-  sh "git tag v#{WirecardMapper::Version}"
-  sh "git push origin master"
-  sh "git push origin v#{WirecardMapper::Version}"
-  sh "gem push wirecardmapper-#{WirecardMapper::Version}.gem"
-end

data/lib/wirecardmapper.rb

@@ -1,52 +1,111 @@
-require "rubygems"
 require "bundler/setup"
 
-require 'net/https'
+require "active_support/core_ext"
+require "net/https"
 require "base64"
-require 'nokogiri'
-require 'uuid'
+require "nokogiri"
+require "uuid"
+require "time"
+require "money"
 
-require 'wirecardmapper/net_http_monkeypatch'
+require "wirecardmapper/railtie" if defined?(Rails)
+require "wirecardmapper/exception"
+require "wirecardmapper/config"
+require "wirecardmapper/response"
+
+require 'wirecardmapper/models/base'
+require 'wirecardmapper/models/mongo_mapper'
 
 module WirecardMapper
-  autoload :Config, 'wirecardmapper/config'
-  autoload :Xml, 'wirecardmapper/xml'
-  autoload :Response, 'wirecardmapper/response'
 
-  extend Xml
+  private
+
+  def self.define_request(name, options = {:default => {}})
+    define_singleton_method("#{name}_request") do |params = {}|
+      build_request(options[:request_method].blank? ? name : options[:request_method], options[:default].blank? ? params : options[:default].deep_merge(params))
+    end
+  end
+
+  public
+
+  define_request :create_card, :default => {:product_data => {:product_id => lambda { Config.product_id }}, :card_data => nil}
 
   def self.create_card(params = {})
-    request("create_card", params)
+    self.post(self.create_card_request(params))
   end
 
-  def self.update_card_info(params = {})
-    request("update_card_info", params)
+  define_request :card_info, :request_method => 'get_card_info'
+
+  def self.card_info(card_id, params = {})
+    self.post(self.card_info_request({:card_data => {:card_id => card_id}}.deep_merge(params)))
+  end
+
+  define_request :update_card_info
+
+  def self.update_card_info(card_id, params = {})
+    self.post(self.update_card_info_request({:card_data => {:card_id => card_id}}.deep_merge(params)))
   end
 
-  def self.card_info(params = {})
-    request("get_card_info", params)
+  define_request :payment_info, :request_method => 'get_payment_info'
+
+  def self.payment_info(card_id, params = {})
+    self.post(self.payment_info_request(params.deep_merge(:card_data => {:card_id => card_id})))
   end
 
-  def self.submit_payment(params = {})
-    request("submit_payment", params)
+  define_request :change_card_status
+
+  def self.change_card_status(card_id, params = {})
+    self.post(self.change_card_status_request(params.deep_merge(:card_data => {:card_id => card_id})))
   end
 
-  def self.payment_info(params = {})
-    request("get_payment_info", params)
+  define_request :submit_payment
+
+  def self.submit_payment(card_id, params = {})
+    self.post(self.submit_payment_request(params.deep_merge(:card_data => {:card_id => card_id})))
   end
 
-  def self.change_card_status(params = {})
-    request("change_card_status", params)
+  private
+
+  def self.build_request(method, params)
+    builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
+      xml.send('issuer-request', :mode => Config.mode, :version => '1.0') do
+        xml.application do
+          xml.send('request-id', UUID.generate)
+          if params[:entity_id].present?
+            xml.send('entity-id', params[:entity_id])
+            params.delete(:entity_id)
+          else
+            xml.send('entity-id', Config.entity_id)
+          end
+        end
+        xml.send(method.to_s.gsub(/_/, '-')) do
+          self.build_request_method_params(xml, params) unless params.blank?
+        end
+      end
+    end
+    builder.to_xml
   end
 
-  def self.request(xml_request_name, params)
-    main_xml = self.main_xml
-    if main_xml
-      sub_xml("#{xml_request_name}.xml", params) do |xml|
-        main_xml.at_css('issuer-request').add_child(xml.at(xml_request_name.to_s.gsub(/_/,'-')))
+  def self.build_request_method_params(xml, params)
+    params.each do |key, value|
+      if value.kind_of?(Hash)
+        if value.include?(:text) || value.include?(:attributes)
+          xml.send(key.to_s.gsub(/_/, '-'), value[:attributes]) do
+            xml.text value[:text]
+          end
+        else
+          xml.send(key.to_s.gsub(/_/, '-')) do
+            self.build_request_method_params(xml, value)
+          end
+        end
+      else
+        if value.kind_of?(Proc)
+          xml.send(key.to_s.gsub(/_/, '-'), value.call)
+        else
+          xml.send(key.to_s.gsub(/_/, '-'), value)
+        end
       end
     end
-    return post(main_xml.to_s)
   end
 
   def self.post(xml)
@@ -54,7 +113,9 @@ module WirecardMapper
     unless uri.nil?
       http = Net::HTTP.new(uri.host, Config.server_port)
       if http
+        http.read_timeout = 30
         http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
         request = Net::HTTP::Post.new(uri.path)
         if request
           request.content_type = "text/xml"
@@ -63,10 +124,15 @@ module WirecardMapper
           request.body = xml
           response = http.request(request)
           if response
-            return WirecardMapper::Response.new(response.body)
+            response = WirecardMapper::Response.new(response.body)
+            if response.return_message.eql?("System error.")
+              raise WirecardMapper::Exception, "Wirecard-System error (#{WirecardMapper::Config.server_uri}) post response : #{response.return_message}"
+            end
+            return response
           end
         end
       end
     end
   end
+
 end

data/lib/wirecardmapper/config.rb

@@ -2,10 +2,19 @@ module WirecardMapper
   module Config
 
     class << self
-      attr_accessor :mode, :entity_id, :server_uri, :login, :password, :product_id
+      attr_accessor :mode, :entity_id, :server_uri, :login, :password, :product_id, :currency
+
       attr_writer :templates_path, :server_port
     end
-    
+
+    def self.config=(config)
+      config.each { |method, value| self.send("#{method}=", value) if self.respond_to?(method) }
+    end
+
+    def self.config
+      yield self
+    end
+
     def self.templates_path
       @templates_path ||= "#{File.dirname(__FILE__)}/../../templates/"
     end
@@ -13,6 +22,6 @@ module WirecardMapper
     def self.server_port
       @server_port ||= 443
     end
-    
+
   end
 end

data/lib/wirecardmapper/exception.rb

@@ -0,0 +1,5 @@
+module WirecardMapper
+  class Exception < RuntimeError
+
+  end
+end

data/lib/wirecardmapper/models/base.rb

@@ -0,0 +1,117 @@
+module WirecardMapper
+  module Model
+    module Base
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def product_id(product_id = nil)
+          if product_id.present?
+            @product_id = product_id
+          else
+            @product_id
+          end
+        end
+
+        def entity_id(entity_id = nil)
+          if entity_id.present?
+            @entity_id = entity_id
+          else
+            @entity_id
+          end
+        end
+      end
+
+      def self.status_writer(*args)
+        args.each do |arg|
+          define_method("#{arg}!") do
+            response = WirecardMapper.change_card_status(self.card_id, {:entity_id => self.class.entity_id, :status_code => arg})
+            unless response.blank?
+              reload_card_info_cache
+              transaction_log("change_card_status", response)
+              raise WirecardMapper::Exception, "Wirecard-System[ERROR]: #{response.return_message}" unless response.ok?
+            end
+            return response
+          end
+        end
+      end
+
+      def self.status_reader(*args)
+        args.each do |arg|
+          define_method("#{arg}?") do
+            status.to_s.eql?(arg.to_s.gsub('_', '-'))
+          end
+        end
+      end
+
+      def self.card_attr_reader(*args)
+        args.each do |arg|
+          define_method(arg) do
+            card_info.send(arg)
+          end
+        end
+      end
+
+      public
+
+      attr_accessor :card_id
+
+      status_writer :activated, :blocked, :cancelled
+
+      status_reader :activated, :activation_pending, :activation_failed
+      status_reader :blocked, :block_requested, :block_pending, :block_failed
+      status_reader :cancelled, :cancellation_requested, :cancellation_pending, :cancellation_failed
+      status_reader :decline, :expired, :inactive, :referral
+
+      card_attr_reader :expiration_year, :expiration_month
+
+      public
+
+      def transaction_log(method_name, response)
+      end
+
+      def status
+        card_info.status_code
+      end
+
+      def balance
+        Money.euro(card_info.balance)
+      end
+
+      def load_amount(amount = self.amount.cents, comment = "load")
+        response = WirecardMapper.submit_payment(self.card_id, {:entity_id => self.class.entity_id, :payment_data => {:amount => {:text => amount, :attributes => {:currency => Config.currency}}, :payment_comment => comment}})
+        unless response.blank?
+          reload_card_info_cache
+          transaction_log("submit_payment - load_amount", response)
+          return response.ok?
+        end
+        return false
+      end
+
+      def unload_amount(amount = self.balance.cents, comment = "unload")
+        response = WirecardMapper.submit_payment(self.card_id, {:entity_id => self.class.entity_id,:payment_data => {:amount => {:text => -amount, :attributes => {:currency => Config.currency}}, :payment_comment => comment}})
+        unless response.blank?
+          reload_card_info_cache
+          transaction_log("submit_payment - unload_amount", response)
+          return response.ok?
+        end
+        return false
+      end
+
+      def amount
+        Money.euro(@amount)
+      end
+
+      private
+
+      def card_info
+        @card_info ||= WirecardMapper.card_info(self.card_id, {:entity_id => self.class.entity_id, :card_activity => 'no'})
+      end
+
+      def reload_card_info_cache
+        @card_info = nil
+      end
+
+    end
+  end
+end