adyen_jpiqueras 2.3.0

data/lib/adyen/api/payment_service.rb

@@ -0,0 +1,374 @@
+require 'adyen/api/simple_soap_client'
+require 'adyen/api/templates/payment_service'
+
+module Adyen
+  module API
+    # This is the class that maps actions to Adyen’s Payment SOAP service.
+    #
+    # It’s encouraged to use the shortcut methods on the {API} module, which abstracts away the
+    # difference between this service and the {RecurringService}. Henceforth, for extensive
+    # documentation you should look at the {API} documentation.
+    #
+    # The most important difference is that you instantiate a {PaymentService} with the parameters
+    # that are needed for the call that you will eventually make.
+    #
+    # @example
+    #  payment = Adyen::API::PaymentService.new({
+    #    :reference => invoice.id,
+    #    :amount => {
+    #      :currency => 'EUR',
+    #      :value => invoice.amount,
+    #    },
+    #    :shopper => {
+    #      :email => user.email,
+    #      :reference => user.id,
+    #      :ip => request.ip,
+    #      :statement => 'Invoice number 123456'
+    #    },
+    #    :card => {
+    #      :expiry_month => 12,
+    #      :expiry_year => 2012,
+    #      :holder_name => 'Simon Hopper',
+    #      :number => '4444333322221111',
+    #      :cvc => '737'
+    #    }
+    #  })
+    #  response = payment.authorise_payment
+    #  response.authorised? # => true
+    #
+    class PaymentService < SimpleSOAPClient
+      # The Adyen Payment SOAP service endpoint uri.
+      ENDPOINT_URI = 'https://pal-%s.adyen.com/pal/servlet/soap/Payment'
+
+      # @see API.generate_billet
+      def generate_billet
+        make_payment_request(generate_billet_request_body, BilletResponse)
+      end
+
+      # @see API.authorise_payment
+      def authorise_payment
+        make_payment_request(authorise_payment_request_body, AuthorisationResponse)
+      end
+
+      # @see API.authorise_recurring_payment
+      def authorise_recurring_payment
+        make_payment_request(authorise_recurring_payment_request_body, AuthorisationResponse)
+      end
+
+      # @see API.authorise_one_click_payment
+      def authorise_one_click_payment
+        make_payment_request(authorise_one_click_payment_request_body, AuthorisationResponse)
+      end
+
+      # @see API.capture_payment
+      def capture
+        make_payment_request(capture_request_body, CaptureResponse)
+      end
+
+      # @see API.refund_payment
+      def refund
+        make_payment_request(refund_request_body, RefundResponse)
+      end
+
+      # @see API.cancel_payment
+      def cancel
+        make_payment_request(cancel_request_body, CancelResponse)
+      end
+
+      # @see API.cancel_or_refund_payment
+      def cancel_or_refund
+        make_payment_request(cancel_or_refund_request_body, CancelOrRefundResponse)
+      end
+
+      private
+
+      def make_payment_request(data, response_class)
+        call_webservice_action('authorise', data, response_class)
+      end
+
+      def authorise_payment_request_body
+        content = card_partial
+        if @params[:recurring]
+          validate_parameters!(:shopper => [:email, :reference])
+          content << ENABLE_RECURRING_CONTRACTS_PARTIAL
+        end
+        payment_request_body(content)
+      end
+
+      def authorise_recurring_payment_request_body
+        validate_parameters!(:shopper => [:email, :reference])
+        content = RECURRING_PAYMENT_BODY_PARTIAL % (@params[:recurring_detail_reference] || 'LATEST')
+        payment_request_body(content)
+      end
+
+      def authorise_one_click_payment_request_body
+        validate_parameters!(:recurring_detail_reference,
+                             :shopper => [:email, :reference])
+        content = one_click_card_partial
+        content << ONE_CLICK_PAYMENT_BODY_PARTIAL % [@params[:recurring_detail_reference]]
+        payment_request_body(content)
+      end
+
+      def payment_request_body(content)
+        validate_parameters!(:merchant_account, :reference, :amount => [:currency, :value])
+        content << amount_partial
+        content << installments_partial if @params[:installments]
+        content << shopper_partial if @params[:shopper]
+        content << fraud_offset_partial if @params[:fraud_offset]
+        content << capture_delay_partial if @params[:instant_capture]
+        LAYOUT % [@params[:merchant_account], @params[:reference], content]
+      end
+
+      def generate_billet_request_body
+        validate_parameters!(:merchant_account, :reference, :amount => [:currency, :value])
+        content  =  amount_partial
+        content << social_security_number_partial if @params[:social_security_number]
+        content << shopper_name_partial if @params[:shopper_name]
+        content << delivery_date_partial if @params[:delivery_date]
+        content << selected_brand_partial if @params[:selected_brand]
+        LAYOUT % [@params[:merchant_account], @params[:reference], content]
+      end
+
+      def capture_request_body
+        CAPTURE_LAYOUT % capture_and_refund_params
+      end
+
+      def refund_request_body
+        REFUND_LAYOUT % capture_and_refund_params
+      end
+
+      def cancel_or_refund_request_body
+        validate_parameters!(:merchant_account, :psp_reference)
+        CANCEL_OR_REFUND_LAYOUT % [@params[:merchant_account], @params[:psp_reference]]
+      end
+
+      def cancel_request_body
+        validate_parameters!(:merchant_account, :psp_reference)
+        CANCEL_LAYOUT % [@params[:merchant_account], @params[:psp_reference]]
+      end
+
+      def capture_and_refund_params
+        validate_parameters!(:merchant_account, :psp_reference, :amount => [:currency, :value])
+        [@params[:merchant_account], @params[:psp_reference], *@params[:amount].values_at(:currency, :value)]
+      end
+
+      def amount_partial
+        AMOUNT_PARTIAL % @params[:amount].values_at(:currency, :value)
+      end
+
+      def one_click_card_partial
+        if @params[:card] && @params[:card][:encrypted] && @params[:card][:encrypted][:json]
+          ENCRYPTED_CARD_PARTIAL % [@params[:card][:encrypted][:json]]
+        else
+          validate_parameters!(:card => [:cvc])
+          card  = @params[:card].values_at(:cvc)
+          ONE_CLICK_CARD_PARTIAL % card
+        end
+      end
+
+      def shopper_name_partial
+        SHOPPER_NAME_PARTIAL % @params[:shopper_name].values_at(:first_name, :last_name)
+      end
+
+      def card_partial
+        if @params[:card] && @params[:card][:encrypted] && @params[:card][:encrypted][:json]
+          ENCRYPTED_CARD_PARTIAL % [@params[:card][:encrypted][:json]]
+        else
+          validate_parameters!(:card => [:holder_name, :number, :expiry_year, :expiry_month])
+          card  = @params[:card].values_at(:holder_name, :number, :expiry_year)
+          card << @params[:card][:expiry_month].to_i
+          card << (['', nil].include?(@params[:card][:cvc]) ? '' : (CARD_CVC_PARTIAL % @params[:card][:cvc]))
+          CARD_PARTIAL % card
+        end
+      end
+
+      def installments_partial
+        if @params[:installments] && @params[:installments][:value]
+          INSTALLMENTS_PARTIAL % @params[:installments].values_at(:value)
+        end
+      end
+
+      def social_security_number_partial
+        if @params[:social_security_number]
+          SOCIAL_SECURITY_NUMBER_PARTIAL % @params[:social_security_number]
+        end
+      end
+
+      def selected_brand_partial
+        if @params[:selected_brand]
+          SELECTED_BRAND_PARTIAL % @params[:selected_brand]
+        end
+      end
+
+      def delivery_date_partial
+        if @params[:delivery_date]
+          DELIVERY_DATE_PARTIAL % @params[:delivery_date]
+        end
+      end
+
+      def shopper_partial
+        @params[:shopper].map { |k, v| SHOPPER_PARTIALS[k] % v }.join("\n")
+      end
+
+      def fraud_offset_partial
+        validate_parameters!(:fraud_offset)
+        FRAUD_OFFSET_PARTIAL % @params[:fraud_offset]
+      end
+
+      def capture_delay_partial(delay = 0)
+        CAPTURE_DELAY_PARTIAL % delay
+      end
+
+      class BilletResponse < Response
+        RECEIVED = "Received"
+
+        response_attrs :result_code, :billet_url, :psp_reference
+
+        def success?
+          super && params[:result_code] == RECEIVED
+        end
+
+        def params
+          @params ||= xml_querier.xpath('//payment:authoriseResponse/payment:paymentResult') do |result|
+            {
+              :psp_reference  => result.text('./payment:pspReference'),
+              :result_code    => result_code = result.text('./payment:resultCode'),
+              :billet_url     => (result_code == RECEIVED) ? result.children[0].children[0].children[1].text : ""
+            }
+          end
+        end
+
+        def invalid_request?
+          !fault_message.nil?
+        end
+      end
+
+      class AuthorisationResponse < Response
+        ERRORS = {
+          "validation 101 Invalid card number"                           => [:number,       'is not a valid creditcard number'],
+          "validation 103 CVC is not the right length"                   => [:cvc,          'is not the right length'],
+          "validation 128 Card Holder Missing"                           => [:holder_name,  "can't be blank"],
+          "validation Couldn't parse expiry year"                        => [:expiry_year,  'could not be recognized'],
+          "validation Expiry month should be between 1 and 12 inclusive" => [:expiry_month, 'could not be recognized'],
+        }
+
+        AUTHORISED = 'Authorised'
+        REFUSED    = 'Refused'
+
+        response_attrs :result_code, :auth_code, :refusal_reason, :psp_reference,
+          :additional_data
+
+        def success?
+          super && params[:result_code] == AUTHORISED
+        end
+
+        def refused?
+          params[:result_code] == REFUSED
+        end
+
+        alias_method :authorised?, :success?
+        alias_method :authorized?, :success?
+
+        # @return [Boolean] Returns whether or not the request was valid.
+        def invalid_request?
+          !fault_message.nil?
+        end
+
+        # In the case of a validation error, or SOAP fault message, this method will return an
+        # array describing what attribute failed validation and the accompanying message. If the
+        # errors is not of the common user validation errors, then the attribute is +:base+ and the
+        # full original message is returned.
+        #
+        # An optional +prefix+ can be given so you can seamlessly integrate this in your
+        # ActiveRecord model and copy over errors.
+        #
+        # @param [String,Symbol] prefix A string that should be used to prefix the error key.
+        # @return [Array<Symbol, String>] A name-message pair of the attribute with an error.
+        def error(prefix = nil)
+          if error = ERRORS[fault_message]
+            prefix ? ["#{prefix}_#{error[0]}".to_sym, error[1]] : error
+          elsif fault_message
+            [:base, fault_message]
+          elsif refused?
+            [:base, 'Transaction was refused.']
+          else
+            [:base, 'Transaction failed for unkown reasons.']
+          end
+        end
+
+        def params
+          @params ||= xml_querier.xpath('//payment:authoriseResponse/payment:paymentResult') do |result|
+            {
+              :psp_reference  => result.text('./payment:pspReference'),
+              :result_code    => result.text('./payment:resultCode'),
+              :auth_code      => result.text('./payment:authCode'),
+              :additional_data => parse_additional_data(result.xpath('.//payment:additionalData')),
+              :refusal_reason => (invalid_request? ? fault_message : result.text('./payment:refusalReason'))
+            }
+          end
+        end
+
+        private
+          def parse_additional_data(xpath)
+            if xpath.empty?
+              {}
+            else
+              results = {}
+
+              xpath.map do |node|
+                key = node.text('./payment:entry/payment:key')
+                value = node.text('./payment:entry/payment:value')
+                results[key] = value unless key.empty?
+              end
+
+              results
+            end
+          end
+      end
+
+      class ModificationResponse < Response
+        class << self
+          # @private
+          attr_accessor :request_received_value, :base_xpath
+        end
+
+        response_attrs :psp_reference, :response
+
+        # This only returns whether or not the request has been successfully received. Check the
+        # subsequent notification to see if the payment was actually mutated.
+        def success?
+          super && params[:response] == self.class.request_received_value
+        end
+
+        def params
+          @params ||= xml_querier.xpath(self.class.base_xpath) do |result|
+            {
+              :psp_reference  => result.text('./payment:pspReference'),
+              :response       => result.text('./payment:response')
+            }
+          end
+        end
+      end
+
+      class CaptureResponse < ModificationResponse
+        self.request_received_value = '[capture-received]'
+        self.base_xpath = '//payment:captureResponse/payment:captureResult'
+      end
+
+      class RefundResponse < ModificationResponse
+        self.request_received_value = '[refund-received]'
+        self.base_xpath = '//payment:refundResponse/payment:refundResult'
+      end
+
+      class CancelResponse < ModificationResponse
+        self.request_received_value = '[cancel-received]'
+        self.base_xpath = '//payment:cancelResponse/payment:cancelResult'
+      end
+
+      class CancelOrRefundResponse < ModificationResponse
+        self.request_received_value = '[cancelOrRefund-received]'
+        self.base_xpath = '//payment:cancelOrRefundResponse/payment:cancelOrRefundResult'
+      end
+    end
+  end
+end

data/lib/adyen/api/recurring_service.rb

@@ -0,0 +1,188 @@
+require 'adyen/api/simple_soap_client'
+require 'adyen/api/templates/recurring_service'
+
+module Adyen
+  module API
+    # This is the class that maps actions to Adyen’s Recurring SOAP service.
+    #
+    # It’s encouraged to use the shortcut methods on the {API} module, which abstracts away the
+    # difference between this service and the {PaymentService}. Henceforth, for extensive
+    # documentation you should look at the {API} documentation.
+    #
+    # The most important difference is that you instantiate a {RecurringService} with the parameters
+    # that are needed for the call that you will eventually make.
+    #
+    # @example
+    #  recurring = Adyen::API::RecurringService.new(:shopper => { :reference => user.id })
+    #  response = recurring.disable
+    #  response.success? # => true
+    #
+    class RecurringService < SimpleSOAPClient
+      # The Adyen Recurring SOAP service endpoint uri.
+      ENDPOINT_URI = 'https://pal-%s.adyen.com/pal/servlet/soap/Recurring'
+
+      # @see API.list_recurring_details
+      def list
+        call_webservice_action('listRecurringDetails', list_request_body, ListResponse)
+      end
+
+      # @see API.disable_recurring_contract
+      def disable
+        call_webservice_action('disable', disable_request_body, DisableResponse)
+      end
+
+      # @see API.store_recurring_token
+      def store_token
+        call_webservice_action('storeToken', store_token_request_body, StoreTokenResponse)
+      end
+
+      private
+
+      # The card's CVC isn't needed when tokenising details, so insert `nil'.
+      def card_partial
+        validate_parameters!(:card => [:holder_name, :number, :expiry_year, :expiry_month])
+        card  = @params[:card].values_at(:holder_name, :number, :cvc, :expiry_year)
+        card << @params[:card][:expiry_month].to_i
+        CARD_PARTIAL % card
+      end
+
+      ELV_ATTRS = [:bank_location, :bank_name, :bank_location_id, :holder_name, :number]
+      # The ELV - (Elektronisches Lastschriftverfahren) does not require bank_location, so insert 'nil'.
+      def elv_partial
+        validate_parameters!(:elv => ELV_ATTRS)
+        elv  = @params[:elv].values_at(*ELV_ATTRS)
+        ELV_PARTIAL % elv
+      end
+
+      def list_request_body
+        validate_parameters!(:merchant_account, :shopper => [:reference])
+        LIST_LAYOUT % [@params[:merchant_account], @params[:shopper][:reference]]
+      end
+
+      def disable_request_body
+        validate_parameters!(:merchant_account, :shopper => [:reference])
+        if reference = @params[:recurring_detail_reference]
+          reference = RECURRING_DETAIL_PARTIAL % reference
+        end
+        DISABLE_LAYOUT % [@params[:merchant_account], @params[:shopper][:reference], reference || '']
+      end
+
+      def store_token_request_body
+        validate_parameters!(:merchant_account, :shopper => [:email, :reference])
+        content = []
+        content << card_partial unless @params[:card].nil?
+        content << elv_partial  unless @params[:elv].nil?    
+        raise ArgumentError, "The required parameter 'card' or 'elv' is missing." if content.empty?    
+        STORE_TOKEN_LAYOUT % [@params[:merchant_account], @params[:shopper][:reference], @params[:shopper][:email], content.join]
+      end
+
+      class DisableResponse < Response
+        DISABLED_RESPONSES = %w{ [detail-successfully-disabled] [all-details-successfully-disabled] }
+
+        response_attrs :response
+
+        def success?
+          super && DISABLED_RESPONSES.include?(params[:response])
+        end
+
+        alias_method :disabled?, :success?
+
+        def params
+          @params ||= { :response => xml_querier.text('//recurring:disableResponse/recurring:result/recurring:response') }
+        end
+      end
+
+      class ListResponse < Response
+        response_attrs :details, :last_known_shopper_email, :shopper_reference, :creation_date
+
+        def references
+          details ? details.map { |d| d[:recurring_detail_reference] } : []
+        end
+
+        def params
+          @params ||= xml_querier.xpath('//recurring:listRecurringDetailsResponse/recurring:result') do |result|
+            details = result.xpath('.//recurring:RecurringDetail')
+            details.empty? ? {} : {
+              :creation_date            => DateTime.parse(result.text('./recurring:creationDate')),
+              :details                  => details.map { |node| parse_recurring_detail(node) },
+              :last_known_shopper_email => result.text('./recurring:lastKnownShopperEmail'),
+              :shopper_reference        => result.text('./recurring:shopperReference')
+            }
+          end
+        end
+
+        private
+
+        def parse_recurring_detail(node)
+          result = {
+            :recurring_detail_reference => node.text('./recurring:recurringDetailReference'),
+            :variant                    => node.text('./recurring:variant'),
+            :creation_date              => DateTime.parse(node.text('./recurring:creationDate'))
+          }
+
+          card = node.xpath('./recurring:card')
+          elv  = node.xpath('./recurring:elv')  
+          bank = node.xpath('./recurring:bank')        
+          
+          if !card.children.empty?
+            result[:card] = parse_card_details(card)
+          elsif !elv.children.empty?
+            result[:elv] = parse_elv_details(elv)
+          else
+            result[:bank] = parse_bank_details(bank)
+          end
+          
+          result
+        end
+
+        def parse_card_details(card)
+          {
+            :expiry_date => Date.new(card.text('./payment:expiryYear').to_i, card.text('./payment:expiryMonth').to_i, -1),
+            :holder_name => card.text('./payment:holderName'),
+            :number      => card.text('./payment:number')
+          }
+        end
+
+        def parse_elv_details(elv)
+          {
+            :holder_name      => elv.text('./payment:accountHolderName'),
+            :number           => elv.text('./payment:bankAccountNumber'),
+            :bank_location    => elv.text('./payment:bankLocation'),
+            :bank_location_id => elv.text('./payment:bankLocationId'),
+            :bank_name        => elv.text('./payment:bankName')
+          }
+        end
+
+        def parse_bank_details(bank)
+          {
+            :number           => bank.text('./payment:bankAccountNumber'),
+            :bank_location_id => bank.text('./payment:bankLocationId'),
+            :bank_name        => bank.text('./payment:bankName'),
+            :bic              => bank.text('./payment:bic'),
+            :country_code     => bank.text('./payment:countryCode'),
+            :iban             => bank.text('./payment:iban'),
+            :holder_name      => bank.text('./payment:ownerName')
+          }
+        end
+      end
+
+      class StoreTokenResponse < Response
+        response_attrs :response, :recurring_detail_reference
+
+        def success?
+          super && response == 'Success'
+        end
+
+        alias_method :stored?, :success?
+
+        def params
+          @params ||= {
+            :response => xml_querier.text('//recurring:storeTokenResponse/recurring:result/recurring:result'),
+            :reference =>  xml_querier.text('//recurring:storeTokenResponse/recurring:result/recurring:rechargeReference'),
+            :recurring_detail_reference => xml_querier.text('//recurring:storeTokenResponse/recurring:result/recurring:recurringDetailReference')
+          }
+        end
+      end
+    end
+  end
+end