wirecard-elastic 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 93c593aa04466a5217eddd272bdc0c62d959a0b0
-  data.tar.gz: f9d366855944b6d2b53d3c0ac782a349af9d1a2b
+  metadata.gz: be41b3bb47704d01618efbb90bfa2a43da8eafe9
+  data.tar.gz: 8ac09806d27b2eeed4c43b0d38cc4c56384b3178
 SHA512:
-  metadata.gz: 8631c8453ac3a939c988c6217bd1e08f2dead70882fdb7b4370f43098442488040269c5cc2e27c80964fa433b69af14844ba8f57fb380ccd2fcf9d8a12351cd5
-  data.tar.gz: 9ef1c8ac9c74c4503173a7c46cc12d95a45796ab1fa0353936cbd6077b23d3a4fc02d33bd1d6ab9ff84b24f68f455e985e915bceaf66bd1afa7ca87261c7f0db
+  metadata.gz: d0c3a3a7ae0894a16c7c80891e618817e9e406c018ce42892aa6e824291299633bb885923efabf70d34a04b6092fbaa09d42eb319bda574273765cab56ab38f3
+  data.tar.gz: 06b173b641550eca9db4af1b406b1f1db0c032075effc7e38bedd5db31873e9f9bd482f627191949d07a849c017e34294cd70f0e41110ba0a5bb74ea65f5db72

data/lib/wirecard/elastic/error.rb

@@ -1,7 +1,6 @@
 module Wirecard
   module Elastic
-    class Error < StandardError
-
-    end
+    class Error < StandardError; end
+    class ConfigError < StandardError; end
   end
 end

data/lib/wirecard/elastic/version.rb

@@ -1,5 +1,5 @@
 module Wirecard
   module Elastic
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/lib/wirecard/elastic.rb

@@ -1,12 +1,14 @@
-require "wirecard/elastic/version"
-require "wirecard/elastic/error"
+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/base"
-require "wirecard/elastic/transaction"
-require "wirecard/elastic/refund"
-require "wirecard/elastic/utils/request"
-require "wirecard/elastic/utils/response_format"
-require "wirecard/elastic/utils/xml_builder"
+require "wirecard/elastic/error"
+require "wirecard/elastic/request"
+require "wirecard/elastic/response"
+require "wirecard/elastic/version"
 
 module Wirecard
   module Elastic
@@ -14,11 +16,11 @@ module Wirecard
     class << self
 
       def transaction(merchant_id, transaction_id, payment_method)
-        Transaction.new(merchant_id, transaction_id, payment_method)
+        Request::Transaction.new(merchant_id, transaction_id, payment_method)
       end
 
       def refund(merchant_id, parent_transaction_id, payment_method)
-        Refund.new(merchant_id, parent_transaction_id, payment_method)
+        Request::Refund.new(merchant_id, parent_transaction_id, payment_method)
       end
 
       def configuration

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wirecard-elastic
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Loschcode
@@ -95,15 +95,8 @@ files:
 - bin/console
 - bin/setup
 - lib/wirecard/elastic.rb
-- lib/wirecard/elastic/base.rb
 - lib/wirecard/elastic/configuration.rb
 - lib/wirecard/elastic/error.rb
-- lib/wirecard/elastic/refund.rb
-- lib/wirecard/elastic/templates/refund.xml
-- lib/wirecard/elastic/transaction.rb
-- lib/wirecard/elastic/utils/request.rb
-- lib/wirecard/elastic/utils/response_format.rb
-- lib/wirecard/elastic/utils/xml_builder.rb
 - lib/wirecard/elastic/version.rb
 - wirecard-elastic.gemspec
 homepage: https://github.com/Loschcode/wirecard-elastic

data/lib/wirecard/elastic/base.rb

@@ -1,7 +0,0 @@
-module Wirecard
-  module Elastic
-    class Base
-
-    end
-  end
-end

data/lib/wirecard/elastic/refund.rb

@@ -1,81 +0,0 @@
-# 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 Refund < Base
-
-      REQUEST_IP_ADDRESS = "127.0.0.1".freeze
-      REFUND_MAP = {:purchase => :'refund-purchase', :debit => :'refund-debit'}.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
-
-      # process the query response
-      # return the response format
-      def response
-        @response ||= begin
-          response = Wirecard::Elastic::Utils::Request.new(query, payment_method, :post, body).response
-          if response.nil?
-            raise Wirecard::Elastic::Error, "The refund was not processed"
-          else
-            Utils::ResponseFormat.new(self, response)
-          end
-        end
-      end
-
-      # query URI to the API
-      def query
-        if parent_transaction.response.transaction_type == :purchase
-          @query ||= "payments"
-        elsif parent_transaction.response.transaction_type == :debit
-          @query ||= "paymentmethods"
-        end
-      end
-
-      # XML body we will send to the elastic API
-      def body
-        @body ||= Elastic::Utils::XmlBuilder.new(:refund, body_params).to_xml
-      end
-
-      private
-
-      # params we will use to fill the XML format request
-      def body_params
-        {
-          :merchant_account_id => merchant_id,
-          :request_id => request_id,
-          :parent_transaction_id => parent_transaction_id,
-          :ip_address => REQUEST_IP_ADDRESS
-        }.merge(remote_params)
-      end
-
-      # get some body params from the remote elastic API itslef rather than our database (safer)
-      def remote_params
-        {
-          :currency => parent_transaction.response.requested_amount_currency,
-          :amount => parent_transaction.response.requested_amount,
-          # potential bug because it's a symbol ?
-          :payment_method => parent_transaction.response.payment_method,
-          :transaction_type => refund_transaction_type
-        }
-      end
-
-      def refund_transaction_type
-        REFUND_MAP[parent_transaction.response.transaction_type]
-      end
-
-      # original transaction of the refund, requested remotely to elastic API
-      def parent_transaction
-        @parent_transaction ||= Wirecard::Elastic::Transaction.new(merchant_id, parent_transaction_id, payment_method)
-      end
-
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-<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/transaction.rb

@@ -1,53 +0,0 @@
-# recover a transaction details from the Wirecard API
-module Wirecard
-  module Elastic
-    class Transaction < Base
-
-      VALID_STATUS_LIST = [:success, :failed].freeze
-
-      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
-
-      def response
-        @response ||= begin
-          response = Wirecard::Elastic::Utils::Request.new(query, payment_method).response
-          if response.nil?
-            raise Wirecard::Elastic::Error, "The transaction was not found"
-          else
-            Utils::ResponseFormat.new(self, response)
-          end
-        end
-      end
-
-      # query URI to the API
-      def query
-        @query ||= "merchants/#{merchant_id}/payments/#{transaction_id}"
-      end
-
-      # check the response consistency and raise possible issues
-      # if the response got errors, otherwise it continues to process
-      # by returning the object itself
-      def raise_response_issues
-        raise Wirecard::Elastic::Error, "The status of the transaction is not correct (#{response.request_status})" unless valid_status?
-        raise Wirecard::Elastic::Error, "The transaction could not be verified. API access refused." if negative_response?
-        self
-      end
-
-      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

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

@@ -1,102 +0,0 @@
-require 'net/http'
-
-# send the request to Wirecard API via authentication
-# get the response from it
-module Wirecard
-  module Elastic
-    module Utils
-      class Request
-
-        CONTENT_TYPE = 'text/xml'.freeze
-
-        attr_reader :engine_url, :username, :password, :method, :body, :query, :payment_method
-
-        # uri_query gets the URI of request to the API
-        # method specify if it has to be a :get or :post
-        # body understood by the API is basically XML
-        def initialize(uri_query, payment_method, method=:get, body='')
-          @payment_method = payment_method
-          @method = method
-          @body = body
-          setup_access!
-          @query = "#{engine_url}#{uri_query}.json"
-        end
-
-        # get the http raw response to the API
-        # it's supposed to be a string, check out #response to get the hashed version
-        def raw_response
-          @raw_response ||= Net::HTTP.start(request_uri.host, request_uri.port,
-                                :use_ssl     => https_request?,
-                                :verify_mode => OpenSSL::SSL::VERIFY_NONE) { |connection| dispatch!(connection) }
-        end
-
-        # check the body of the response and return it or `nil`
-        # NOTE : sometimes the API answers with bullshit like a HTML 404 ERROR
-        # so we have to check if the body is valid beforehand
-        def response
-          @response ||= JSON.parse(raw_response.body).deep_symbolize_keys if valid_body?
-        end
-
-        private
-
-        def valid_body?
-          raw_response.body && valid_json?(raw_response.body)
-        end
-
-        def valid_json?(json)
-          JSON.parse(json)
-          true
-        rescue JSON::ParserError
-          false
-        end
-
-        # connect and authenticate the client to the API server
-        def dispatch!(connection)
-          request.basic_auth username, 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 and manage the differents methods used
-        def request
-          @request ||= begin
-            if method == :get
-              Net::HTTP::Get.new(request_uri.request_uri)
-            elsif method == :post
-              Net::HTTP::Post.new(request_uri.request_uri)
-            else
-              raise Wirecard::Elastic::Error, "Request method not recognized"
-            end
-          end
-        end
-
-        def request_uri
-          @request_uri ||= URI(query)
-        end
-
-        def https_request?
-          request_uri.scheme == 'https'
-        end
-
-        private
-
-        def setup_access!
-          @engine_url = access[:engine_url]
-          @username = access[:username]
-          @password = access[:password]
-        end
-
-        def access
-          config = Wirecard::Elastic.configuration.instance_variable_get("@#{payment_method}")
-          if config.nil?
-            raise Wirecard::Elastic::Error, "Can't recover #{payment_method} details. Please check your configuration."
-          else
-            config
-          end
-        end
-
-      end
-    end
-  end
-end

data/lib/wirecard/elastic/utils/response_format.rb

@@ -1,91 +0,0 @@
-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
-    module Utils
-      class ResponseFormat
-
-        # will force symbol conversion for those specific methods calls
-        # *method.status will return a symbol
-        # *method.anything will return the raw value
-        # NOTE : `transaction_type` isn't here because we don't want to turn `refund-purchase` into `refund_purchase`
-        # we use UNDERSCORE_MAP for that
-        SYMBOLS_MAP = [:request_status, :transaction_type, :transaction_state, :payment_method]
-        UNDERSCORE_MAP = [:request_status, :transaction_state, :payment_method]
-        
-        attr_reader :origin, :raw
-
-        # .to_call will convert the `method_name` into
-        # the raw method matching to it and sybmolize
-        class << self
-          def to_call(method_name)
-            "raw_#{method_name}".to_sym
-          end
-        end
-
-        def initialize(origin, raw)
-          @origin = origin
-          @raw = raw
-        end
-
-        # we are calling the different raw_* methods
-        # if someone tries to access an unknown method
-        # it can also convert some strings responses
-        # into symbols on the way
-        # TODO : could be refactored (chaining if are bad.)
-        def method_missing(method_symbol, *arguments, &block)
-          to_call = ResponseFormat.to_call(method_symbol)
-          if self.respond_to?(to_call)
-            response = self.send(to_call)
-            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
-
-        def raw_request_id; cycle(:"request-id"); end
-        def raw_request_status; cycle(:statuses, :status, 0, :severity); end
-        def raw_requested_amount; cycle(:"requested-amount", :value); end
-        # raw_currency original
-        def raw_requested_amount_currency; cycle(:"requested-amount", :currency); end
-        def raw_transaction_id; cycle(:"transaction-id"); end
-        def raw_transaction_type; cycle(:"transaction-type"); end
-        # raw_status originaly (TO TEST A LOT BEFORE TO REMOVE THIS COMMENT)
-        def raw_transaction_state; cycle(:"transaction-state"); end
-        def raw_payment_method; cycle(:"payment-methods", :"payment-method", 0, :name); end
-
-        private
-
-        # cool method to try to go through a hash, could be WAY improved
-        # but who got time for that ?
-        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 to a symbol
-        def symbolize_data(data)
-          data.to_s.to_sym
-        end
-
-        def underscore_data(data)
-          data.to_s.gsub("-", "_")
-        end
-
-      end
-    end
-  end
-end

data/lib/wirecard/elastic/utils/xml_builder.rb

@@ -1,47 +0,0 @@
-require 'rexml/text'
-
-# build a XML from a template and some variables
-# output a string
-module Wirecard
-  module Elastic
-    module Utils
-      class XmlBuilder
-
-        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 to_xml
-          xml_template = File.open(template_path, "r:#{TEMPLATE_FORMAT}", &:read)
-          xml_template.gsub(/{{\w+}}/, request_params)
-        end
-
-        private
-
-        def request_params
-          request.each_with_object({}) do |(k,v), h|
-            h["{{#{k.upcase}}}"] = REXML::Text.new(v.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