tbk-sdk 1.5.0.pre.ruby2.3

data/lib/transbank/sdk/onepay/models/item.rb

@@ -0,0 +1,103 @@
+module Transbank
+  module Onepay
+    class Item
+      include Transbank::Utils::JSONUtils
+      # An Item to be purchased by the user, and to be added to a [ShoppingCart]
+
+      # @return [String] An item's description
+      attr_reader :description
+
+      # @return quantity [Integer] How many of units of [Item]
+      attr_reader :quantity
+
+      # @return amount [Integer] The value of each unit of [Item]
+      attr_reader :amount
+
+      # @return additional_data [String] A string with whatever additional data the
+      # Merchant might want to add
+      attr_reader :additional_data
+
+      # @return expire [Integer] Expiry for the Item
+      attr_reader :expire
+      # @param [Hash] opts options Hash
+      # @param description [String] The item's description
+      # @param quantity [Integer] How many of units of [Item]
+      # @param amount [Integer] The value of each unit of [Item]
+      # @param additional_data [String] A string with whatever additional data the
+      # Merchant might want to add
+      # @param expire [Integer] Expiry for the Item
+      # @raise [ItemError] when opts is not a [Hash]
+      def initialize(opts = {})
+        raise Errors::ItemError, 'Item must be a Hash' unless opts.is_a? Hash
+        opts = transform_hash_keys opts
+        self.description = opts.fetch(:description)
+        self.quantity = opts.fetch(:quantity)
+        self.amount = opts.fetch(:amount)
+        self.additional_data = opts.fetch(:additional_data, nil)
+        self.expire = opts.fetch(:expire, nil)
+      end
+
+      # @param description [String] An item's description
+      # @raise [ItemError] when description is null
+      def description=(description)
+        raise Errors::ItemError, "Description cannot be null" if description.nil?
+        @description = description
+      end
+
+      # @param quantity [Integer] How many of units of [Item]
+      # @raise [ItemError] when given quantity is nil or less than zero.
+      def quantity=(quantity)
+        raise Errors::ItemError, "Quantity cannot be null" if quantity.nil?
+        if quantity < 0
+          raise Errors::ItemError, "Quantity cannot be less than zero"
+        end
+        @quantity = quantity
+      end
+
+      # @param amount [Integer] The value of each unit of [Item]
+      # @raise [ItemError] when amount cannot be null.
+      # @raise [ArgumentError] when amount is not an Integer.
+      def amount=(amount)
+        raise Errors::ItemError, "Amount cannot be null" if amount.nil?
+        if amount != Integer(amount)
+          raise ArgumentError, "Amount is not an Integer"
+        end
+        @amount = amount
+      end
+
+      # @param additional_data [String] A string with whatever additional data the
+      # Merchant might want to add
+      def additional_data=(additional_data)
+        additional_data = '' if additional_data.nil?
+        @additional_data = additional_data
+      end
+
+      # @param expire [Integer] Expiry for the Item
+      def expire=(expire)
+        expire = expire || 0
+        @expire = expire
+      end
+
+      # Return the total amount to pay for the Item, that is, amount * quantity
+      # @return [Numeric] the total amount to pay for the [Item]
+      def total
+        self.quantity * self.amount
+      end
+
+      # Override == to allow comparison between [Item]s
+      # @return [boolean] true if equal, false otherwise
+      def ==(another_item)
+         self.description == another_item.description &&
+         self.quantity == another_item.quantity &&
+         self.amount == another_item.amount &&
+         self.additional_data == another_item.additional_data &&
+         self.expire == another_item.expire
+      end
+
+      # Alias for #==
+      def eql?(another_item)
+        self.==(another_item)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+require 'transbank/sdk/onepay/models/item'
+require 'transbank/sdk/onepay/models/channels'
+require 'transbank/sdk/onepay/models/refund'
+require 'transbank/sdk/onepay/models/shopping_cart'
+require 'transbank/sdk/onepay/models/transaction'
+
+module Transbank
+  module Onepay
+  end
+end

data/lib/transbank/sdk/onepay/models/refund.rb

@@ -0,0 +1,50 @@
+module Transbank
+  module Onepay
+    class Refund
+      extend Transbank::Utils::NetHelper, Utils::RequestBuilder
+      # Manages Refunds
+      REFUND_TRANSACTION = 'nullifytransaction'.freeze
+      TRANSACTION_BASE_PATH = '/ewallet-plugin-api-services/services/transactionservice/'.freeze
+
+      class << self
+        # Create a request for a Refund
+        # @param amount [Integer] Amount to be refunded. Must be the full amount of the
+        # [Transaction] to be refunded
+        # @param occ [String] Merchant purchase order
+        # @param external_unique_number [String] Unique identifier (per Merchant) of the [Transaction] that
+        # will be refunded
+        # @param authorization_code [String] Authorization code. This is given when the [Transaction]
+        # is successfully committed (with the #commit method of [Transaction])
+        # @param options[Hash, nil] an optional Hash with configuration overrides
+        # @raise [RefundCreateError] if the response is nil or has no response code
+        # @raise [RefundCreateError] if response from the service is not equal to 'OK'
+        def create(amount:, occ:, external_unique_number:, authorization_code:, options: nil)
+          refund_request = refund_transaction(refund_amount: amount,
+                                              occ: occ,
+                                              external_unique_number: external_unique_number,
+                                              authorization_code: authorization_code,
+                                              options: options)
+          response = http_post(uri_string: refund_path, body: refund_request.to_h)
+          if response.nil? || !JSON.parse(response.body)['responseCode']
+            raise Errors::RefundCreateError, 'Could not obtain a response from the service.'
+          end
+
+          refund_create_response = RefundCreateResponse.new(JSON.parse(response.body))
+
+          unless refund_create_response.response_ok?
+            raise Errors::RefundCreateError, refund_create_response.full_description
+          end
+
+          refund_create_response
+        end
+
+        # Return the string url to POST to
+        # @return [String] the url to POST to
+        def refund_path
+          Base.current_integration_type_url + TRANSACTION_BASE_PATH + REFUND_TRANSACTION
+        end
+      end
+
+    end
+  end
+end

data/lib/transbank/sdk/onepay/models/shopping_cart.rb

@@ -0,0 +1,65 @@
+module Transbank
+  module Onepay
+    # Represents a Shopping Cart, which contains [Item]s that the user wants to buy
+    class ShoppingCart
+      include Transbank::Utils::JSONUtils
+
+      # @return [Array<Item>] An [Array<Item>] with the [ShoppingCart] contents
+      attr_reader :items
+
+      # @param items [Array, nil] an array of Hashes that can be converted to [Item]
+      # if nil, an empty shopping cart is created
+      def initialize(items = [])
+        # An [Array<Item>] with the [ShoppingCart] contents
+        @items = []
+        return if items.nil? || items.empty?
+
+        items.each do |it|
+          it = transform_hash_keys it
+          item = Item.new it
+          self << item
+        end
+      end
+
+      # @param item [Item] an instance of [Item]
+      # @return [boolean] return true if item is successfully added
+      def add(item)
+        new_total = total + item.total
+        if new_total < 0
+          raise Errors::ShoppingCartError, "Total amount cannot be less than zero."
+        end
+        @items << item
+      end
+
+      # Alias for #add
+      def << item
+        add item
+      end
+
+      # Remove an [Item] from self
+      # @raise [ShoppingCartError] if item is not found
+      def remove(item)
+        if @items.delete(item).nil?
+          raise Errors::ShoppingCartError, "Item not found"
+        end
+      end
+
+      # Clear the cart, setting @items to []
+      def remove_all
+        @items = []
+      end
+
+      # @return [Integer] The amount in CLP of the [Item]s included in the [ShoppingCart]
+      def total
+        # Array#sum is Ruby 2.4+
+        @items.reduce(0) { |total, item| total + item.total }
+      end
+
+      # Sum the quantity of items in the cart
+      def items_quantity
+        # Array#sum is Ruby 2.4+
+        @items.reduce(0) { |total, item| total + item.quantity }
+      end
+    end
+  end
+end

data/lib/transbank/sdk/onepay/models/transaction.rb

@@ -0,0 +1,143 @@
+module Transbank
+  module Onepay
+    ## Class Transaction
+    #  This class creates or commits a Transaction (that is, a purchase)
+    class Transaction
+      extend Transbank::Utils::NetHelper, Utils::RequestBuilder
+
+      SEND_TRANSACTION = 'sendtransaction'.freeze
+      COMMIT_TRANSACTION = 'gettransactionnumber'.freeze
+      TRANSACTION_BASE_PATH = '/ewallet-plugin-api-services/services/transactionservice/'.freeze
+
+      class << self
+        # Create a [Transaction], initiating the purchase process.
+        # @param shopping_cart [ShoppingCart] contains the [Item]s to be purchased
+        # @param channel [String] The channel that the transaction is going to be done through. Valid values are contained on the [Transbank::Onepay::Channel] class
+        # @param external_unique_number [String] a unique value (per Merchant, not global) that is used to identify a Transaction
+        # @param options[Hash, nil] an optional Hash with configuration overrides
+        # @return [TransactionCreateResponse] the response to your request.
+        # Includes data that you will need to #commit your [Transaction]
+        # @raise [ShoppingCartError] if shopping cart is nil or empty
+        # @raise [TransactionCreateError] if channel is not valid
+        # @raise [TransactionCreateError] if no response is gotten, or responseCode of the response is not 'OK'
+        def create(shopping_cart:, channel: nil, external_unique_number: nil,
+                   options: nil)
+          if is_options_hash?(channel)
+            options = channel
+            channel = nil
+          end
+
+          if is_options_hash?(external_unique_number)
+            options = external_unique_number
+            external_unique_number = nil
+          end
+
+          validate_channel!(channel)
+          validate_shopping_cart!(shopping_cart)
+
+          options = complete_options(options)
+          create_request = create_transaction(shopping_cart: shopping_cart,
+                                              channel: channel,
+                                              external_unique_number: external_unique_number,
+                                              options: options)
+          response = http_post(uri_string: transaction_create_path, body: create_request.to_h)
+          validate_create_response!(response)
+          transaction_create_response = TransactionCreateResponse.new JSON.parse(response.body)
+          signature_is_valid = transaction_create_response.valid_signature?(options.fetch(:shared_secret))
+          unless signature_is_valid
+            raise Errors::SignatureError, "The response's signature is not valid."
+          end
+          transaction_create_response
+        end
+
+        # Commit a [Transaction]. It is MANDATORY for this to be done, and you have
+        # 30 seconds to do so, otherwise the [Transaction] is automatically REVERSED
+        # @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] an optional Hash with configuration overrides
+        # @return [TransactionCommitResponse] The response to your commit request.
+        # @raise [TransactionCommitError] if response is nil or responseCode of the response is not 'OK'
+        def commit(occ:, external_unique_number:, options: nil)
+          options = complete_options(options)
+          commit_request = commit_transaction(occ: occ,
+                                              external_unique_number: external_unique_number,
+                                              options: options)
+          response = http_post(uri_string: transaction_commit_path, body: commit_request.to_h)
+          validate_commit_response!(response)
+          transaction_commit_response = TransactionCommitResponse.new(JSON.parse(response.body))
+          signature_is_valid = transaction_commit_response.valid_signature?(options.fetch(:shared_secret))
+          unless signature_is_valid
+            raise Errors::SignatureError, "The response's signature is not valid."
+          end
+          transaction_commit_response
+        end
+
+        private
+
+        def is_options_hash?(hash)
+          return false unless hash.respond_to? :keys
+          # Intersection of the two arrays
+          ([:api_key, :shared_secret] & hash.keys).any?
+        end
+
+        def validate_channel!(channel)
+          if channel_is_app?(channel) && Base::app_scheme.nil?
+            raise Errors::TransactionCreateError, 'You need to set an app_scheme if you want to use the APP channel'
+          end
+
+          if channel_is_mobile?(channel) && Base::callback_url.nil?
+            raise Errors::TransactionCreateError, 'You need to set a valid callback if you want to use the MOBILE channel'
+          end
+        end
+
+        def validate_shopping_cart!(shopping_cart)
+          if shopping_cart.items.nil? || shopping_cart.items.empty?
+            raise Errors::ShoppingCartError, 'Shopping cart is null or empty.'
+          end
+        end
+
+        def validate_commit_response!(response)
+          unless response
+            raise Errors::TransactionCommitError, 'Could not obtain a response from the service.'
+          end
+
+          unless JSON.parse(response.body).fetch('responseCode') == 'OK'
+            body = JSON.parse(response.body)
+            msg = "#{body.fetch('responseCode')} : #{body.fetch('description')}"
+            raise Errors::TransactionCommitError,  msg
+          end
+          response
+        end
+
+        def validate_create_response!(response)
+          unless response
+            raise Errors::TransactionCreateError, 'Could not obtain a response from the service.'
+          end
+
+          unless JSON.parse(response.body).fetch('responseCode') == 'OK'
+            body = JSON.parse(response.body)
+            msg = "#{body.fetch('responseCode')} : #{body['description']}"
+            raise Errors::TransactionCreateError, msg
+          end
+          response
+        end
+
+        def channel_is_app?(channel)
+          channel && channel == Transbank::Onepay::Channel::APP
+        end
+
+        def channel_is_mobile?(channel)
+          channel && channel == Transbank::Onepay::Channel::MOBILE
+        end
+
+        def transaction_create_path
+          Base.current_integration_type_url + TRANSACTION_BASE_PATH + SEND_TRANSACTION
+        end
+
+        def transaction_commit_path
+          Base.current_integration_type_url + TRANSACTION_BASE_PATH + COMMIT_TRANSACTION
+        end
+      end
+    end
+  end
+end

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 Transbank::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,85 @@
+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,
+                    :commerce_logo_url, :width_height
+      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
+      # @param commerce_logo_url [String] The URL pointing to the Merchant's logo
+      # @param width_height [Numeric] qr width and height used by the frontend JS SDK.
+      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
+        self.commerce_logo_url = opts.fetch(:commerce_logo_url)
+        self.width_height = opts.fetch(:width_height)
+        # 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 = 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, Transbank::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