transbank-sdk 1.1.0 → 1.4.1

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

@@ -0,0 +1,10 @@
+module Transbank
+  module TransaccionCompleta
+    class TransactionCreateResponse
+      attr_accessor :token
+      def initialize(json)
+        @token = json['token']
+      end
+    end
+  end
+end

data/lib/transbank/sdk/transaccion_completa/responses/transaction_installments_response.rb

@@ -0,0 +1,13 @@
+module Transbank
+  module TransaccionCompleta
+    class TransactionInstallmentsResponse
+      attr_accessor :installments_amount, :id_query_installments,
+                    :deferred_periods
+      def initialize(json)
+        @installments_amount = json['installments_amount']
+        @id_query_installments = json['id_query_installments']
+        @deferred_periods = json['deferred_periods']
+      end
+    end
+  end
+end

data/lib/transbank/sdk/transaccion_completa/responses/transaction_refund_response.rb

@@ -0,0 +1,14 @@
+module Transbank
+  module TransaccionCompleta
+    class TransactionRefundResponse
+      FIELDS = %i(
+                  type authorization_code authorization_date
+                  nullified_amount balance response_code
+                  )
+      attr_accessor *FIELDS
+      def initialize(json)
+        FIELDS.each { |field| send("#{field}=", json["#{field}"])}
+      end
+    end
+  end
+end

data/lib/transbank/sdk/transaccion_completa/responses/transaction_status_response.rb

@@ -0,0 +1,16 @@
+module Transbank
+  module TransaccionCompleta
+    class TransactionStatusResponse
+      FIELDS = %i(
+                  vci amount status buy_order session_id card_number
+                  accounting_date transaction_date authorization_code
+                  payment_type_code response_code installments_number
+                  installments_amount balance
+                  )
+      attr_accessor *FIELDS
+      def initialize(json)
+        FIELDS.each { |field| send("#{field}=", json["#{field}"])}
+      end
+    end
+  end
+end

data/lib/transbank/sdk/transaccion_completa/transaccion_completa.rb

@@ -0,0 +1,5 @@
+require 'transbank/sdk/transaccion_completa/errors/transaccion_completa_errors'
+require 'transbank/sdk/transaccion_completa/responses/transaccion_completa_responses'
+require 'transbank/sdk/transaccion_completa/options'
+require 'transbank/sdk/transaccion_completa/base'
+require 'transbank/sdk/transaccion_completa/transaction'

data/lib/transbank/sdk/transaccion_completa/transaction.rb

@@ -0,0 +1,117 @@
+module Transbank
+  module TransaccionCompleta
+    class Transaction
+      extend Utils::NetHelper
+
+      CREATE_TRANSACTION_ENDPOINT = 'rswebpaytransaction/api/webpay/v1.0/transactions'
+      TRANSACTION_INSTALLMENTS_ENDPOINT = 'rswebpaytransaction/api/webpay/v1.0/transactions/:token/installments'
+      COMMIT_TRANSACTION_ENDPOINT = 'rswebpaytransaction/api/webpay/v1.0/transactions/:token'
+      TRANSACTION_STATUS_ENDPOINT = 'rswebpaytransaction/api/webpay/v1.0/transactions/:token'
+      REFUND_TRANSACTION_ENDPOINT = 'rswebpaytransaction/api/webpay/v1.0/transactions/:token/refunds'
+
+      class << self
+        def create(buy_order:, session_id:, amount:, card_number:, cvv:,
+                   card_expiration_date:, options:nil)
+          api_key = options&.api_key || default_integration_params[:api_key]
+          commerce_code = options&.commerce_code || default_integration_params[:commerce_code]
+          integration_type = options&.integration_type || default_integration_params[:integration_type]
+          base_url = integration_type.nil? ? TransaccionCompleta::Base::integration_type[:TEST] : TransaccionCompleta::Base.integration_type_url(integration_type)
+
+          body = {
+            buy_order: buy_order, session_id: session_id,
+            amount: amount, card_number: card_number, cvv: cvv,
+            card_expiration_date: card_expiration_date
+          }
+
+          url = base_url + CREATE_TRANSACTION_ENDPOINT
+          headers = webpay_headers(commerce_code: commerce_code, api_key: api_key)
+          resp = http_post(uri_string: url, body: body, headers: headers, camel_case_keys: false)
+          body = JSON.parse(resp.body)
+          return ::Transbank::TransaccionCompleta::TransactionCreateResponse.new(body) if resp.kind_of? Net::HTTPSuccess
+          raise Errors::TransactionCreateError.new(body['error_message'], resp.code)
+        end
+
+        def installments(token:, installments_number:, options:nil)
+          api_key = options&.api_key || default_integration_params[:api_key]
+          commerce_code = options&.commerce_code || default_integration_params[:commerce_code]
+          integration_type = options&.integration_type || default_integration_params[:integration_type]
+          base_url = integration_type.nil? ? TransaccionCompleta::Base::integration_type[:TEST] : TransaccionCompleta::Base.integration_type_url(integration_type)
+
+          url = base_url + TRANSACTION_INSTALLMENTS_ENDPOINT.gsub(':token', token)
+          headers = webpay_headers(commerce_code: commerce_code, api_key: api_key)
+
+          body = {installments_number: installments_number}
+
+          resp = http_post(uri_string: url, body: body, headers: headers, camel_case_keys: false)
+          body = JSON.parse(resp.body)
+          return ::Transbank::TransaccionCompleta::TransactionInstallmentsResponse.new(body) if resp.kind_of? Net::HTTPSuccess
+          raise Errors::TransactionInstallmentsError.new(body['error_message'], resp.code)
+        end
+
+        def commit(token:, id_query_installments:, deferred_period_index:,
+                   grace_period:, options:nil)
+          api_key = options&.api_key || default_integration_params[:api_key]
+          commerce_code = options&.commerce_code || default_integration_params[:commerce_code]
+          integration_type = options&.integration_type || default_integration_params[:integration_type]
+          base_url = integration_type.nil? ? TransaccionCompleta::Base::integration_type[:TEST] : TransaccionCompleta::Base.integration_type_url(integration_type)
+
+          url = base_url + COMMIT_TRANSACTION_ENDPOINT.gsub(':token', token)
+          headers = webpay_headers(commerce_code: commerce_code, api_key: api_key)
+          body = {
+            id_query_installments: id_query_installments,
+            deferred_period_index: deferred_period_index,
+            grace_period: grace_period
+          }
+
+          resp = http_put(uri_string: url, body: body,  headers: headers)
+          body = JSON.parse(resp.body)
+          return ::Transbank::TransaccionCompleta::TransactionCommitResponse.new(body) if resp.kind_of? Net::HTTPSuccess
+          raise Errors::TransactionCommitError.new(body['error_message'], resp.code)
+        end
+
+        def status(token:, options: nil)
+          api_key = options&.api_key || default_integration_params[:api_key]
+          commerce_code = options&.commerce_code || default_integration_params[:commerce_code]
+          integration_type = options&.integration_type || default_integration_params[:integration_type]
+          base_url = integration_type.nil? ? TransaccionCompleta::Base::integration_type[:TEST] : TransaccionCompleta::Base.integration_type_url(integration_type)
+
+          url = base_url + TRANSACTION_STATUS_ENDPOINT.gsub(':token', token)
+          headers = webpay_headers(commerce_code: commerce_code, api_key: api_key)
+          resp = http_get(uri_string: url, headers: headers)
+          body = JSON.parse(resp.body)
+          return ::Transbank::TransaccionCompleta::TransactionStatusResponse.new(body) if resp.kind_of? Net::HTTPSuccess
+          raise Errors::TransactionStatusError.new(body['error_message'], resp.code)
+        end
+
+        def refund(token:, amount:, options:nil)
+          api_key = options&.api_key || default_integration_params[:api_key]
+          commerce_code = options&.commerce_code || default_integration_params[:commerce_code]
+          integration_type = options&.integration_type || default_integration_params[:integration_type]
+          base_url = integration_type.nil? ? TransaccionCompleta::Base::integration_type[:TEST] : TransaccionCompleta::Base.integration_type_url(integration_type)
+
+          body = {
+            amount: amount
+          }
+
+          url = base_url + REFUND_TRANSACTION_ENDPOINT.gsub(':token', token)
+          headers = webpay_headers(commerce_code: commerce_code, api_key: api_key)
+          resp = http_post(uri_string: url, body: body, headers: headers, camel_case_keys: false)
+          body = JSON.parse(resp.body)
+          return ::Transbank::TransaccionCompleta::TransactionRefundResponse.new(body) if resp.kind_of? Net::HTTPSuccess
+          raise Errors::TransactionRefundError.new(body['error_message'], resp.code)
+        end
+
+        def default_integration_params
+          {
+            api_key: TransaccionCompleta::Base.api_key,
+            commerce_code: TransaccionCompleta::Base.commerce_code,
+            integration_type: TransaccionCompleta::Base::integration_type,
+            base_url: TransaccionCompleta::Base::current_integration_type_url
+          }
+        end
+      end
+    end
+  end
+end
+
+

data/lib/transbank/sdk/transbank_error.rb

@@ -0,0 +1,6 @@
+module Transbank
+  module Errors
+    class TransbankError < StandardError
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module Transbank
+  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
+        # Some values can't be null and must be removed if they are
+        instance_as_hash.reject! do |key, value|
+          %w[commerce_logo_url width_height].include?(key) && value.nil?
+        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
+
+

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

@@ -0,0 +1,82 @@
+module Transbank
+  module Utils
+    module NetHelper
+      def http_get(uri_string:, headers:nil)
+        uri = URI.parse(uri_string)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        request_headers = {'Content-Type' => 'application/json'}.merge(headers || {})
+        request = Net::HTTP::Get.new(uri.path, request_headers)
+        http.request(request)
+      end
+      # 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: nil, headers: nil, camel_case_keys: true)
+        uri = URI.parse(uri_string)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+
+        request_headers = {'Content-Type' => 'application/json'}.merge(headers || {})
+        request = Net::HTTP::Post.new(uri.path, request_headers)
+        sendable_body = camel_case_keys ? keys_to_camel_case(body) : body
+        request.body = sendable_body.to_json
+        http.request(request)
+      end
+
+      def http_put(uri_string:, body: nil, headers: nil)
+        uri = URI.parse(uri_string)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+
+        request_headers = {'Content-Type' => 'application/json'}.merge(headers || {})
+        request = Net::HTTP::Put.new(uri.path, request_headers)
+        request.body = JSON.generate(body)
+        http.request(request)
+      end
+
+      def http_delete(uri_string:, body: nil, headers: nil)
+        uri = URI.parse(uri_string)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+
+        request_headers = {'Content-Type' => 'application/json'}.merge(headers || {})
+        request = Net::HTTP::Delete.new(uri.path, request_headers)
+        request.body = JSON.generate(body)
+        http.request(request)
+      end
+
+      # Required for sending data to Transbank on Onepay.
+      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
+
+      def webpay_headers(commerce_code:, api_key:)
+        {
+            "Tbk-Api-Key-Id" => commerce_code,
+            "Tbk-Api-Key-Secret" => api_key
+        }
+      end
+
+      def patpass_comercio_headers(commerce_code:, api_key:)
+        {
+            "commercecode" => commerce_code,
+            "Authorization" => api_key
+        }
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require 'transbank/sdk/utils/json_utils'
+require 'transbank/sdk/utils/net_helper'
+require 'transbank/sdk/utils/signature_utils'
+require 'transbank/sdk/utils/request_builder'
+
+module Transbank
+  module Onepay
+  end
+end

data/lib/transbank/sdk/version.rb

@@ -1,5 +1,5 @@
 module Transbank
   module Sdk
-    VERSION = "1.1.0"
+    VERSION = "1.4.1"
   end
 end

data/lib/transbank/sdk/webpay/errors/integration_type_error.rb

@@ -0,0 +1,8 @@
+module Transbank
+  module Webpay
+    module Errors
+      class IntegrationTypeError < ::Transbank::Errors::TransbankError
+      end
+    end
+  end
+end

data/lib/transbank/sdk/webpay/errors/webpay_error.rb

@@ -0,0 +1,14 @@
+module Transbank
+  module Webpay
+    module Errors
+      class WebpayError < ::Transbank::Errors::TransbankError
+        attr_accessor :message, :code
+        def initialize(message, code = nil)
+          self.message = message
+          self.code = code
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/transbank/sdk/webpay/webpay_plus/base.rb

@@ -0,0 +1,74 @@
+module Transbank
+  module Webpay
+    module WebpayPlus
+      class Base
+
+        DEFAULT_API_KEY = '579B532A7440BB0C9079DED94D31EA1615BACEB56610332264630D42D0A36B1C'.freeze
+        DEFAULT_COMMERCE_CODE = '597055555532'.freeze
+        DEFAULT_DEFERRED_COMMERCE_CODE = '597055555540'.freeze
+
+        DEFAULT_MALL_COMMERCE_CODE = '597055555535'.freeze
+        DEFAULT_MALL_CHILD_COMMERCE_CODES = ['597055555536'.freeze,'597055555537'.freeze].freeze;
+        DEFAULT_MALL_DEFERRED_COMMERCE_CODE = '597055555544 '.freeze
+        DEFAULT_MALL_DEFERRED_CHILD_COMMERCE_CODES = ['597055555545'.freeze,
+                                                      '597055555546'.freeze].freeze
+
+
+        @api_key = DEFAULT_API_KEY
+        @commerce_code = DEFAULT_COMMERCE_CODE
+        @integration_type = :TEST
+        @integration_types = {
+          LIVE: "https://webpay3g.transbank.cl/",
+          TEST: "https://webpay3gint.transbank.cl/"
+        }
+        class << self
+          attr_reader :integration_types
+          attr_accessor :api_key, :integration_type, :commerce_code
+
+
+          def integration_type_url(integration_type)
+            type = integration_type.upcase.to_sym
+            return @integration_types[type] unless @integration_types[type].nil?
+            valid_values = @integration_types.keys.join(', ')
+            raise Transbank::Webpay::Errors::IntegrationTypeError, "Invalid integration type, valid values are #{valid_values}"
+          end
+
+          def current_integration_type_url
+            @integration_types[@integration_type]
+          end
+
+          def integration_type=(integration_type)
+            type = integration_type.upcase.to_sym
+            return @integration_type = type unless @integration_types[type].nil?
+            valid_values = @integration_types.keys.join(', ')
+            raise Transbank::Webpay::Errors::IntegrationTypeError, "Invalid integration type, valid values are #{valid_values}"
+          end
+
+          def configure_for_testing
+            @api_key = DEFAULT_API_KEY
+            @commerce_code = DEFAULT_COMMERCE_CODE
+            self.integration_type = :TEST
+          end
+
+          def configure_mall_for_testing
+            @api_key = DEFAULT_API_KEY
+            @commerce_code = DEFAULT_MALL_COMMERCE_CODE
+            self.integration_type = :TEST
+          end
+
+          def configure_deferred_for_testing
+            @api_key = DEFAULT_API_KEY
+            @commerce_code = DEFAULT_DEFERRED_COMMERCE_CODE
+            self.integration_type = :TEST
+          end
+
+          def configure_mall_deferred_for_testing
+            @api_key = DEFAULT_API_KEY
+            @commerce_code = DEFAULT_MALL_DEFERRED_COMMERCE_CODE
+            self.integration_type = :TEST
+          end
+        end
+      end
+    end
+  end
+end