transbank-sdk 1.5.0 → 2.0.0

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

@@ -1,16 +0,0 @@
-module Transbank
-  module TransaccionCompleta
-    class TransactionCommitResponse
-      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/responses/transaction_create_response.rb

@@ -1,10 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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'
-require 'transbank/sdk/transaccion_completa/mall/mall_transaction'
-require 'transbank/sdk/transaccion_completa/mall/responses/mall_transaction_responses'

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

@@ -1,144 +0,0 @@
-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'
-      CAPTURE_TRANSACTION_ENDPOINT = 'rswebpaytransaction/api/webpay/v1.0/transactions/:token/capture'
-
-      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.is_a? 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)
-          if resp.is_a? Net::HTTPSuccess
-            return ::Transbank::TransaccionCompleta::TransactionInstallmentsResponse.new(body)
-          end
-
-          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.is_a? 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.is_a? 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.is_a? Net::HTTPSuccess
-
-          raise Errors::TransactionRefundError.new(body['error_message'], resp.code)
-        end
-
-        def capture(token:, buy_order:, authorization_code:, capture_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 = {
-            buy_order: buy_order,
-            authorization_code: authorization_code,
-            capture_amount: capture_amount
-          }
-
-          url = base_url + CAPTURE_TRANSACTION_ENDPOINT.gsub(':token', token)
-          headers = webpay_headers(commerce_code: commerce_code, api_key: api_key)
-          resp = http_put(uri_string: url, body: body, headers: headers)
-          body = JSON.parse(resp.body)
-          return ::Transbank::TransaccionCompleta::TransactionCaptureResponse.new(body) if resp.is_a? Net::HTTPSuccess
-
-          raise Errors::TransactionCaptureError.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

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

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

@@ -1,75 +0,0 @@
-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

@@ -1,82 +0,0 @@
-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/request_builder.rb

@@ -1,96 +0,0 @@
-module Transbank
-  module Onepay
-    module Utils
-      module RequestBuilder
-        # Create a [Transaction] request. Used internally by [Transaction]#create
-        # @param shopping_cart [ShoppingCart] the user's ShoppingCart, with [Item]s
-        # he/she intends to purchase
-        # @param channel [String] The channel the operation is made on. Valid values
-        # are on the [Channel] class
-        # @param external_unique_number [String, nil] a unique value (per Merchant, not global) that is used to identify a Transaction
-        # @param options [Hash, nil] a hash with config overrides
-        def create_transaction(shopping_cart:, channel:, external_unique_number: nil, options: nil)
-          channel = Base.default_channel if channel.nil?
-          external_unique_number = time_as_number if external_unique_number.nil?
-          options = complete_options(options)
-          issued_at = Time.now.to_i
-
-          request = TransactionCreateRequest.new(
-            external_unique_number: external_unique_number,
-            total: shopping_cart.total,
-            items_quantity: shopping_cart.items_quantity,
-            issued_at: issued_at,
-            items: shopping_cart.items,
-            callback_url: Base.callback_url,
-            channel: channel,
-            app_scheme: Base.app_scheme,
-            commerce_logo_url: options[:commerce_logo_url],
-            width_height: options[:qr_width_height]
-          )
-          request.set_keys_from_options(options)
-          request.app_key = Base::current_integration_type_app_key
-          request.sign(options.fetch(:shared_secret))
-        end
-
-        # Used internally by [Transaction]#commit
-        # @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 options [Hash, nil] a hash with config overrides
-        def commit_transaction(occ:, external_unique_number:, options: nil)
-          options = complete_options(options)
-          issued_at = Time.now.to_i
-          request = TransactionCommitRequest.new(occ, external_unique_number, issued_at)
-          request.set_keys_from_options(options)
-          request.app_key = Base::current_integration_type_app_key
-          request.sign(options.fetch(:shared_secret))
-        end
-
-        # Used internally by [Refund]#create
-        # @param refund_amount [Integer] the full amount of the [Transaction] to refund. No partial refunds allowed.
-        # @param occ [String] Merchant purchase order of the order to refund
-        # @param external_unique_number [String] external unique number of the [Transaction] to refund
-        # @param authorization_code [String] authorization code for the [Transaction] to refund.
-        # This is given when you successfully #commit a [Transaction]
-        # @param options [Hash, nil] a hash with config overrides
-        def refund_transaction(refund_amount:, occ:, external_unique_number:, authorization_code:, options: nil)
-          options = complete_options(options)
-          issued_at = Time.now.to_i
-          request = RefundCreateRequest.new(nullify_amount: refund_amount,
-                                            occ: occ,
-                                            external_unique_number: external_unique_number,
-                                            authorization_code: authorization_code,
-                                            issued_at: issued_at)
-          request.set_keys_from_options(options)
-          request.app_key = Base::current_integration_type_app_key
-          request.sign(options.fetch(:shared_secret))
-        end
-
-        def time_as_number
-          # Float#truncate(number_of_digits_to_leave) is from Ruby 2.4 onwards
-          number, decimals = Time.now.to_f.to_s.split('.')
-          (number + decimals[0..2]).to_i
-        end
-
-        # Fill options with default values
-        def complete_options(options = {})
-          options = {} if options.nil?
-          default_options.merge(options)
-        end
-
-        # Return the default options values:
-        # api_key: Base::api_key
-        # app_key: Base::current_integration_type_app_key
-        # shared_secret: Base::shared_secret
-        # @return [Hash] a hash with the aforementioned keys/values
-        def default_options
-          {
-            api_key: Base::api_key,
-            shared_secret: Base::shared_secret,
-            commerce_logo_url: Base::commerce_logo_url,
-            qr_width_height: Base::qr_width_height
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-module Transbank
-  module Onepay
-    module Utils
-      # Utils for creating signatures, included on classes that need to be signed
-      module SignatureUtils
-        # Transform the instance of the class that calls this method into a
-        # string in the format required for the signature, using the params defined
-        # in the class' SIGNATURE_PARAMS array constant
-        # @raise [RuntimeError] if self.class::SIGNATURE_PARAMS is nil or empty
-        def to_data
-          if self.class::SIGNATURE_PARAMS.nil? || self.class::SIGNATURE_PARAMS.empty?
-            raise RuntimeError, 'SIGNATURE_PARAMS is empty or nil!'
-          end
-          self.class::SIGNATURE_PARAMS.reduce('') do |data_string, current_value|
-            value_of_getter = send(current_value)
-            # Integer#digits is ruby 2.4 upwards :(
-            data_string + value_of_getter.to_s.length.to_s + value_of_getter.to_s
-          end
-        end
-
-        # Digest data and secret, creating a hashed string
-        # @param data [String] a string created from the signable, created using #to_data
-        # @param secret [String] the string to hash the data with.
-        # @return [String] the result of the hashing of data with secret.
-        def hmac_sha256(data, secret)
-          OpenSSL::HMAC.digest(OpenSSL::Digest.new('sha256'), secret, data)
-        end
-
-        # Return the base64 of the hmac_sha256'd data & secret
-        # @param data [String] a string created from the signable, created using #to_data
-        # @param secret [String] the string to hash the data with.
-        # @return [String] Base64 representation of the hmac_sha256 hashing of data & secret
-        def signature_for(data, secret)
-          Base64.encode64(hmac_sha256(data, secret)).strip
-        end
-
-        # Compare the @signature of self with the one recreated from self using
-        # the secret param. Return true if equal
-        # @param secret [String] the secret used to create the signature with.
-        # @return [boolean] return true if signatures match, false otherwise
-        def valid_signature?(secret)
-          # We should be able to recreate the same signature from the signable's data
-          # and the secret
-          self.signature == signature_for(self.to_data, secret)
-        end
-      end
-    end
-  end
-end

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

@@ -1,9 +0,0 @@
-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/webpay/errors/integration_type_error.rb

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

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

@@ -1,14 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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