eway_rapid 1.0.0

data/lib/eway_rapid/message/convert/response/direct_customer_to_query_customer.rb

@@ -0,0 +1,55 @@
+module EwayRapid
+  module Message
+    module Convert
+      module Response
+        class DirectCustomerToQueryCustomer
+
+          # @param [DirectCustomerSearchResponse] response
+          # @return [QueryCustomerResponse]
+          def do_convert(response)
+            result = QueryCustomerResponse.new
+            if response
+              result.errors = response.errors.split(/\s*,\s*/) if response.errors
+
+              # @type [Array]
+              list_customer = response.customers
+              if list_customer && list_customer.length > 0
+                list_customer.each do |cust|
+                  result.reference = cust.reference
+                  result.title = cust.title
+                  result.first_name = cust.first_name
+                  result.last_name = cust.last_name
+                  result.company_name = cust.company_name
+                  result.job_description = cust.job_description
+
+                  # @type [String]
+                  street = cust.street1
+                  if street && street.strip
+                    arr = street.split(',', 2)
+                    result.street1 = street.split(',', 2).first
+                    result.street2 = street.split(',', 2).last if arr.length > 1
+                  end
+
+                  result.token_customer_id = cust.token_customer_id
+                  result.city = cust.city
+                  result.state = cust.state
+                  result.postal_code = cust.postal_code
+                  result.phone = cust.phone
+                  result.mobile = cust.mobile
+                  result.email = cust.email
+                  result.url = cust.url
+                  result.card_detail = cust.card_details
+                  result.country = cust.country
+                  result.comments = cust.comments
+                  result.fax = cust.fax
+                  result
+                end
+              end
+            end
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/response/direct_payment_to_create_cust.rb

@@ -0,0 +1,23 @@
+module EwayRapid
+  module Message
+    module Convert
+      module Response
+        class DirectPaymentToCreateCust
+
+          # @param [DirectPaymentResponse] response
+          # @return [CreateCustomerResponse]
+          def do_convert(response)
+            customer_response = CreateCustomerResponse.new
+            cust_convert = InternalCustomerToCustomer.new
+
+            customer_response.customer = cust_convert.do_convert(response.customer)
+
+            customer_response.errors = response.errors.split(/\s*,\s*/) if response.errors
+
+            customer_response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/response/direct_payment_to_create_trans.rb

@@ -0,0 +1,32 @@
+module EwayRapid
+  module Message
+    module Convert
+      module Response
+        class DirectPaymentToCreateTrans
+
+          # @param [DirectPaymentResponse] response
+          # @return [CreateTransactionResponse]
+          def do_convert(response)
+            transaction_response = CreateTransactionResponse.new
+            transaction = Models::Transaction.new
+
+            transaction.transaction_type = response.transaction_type
+
+            payment_converter = PaymentToPaymentDetails.new
+            transaction.payment_details = payment_converter.do_convert(response.payment)
+
+            cust_convert = InternalCustomerToCustomer.new
+            transaction.customer = cust_convert.do_convert(response.customer)
+
+            transaction_response.transaction = transaction
+            transaction_response.errors = response.errors.split(/\s*,\s*/) if response.errors
+
+            status_convert = DirectPaymentToTransStatus.new
+            transaction_response.transaction_status = status_convert.do_convert(response)
+            transaction_response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/response/direct_refund_to_refund_response.rb

@@ -0,0 +1,28 @@
+module EwayRapid
+  module Message
+    module Convert
+      module Response
+        class DirectRefundToRefundResponse
+
+          # @param [DirectRefundResponse] response
+          # @return [RefundResponse]
+          def do_convert(response)
+            refund = Models::Refund.new
+            refund.refund_details = response.refund
+
+            cust_convert = InternalCustomerToCustomer.new
+            refund.customer = cust_convert.do_convert(response.customer)
+
+            refund_response = RefundResponse.new
+            refund_response.errors = response.errors.split(/\s*,\s*/) if response.errors
+            refund_response.refund = refund
+
+            trans_status_convert = DirectRefundToTransStatus.new
+            refund_response.transaction_status = trans_status_convert.do_convert(response)
+            refund_response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/convert/response/search_to_query_trans.rb

@@ -0,0 +1,30 @@
+module EwayRapid
+  module Message
+    module Convert
+      module Response
+        class SearchToQueryTrans
+
+          # @param [TransactionSearchResponse] response
+          # @return [QueryTransactionResponse]
+          def do_convert(response)
+            query_transaction_response = QueryTransactionResponse.new
+
+            if response.transactions && response.transactions.length > 0
+              trans_convert = InternalTransToTrans.new
+              query_transaction_response.transaction = trans_convert.do_convert(response.transactions[0])
+            end
+
+            query_transaction_response.errors = response.error.split(/\s*,\s*/) if response.error
+
+            status_convert = InternalTransactionToStatus.new
+            if response.transactions && response.transactions.length > 0
+              query_transaction_response.transaction_status = status_convert.do_convert(response.transactions[0])
+            end
+
+            query_transaction_response
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module EwayRapid
+  module Message
+    module Convert
+      class ShippingDetailsToAddress
+
+        # @param [Models::ShippingDetails] detail
+        # @return [InternalModels::ShippingAddress]
+        def do_convert(detail)
+          address = InternalModels::ShippingAddress.new
+
+          if detail
+            # @type [InternalModels::ShippingAddress]
+            add = detail.shipping_address
+
+            if add
+              address.city = add.city
+              address.country = add.country
+              address.state = add.state
+              address.street1 = add.street1
+              address.street2 = add.street2
+              address.postal_code = add.postal_code
+            end
+
+            address.first_name = detail.first_name
+            address.last_name = detail.last_name
+            address.phone = detail.phone
+            address.fax = detail.fax
+            address.shipping_method = detail.shipping_method || ''
+          end
+          address
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module EwayRapid
+  module Message
+    module Convert
+      class TransactionShippingAddress
+
+        # @param [Models::Transaction] transaction
+        # @return [InternalModels::ShippingAddress]
+        def do_convert(transaction)
+          shipping_address = InternalModels::ShippingAddress.new
+
+          # @type [Models::ShippingDetails]
+          detail = transaction.shipping_details
+          if detail
+            shipping_address.first_name = detail.first_name
+            shipping_address.last_name = detail.last_name
+            shipping_address.shipping_method = detail.shipping_method
+            shipping_address.email = detail.email
+            shipping_address.phone = detail.phone
+            shipping_address.fax = detail.fax
+
+            # @type [Models::Address]
+            address = detail.shipping_address
+            if address
+              shipping_address.city = address.city
+              shipping_address.country = address.country
+              shipping_address.postal_code = address.postal_code
+              shipping_address.state = address.state
+              shipping_address.street1 = address.street1
+              shipping_address.street2 = address.street2
+            end
+          end
+          shipping_address
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+module EwayRapid
+  module Message
+    module Convert
+      class TransactionToArrLineItem
+
+        # @param [Models::Transaction] transaction
+        # @return [Array]
+        def do_convert(transaction)
+          transaction.line_items || []
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module EwayRapid
+  module Message
+    module Convert
+      class TransactionToArrOption
+
+        # @param [Models::Transaction] transaction
+        # @return [Array]
+        def do_convert(transaction)
+          if transaction.options
+            list_option = Array.new
+
+            transaction.options.each do |opt|
+              option = InternalModels::Option.new
+              option.value = opt
+              list_option.push(option)
+            end
+            list_option
+          else
+            Array.new(3)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module EwayRapid
+  module Message
+    module Convert
+      class TransactionToPayment
+
+        # @param [Models::Transaction] transaction
+        # @return [InternalModels::Payment]
+        def do_convert(transaction)
+          payment = InternalModels::Payment.new
+
+          # @type [Models::PaymentDetails]
+          payment_details = transaction.payment_details
+
+          if payment_details
+            payment.currency_code = payment_details.currency_code
+            payment.invoice_description = payment_details.invoice_description
+            payment.invoice_number = payment_details.invoice_number
+            payment.invoice_reference = payment_details.invoice_reference
+            payment.total_amount = payment_details.total_amount
+          else
+            payment.total_amount = 0
+          end
+
+          payment
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module EwayRapid
+  module Message
+    module Convert
+      class VerificationToVerificationResult
+
+        # @param [InternalModels::Verification] verification
+        def do_convert(verification)
+          result = Models::VerificationResult.new
+
+          if verification
+            result.address = get_verify_status(verification.address)
+            result.cvn = get_verify_status(verification.cvn)
+            result.email = get_verify_status(verification.email)
+            result.mobile = get_verify_status(verification.mobile)
+            result.phone = get_verify_status(verification.mobile)
+          end
+          result
+        end
+
+        # @param [String] status
+        # @return [String]
+        def get_verify_status(status)
+          begin
+            index = Integer(status)
+            Enums::VerifyStatus.calculate_status(index)
+          rescue StandardError
+            return nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eway_rapid/message/process/customer_process.rb

@@ -0,0 +1,255 @@
+module EwayRapid
+  module Message
+    module CustomerProcess
+
+      # Create customer with direct payment method message process
+      class CustDirectPaymentMsgProcess
+        include RestProcess
+
+        # @param [Models::Customer] input
+        # @return [DirectPaymentRequest]
+        def self.create_request(input)
+          request = DirectPaymentRequest.new
+          convert = Convert::CustomerToInternalCustomer.new(false)
+          request.customer = convert.do_convert(input)
+          request.customer_ip = input.customer_device_ip
+          request.method = Constants::CREATE_TOKEN_CUSTOMER_METHOD
+          request.transaction_type = Enums::TransactionType::PURCHASE
+          request
+        end
+
+        # @param [String] url
+        # @param [String] api_key
+        # @param [String] password
+        # @param [DirectPaymentRequest] request
+        # @return [String]
+        def self.send_request(url, api_key, password, request)
+          begin
+            CustDirectPaymentMsgProcess.new.do_post(url, api_key, password, request)
+          rescue SocketError => e
+            raise Exceptions::CommunicationFailureException.new(e.message)
+          rescue RestClient::Exception => e
+            if e.http_code == 401 || e.http_code == 403 || e.http_code == 404
+              raise Exceptions::AuthenticationFailureException.new(e.message)
+            else
+              raise Exceptions::SystemErrorException.new(e.message)
+            end
+          end
+        end
+
+        # @param [String] response
+        # @return [CreateCustomerResponse]
+        def self.make_result(response)
+          direct_payment_response = DirectPaymentResponse.from_json(response)
+          convert = Convert::Response::DirectPaymentToCreateCust.new
+          convert.do_convert(direct_payment_response)
+        end
+      end
+
+      # Create customer with responsive shared method message process
+      class CustResponsiveSharedMsgProcess
+        include RestProcess
+
+        # @param [Models::Customer] input
+        # @return [CreateAccessCodeSharedRequest]
+        def self.create_request(input)
+          request = CreateAccessCodeSharedRequest.new
+          convert = Convert::CustomerToInternalCustomer.new(false)
+          request.customer = convert.do_convert(input)
+          request.method = Constants::CREATE_TOKEN_CUSTOMER_METHOD
+          request.transaction_type = Enums::TransactionType::PURCHASE
+          request.redirect_url = input.redirect_url
+          request.cancel_url = input.cancel_url
+          request
+        end
+
+        # @param [String] url
+        # @param [String] api_key
+        # @param [String] password
+        # @param [CreateAccessCodeSharedRequest] request
+        # @return [String]
+        def self.send_request(url, api_key, password, request)
+          CustResponsiveSharedMsgProcess.new.do_post(url, api_key, password, request)
+        end
+
+        # @param [String] response
+        # @return [CreateCustomerResponse]
+        def self.make_result(response)
+          code_shared_response = CreateAccessCodeSharedResponse.from_json(response)
+          convert = Convert::Response::AccessCodeSharedToCreateCust.new
+          convert.do_convert(code_shared_response)
+        end
+      end
+
+      # Create customer with transparent redirect message process
+      class CustTransparentRedirectMsgProcess
+        include RestProcess
+
+        # @param [Models::Customer] input
+        # @return [CreateAccessCodeRequest]
+        def self.create_request(input)
+          request = CreateAccessCodeRequest.new
+          convert = Convert::CustomerToInternalCustomer.new(false)
+          request.customer = convert.do_convert(input)
+          request.method = Constants::CREATE_TOKEN_CUSTOMER_METHOD
+          request.transaction_type = Enums::TransactionType::PURCHASE
+          request.redirect_url = input.redirect_url
+          request
+        end
+
+        # @param [String] url
+        # @param [String] api_key
+        # @param [String] password
+        # @param [CreateAccessCodeRequest] request
+        # @return [String]
+        def self.send_request(url, api_key, password, request)
+          CustTransparentRedirectMsgProcess.new.do_post(url, api_key, password, request)
+        end
+
+        # @param [String] response
+        # @return [CreateCustomerResponse]
+        def self.make_result(response)
+          access_code_response = CreateAccessCodeResponse.from_json(response)
+          convert = Convert::Response::AccessCodeToCreateCust.new
+          convert.do_convert(access_code_response)
+        end
+      end
+
+      # Query customer message process
+      class QueryCustomerMsgProcess
+        include RestProcess
+
+        # @param [String] token_customer_id
+        # @return [DirectCustomerSearchRequest]
+        def self.create_request(token_customer_id)
+          request = DirectCustomerSearchRequest.new
+          request.token_customer_id = token_customer_id
+          request
+        end
+
+        # @param [DirectCustomerSearchRequest] request
+        # @return [String]
+        def self.send_request(url, api_key, password, request)
+          QueryCustomerMsgProcess.new.do_post(url, api_key, password, request)
+        end
+
+        # @param [String] response
+        # @return [DirectCustomerSearchResponse]
+        def self.make_result(response)
+          direct_customer_response = DirectCustomerSearchResponse.from_json(response)
+          converter = Convert::Response::DirectCustomerToQueryCustomer.new
+          converter.do_convert(direct_customer_response)
+        end
+      end
+
+      # Create customer with direct payment method message process
+      class CustDirectUpdateMsgProcess
+        include RestProcess
+
+        # @param [Models::Customer] input
+        # @return [DirectPaymentRequest]
+        def self.create_request(input)
+          request = DirectPaymentRequest.new
+          converter = Convert::CustomerToInternalCustomer.new
+          payment = InternalModels::Payment.new
+          payment.total_amount = 0
+          request.payment = payment
+          request.customer = converter.do_convert(input)
+          request.customer_ip = input.customer_device_ip
+          request.method = Constants::UPDATE_TOKEN_CUSTOMER_METHOD
+          request.transaction_type = Enums::TransactionType::PURCHASE
+          request
+        end
+
+        # @param [String] url
+        # @param [String] api_key
+        # @param [String] password
+        # @param [DirectPaymentRequest] request
+        def self.send_request(url, api_key, password, request)
+          CustDirectUpdateMsgProcess.new.do_post(url, api_key, password, request)
+        end
+
+        # @param [String] response
+        # @return [CreateCustomerResponse]
+        def self.make_result(response)
+          direct_response = DirectPaymentResponse.from_json(response)
+          converter = Convert::Response::DirectPaymentToCreateCust.new
+          converter.do_convert(direct_response)
+        end
+      end
+
+      # Create customer with responsive shared method message process
+      class CustResponsiveUpdateMsgProcess
+        include RestProcess
+
+        # @param [Models::Customer] input
+        # @return [CreateAccessCodeSharedRequest]
+        def self.create_request(input)
+          request = CreateAccessCodeSharedRequest.new
+          converter = Convert::CustomerToInternalCustomer.new
+          payment = InternalModels::Payment.new
+          payment.total_amount = 0
+          request.payment = payment
+          request.customer = converter.do_convert(input)
+          request.method = Constants::UPDATE_TOKEN_CUSTOMER_METHOD
+          request.transaction_type = Enums::TransactionType::PURCHASE
+          request.redirect_url = input.redirect_url
+          request.cancel_url = input.cancel_url
+          request
+        end
+
+        # @param [String] url
+        # @param [String] api_key
+        # @param [String] password
+        # @param [CreateAccessCodeSharedRequest] request
+        def self.send_request(url, api_key, password, request)
+          CustResponsiveUpdateMsgProcess.new.do_post(url, api_key, password, request)
+        end
+
+        # @param [String] response
+        # @return [CreateCustomerResponse]
+        def self.make_result(response)
+          shared_response = CreateAccessCodeSharedResponse.from_json(response)
+          converter = Convert::Response::AccessCodeSharedToCreateCust.new
+          converter.do_convert(shared_response)
+        end
+      end
+
+      # Create customer with transparent redirect message process
+      class CustTransparentUpdateMsgProcess
+        include RestProcess
+
+        # @param [Models::Customer] input
+        # @return [CreateAccessCodeRequest]
+        def self.create_request(input)
+          request = CreateAccessCodeRequest.new
+          converter = Convert::CustomerToInternalCustomer.new
+          payment = InternalModels::Payment.new
+          payment.total_amount = 0
+          request.payment = payment
+          request.customer = converter.do_convert(input)
+          request.method = Constants::UPDATE_TOKEN_CUSTOMER_METHOD
+          request.transaction_type = Enums::TransactionType::PURCHASE
+          request.redirect_url = input.redirect_url
+          request
+        end
+
+        # @param [String] url
+        # @param [String] api_key
+        # @param [String] password
+        # @param [CreateAccessCodeRequest] request
+        def self.send_request(url, api_key, password, request)
+          CustTransparentUpdateMsgProcess.new.do_post(url, api_key, password, request)
+        end
+
+        # @param [String] response
+        # @return [CreateCustomerResponse]
+        def self.make_result(response)
+          access_code_response = CreateAccessCodeResponse.from_json(response)
+          converter = Convert::Response::AccessCodeToCreateCust.new
+          converter.do_convert(access_code_response)
+        end
+      end
+    end
+  end
+end