wirecard-elastic 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: be41b3bb47704d01618efbb90bfa2a43da8eafe9
-  data.tar.gz: 8ac09806d27b2eeed4c43b0d38cc4c56384b3178
+  metadata.gz: 7dfbfe4ac51493be85c504c280f35891dd271ed0
+  data.tar.gz: 2aca41a8ad720d5b29d7527d6f7640a434a63a68
 SHA512:
-  metadata.gz: d0c3a3a7ae0894a16c7c80891e618817e9e406c018ce42892aa6e824291299633bb885923efabf70d34a04b6092fbaa09d42eb319bda574273765cab56ab38f3
-  data.tar.gz: 06b173b641550eca9db4af1b406b1f1db0c032075effc7e38bedd5db31873e9f9bd482f627191949d07a849c017e34294cd70f0e41110ba0a5bb74ea65f5db72
+  metadata.gz: 22b83d0b615cc40bae13f7e2ec6404ad6f4383021a60075e60deec803ca23964dbc00ee636e2f49119bf4d01e55bb9d3c00ad9e685e9b7ce10e73e8e9853cb9c
+  data.tar.gz: 6237450ae7354ea5e9a49bc9e082a096b9936aef2b29d7c7ae8cc8f2d0d39e1fe64bb18a9dbfea65878b944bee598e9928c02d4c544ad73234a236fac78c0ffd

data/Gemfile.lock

@@ -0,0 +1,58 @@
+PATH
+  remote: .
+  specs:
+    wirecard-elastic (0.2.1)
+      activesupport
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.2.6)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    coderay (1.1.1)
+    diff-lcs (1.2.5)
+    i18n (0.7.0)
+    json (1.8.3)
+    method_source (0.8.2)
+    minitest (5.8.4)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-rails (0.3.4)
+      pry (>= 0.9.10)
+    rake (10.4.2)
+    rspec (3.4.0)
+      rspec-core (~> 3.4.0)
+      rspec-expectations (~> 3.4.0)
+      rspec-mocks (~> 3.4.0)
+    rspec-core (3.4.4)
+      rspec-support (~> 3.4.0)
+    rspec-expectations (3.4.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-mocks (3.4.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.4.0)
+    rspec-support (3.4.1)
+    slop (3.6.0)
+    thread_safe (0.3.5)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.12)
+  pry-rails
+  rake (~> 10.0)
+  rspec
+  wirecard-elastic!
+
+BUNDLED WITH
+   1.12.4

data/lib/wirecard/elastic/configuration.rb

@@ -1,3 +1,5 @@
+# configuration of the gem and
+# default values set here
 module Wirecard
   module Elastic
     class Configuration
@@ -6,8 +8,8 @@ module Wirecard
       attr_accessor :upop
 
       def initialize
-        @upop = {}
-        @creditcard = {}
+        @upop       = { }
+        @creditcard = { }
       end
 
     end

data/lib/wirecard/elastic/error.rb

@@ -1,3 +1,5 @@
+# any error occurring from the gem should be
+# generated through those classes
 module Wirecard
   module Elastic
     class Error < StandardError; end

data/lib/wirecard/elastic/request/base.rb

@@ -0,0 +1,36 @@
+module Wirecard
+  module Elastic
+    class Request
+      class Base
+
+        VALID_STATUS_LIST = [:success, :failed].freeze
+
+        # calling #safe will check if the transaction was successful or/and valid
+        # and raise an error if not ; this is a useful shortcut
+        # when manipulating the datas at a upper level
+        def safe
+          unless valid_status?
+            raise Wirecard::Elastic::Error, "The status of the transaction is not correct (#{response.request_status})"
+          end
+          if negative_response?
+            raise Wirecard::Elastic::Error, "The transaction could not be verified. API access refused."
+          end
+          self
+        end
+
+        alias :raise_response_issues :safe # retro compatibility v0.1.1
+
+        private
+
+        def valid_status?
+          VALID_STATUS_LIST.include? response.transaction_state
+        end
+
+        def negative_response?
+          response.transaction_state == :failed && response.request_status == :error
+        end
+
+      end
+    end
+  end
+end

data/lib/wirecard/elastic/request/body/builder/xml.rb

@@ -0,0 +1,53 @@
+require 'rexml/text'
+
+# build a XML from a template and some variables
+# output a string to be transmitted to the API
+module Wirecard
+  module Elastic
+    class Request
+      module Body
+        class Builder
+          class Xml
+
+            TEMPLATE_FORMAT = "UTF-8".freeze
+            TEMPLATE_PATH   = "../../templates/".freeze
+
+            attr_reader :template_name, :request
+
+            # template_name is contained in /templates/
+            # the request matches the variables to convert (in hash) e.g. :refund
+            def initialize(template_name, request)
+              @template_name = template_name
+              @request       = request
+            end
+
+            # actually convert the file into a full XML with processed variables
+            def build!
+              xml_template = File.open(template_path, "r:#{TEMPLATE_FORMAT}", &:read)
+              xml_template.gsub(/{{\w+}}/, request_params)
+            end
+
+            private
+
+            # convert the current {{VARIABLES}}
+            # into their real values
+            def request_params
+              request.each_with_object({}) do |(key,value), hash|
+                hash["{{#{key.upcase}}}"] = REXML::Text.new(value.to_s)
+              end
+            end
+
+            def template_path
+              File.expand_path "#{TEMPLATE_PATH}#{template_file}", __FILE__
+            end
+
+            def template_file
+              "#{template_name}.xml"
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wirecard/elastic/request/body/builder.rb

@@ -0,0 +1,35 @@
+# build the template, this system is type agnostic
+# which means any type of file could be output from this point
+module Wirecard
+  module Elastic
+    class Request
+      module Body
+        class Builder
+
+          attr_reader :origin, :template
+
+          # set the template and the origin instance
+          # the origin will be used to setup the params
+          # by using the different datas of the class asking
+          # for a body content
+          def initialize(origin, template)
+            @origin   = origin
+            @template = template
+          end
+
+          # conversion into XML format
+          def to_xml
+            Xml.new(template, params).build!
+          end
+
+          # generation of the parameters used in the template
+          # through the origin instance
+          def params
+            Params.const_get(template.capitalize).new(origin).deliver!
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/wirecard/elastic/request/body/params/refund.rb

@@ -0,0 +1,58 @@
+# setup the parameters that will be transmitted to the body builder
+# which will convert the template into real values
+module Wirecard
+  module Elastic
+    class Request
+      module Body
+        module Params
+          class Refund
+
+            # the request IP address is for now a static local address
+            REQUEST_IP_ADDRESS = "127.0.0.1".freeze
+
+            # each transaction its symetric refund term
+            REFUND_MAP         = {:purchase => :'refund-purchase', :debit => :'refund-debit'}.freeze
+
+            attr_reader :origin
+
+            def initialize(origin)
+              @origin = origin
+            end
+
+            # output the hash
+            def deliver!
+              local.merge(remote)
+            end
+
+            private
+
+            # params we will use to fill the XML format request
+            def local
+              {
+                :merchant_account_id   => origin.merchant_id,
+                :request_id            => origin.request_id,
+                :parent_transaction_id => origin.parent_transaction_id,
+                :ip_address            => REQUEST_IP_ADDRESS
+              }
+            end
+
+            # get some body params from the remote elastic API itself rather than our database (safer)
+            def remote
+              {
+                :currency         => origin.parent_transaction.response.requested_amount_currency,
+                :amount           => origin.parent_transaction.response.requested_amount,
+                :payment_method   => origin.parent_transaction.response.payment_method,
+                :transaction_type => refund_transaction_type
+              }
+            end
+
+            def refund_transaction_type
+              REFUND_MAP[origin.parent_transaction.response.transaction_type]
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wirecard/elastic/request/body/templates/refund.xml

@@ -0,0 +1,13 @@
+<payment xmlns="http://www.elastic-payments.com/schema/payment">
+  <merchant-account-id>{{MERCHANT_ACCOUNT_ID}}</merchant-account-id>
+  <request-id>{{REQUEST_ID}}</request-id>
+  <transaction-type>{{TRANSACTION_TYPE}}</transaction-type>
+  <parent-transaction-id>{{PARENT_TRANSACTION_ID}}</parent-transaction-id>
+
+  <requested-amount currency="{{CURRENCY}}">{{AMOUNT}}</requested-amount>
+     <payment-methods>
+                <payment-method name="{{PAYMENT_METHOD}}"/>
+   </payment-methods>
+
+  <ip-address>{{IP_ADDRESS}}</ip-address>
+</payment>

data/lib/wirecard/elastic/request/refund.rb

@@ -0,0 +1,49 @@
+# refund a customer via the API
+# this will make a double API call
+# to first recover the original payment transaction
+module Wirecard
+  module Elastic
+    class Request
+      class Refund < Base
+
+        PAYMENT_QUERY_MAP = {:purchase => "payments", :debit => "paymentmethods"}.freeze
+
+        attr_reader :merchant_id, :parent_transaction_id, :request_id, :payment_method
+
+        def initialize(merchant_id, parent_transaction_id, payment_method)
+          @merchant_id           = merchant_id
+          @parent_transaction_id = parent_transaction_id
+          @request_id            = SecureRandom.uuid
+          @payment_method        = payment_method
+        end
+
+        # calling request
+        def request
+          @request ||= Request.new(query_uri: query, payment_method: payment_method, method: :post, body: body).dispatch!
+        end
+
+        # processed response
+        def response
+          @response ||= Response.new(request: request, action: :refund).dispatch!
+        end
+
+        # address we want to access on the API
+        def query
+          @query ||= PAYMENT_QUERY_MAP[parent_transaction.response.transaction_type]
+        end
+
+        # XML body we will send to the elastic API
+        def body
+          @body ||= Body::Builder.new(self, :refund).to_xml
+        end
+
+        # original transaction of the refund
+        # requested remotely to elastic API
+        def parent_transaction
+          @parent_transaction ||= Transaction.new(merchant_id, parent_transaction_id, payment_method)
+        end
+
+      end
+    end
+  end
+end

data/lib/wirecard/elastic/request/transaction.rb

@@ -0,0 +1,33 @@
+# recover a transaction details from the Wirecard API
+module Wirecard
+  module Elastic
+    class Request
+      class Transaction < Base
+
+        attr_reader :merchant_id, :transaction_id, :payment_method
+
+        def initialize(merchant_id, transaction_id, payment_method)
+          @merchant_id    = merchant_id
+          @transaction_id = transaction_id
+          @payment_method = payment_method
+        end
+
+        # calling request
+        def request
+          @request ||= Request.new(query_uri: query, payment_method: payment_method).dispatch!
+        end
+
+        # processed response
+        def response
+          @response ||= Response.new(request: request, action: :transaction).dispatch!
+        end
+
+        # address we want to access on the API
+        def query
+          @query ||= "merchants/#{merchant_id}/payments/#{transaction_id}"
+        end
+
+      end
+    end
+  end
+end

data/lib/wirecard/elastic/request.rb

@@ -0,0 +1,112 @@
+require 'net/http'
+
+# entry point of the request system
+# this is where the API call is produced
+module Wirecard
+  module Elastic
+    class Request
+
+      # content type might be flexible in the future
+      # for now it's a simple constant as the API
+      # is still simple
+      CONTENT_TYPE = 'text/xml'.freeze
+
+      # allowed methods to communicate to the API
+      # a get is usually without body
+      # a post will be with XML datas transmitted
+      ALLOWED_METHODS = [:get, :post]
+
+      # checking of the URL validity via REGEX
+      URL_PATTERN = /\A#{URI::regexp(['http', 'https'])}\z/
+
+      attr_reader :method, :body, :query_uri, :payment_method
+
+      # prepare the request datas and check the query URL on the fly
+      def initialize(query_uri:, payment_method:, method: :get, body: '')
+        @payment_method = payment_method
+        @method         = method
+        @body           = body
+        @query_uri      = query_uri
+        raise Wirecard::Elastic::ConfigError, "Invalid engine URL. Please check your configuration." unless valid_query?
+      end
+
+      # process the actual call and return the instance
+      # raise an error if the server didn't answer anything
+      def dispatch!
+        @dispatch ||= begin
+          if feedback.nil?
+            raise Wirecard::Elastic::Error, "The request was not successful"
+          else
+            self
+          end
+        end
+      end
+
+      # compose the query via configuration and transmitted URI
+      def query
+        @query ||= "#{gateway[:engine_url]}#{query_uri}.json"
+      end
+
+      # get the http raw response from the API
+      # it's supposed to be a simple string
+      # we might parse as JSON later on
+      def feedback
+        @feedback ||= Net::HTTP.start(query_url.host, query_url.port,
+        :use_ssl     => https_request?,
+        :verify_mode => OpenSSL::SSL::VERIFY_NONE) { |connection| send(connection) }
+      end
+
+      private
+
+      # connect and authenticate
+      # the client to the remote API
+      def send(connection)
+        request.basic_auth gateway[:username], gateway[:password] # authentification here
+        request.body         = body # body (XML for instance)
+        request.content_type = CONTENT_TYPE # XML
+        connection.request request # give a response
+      end
+
+      # prepare the request by instanting Net::HTTP::Get/Post
+      # and manage it depending on the method
+      def request
+        @request ||= begin
+          if ALLOWED_METHODS.include?(method)
+            Net::HTTP.const_get(method.capitalize).new(query_url.request_uri)
+          else
+            raise Wirecard::Elastic::Error, "Request method not recognized"
+          end
+        end
+      end
+
+      # simple query URL checker
+      def valid_query?
+        (query =~ URL_PATTERN) != nil
+      end
+
+      # encapsulate the query into URI(*)
+      def query_url
+        @query_url ||= URI(query)
+      end
+
+      # check if the request is SSL or not
+      def https_request?
+        query_url.scheme == 'https'
+      end
+
+      # get the details from the configuration
+      # will fail if there's no valid configuration
+      def gateway
+        @gateway ||= begin
+          @gateway = Wirecard::Elastic.configuration.instance_variable_get("@#{payment_method}")
+          if @gateway.nil?
+            raise Wirecard::Elastic::ConfigError, "Can't recover #{payment_method} details. Please check your configuration."
+          else
+            @gateway
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/wirecard/elastic/response/base.rb

@@ -0,0 +1,85 @@
+require 'rexml/text'
+
+# format the response and handle / convert the result hash
+# it's used throughout the whole ElasticApi library when a `response`
+# has to be returned
+module Wirecard
+  module Elastic
+    class Response
+      class Base
+
+        # will force symbol conversion for those specific methods calls
+        # *method.transaction_state will return a symbol
+        # *method.anything will return the raw value from the API
+        SYMBOLS_MAP    = [:request_status, :transaction_type, :transaction_state, :payment_method]
+
+        # `transaction_type` isn't here because we don't want
+        # to turn `refund-purchase` into `refund_purchase`
+        # we use UNDERSCORE_MAP for that
+        UNDERSCORE_MAP = [:request_status, :transaction_state, :payment_method]
+
+        attr_reader :origin, :raw
+
+        def initialize(origin, raw)
+          @origin = origin
+          @raw    = raw
+        end
+
+        def method_missing(method_symbol, *arguments, &block)
+          if map.include?(method_symbol)
+            response = cycle(*map[method_symbol])
+            if SYMBOLS_MAP.include?(method_symbol)
+              if UNDERSCORE_MAP.include?(method_symbol)
+                symbolize_data(underscore_data(response))
+              else
+                symbolize_data(response)
+              end
+            else
+              response
+            end
+          end
+        end
+
+        # general mapping for automatic method recovery
+        # when you basically ask for MyResponse.request_id it will go through the hash
+        # following the map and return the value at the end of the loop
+        # each response class can extend easily the map for its own specific use
+        def map
+          {
+            :request_id                => [:"request-id"],
+            :request_status            => [:statuses, :status, 0, :severity],
+            :requested_amount          => [:"requested-amount", :value],
+            :requested_amount_currency => [:"requested-amount", :currency],
+            :transaction_id            => [:"requested-id"],
+            :transaction_type          => [:"transaction-type"],
+            :transaction_state         => [:"transaction-state"],
+            :payment_method            => [:"payment-methods", :"payment-method", 0, :name]
+          }
+        end
+
+        private
+
+        # navigate through the hash without crashing
+        def cycle(*elements)
+          position = raw[:payment] || raw[:payment]&.[](:"merchant-account-id")
+          elements.each do |element|
+            position = position&.[](element)
+            return position if position.nil?
+          end
+          position
+        end
+
+        # convert the data into a symbol
+        def symbolize_data(data)
+          data.to_s.to_sym
+        end
+
+        # convert - into _
+        def underscore_data(data)
+          data.to_s.gsub("-", "_")
+        end
+
+      end
+    end
+  end
+end

data/lib/wirecard/elastic/response/refund.rb

@@ -0,0 +1,15 @@
+module Wirecard
+  module Elastic
+    class Response
+      class Refund < Base
+
+          # lots of refund specific mapping can be added below
+          # you just have to do `super.merge(whatever)`
+          def map
+            super.merge({})
+          end
+
+      end
+    end
+  end
+end

data/lib/wirecard/elastic/response/transaction.rb

@@ -0,0 +1,15 @@
+module Wirecard
+  module Elastic
+    class Response
+      class Transaction < Base
+
+          # lots of transaction specific mapping can be added below
+          # you just have to do `super.merge(whatever)`
+          def map
+            super.merge({})
+          end
+
+      end
+    end
+  end
+end

data/lib/wirecard/elastic/response.rb

@@ -0,0 +1,46 @@
+# after the request comes the processing of the response
+# it checks the actual feedback from the API and react accordingly
+module Wirecard
+  module Elastic
+    class Response
+
+      attr_reader :request, :action
+
+      def initialize(request:, action:)
+        @request = request
+        @action = action
+      end
+
+      # check the response and parse it if possible via JSON
+      # transmit the process to one of the Response subclasses (e.g. Refund, Transaction)
+      def dispatch!
+        if response.nil?
+          raise Wirecard::Elastic::Error, "The request failed."
+        else
+          Wirecard::Elastic::Response.const_get(action.capitalize).new(request, response)
+        end
+      end
+
+      # process the API feedback by converting it into JSON
+      def response
+        @response ||= JSON.parse(request.feedback.body).deep_symbolize_keys if valid_body?
+      end
+
+      private
+
+      # is the API feedback valid ?
+      def valid_body?
+        request.feedback.body && valid_json?(request.feedback.body)
+      end
+
+      # check it's a parsable JSON
+      def valid_json?(json)
+        JSON.parse(json)
+        true
+      rescue JSON::ParserError
+        false
+      end
+
+    end
+  end
+end

data/lib/wirecard/elastic/version.rb

@@ -1,5 +1,6 @@
+# current version of the gem
 module Wirecard
   module Elastic
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

data/lib/wirecard/elastic.rb

@@ -1,28 +1,29 @@
-require "wirecard/elastic/request/body/builder/xml"
-require "wirecard/elastic/request/body/builder"
-require "wirecard/elastic/request/base"
-require "wirecard/elastic/request/refund" # should be dynamically loaded ?
-require "wirecard/elastic/request/transaction" # should be dynamically loaded ? -> method missing
-require "wirecard/elastic/response/builder"
-require "wirecard/elastic/configuration"
-require "wirecard/elastic/error"
-require "wirecard/elastic/request"
-require "wirecard/elastic/response"
-require "wirecard/elastic/version"
+# classes auto loader
+Dir[File.expand_path "lib/**/*.rb"].each { |file| require_relative(file) }
 
+# this is the entry point of the gem, here goes the configuration system
+# also the different methods that should be publicly called
+# such as Wirecard::Elastic.transaction(*) or Wirecard::Elastic.refund(*)
 module Wirecard
   module Elastic
 
-    class << self
+    # this restrict the actions available via the library to avoid crashes
+    # adding `:whatever` will allow to call Elastic.whatever
+    # and try to load Request::Whatever.new(*args) with it
+    METHODS_MAP = [:transaction, :refund]
 
-      def transaction(merchant_id, transaction_id, payment_method)
-        Request::Transaction.new(merchant_id, transaction_id, payment_method)
-      end
+    class << self
 
-      def refund(merchant_id, parent_transaction_id, payment_method)
-        Request::Refund.new(merchant_id, parent_transaction_id, payment_method)
+      def method_missing(method, *args)
+        unless METHODS_MAP.include?(method)
+          raise Error, "Invalid action. Please use the methods available (#{METHODS_MAP.join(', ')})"
+        end
+        Request.const_get(method.capitalize).new(*args)
       end
 
+      # access and define configuration
+      # this is used while loading
+      # your environment (initializers)
       def configuration
         @configuration ||= Configuration.new
         if block_given?
@@ -32,13 +33,15 @@ module Wirecard
         end
       end
 
+      alias :config :configuration
+
+      # simply reset the configuration
+      # NOTE : avoid to use this if you're
+      # not resetting anything afterwards
       def reset
         @configuration = Configuration.new
       end
 
-      alias :config :configuration
-
     end
-
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wirecard-elastic
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Loschcode
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-26 00:00:00.000000000 Z
+date: 2016-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -90,6 +90,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - Gemfile
+- Gemfile.lock
 - README.md
 - Rakefile
 - bin/console
@@ -97,7 +98,22 @@ files:
 - lib/wirecard/elastic.rb
 - lib/wirecard/elastic/configuration.rb
 - lib/wirecard/elastic/error.rb
+- lib/wirecard/elastic/request.rb
+- lib/wirecard/elastic/request/base.rb
+- lib/wirecard/elastic/request/body/builder.rb
+- lib/wirecard/elastic/request/body/builder/xml.rb
+- lib/wirecard/elastic/request/body/params/refund.rb
+- lib/wirecard/elastic/request/body/templates/refund.xml
+- lib/wirecard/elastic/request/refund.rb
+- lib/wirecard/elastic/request/transaction.rb
+- lib/wirecard/elastic/response.rb
+- lib/wirecard/elastic/response/base.rb
+- lib/wirecard/elastic/response/refund.rb
+- lib/wirecard/elastic/response/transaction.rb
 - lib/wirecard/elastic/version.rb
+- pkg/wirecard-elastic-0.1.0.gem
+- pkg/wirecard-elastic-0.1.1.gem
+- pkg/wirecard-elastic-0.2.0.gem
 - wirecard-elastic.gemspec
 homepage: https://github.com/Loschcode/wirecard-elastic
 licenses: []