mercadopago-sdk 1.3.0 → 2.0.1

data/lib/mercadopago/http/http_client.rb

@@ -0,0 +1,74 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'json'
+
+module Mercadopago
+  class HttpClient
+    def get(url:, headers:, params: nil, timeout: nil, maxretries: nil)
+      try = 0
+      headers = {} if headers.nil?
+      headers[:params] = params unless params.nil?
+
+      begin
+        result = RestClient::Request.execute(method: :get, url: url, headers: headers, timeout: timeout)
+        {
+          status: result.code,
+          response: JSON.parse(result.body)
+        }
+      rescue RestClient::Exception => e
+        try += 1
+        if [429, 500, 502, 503, 504].include?(e.http_code) && (try < maxretries)
+          sleep(1)
+          retry
+        end
+        {
+          status: e.http_code,
+          response: JSON.parse(e.response.body)
+        }
+      end
+    end
+
+    def post(url:, data:, headers:, timeout: nil)
+      result = RestClient::Request.execute(method: :post, url: url, payload: data, headers: headers,
+                                           timeout: timeout)
+      {
+        status: result.code,
+        response: JSON.parse(result.body)
+      }
+    rescue RestClient::Exception => e
+      {
+        status: e.http_code,
+        response: JSON.parse(e.response.body)
+      }
+    end
+
+    def put(url:, data:, headers:, timeout: nil)
+      result = RestClient::Request.execute(method: :put, url: url, payload: data, headers: headers,
+                                           timeout: timeout)
+      {
+        status: result.code,
+        response: JSON.parse(result.body)
+      }
+    rescue RestClient::Exception => e
+      {
+        status: e.http_code,
+        response: JSON.parse(e.response.body)
+      }
+    end
+
+    def delete(url:, headers:, timeout: nil)
+      result = RestClient::Request.execute(method: 'delete', url: url, headers: headers, timeout: timeout)
+      {
+        status: result.code,
+        response: JSON.parse(result.body)
+      }
+    rescue RestClient::Exception => e
+      {
+        status: e.http_code,
+        response: JSON.parse(e.response.body)
+      }
+    end
+  end
+end

data/lib/mercadopago/resources/advanced_payment.rb

@@ -0,0 +1,48 @@
+# typed: false
+# frozen_string_literal: true
+
+module Mercadopago
+  ###
+  # Access to Advanced Payments
+
+  class AdvancedPayment < MPBase
+    def search(filters: nil, request_options: nil)
+      raise TypeError, 'Param filters must be a Hash' unless filters.nil? || filters.is_a?(Hash)
+
+      _get(uri: '/v1/advanced_payments/search', filters: filters, request_options: request_options)
+    end
+
+    def get(advanced_payment_id, request_options: nil)
+      _get(uri: "/v1/advanced_payments/#{advanced_payment_id}", request_options: request_options)
+    end
+
+    def create(advanced_payment_data, request_options: nil)
+      raise TypeError, 'Param advanced_payment_data must be a Hash' unless advanced_payment_data.is_a?(Hash)
+
+      _post(uri: '/v1/advanced_payments', data: advanced_payment_data, request_options: request_options)
+    end
+
+    def capture(advanced_payment_id, request_options: nil)
+      capture_data = { capture: true }
+      _put(uri: "/v1/advanced_payments/#{advanced_payment_id}", data: capture_data, request_options: request_options)
+    end
+
+    def update(advanced_payment_id, advanced_payment_data, request_options: nil)
+      raise TypeError, 'Param advanced_payment_data must be a Hash' unless advanced_payment_data.is_a?(Hash)
+
+      _put(uri: "/v1/advanced_payments/#{advanced_payment_id}", data: advanced_payment_data,
+           request_options: request_options)
+    end
+
+    def cancel(advanced_payment_id, request_options: nil)
+      cancel_data = { status: 'cancelled' }
+      _put(uri: "/v1/advanced_payments/#{advanced_payment_id}", data: cancel_data, request_options: request_options)
+    end
+
+    def update_release_date(advanced_payment_id, release_date, request_options: nil)
+      disbursement_data = { money_release_date: release_date.strftime('%Y-%m-%d %H:%M:%S.%f') }
+      _post(uri: "/v1/advanced_payments/#{advanced_payment_id}/disburses", data: disbursement_data,
+            request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/card.rb

@@ -0,0 +1,31 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  ###
+  # The cards class is the way to store card data of your customers safely to improve the shopping experience.
+  # This will allow your customers to complete their purchases much faster and easily, since they will not have to complete their card data again.
+
+  # This class must be used in conjunction with the Customer class.
+  # [Click here for more infos](https://www.mercadopago.com/developers/en/guides/online-payments/web-tokenize-checkout/customers-and-cards)
+
+  class Card < MPBase
+    def get(customer_id, card_id, request_options: nil)
+      _get(uri: "/v1/customers/#{customer_id}/cards/#{card_id}", request_options: request_options)
+    end
+
+    def create(customer_id, card_data, request_options: nil)
+      raise TypeError, 'Param card_data must be a Hash' if card_data.nil? || !card_data.is_a?(Hash)
+
+      _post(uri: "/v1/customers/#{customer_id}/cards/", data: card_data, request_options: request_options)
+    end
+
+    def delete(customer_id, card_id, request_options: nil)
+      _delete(uri: "/v1/customers/#{customer_id}/cards/#{card_id}", request_options: request_options)
+    end
+
+    def list(customer_id, request_options: nil)
+      _get(uri: "/v1/customers/#{customer_id}/cards", request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/card_token.rb

@@ -0,0 +1,19 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  ##
+  # This class will allow you to send your customers card data for Mercado Pago server and receive a token to complete the payments transactions.
+
+  class CardToken < MPBase
+    def get(card_token_id, request_options: nil)
+      _get(uri: "/v1/card_tokens/#{card_token_id}", request_options: request_options)
+    end
+
+    def create(card_token_data, request_options: nil)
+      raise TypeError, 'Param card_token_data must be a Hash' unless card_token_data.is_a?(Hash)
+
+      _post(uri: '/v1/card_tokens', data: card_token_data, request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/customer.rb

@@ -0,0 +1,36 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  ###
+  # This class allows you to store customers data safely to improve the shopping experience.
+
+  # This will allow your customer to complete their purchases much faster and easily when used in conjunction with the Cards class.
+  # [Click here for more infos](https://mercadopago.com.br/developers/en/guides/online-payments/web-tokenize-checkout/customers-and-cards)
+
+  class Customer < MPBase
+    def search(filters: nil, request_options: nil)
+      _get(uri: '/v1/customers/search', filters: filters, request_options: request_options)
+    end
+
+    def get(customer_id, request_options: nil)
+      _get(uri: "/v1/customers/#{customer_id}", request_options: request_options)
+    end
+
+    def create(customer_data, request_options: nil)
+      raise TypeError, 'Param customer_data must be a Hash' unless customer_data.is_a?(Hash)
+
+      _post(uri: '/v1/customers', data: customer_data, request_options: request_options)
+    end
+
+    def update(customer_id, customer_data, request_options: nil)
+      raise TypeError, 'Param customer_data must be a Hash' unless customer_data.is_a?(Hash)
+
+      _put(uri: "/v1/customers/#{customer_id}", data: customer_data, request_options: request_options)
+    end
+
+    def delete(customer_id, request_options: nil)
+      _delete(uri: "/v1/customers/#{customer_id}", request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/disbursement_refund.rb

@@ -0,0 +1,24 @@
+# typed: false
+# frozen_string_literal: true
+
+module Mercadopago
+  #     ###
+  #     #Access to Advanced Payments Refunds
+
+  class DisbursementRefund < MPBase
+    def list(advanced_payment_id, request_options: nil)
+      _get(uri: "/v1/advanced_payments/#{advanced_payment_id}/refunds", request_options: nil)
+    end
+
+    def create_all(advanced_payment_id, request_options: nil)
+      _post(uri: "/v1/advanced_payments/#{advanced_payment_id}/refunds", request_options: request_options)
+    end
+
+    def create(advanced_payment_id, disbursement_id, amount: nil, request_options: nil)
+      disbursement_refund_data = amount.nil? ? nil : { amount: amount }
+
+      _post(uri: "/v1/advanced_payments/#{advanced_payment_id}/disbursements/#{disbursement_id}/refunds",
+            data: disbursement_refund_data, request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/identification_type.rb

@@ -0,0 +1,13 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  ###
+  # Access to Identification Types
+
+  class IdentificationType < MPBase
+    def get(request_options: nil)
+      _get(uri: '/v1/identification_types', request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/merchant_order.rb

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  ###
+  # This class will allow you to create and manage your orders. You can attach one or more payments in your merchant order.
+
+  class MerchantOrder < MPBase
+    def search(filters: nil, request_options: nil)
+      raise TypeError, 'Param filters must be a Hash' unless filters.nil? || filters.is_a?(Hash)
+
+      _get(uri: '/merchant_orders/search', filters: filters, request_options: request_options)
+    end
+
+    def get(merchant_order_id, request_options: nil)
+      _get(uri: "/merchant_orders/#{merchant_order_id}", request_options: request_options)
+    end
+
+    def create(merchant_order_data, request_options: nil)
+      raise TypeError, 'Param merchant_orders_object must be a Hash' unless merchant_order_data.is_a?(Hash)
+
+      _post(uri: '/merchant_orders', data: merchant_order_data, request_options: request_options)
+    end
+
+    def update(merchant_order_id, merchant_order_data, request_options: nil)
+      raise TypeError, 'Param merchant_orders_object must be a Hash' unless merchant_order_data.is_a?(Hash)
+
+      _put(uri: "/merchant_orders/#{merchant_order_id}", data: merchant_order_data,
+           request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/payment.rb

@@ -0,0 +1,35 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  ###
+  # This class provides the methods to access the API that will allow you to create your own payment experience on your website.
+
+  # From basic to advanced configurations, you control the whole experience.
+
+  # [Click here for more infos](https://www.mercadopago.com.br/developers/en/guides/online-payments/checkout-api/introduction/)
+
+  class Payment < MPBase
+    def search(filters: nil, request_options: nil)
+      raise TypeError, 'Param filters must be a Hash' unless filters.nil? || filters.is_a?(Hash)
+
+      _get(uri: '/v1/payments/search', filters: filters, request_options: request_options)
+    end
+
+    def get(payment_id, request_options: nil)
+      _get(uri: "/v1/payments/#{payment_id}", request_options: request_options)
+    end
+
+    def create(payment_data, request_options: nil)
+      raise TypeError, 'Param payment_data must be a Hash' unless payment_data.is_a?(Hash)
+
+      _post(uri: '/v1/payments/', data: payment_data, request_options: request_options)
+    end
+
+    def update(payment_id, payment_data, request_options: nil)
+      raise TypeError, 'Param payment_data must be a Hash' unless payment_data.is_a?(Hash)
+
+      _put(uri: "/v1/payments/#{payment_id}", data: payment_data, request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/payment_methods.rb

@@ -0,0 +1,13 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  ###
+  # Access to Payment Methods
+
+  class PaymentMethods < MPBase
+    def get(request_options: nil)
+      _get(uri: '/v1/payment_methods', request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/preference.rb

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  ##
+  # This class will allow you to charge your customers through our web form from any device in a simple, fast and secure way.
+  # [Click here for more infos](https://www.mercadopago.com.br/developers/en/guides/online-payments/checkout-pro/introduction)
+
+  class Preference < MPBase
+    def get(preference_id, request_options: nil)
+      _get(uri: "/checkout/preferences/#{preference_id}", request_options: request_options)
+    end
+
+    def create(preference_data, request_options: nil)
+      raise TypeError, 'Param preference_data must be a Hash' unless preference_data.is_a?(Hash)
+
+      _post(uri: '/checkout/preferences', data: preference_data, request_options: request_options)
+    end
+
+    def update(preference_id, preference_data, request_options: nil)
+      raise TypeError, 'Param preference_data must be a Hash' unless preference_data.is_a?(Hash)
+
+      _put(uri: "/checkout/preferences/#{preference_id}", data: preference_data, request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/refund.rb

@@ -0,0 +1,24 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  ###
+  # This class will allow you to refund payments created through the Payments class.
+  # You can refund a payment within 180 days after it was approved.
+
+  # You must have sufficient funds in your account in order to successfully refund the payment amount. Otherwise, you will get a 400 Bad Request error.
+
+  # [Click here for more infos](https://www.mercadopago.com.br/developers/en/guides/manage-account/account/cancellations-and-refunds#bookmark_refunds)
+
+  class Refund < MPBase
+    def list(payment_id, request_options: nil)
+      _get(uri: "/v1/payments/#{payment_id}/refunds", request_options: request_options)
+    end
+
+    def create(payment_id, refund_data: nil, request_options: nil)
+      raise TypeError, 'Param refund_data must be a Hash' unless refund_data.nil? || refund_data.is_a?(Hash)
+
+      _post(uri: "/v1/payments/#{payment_id}/refunds", data: refund_data, request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/resources/user.rb

@@ -0,0 +1,13 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  ###
+  # Access to Users
+
+  class User < MPBase
+    def get(request_options: nil)
+      _get(uri: '/users/me', request_options: request_options)
+    end
+  end
+end

data/lib/mercadopago/sdk.rb

@@ -0,0 +1,85 @@
+# typed: true
+# frozen_string_literal: true
+
+module Mercadopago
+  class SDK
+    attr_reader :access_token, :http_client
+
+    def initialize(access_token, http_client: nil, request_options: nil)
+      self.access_token = access_token
+      self.http_client = http_client.nil? ? HttpClient.new : http_client
+      self.request_options = request_options.nil? ? RequestOptions.new(access_token: access_token) : request_options
+    end
+
+    def advanced_payment
+      AdvancedPayment.new(request_options, http_client)
+    end
+
+    def card
+      Card.new(request_options, http_client)
+    end
+
+    def card_token
+      CardToken.new(request_options, http_client)
+    end
+
+    def customer
+      Customer.new(request_options, http_client)
+    end
+
+    def disbursement_refund
+      DisbursementRefund.new(request_options, http_client)
+    end
+
+    def user
+      User.new(request_options, http_client)
+    end
+
+    def identification_type
+      IdentificationType.new(request_options, http_client)
+    end
+
+    def merchant_order
+      MerchantOrder.new(request_options, http_client)
+    end
+
+    def payment
+      Payment.new(request_options, http_client)
+    end
+
+    def payment_methods
+      PaymentMethods.new(request_options, http_client)
+    end
+
+    def preference
+      Preference.new(request_options, http_client)
+    end
+
+    def refund
+      Refund.new(request_options, http_client)
+    end
+
+    def access_token=(value)
+      raise TypeError, 'Param access_token must be a String' unless value.is_a?(String)
+
+      @access_token = value
+    end
+
+    def http_client=(value)
+      raise TypeError, 'Param http_client must be a implementation of HttpClient' unless value.is_a?(HttpClient)
+
+      @http_client = value
+    end
+
+    def request_options=(value)
+      raise TypeError, 'Param request_options must be a RequestOptions object' unless value.is_a?(RequestOptions)
+
+      @request_options = value
+    end
+
+    def request_options
+      @request_options.access_token = @access_token if @request_options.access_token.nil?
+      @request_options
+    end
+  end
+end