eway_rapid 1.0.0

data/lib/eway_rapid/entities/direct_refund_request.rb

@@ -0,0 +1,26 @@
+module EwayRapid
+  class DirectRefundRequest
+    attr_accessor :customer
+    attr_accessor :shipping_address
+    attr_accessor :refund
+    attr_accessor :line_items
+    attr_accessor :options
+    attr_accessor :device_id
+    attr_accessor :customer_ip
+    attr_accessor :partner_id
+
+    def to_json(opts={})
+      {
+          Constants::CUSTOMER           => InternalModels::Customer.to_hash(customer),
+          Constants::SHIPPING_ADDRESS   => InternalModels::ShippingAddress.to_hash(shipping_address),
+          Constants::REFUND             => InternalModels::RefundDetails.to_hash(refund),
+          Constants::LINE_ITEMS         => Models::LineItem.to_array(line_items),
+          Constants::OPTIONS            => InternalModels::Option.to_array(options),
+          Constants::DEVICE_ID          => device_id,
+          Constants::CUSTOMER_DEVICE_IP => customer_ip,
+          Constants::PARTNER_ID         => partner_id
+      }.to_json
+    end
+
+  end
+end

data/lib/eway_rapid/entities/direct_refund_response.rb

@@ -0,0 +1,44 @@
+module EwayRapid
+  class DirectRefundResponse
+    attr_accessor :authorisation_code
+    attr_accessor :response_code
+    attr_accessor :response_message
+    attr_accessor :transaction_id
+    attr_accessor :transaction_status
+    attr_accessor :verification
+    attr_accessor :customer
+    attr_accessor :refund
+    attr_accessor :errors
+
+    alias_method :transaction_status?, :transaction_status
+
+    def to_json(options={})
+      {Constants::AUTHORISATION_CODE  => authorisation_code,
+       Constants::RESPONSE_CODE       => response_code,
+       Constants::TRANSACTION_ID      => transaction_id,
+       Constants::TRANSACTION_STATUS  => transaction_status,
+       Constants::VERIFICATION        => verification,
+       Constants::CUSTOMER            => customer,
+       Constants::REFUND              => refund,
+       Constants::ERRORS_CAPITALIZED  => errors}.to_json
+    end
+
+    def self.from_json(json)
+      hash = JSON.parse(json)
+      from_hash(hash)
+    end
+
+    def self.from_hash(hash)
+      direct_refund_response = DirectRefundResponse.new
+      direct_refund_response.authorisation_code = hash[Constants::AUTHORISATION_CODE]
+      direct_refund_response.response_code = hash[Constants::RESPONSE_CODE]
+      direct_refund_response.transaction_id = hash[Constants::TRANSACTION_ID]
+      direct_refund_response.transaction_status = hash[Constants::TRANSACTION_STATUS]
+      direct_refund_response.verification = hash[Constants::VERIFICATION]
+      direct_refund_response.customer = InternalModels::Customer.from_hash(hash[Constants::CUSTOMER])
+      direct_refund_response.refund = InternalModels::RefundDetails.from_hash(hash[Constants::REFUND])
+      direct_refund_response.errors = hash[Constants::ERRORS_CAPITALIZED]
+      direct_refund_response
+    end
+  end
+end

data/lib/eway_rapid/entities/transaction_search_response.rb

@@ -0,0 +1,23 @@
+module EwayRapid
+  class TransactionSearchResponse
+    attr_accessor :transactions
+    attr_accessor :error
+
+    def to_json(options={})
+      {Constants::TRANSACTIONS => transactions,
+       Constants::ERRORS_CAPITALIZED => error}.to_json
+    end
+
+    def self.from_json(json)
+      hash = JSON.parse(json)
+      from_hash(hash)
+    end
+
+    def self.from_hash(hash)
+      transaction_search_response = TransactionSearchResponse.new
+      transaction_search_response.transactions = InternalModels::Transaction.from_array(hash[Constants::TRANSACTIONS])
+      transaction_search_response.error = hash[Constants::ERRORS_CAPITALIZED]
+      transaction_search_response
+    end
+  end
+end

data/lib/eway_rapid/exceptions.rb

@@ -0,0 +1,51 @@
+module EwayRapid
+  module Exceptions
+
+    # The root exception class for all of business Rapid API exceptions
+    # Optional parameters :
+    # * :error_code the business error code
+    class RapidSdkException < StandardError
+      attr_accessor :error_code
+
+      def initialize(error_code, message)
+        super(message)
+        @error_code = error_code
+      end
+    end
+
+    # Rapid API key, password or endpoint invalid exception
+    class APIKeyInvalidException < RapidSdkException
+      def initialize(message)
+        super(Constants::API_KEY_INVALID_ERROR_CODE, message)
+      end
+    end
+
+    # Authentication to Rapid API failed (server returned HTTP 40*)
+    class AuthenticationFailureException < RapidSdkException
+      def initialize(message)
+        super(Constants::AUTHENTICATION_FAILURE_ERROR_CODE, message)
+      end
+    end
+
+    # Error connecting to Rapid API
+    class CommunicationFailureException < RapidSdkException
+      def initialize(message)
+        super(Constants::COMMUNICATION_FAILURE_ERROR_CODE, message)
+      end
+    end
+
+    # Invalid parameter exception
+    class ParameterInvalidException < RapidSdkException
+      def initialize(message)
+        super(Constants::INTERNAL_RAPID_API_ERROR_CODE, message)
+      end
+    end
+
+    # Invalid response from Rapid API
+    class SystemErrorException <RapidSdkException
+      def initialize(message)
+        super(Constants::INTERNAL_RAPID_SERVER_ERROR_CODE, message)
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/customer_to_internal_customer.rb

@@ -0,0 +1,70 @@
+module EwayRapid
+  module Message
+    module Convert
+      class CustomerToInternalCustomer
+        @merge_card_detail_to_this = true
+
+        def initialize(is_merge_card_info = nil)
+          @merge_card_detail_to_this = is_merge_card_info unless is_merge_card_info.nil?
+        end
+
+        # @param [Models::Customer] customer
+        # @return [InternalModels::Customer]
+        def do_convert(customer)
+          i_customer = InternalModels::Customer.new
+          if customer
+            i_customer.phone = customer.phone
+            i_customer.reference = customer.reference
+            i_customer.token_customer_id = customer.token_customer_id
+            i_customer.comments = customer.comments
+            i_customer.mobile = customer.mobile
+            i_customer.title = customer.title
+            i_customer.fax = customer.fax
+            i_customer.customer_device_ip = customer.customer_device_ip
+            i_customer.email = customer.email
+
+            # @type [Models::CardDetails]
+            card_details = customer.card_details
+            i_customer.card_details = card_details
+
+            if card_details && @merge_card_detail_to_this
+              i_customer.card_start_month = card_details.start_month
+              i_customer.card_start_year = card_details.start_year
+              i_customer.card_issue_number = card_details.issue_number
+              i_customer.card_name = card_details.name
+              i_customer.card_number = card_details.number
+              begin
+                i_customer.card_expiry_year = Integer(card_details.expiry_year)
+              rescue
+                raise ArgumentError.new 'Invalid expiry year in card details'
+              end
+              begin
+                i_customer.card_expiry_month = Integer(card_details.expiry_month)
+              rescue
+                raise ArgumentError.new 'Invalid expiry month param in card details'
+              end
+            end
+
+            i_customer.company_name = customer.company_name
+            i_customer.url = customer.url
+            i_customer.first_name = customer.first_name
+            i_customer.last_name = customer.last_name
+
+            # @type [Models::Address]
+            cus_address = customer.address
+            if cus_address
+              i_customer.state = cus_address.state
+              i_customer.postal_code = cus_address.postal_code
+              i_customer.country = cus_address.country
+              i_customer.city = cus_address.city
+              i_customer.street1 = cus_address.street1
+              i_customer.street2 = cus_address.street2
+            end
+            i_customer.job_description = customer.job_description
+          end
+          i_customer
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/direct_payment_to_trans_status.rb

@@ -0,0 +1,47 @@
+module EwayRapid
+  module Message
+    module Convert
+      class DirectPaymentToTransStatus
+
+        # @param [DirectPaymentResponse] response
+        # @return [Models::TransactionStatus]
+        def do_convert(response)
+          status = Models::TransactionStatus.new
+          status.beagle_score = !response.beagle_score.nil? ? response.beagle_score : 0.0
+          status.captured = to_boolean(response.transaction_captured)
+          status.fraud_action = response.fraud_action if response.fraud_action
+          status.processing_details = get_processing_details(response)
+          status.status = response.transaction_status if response.transaction_status
+          status.total = response.payment.total_amount if response.payment
+          status.transaction_id = if response.transaction_id
+                                    begin
+                                      Integer(response.transaction_id)
+                                    rescue
+                                      raise ArgumentError.new 'Invalid transaction id when converting direct payment to transaction status'
+                                    end
+                                  else
+                                    0
+                                  end
+
+          verification_convert = VerificationToVerificationResult.new
+          status.verification_result = verification_convert.do_convert(response.verification)
+          status
+        end
+
+        def to_boolean(string)
+          string == 'true'
+        end
+
+        # @param [DirectPaymentResponse] response
+        # @return [Models::ProcessingDetails]
+        def get_processing_details(response)
+          processing_details = Models::ProcessingDetails.new
+          processing_details.authorisation_code = response.authorisation_code
+          processing_details.response_code = response.response_code
+          processing_details.response_message = response.response_message
+          processing_details
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/direct_refund_to_trans_status.rb

@@ -0,0 +1,33 @@
+module EwayRapid
+  module Message
+    module Convert
+      class DirectRefundToTransStatus
+
+        # @param [DirectRefundResponse] response
+        # @return [Models::TransactionStatus]
+        def do_convert(response)
+          status = Models::TransactionStatus.new
+          status.processing_details = get_processing_details(response)
+          status.status = response.transaction_status if response.transaction_status
+          begin
+          status.transaction_id = Integer(response.transaction_id) if response.transaction_id
+          rescue
+            raise ArgumentError.new 'Invalid transaction id when converting direct refund to transaction status'
+          end
+
+          status
+        end
+
+        # @param [DirectRefundResponse] response
+        # @return [Models::ProcessingDetails]
+        def get_processing_details(response)
+          processing_details = Models::ProcessingDetails.new
+          processing_details.authorisation_code = response.authorisation_code
+          processing_details.response_code = response.response_code
+          processing_details.response_message = response.response_message
+          processing_details
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/internal_customer_to_customer.rb

@@ -0,0 +1,41 @@
+module EwayRapid
+  module Message
+    module Convert
+      class InternalCustomerToCustomer
+
+        # @param [InternalModels::Customer] i_customer
+        # @return [Models::Customer]
+        def do_convert(i_customer)
+          customer = Models::Customer.new
+          if i_customer
+            customer.comments = i_customer.comments
+            customer.token_customer_id = i_customer.token_customer_id
+            customer.mobile = i_customer.mobile
+            customer.phone = i_customer.phone
+            customer.title = i_customer.title
+            customer.company_name = i_customer.company_name
+            customer.fax = i_customer.fax
+            customer.first_name = i_customer.first_name
+            customer.last_name = i_customer.last_name
+            customer.job_description = i_customer.job_description
+            customer.reference = i_customer.reference
+            customer.url = i_customer.url
+            customer.customer_device_ip = i_customer.customer_device_ip
+            customer.email = i_customer.email
+
+            address = Models::Address.new
+            address.city = i_customer.city
+            address.street1 = i_customer.street1
+            address.street2 = i_customer.street2
+            address.postal_code = i_customer.postal_code
+            address.country = i_customer.country
+            address.state = i_customer.state
+            customer.address = address
+            customer.card_details = i_customer.card_details
+          end
+          customer
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/internal_trans_to_trans.rb

@@ -0,0 +1,62 @@
+module EwayRapid
+  module Message
+    module Convert
+      class InternalTransToTrans
+
+        # @param [InternalModels::Transaction] i_transaction
+        # @return [Models::Transaction]
+        def do_convert(i_transaction)
+          transaction = Models::Transaction.new
+          transaction.customer = get_eway_customer(i_transaction)
+          transaction.payment_details = get_payment_details(i_transaction)
+          transaction.shipping_details = get_shipping_details(i_transaction)
+          transaction.options = i_transaction.options
+          transaction
+        end
+
+        # @param [InternalModels::Transaction] i_transaction
+        # @return [Models::Customer]
+        def get_eway_customer(i_transaction)
+          # @type [InternalModels::Customer]
+          i_customer = i_transaction.customer
+          customer_convert = InternalCustomerToCustomer.new
+
+          # @type [Models::Customer]
+          customer = customer_convert.do_convert(i_customer)
+          address_convert = InternalTransactionToAddress.new
+          customer.address = address_convert.do_convert(i_transaction)
+          customer
+        end
+
+        # @param [InternalModels::Transaction] i_transaction
+        # @return [Models::PaymentDetails]
+        def get_payment_details(i_transaction)
+          payment_details = Models::PaymentDetails.new
+          payment_details.total_amount = i_transaction.total_amount
+          payment_details.invoice_reference = i_transaction.invoice_reference
+          payment_details.invoice_number = i_transaction.invoice_number
+          payment_details
+        end
+
+        # @param [InternalModels::Transaction] i_transaction
+        # @return [Models::ShippingDetails]
+        def get_shipping_details(i_transaction)
+          shipping_details = Models::ShippingDetails.new
+
+          if i_transaction.shipping_address
+            address_convert = InternalTransactionToAddress.new
+            shipping_details.shipping_address = address_convert.do_convert(i_transaction)
+            shipping_details.shipping_method = i_transaction.shipping_address.shipping_method || ''
+            shipping_details.first_name = i_transaction.shipping_address.first_name
+            shipping_details.last_name = i_transaction.shipping_address.last_name
+            shipping_details.email = i_transaction.shipping_address.email
+            shipping_details.fax = i_transaction.shipping_address.fax
+            shipping_details.phone = i_transaction.shipping_address.phone
+          end
+
+          shipping_details
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/internal_transaction_to_address.rb

@@ -0,0 +1,27 @@
+module EwayRapid
+  module Message
+    module Convert
+      class InternalTransactionToAddress
+
+        # @param [InternalModels::Transaction] i_transaction
+        # @return [Models::Address]
+        def do_convert(i_transaction)
+          address = Models::Address.new
+
+          # @type [InternalModels::ShippingAddress]
+          shipping_address = i_transaction.shipping_address
+
+          if shipping_address
+            address.state = shipping_address.state
+            address.street1 = shipping_address.street1
+            address.postal_code = shipping_address.postal_code
+            address.city = shipping_address.city
+            address.country = shipping_address.country
+            address.street2 = shipping_address.street2
+          end
+          address
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/internal_transaction_to_status.rb

@@ -0,0 +1,55 @@
+module EwayRapid
+  module Message
+    module Convert
+      class InternalTransactionToStatus
+
+        # @param [InternalModels::Transaction] transaction
+        # @return [Models::TransactionStatus]
+        def do_convert(transaction)
+          transaction_status = Models::TransactionStatus.new
+          transaction_status.beagle_score = transaction.beagle_score if transaction.beagle_score
+          transaction_status.status = transaction.transaction_status
+          transaction_status.total = transaction.total_amount
+          transaction_status.processing_details = get_processing_details(transaction)
+          transaction_status.verification_result = get_verification_result(transaction)
+          begin
+            transaction_status.transaction_id = Integer(transaction.transaction_id) if transaction.transaction_id
+          rescue
+            raise ArgumentError.new 'Invalid transaction id when converting transaction to internal transaction status'
+          end
+          transaction_status
+        end
+
+        # @param [InternalModels::Transaction] transaction
+        # @return [Models::ProcessingDetails]
+        def get_processing_details(transaction)
+          processing_details = Models::ProcessingDetails.new
+          processing_details.authorisation_code = transaction.authorisation_code
+          processing_details.response_code = transaction.response_code
+          processing_details.response_message = transaction.response_message
+          processing_details
+        end
+
+        # @param [InternalModels::Transaction] transaction
+        def get_verification_result(transaction)
+          converter = VerificationToVerificationResult.new
+          verification_result = converter.do_convert(transaction.verification)
+          if transaction.beagle_verification
+            verification_result.beagle_email = get_beagle_status(transaction.beagle_verification.phone)
+            verification_result.beagle_phone = get_beagle_status(transaction.beagle_verification.email)
+          end
+          verification_result
+        end
+
+        def get_beagle_status(status)
+          begin
+            index = Integer(status)
+            Enums::BeagleVerifyStatus.calculate_beagle_status(index)
+          rescue StandardError
+            return nil
+          end
+        end
+      end
+    end
+  end
+end