wirecard-elastic 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 621ede31a948a8e6d6c43f685b56f424de798b0e
-  data.tar.gz: 71df9395ebfe66fc299d6cf4da4b1c50725c6d51
+  metadata.gz: 93c593aa04466a5217eddd272bdc0c62d959a0b0
+  data.tar.gz: f9d366855944b6d2b53d3c0ac782a349af9d1a2b
 SHA512:
-  metadata.gz: 5063638dfa1c6940e398dbcb56875d0a02d763a8b6e9bdcb08bbb8528f5cf3864a110b82d20599ae3f803dd85c119bb4f76aaa9df6364be7a33d8b744f611bcc
-  data.tar.gz: 3aa54477d500ab914f95c17d13a98b8b3bfc56737c895903a1c5a556bd4735486970c3c4e454a56eef82f4a5af1c9f568e17433bd189292d7ecc45687dc7e810
+  metadata.gz: 8631c8453ac3a939c988c6217bd1e08f2dead70882fdb7b4370f43098442488040269c5cc2e27c80964fa433b69af14844ba8f57fb380ccd2fcf9d8a12351cd5
+  data.tar.gz: 9ef1c8ac9c74c4503173a7c46cc12d95a45796ab1fa0353936cbd6077b23d3a4fc02d33bd1d6ab9ff84b24f68f455e985e915bceaf66bd1afa7ca87261c7f0db

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "wirecard/elastic"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/wirecard/elastic.rb

@@ -0,0 +1,42 @@
+require "wirecard/elastic/version"
+require "wirecard/elastic/error"
+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"
+
+module Wirecard
+  module Elastic
+
+    class << self
+
+      def transaction(merchant_id, transaction_id, payment_method)
+        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)
+      end
+
+      def configuration
+        @configuration ||= Configuration.new
+        if block_given?
+          yield @configuration
+        else
+          @configuration
+        end
+      end
+
+      def reset
+        @configuration = Configuration.new
+      end
+
+      alias :config :configuration
+
+    end
+
+  end
+end

data/lib/wirecard/elastic/base.rb

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

data/lib/wirecard/elastic/configuration.rb

@@ -0,0 +1,15 @@
+module Wirecard
+  module Elastic
+    class Configuration
+
+      attr_accessor :creditcard
+      attr_accessor :upop
+
+      def initialize
+        @upop = {}
+        @creditcard = {}
+      end
+
+    end
+  end
+end

data/lib/wirecard/elastic/error.rb

@@ -0,0 +1,7 @@
+module Wirecard
+  module Elastic
+    class Error < StandardError
+
+    end
+  end
+end

data/lib/wirecard/elastic/refund.rb

@@ -0,0 +1,81 @@
+# 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

@@ -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/transaction.rb

@@ -0,0 +1,53 @@
+# 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

@@ -0,0 +1,102 @@
+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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1,47 @@
+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

data/lib/wirecard/elastic/version.rb

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

data/wirecard-elastic.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wirecard/elastic/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wirecard-elastic"
+  spec.version       = Wirecard::Elastic::VERSION
+  spec.authors       = ["Loschcode"]
+  spec.email         = ["laurent.schaffner.code@gmail.com"]
+
+  spec.summary       = "Wirecard support for Elastic Api"
+  spec.description   = "Wirecard support for Elastic Api"
+  spec.homepage      = "https://github.com/Loschcode/wirecard-elastic"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "pry-rails"
+  spec.add_development_dependency "rspec"
+
+  spec.add_dependency "activesupport"
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: wirecard-elastic
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Loschcode
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-25 00:00:00.000000000 Z
+date: 2016-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -38,6 +38,48 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: pry-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Wirecard support for Elastic Api
 email:
 - laurent.schaffner.code@gmail.com
@@ -45,8 +87,26 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
 - README.md
-homepage: https://github.com/Loschcode/wirecard-elastic-api
+- Rakefile
+- 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
 licenses: []
 metadata: {}
 post_install_message: