transbank-sdk 1.0.1

data/lib/transbank/sdk/onepay/requests/refund_create_request.rb

@@ -0,0 +1,45 @@
+module Transbank
+  module Onepay
+    # Creates a Refund request
+    class RefundCreateRequest
+      include Request
+      attr_accessor :nullify_amount, :occ, :external_unique_number,
+                    :authorization_code, :issued_at, :signature
+
+      # These are the params used to build this class's @signature
+      SIGNATURE_PARAMS = [:occ,
+                          :external_unique_number,
+                          :authorization_code,
+                          :issued_at,
+                          :nullify_amount].freeze
+
+      # @param nullify_amount [Integer, nil] The total amount of the [Transaction] to Refund.
+      # No partial refunds are possible
+      # @param external_unique_number [String] a unique value (per Merchant, not global) that is used to identify a Transaction
+      # @param occ [String] Merchant purchase order
+      # @param authorization_code [String] a string returned when [Transaction]#commit completes correctly
+      # @param issued_at [Integer, nil] a timestamp
+      # @param signature [String, nil] a hashed string to verify the data
+      def initialize(nullify_amount: nil,
+                     occ: nil,
+                     external_unique_number: nil,
+                     authorization_code: nil,
+                     issued_at: nil,
+                     signature: nil)
+        @nullify_amount = nullify_amount
+        @occ = occ
+        @external_unique_number = external_unique_number
+        @authorization_code = authorization_code
+        @issued_at = issued_at
+        @signature = signature
+      end
+
+      # Create and set the signature for this instance of RefundCreateRequest
+      # @return [RefundCreateRequest] returns self
+      def sign(secret)
+        @signature = signature_for(to_data, secret)
+        self
+      end
+    end
+  end
+end

data/lib/transbank/sdk/onepay/requests/request.rb

@@ -0,0 +1,18 @@
+module Transbank
+  module Onepay
+    # Base module with methods & attributes common to Requests
+    module Request
+      include Utils::JSONUtils, Utils::SignatureUtils
+      attr_accessor :api_key
+      attr_accessor :app_key
+
+      # Set the request's @api_key overriding the one in
+      # the [Base] class
+      def set_keys_from_options(options)
+        transform_hash_keys(options)
+        new_api_key = options.fetch(:api_key, nil)
+        self.api_key = new_api_key unless new_api_key.nil?
+      end
+    end
+  end
+end

data/lib/transbank/sdk/onepay/requests/requests.rb

@@ -0,0 +1,9 @@
+require 'transbank/sdk/onepay/requests/request'
+require 'transbank/sdk/onepay/requests/transaction_create_request'
+require 'transbank/sdk/onepay/requests/transaction_commit_request'
+require 'transbank/sdk/onepay/requests/refund_create_request'
+
+module Transbank
+  module Onepay
+  end
+end

data/lib/transbank/sdk/onepay/requests/transaction_commit_request.rb

@@ -0,0 +1,48 @@
+module Transbank
+  module Onepay
+    # Creates a request to Transbank attempting to commit a [Transaction]
+    class TransactionCommitRequest
+      include Request
+      attr_reader :occ,  :external_unique_number, :issued_at, :signature
+
+      SIGNATURE_PARAMS = [:occ,
+                          :external_unique_number,
+                          :issued_at].freeze
+      # @param occ [String] Merchant purchase order
+      # @param external_unique_number [String] a unique value (per Merchant, not global) that is used to identify a Transaction
+      # @param issued_at [Integer] timestamp for when the transaction commit request was created
+      def initialize(occ, external_unique_number, issued_at)
+        self.occ = occ
+        self.external_unique_number = external_unique_number
+        self.issued_at = issued_at
+        @signature = nil
+      end
+
+      # @param occ [String] Merchant purchase order
+      def occ=(occ)
+        raise Errors::TransactionCommitError, 'occ cannot be null.' if occ.nil?
+        @occ = occ
+      end
+
+      # @param external_unique_number [String] a unique value (per Merchant, not global) that is used to identify a Transaction
+      def external_unique_number=(external_unique_number)
+        raise Errors::TransactionCommitError, 'external_unique_number cannot be null.' if external_unique_number.nil?
+        @external_unique_number = external_unique_number
+      end
+
+      # @param issued_at [Integer] timestamp for when the transaction commit request was created
+      def issued_at=(issued_at)
+        raise Errors::TransactionCommitError, 'issued_at cannot be null.' if issued_at.nil?
+        @issued_at = issued_at
+      end
+
+      # Create a signature string and assign it to @signature
+      # @return [TransactionCommitRequest] self
+      def sign(secret)
+        @signature = signature_for(to_data, secret)
+        self
+      end
+
+    end
+  end
+end

data/lib/transbank/sdk/onepay/requests/transaction_create_request.rb

@@ -0,0 +1,80 @@
+module Transbank
+  module Onepay
+    # Create a payload to create [Transaction] on Transbank
+    class TransactionCreateRequest
+      include Request
+
+      attr_accessor :external_unique_number, :total, :items_quantity, :issued_at,
+                    :items, :callback_url, :channel, :app_scheme, :signature
+      attr_reader :generate_ott_qr_code
+
+      SIGNATURE_PARAMS = [:external_unique_number,
+                          :total,
+                          :items_quantity,
+                          :issued_at,
+                          :callback_url].freeze
+      # @param opts [Hash] options hash with params needed to initialize this
+      # @param external_unique_number [String] Unique identifier (per Merchant) of the [Transaction] that
+      # @param total [Numeric] the total amount to pay for the items
+      # @param items_quantity [Numeric] the quantity of items on the shopping cart
+      # @param items [Array<Item] the items on the shopping cart
+      # @param issued_at [Numeric] timestamp at the moment the transaction is created
+      # @param callback_url [String] used when the channel is mobile, to be able to finish the [Transaction]
+      # @param channel [String] The channel the operation is made on. Valid values
+      # are on the [Channel] class
+      # @param app_scheme [String] identificator for the Merchant's app
+      # @param signature [String, nil] a hashstring created for verification purposes
+      def initialize(opts = {})
+        self.external_unique_number = opts.fetch(:external_unique_number)
+        self.total = opts.fetch(:total)
+        self.items_quantity = opts.fetch(:items_quantity)
+        self.items = opts.fetch(:items)
+        self.issued_at = opts.fetch(:issued_at)
+        self.callback_url = opts.fetch(:callback_url)
+        channel = opts.fetch(:channel, Channel::WEB)
+        self.channel = channel
+        self.app_scheme = opts.fetch(:app_scheme, '')
+        self.signature = nil
+        # This is never anything but true, but it is required by the server
+        @generate_ott_qr_code = true
+      end
+
+      def external_unique_number=(external_unique_number)
+        raise Errors::TransactionCreateError, 'External Unique Number cannot be null.' if external_unique_number.nil?
+        @external_unique_number = external_unique_number
+      end
+
+      def total=(total)
+        raise Errors::TransactionCreateError, 'Total cannot be null.' if total.nil?
+        raise Errors::TransactionCreateError, 'Total cannot be less than zero.' if total < 0
+        @total = total
+      end
+
+      def items_quantity=(items_quantity)
+        raise Errors::TransactionCreateError, 'Items quantity cannot be null.' if items_quantity.nil?
+        raise Errors::TransactionCreateError, 'Items quantity cannot be less than zero.' if items_quantity < 0
+        @items_quantity = items_quantity
+      end
+
+      def items=(items)
+        raise Errors::TransactionCreateError, 'Items must not be empty.' if items.empty?
+        @items = items
+      end
+
+      def callback_url=(callback_url)
+        raise Errors::TransactionCreateError, 'Callback url cannot be null.' if callback_url.nil?
+        @callback_url = callback_url
+      end
+
+      def channel=(channel)
+        raise Errors::TransactionCreateError, 'Channel cannot be null.' if channel.nil?
+        channel
+      end
+
+      def sign(secret)
+        @signature = signature_for(to_data, secret)
+        self
+      end
+    end
+  end
+end

data/lib/transbank/sdk/onepay/responses/refund_create_response.rb

@@ -0,0 +1,24 @@
+module Transbank
+  module Onepay
+    # Serializes the response to a RefundCreateRequest
+    class RefundCreateResponse
+      include Response
+      attr_accessor :occ, :external_unique_number, :reverse_code, :issued_at,
+                    :signature
+      # @raise []RefundCreateError] if the responseCode from the service is not 'OK'
+      def initialize(json)
+        unless json.fetch('responseCode').downcase == 'ok'
+          raise Errors::RefundCreateError, "#{json.fetch('responseCode')} : #{json.fetch('description')}"
+        end
+        result = json.fetch('result')
+        @response_code = json.fetch('responseCode')
+        @description = json.fetch('description')
+        @occ = result.fetch('occ')
+        @external_unique_number = result.fetch('externalUniqueNumber')
+        @reverse_code = result.fetch('reverseCode')
+        @issued_at = result.fetch('issuedAt')
+        @signature = result.fetch('signature')
+      end
+    end
+  end
+end

data/lib/transbank/sdk/onepay/responses/response.rb

@@ -0,0 +1,18 @@
+module Transbank
+  module Onepay
+    # Shared methods and attributes between all types of Responses
+    module Response
+      include Utils::SignatureUtils, Utils::JSONUtils
+      attr_accessor :response_code
+      attr_accessor :description
+
+      def response_ok?
+        response_code.downcase == 'ok'
+      end
+
+      def full_description
+        "#{ response_code } : #{ description }"
+      end
+    end
+  end
+end

data/lib/transbank/sdk/onepay/responses/responses.rb

@@ -0,0 +1,9 @@
+require 'transbank/sdk/onepay/responses/response'
+require 'transbank/sdk/onepay/responses/refund_create_response'
+require 'transbank/sdk/onepay/responses/transaction_commit_response'
+require 'transbank/sdk/onepay/responses/transaction_create_response'
+
+module Transbank
+  module Onepay
+  end
+end

data/lib/transbank/sdk/onepay/responses/transaction_commit_response.rb

@@ -0,0 +1,39 @@
+module Transbank
+  module Onepay
+    # Serializes the response to a TransactionCommitRequest
+    class TransactionCommitResponse
+      include Response
+
+      attr_accessor :occ, :authorization_code, :signature, :transaction_desc,
+                    :buy_order, :issued_at, :amount, :installments_amount,
+                    :installments_number
+
+      SIGNATURE_PARAMS = [:occ,
+                          :authorization_code,
+                          :issued_at,
+                          :amount,
+                          :installments_amount,
+                          :installments_number,
+                          :buy_order].freeze
+      # @raise [KeyError] upon missing a response parameter
+      def initialize(json)
+        result = json.fetch('result')
+        @response_code = json.fetch('responseCode')
+        @description = json.fetch('description')
+        @occ = result.fetch('occ')
+        @authorization_code = result.fetch('authorizationCode')
+        @signature = result.fetch('signature')
+        @transaction_desc = result.fetch('transactionDesc')
+        @buy_order = result.fetch('buyOrder')
+        @issued_at = result.fetch('issuedAt')
+        @amount = result.fetch('amount')
+        @installments_amount = result.fetch('installmentsAmount')
+        @installments_number = result.fetch('installmentsNumber')
+      end
+
+      def sign(secret)
+        @signature = signature_for(to_data, secret)
+      end
+    end
+  end
+end

data/lib/transbank/sdk/onepay/responses/transaction_create_response.rb

@@ -0,0 +1,32 @@
+module Transbank
+  module Onepay
+    # Serializes the response to a TransactionCreateRequest
+    class TransactionCreateResponse
+      include Response
+
+      attr_accessor :occ, :ott, :external_unique_number, :qr_code_as_base64,
+                    :issued_at, :signature
+
+      SIGNATURE_PARAMS = [:occ,
+                          :external_unique_number,
+                          :issued_at].freeze
+      # @raise [KeyError] upon trying to fetch a missing key from the response
+      def initialize(json)
+        result = json.fetch('result')
+        @response_code = json.fetch('responseCode')
+        @description = json.fetch('description')
+        @occ = result.fetch('occ')
+        @ott = result.fetch('ott')
+        @external_unique_number = result.fetch('externalUniqueNumber')
+        @qr_code_as_base64 = result.fetch('qrCodeAsBase64')
+        @issued_at = result.fetch('issuedAt')
+        @signature = result.fetch('signature')
+      end
+
+      def sign(secret)
+        @signature = signature_for(to_data, secret)
+        self
+      end
+    end
+  end
+end

data/lib/transbank/sdk/onepay/utils/json_utils.rb

@@ -0,0 +1,73 @@
+module Transbank
+  module Onepay
+    module Utils
+      module JSONUtils
+        def self.included(mod)
+          # Implement #to_h if the class that includes this module doesn't have it
+          # implemented. Used in several model classes to make them easier to
+          # transform to hashes so they can be transformed to JSON afterwards
+          unless mod.respond_to? :to_h
+            mod.send(:define_method, :to_h) do
+              JSON.parse(self.jsonify)
+            end
+          end
+        end
+        # Get all instance variables of an instance of a class,
+        # then for all of these variables,
+        # if the instance of the class' respond_to? returns true,
+        # #send the variable name (so, you'll get the value of the instance variable's
+        # getter), then save that to a Hash where [key] is the instance variable's name
+        # and [value] is its value
+        #
+        # Finally, generate a JSON string from this hash
+        # @return [String] a JSON string created from the Hash resulting from the
+        # above operation
+        def jsonify
+          instance_vars = instance_variables.map! { |var| var.to_s.gsub!(/^@/, '') }
+          instance_as_hash =
+              instance_vars.reduce({}) do |resulting_hash, instance_variable|
+                if respond_to? instance_variable
+                  value = send(instance_variable)
+                  # Safe navigation operator is Ruby 2.3+
+                  value = value.to_h if value && value.respond_to?(:to_h) unless value.is_a? Array
+                  value = value.to_a if value && value.respond_to?(:to_a) unless value.is_a? Hash
+                  if value.is_a? Array
+                    value = value.map {|x| x.respond_to?(:jsonify) ? JSON.parse(x.jsonify) : x }
+                  end
+
+                  value = value.jsonify if value.respond_to? :jsonify
+                  resulting_hash[instance_variable] = value
+                end
+                resulting_hash
+              end
+          JSON.generate instance_as_hash
+        end
+
+        # Receive a Hash and return a new hash same as the one we received,
+        # but all keys that were strings or camelCase'd are snake_case'd and
+        # turned into symbols.
+        # Example: {'camelCaseKey': "somevalue"}
+        # Would return: {camel_case_key: "somevalue"}
+        def transform_hash_keys(hash)
+          hash.reduce({}) do |new_hsh, (key, val)|
+            new_key = underscore(key).to_sym
+            new_hsh[new_key] = val
+            new_hsh
+          end
+        end
+
+        # FROM https://stackoverflow.com/a/1509957
+        # Transforms camelCaseWords to snake_case_words
+        def underscore(camel_cased_word)
+          camel_cased_word.to_s.gsub(/::/, '/')
+              .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+              .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+              .tr("-", "_")
+              .downcase
+        end
+      end
+    end
+  end
+end
+
+

data/lib/transbank/sdk/onepay/utils/net_helper.rb

@@ -0,0 +1,38 @@
+module Transbank
+  module Onepay
+    module Utils
+      module NetHelper
+        # POST a request to Transbank's servers, and return the parsed response
+        # @param uri_string [String] an URI to post to
+        # @param body [Hash] the body of your POST request
+        # @return [Hash] the JSON.parse'd response body
+        def http_post(uri_string, body)
+          uri = URI.parse(uri_string)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = uri.scheme == 'https'
+          request = Net::HTTP::Post.new(uri.path, 'Content-Type'=> 'application/json')
+          camel_cased_body = keys_to_camel_case(body)
+          request.body = JSON.generate(camel_cased_body)
+          result = http.request(request)
+          JSON.parse(result.body)
+        end
+
+        # Required for sending data to Transbank.
+        def keys_to_camel_case(hash)
+          hash.reduce({}) do |new_hash, (key, val)|
+            if val.is_a? Array
+              val = val.map {|value| value.is_a?(Hash) ? keys_to_camel_case(value) : value }
+            end
+            new_key = snake_to_camel_case(key.to_s)
+            new_hash[new_key] = val
+            new_hash
+          end
+        end
+
+        def snake_to_camel_case(str)
+          str.split('_').reduce { |string, current_word| string + current_word.capitalize }
+        end
+      end
+    end
+  end
+end