mp_api 1.2.2 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 59d843843d099fc02a62263d86caacb6d71655c160680034923a443155c2b1c8
-  data.tar.gz: 42bf488a1003f5e38d2418125e5d5b29f0de78c7c0aca65bb6a9329f2831f092
+  metadata.gz: e7626180e5c5faecffcf4f6f0a29befaf72d9a572549697ef4ebae057e404c85
+  data.tar.gz: ffb2373be7426f18b8f2ec3be5b7fd7a1e48e03ac6b19bd92f79b6d6fd574403
 SHA512:
-  metadata.gz: 0b769d68eb164df97a1ff8d2e7745b6205472acb3619aa22ee41fd1f869c17099cc1479bee8743dfcc30ada82c6b553169dfc43c55e6121e8ee6e4026f0b7d5b
-  data.tar.gz: 8d5503eb188b0bdc9bf1be1b9ecc8e2532a33b5474048bda8c46ef897cc8b9d597e63a6b7843f1af48ab8c328d0f1bcf61f8d12021dec506afc254c0eb226613
+  metadata.gz: bc745ec3c6f9820bf9ff76ed44485baf7300e1197fa4274d5afe1e8ff275c0d949bdefcfea394be558c800aae6b1007e7316adc95226006e28672ad43999e63f
+  data.tar.gz: a8be7e24c71e403b3ff02017d137dfb4ea2c588b6edc697e7f6575e3ce16c23d3a1ea37c2470abe107ea319abe6837238c23eb6a697e5ffb0b0964a186178357

data/README.md

@@ -1,86 +1,174 @@
 # MpApi
 
-Wrapper de integração com a API do Mercado Pago.
-
-[Documentação API Mercado Pago](https://www.mercadopago.com.br/developers/pt/docs)
-
-### Funcionalidades:
-- Criar pagamentos Pix ou cartão de crédito
-- Gerar token único para um cartão de crédito
-- Atualizar e encontrar pagamentos pelo ID
-- Buscar bandeira do cartão a partir dos seis primeiros digitos
+Uma gem Ruby para integração com a API do Mercado Pago, oferecendo uma interface simples e elegante para gerenciar pagamentos, clientes e cartões.
 
 ## Instalação
 
-Adicionar mp_api no Gemfile:
+Adicione esta linha ao Gemfile da sua aplicação:
 
 ```ruby
 gem 'mp_api'
 ```
-ou
-```shell
-bundle add mp_api
+
+E então execute:
+
+```bash
+bundle install
 ```
 
-Instalar a gem:
+Ou instale diretamente:
 
-```shell
-bin/rails generate mp_api:install
+```bash
+gem install mp_api
 ```
 
-## Uso
+### Criando um Cliente
 
-Configurar access_token no initializer ou direto no código:
 ```ruby
-MpApi.configure do |config|
-  config.access_token = "ACCESS_TOKEN"
-end
+# Inicialize o cliente
+client = MpApi::Client.new("SEU_ACCESS_TOKEN")
 ```
 
-### Exemplos de criação de pagamento
-#### Cartão de crédito
+### Pagamentos PIX
+
 ```ruby
-# Criação de um token para cartão teste
-token = MpApi::Token.new(
-  card_number: "5031433215406351",
-  expiration_year: "2025",
-  expiration_month: "11",
-  security_code: "123",
-  cardholder_name: "APRO"
-).create
-puts token.id # c8ad2335a9bb58e585a8c35bfd9f29ad
-
-# Encontra o ID e a bandeira do cartão
-payment_method = MpApi::PaymentMethod.find_by_first_six_digits("503143")
-puts payment_method.payment_method_id # "master"
-
-# Criação do pagamento
-payment = MpApi::Payment.new(
-  amount: 140.0,
-  payment_method: payment_method.payment_method_id,
-  payer_email: "email@example.com",
+# Criar um pagamento PIX
+response = client.create_pix_payment(
+  amount: 100.50,
+  description: "Pagamento de teste",
+  payment_method: "pix",
+  payer_email: "cliente@exemplo.com",
   payer_identification_type: "CPF",
-  payer_identification_number: "12345678909",
-  token: token.id,
-  issuer_id: payment_method.issuer_id,
-  installments: 1,
+  payer_identification_number: "12345678901",
+  date_of_expiration: "2025-12-31T23:59:59.000-04:00"
+)
+```
+
+### Pagamentos com Cartão de Crédito
+
+```ruby
+# Criar um pagamento com cartão de crédito
+response = client.create_credit_card_payment(
+  amount: 250.00,
+  description: "Compra online",
+  payment_method: "visa",
+  payer_email: "cliente@exemplo.com",
+  payer_identification_type: "CPF",
+  payer_identification_number: "12345678901",
+  token: "TOKEN_DO_CARTAO",
+  installments: 3,
   three_d_secure_mode: true
-).create
+)
+```
+
+### Pagamentos com Cartão Salvo
 
-puts payment.id # 1318474186
-puts payment.status # "approved"
+```ruby
+# Criar pagamento com cartão previamente salvo
+response = client.create_saved_credit_card_payment(
+  amount: 150.00,
+  token: "TOKEN_DO_CARTAO_SALVO",
+  installments: 1,
+  customer_id: "CUSTOMER_ID"
+)
 ```
 
-#### Pix
+### Gerenciamento de Pagamentos
+
 ```ruby
-# Criação do pagamento
-payment = MpApi::Payment.new(
-  payer_email: "email@example.com",
-  payer_identification_type: "CPF",
-  payer_identification_number: "12345678909",
-  payment_method: "pix",
-  amount: 140.0
-).create
-puts payment.id # 1318474264
-puts payment.status # "pending"
-```
+# Consultar um pagamento
+payment = client.get_payment("PAYMENT_ID")
+
+# Atualizar status de um pagamento
+client.update_payment(
+  payment_id: "PAYMENT_ID",
+  status: "cancelled"
+)
+```
+
+### Tokenização de Cartões
+
+```ruby
+# Criar token para um cartão
+token_response = client.create_token(
+  card_number: "4111111111111111",
+  expiration_year: "2028",
+  expiration_month: "12",
+  security_code: "123",
+  cardholder_name: "João Silva"
+)
+```
+
+### Métodos de Pagamento
+
+```ruby
+# Buscar métodos de pagamento por BIN
+payment_methods = client.search_payment_methods(
+  first_six_digits: "411111"
+)
+
+# Listar todos os métodos de pagamento
+all_methods = client.get_payment_methods
+```
+
+### Gerenciamento de Clientes
+
+```ruby
+# Buscar cliente por email
+customer = client.get_customer("cliente@exemplo.com")
+
+# Criar um novo cliente
+new_customer = client.create_customer(
+  email: "novo@cliente.com",
+  first_name: "João",
+  identification_type: "CPF",
+  identification_number: "12345678901",
+  phone_area_code: "11",
+  phone_number: "999999999"
+)
+```
+
+### Gerenciamento de Cartões
+
+```ruby
+# Adicionar cartão a um cliente
+card = client.create_card(
+  customer_id: "CUSTOMER_ID",
+  token: "TOKEN_DO_CARTAO"
+)
+
+# Remover cartão de um cliente
+client.delete_card(
+  customer_id: "CUSTOMER_ID",
+  card_id: "CARD_ID"
+)
+```
+
+## Tratamento de Erros
+
+A gem utiliza a classe `MpApi::Error` para tratamento de erros:
+
+```ruby
+begin
+  response = client.create_pix_payment(...)
+rescue MpApi::Error => e
+  puts "Erro na API: #{e.message}"
+end
+```
+
+## Funcionalidades
+
+- ✅ Pagamentos PIX
+- ✅ Pagamentos com cartão de crédito
+- ✅ Pagamentos com cartões salvos
+- ✅ Tokenização de cartões
+- ✅ Gerenciamento de clientes
+- ✅ Gerenciamento de cartões
+- ✅ Consulta de métodos de pagamento
+- ✅ Atualização de pagamentos
+- ✅ Suporte a parcelamento
+- ✅ Suporte a 3D Secure
+
+## Dependências
+
+Esta gem depende da gem `ac` (>= 1.1.0) para funcionalidades de cliente HTTP.

data/lib/mp_api/client.rb

@@ -4,52 +4,126 @@ module MpApi
     MAX_RETRIES = 1
     SAVE_RESPONSES = true
 
-    attr_reader :access_token
-    def initialize(access_token = MpApi.configuration.access_token)
-      @headers = {
-        "Content-Type" => "application/json",
-        "x-idempotency-key" => SecureRandom.uuid
-      }
-      super(access_token)
+    def create_pix_payment(date_of_expiration: nil, amount:, description: nil, statement_descriptor: nil, payment_method:, payer_email:, payer_identification_type:, payer_identification_number:)
+      body = {
+        date_of_expiration: date_of_expiration,
+        transaction_amount: amount,
+        description: description,
+        statement_descriptor: statement_descriptor,
+        payment_method_id: payment_method,
+        payer: {
+          email: payer_email,
+          identification: {
+            type: payer_identification_type,
+            number: payer_identification_number
+          }
+        }
+      }.compact
+      post("/payments", body:)
     end
 
-    def create_payment(body)
-      post("/payments", body: body, headers: @headers) { |response| validate_response(response, "id") }
+    def create_credit_card_payment(date_of_expiration: nil, amount:, description: nil, statement_descriptor: nil, payment_method:, payer_email:, payer_identification_type:, payer_identification_number:, capture: nil, token: nil, issuer_id: nil, installments: nil, three_d_secure_mode: false)
+      body = {
+        date_of_expiration: date_of_expiration,
+        transaction_amount: amount,
+        description: description,
+        statement_descriptor: statement_descriptor,
+        payment_method_id: payment_method,
+        payer: {
+          email: payer_email,
+          identification: {
+            type: payer_identification_type,
+            number: payer_identification_number
+          }
+        },
+        capture: capture,
+        token: token,
+        issuer_id: issuer_id,
+        installments: installments,
+        three_d_secure_mode: three_d_secure_mode ? "optional" : "not_supported"
+      }.compact
+      post("/payments", body:)
+    end
+
+    def create_saved_credit_card_payment(amount:, token: nil, installments: nil, customer_id: nil)
+      body = {
+        transaction_amount: amount,
+        token: token,
+        installments: installments,
+        payer: {
+          type: "customer",
+          id: customer_id
+        }
+      }
+      post("/payments", body:)
     end
 
     def get_payment(payment_id)
-      get("/payments/#{payment_id}") { |response| validate_response(response, "id") }
+      get("/payments/#{payment_id}")
     end
 
-    def update_payment(payment_id, body)
-      put("/payments/#{payment_id}", body: body, headers: @headers) { |response| validate_response(response, "id") }
+    def update_payment(payment_id:, status:)
+      body = {
+        status: status
+      }
+      put("/payments/#{payment_id}", body:)
     end
 
-    def create_token(card_token_data)
-      post("/card_tokens", body: card_token_data, headers: @headers) { |response| validate_response(response, "id") }
+    def create_token(card_number:, expiration_year:, expiration_month:, security_code:, cardholder_name:)
+      body = {
+        card_number: card_number,
+        expiration_year: expiration_year,
+        expiration_month: expiration_month,
+        security_code: security_code,
+        cardholder: {
+          name: cardholder_name
+        }
+      }
+      post("/card_tokens", body:)
     end
 
-    def search_payment_methods(query)
-      get("/payment_methods/search", params: query) { |response| validate_response(response, ["results", 0]) }
+    def search_payment_methods(first_six_digits:)
+      body = {
+        marketplace: "NONE",
+        status: "active",
+        bins: first_six_digits
+      }
+      get("/payment_methods/search", params: body)
     end
 
     def get_payment_methods
-      get("/payment_methods") { |response| validate_response(response, "id") }
+      get("/payment_methods")
     end
 
-    def create_customer(body)
-      post("/customers", body: body, headers: @headers) { |response| validate_response(response, "id") }
+    def get_customer(email)
+       get("/customers/search?email=#{email}")
     end
 
-    def create_card(customer_id, body)
-      post("/customers/#{customer_id}/cards", body: body, headers: @headers) { |response| validate_response(response, "id") }
+    def create_customer(email:, first_name: nil, identification_type:, identification_number:, phone_area_code: "55", phone_number: nil)
+      body = {
+        email: email,
+        first_name: first_name,
+        identification: {
+          type: identification_type,
+          number: identification_number
+        },
+        phone: {
+          area_code: phone_area_code,
+          number: phone_number
+        }
+      }
+      post("/customers", body:)
     end
 
-    private
+    def create_card(customer_id:, token:)
+      body = {
+        token: token
+      }
+      post("/customers/#{customer_id}/cards", body:)
+    end
 
-    def validate_response(response, required_response_key)
-      puts response.json unless response.success?
-      ![500, 429].include?(response.code) || response.json.dig(*required_response_key)
+    def delete_card(customer_id:, card_id:)
+      delete("/customers/#{customer_id}/cards/#{card_id}")
     end
   end
 end

data/lib/mp_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MpApi
-  VERSION = "1.2.2"
+  VERSION = "2.0.0"
 end

data/lib/mp_api.rb

@@ -3,33 +3,8 @@
 require "ac"
 require "securerandom"
 require_relative "mp_api/client"
-require_relative "mp_api/payment"
-require_relative "mp_api/payment_error"
-require_relative "mp_api/token"
-require_relative "mp_api/payment_method"
-require_relative "mp_api/customer"
-require_relative "mp_api/card"
 require_relative "mp_api/version"
 
 module MpApi
   class Error < StandardError; end
-
-  class RequestError < StandardError
-    def initialize(message = "Request error")
-      super(message)
-    end
-  end
-
-  class Configuration
-    attr_accessor :access_token, :public_key
-  end
-
-  class << self
-    attr_accessor :configuration
-  end
-
-  def self.configure
-    self.configuration ||= Configuration.new
-    yield configuration
-  end
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: mp_api
 version: !ruby/object:Gem::Version
-  version: 1.2.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Todas Essas Coisas
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-11-14 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ac
@@ -16,15 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-description: 
+        version: 1.1.0
 email:
 - caioif4@gmail.com
 executables: []
@@ -34,16 +32,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- lib/generators/mp_api/install/install_generator.rb
-- lib/generators/mp_api/install/templates/initializer.rb
 - lib/mp_api.rb
-- lib/mp_api/card.rb
 - lib/mp_api/client.rb
-- lib/mp_api/customer.rb
-- lib/mp_api/payment.rb
-- lib/mp_api/payment_error.rb
-- lib/mp_api/payment_method.rb
-- lib/mp_api/token.rb
 - lib/mp_api/version.rb
 homepage: https://github.com/todasessascoisas/mp_api
 licenses:
@@ -52,7 +42,6 @@ metadata:
   homepage_uri: https://github.com/todasessascoisas/mp_api
   source_code_uri: https://github.com/todasessascoisas/mp_api
   changelog_uri: https://github.com/todasessascoisas/mp_api
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -67,8 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key: 
+rubygems_version: 3.6.9
 specification_version: 4
 summary: ''
 test_files: []

data/lib/generators/mp_api/install/install_generator.rb

@@ -1,10 +0,0 @@
-module MpApi
-  module Generators
-    class InstallGenerator < Rails::Generators::Base
-      source_root File.expand_path("templates", __dir__)
-      def copy_initializer
-        template "initializer.rb", "config/initializers/mp_api.rb"
-      end
-    end
-  end
-end

data/lib/generators/mp_api/install/templates/initializer.rb

@@ -1,3 +0,0 @@
-MpApi.configure do |config|
-  # config.access_token = nil
-end

data/lib/mp_api/card.rb

@@ -1,46 +0,0 @@
-module MpApi
-  class Card
-    attr_reader :token, :customer_id, :external_id, :cardholder_name, :expiration_month, :expiration_year, :first_six_digits, :last_four_digits, :issuer_id, :mp_payment_method_id, :error, :error_detail
-
-    def initialize(token: nil, customer_id: nil, external_id: nil, cardholder_name: nil, expiration_month: nil, expiration_year: nil, first_six_digits: nil, last_four_digits: nil, issuer_id: nil, mp_payment_method_id: nil, error: nil, error_detail: nil)
-      @token = token
-      @customer_id = customer_id
-      @external_id = external_id
-      @cardholder_name = cardholder_name
-      @expiration_month = expiration_month
-      @expiration_year = expiration_year
-      @first_six_digits = first_six_digits
-      @last_four_digits = last_four_digits
-      @issuer_id = issuer_id
-      @mp_payment_method_id = mp_payment_method_id
-      @error = error
-      @error_detail = error_detail
-    end
-    
-    def build_json
-      {
-        token: token
-      }
-    end
-
-    def create
-      response = Client.new.create_card(customer_id, JSON.dump(build_json))
-      self.class.new(**self.class.build_hash(response.json))
-    end
-
-    def self.build_hash(response)
-      {
-        external_id: response.dig("id"),
-        cardholder_name: response.dig("cardholder", "name"),
-        expiration_month: response.dig("expiration_month"),
-        expiration_year: response.dig("expiration_year"),
-        first_six_digits: response.dig("first_six_digits"),
-        last_four_digits: response.dig("last_four_digits"),
-        issuer_id: response.dig("issuer", "id"),
-        mp_payment_method_id: response.dig("payment_method", "id"),
-        error: response.dig("message"),
-        error_detail: response.dig("cause")
-      }
-    end
-  end
-end

data/lib/mp_api/customer.rb

@@ -1,54 +0,0 @@
-module MpApi
-  class Customer
-
-    attr_reader :external_id, :email, :first_name, :identification_type, :identification_number, :phone_area_code, :phone_number, :status, :error, :error_detail
-    def initialize(external_id: nil, email:, first_name: nil, identification_type:, identification_number:, phone_area_code: "55", phone_number: nil, status: nil, error: nil, error_detail: nil)
-      @external_id = external_id
-      @email = email
-      @first_name = first_name
-      @identification_type = identification_type
-      @identification_number = identification_number
-      @phone_area_code = phone_area_code
-      @phone_number = phone_number
-      @status = status
-      @error = error
-      @error_detail = error_detail
-    end
-
-    def build_json
-      {
-        email: email,
-        first_name: first_name,
-        identification: {
-          type: identification_type,
-          number: identification_number
-        },
-        phone: {
-          area_code: phone_area_code,
-          number: phone_number
-        }
-      }
-    end
-
-    def create
-      response = Client.new.create_customer(JSON.dump(build_json))
-      self.class.new(**self.class.build_hash(response.json))
-    end
-
-    def self.build_hash(response)
-      {
-        external_id: response.dig("id"),
-        email: response.dig("email"),
-        first_name: response.dig("first_name"),
-        identification_type: response.dig("identification", "type"),
-        identification_number: response.dig("identification", "number"),
-        phone_area_code: response.dig("phone", "area_code"),
-        phone_number: response.dig("phone", "number"),
-        status: response.dig("status"),
-        error: response.dig("message"),
-        error_detail: response.dig("cause")
-      }
-    end
-
-  end
-end

data/lib/mp_api/payment.rb

@@ -1,149 +0,0 @@
-module MpApi
-  class Payment
-    attr_reader :status_detail, :three_ds_info_creq, :three_ds_info_external_resource_url, :three_d_secure_mode, :id, :description, :date_approved, :date_created, :money_release_date, :payer_email, :payer_identification_type, :payer_identification_number, :payment_method, :last_four_digits, :payment_type, :qr_code, :qr_code_base_64, :transaction_id, :ticket_url, :status, :amount, :token, :issuer_id, :installments, :statement_descriptor, :items, :error, :internal_error, :capture, :date_of_expiration, :saved_card, :customer_id
-    def initialize(payer_email:, payer_identification_type:, payer_identification_number:, payment_method:, amount:, last_four_digits: nil, status_detail: nil, three_ds_info_creq: nil, three_ds_info_external_resource_url: nil, three_d_secure_mode: nil, id: nil, description: nil, date_approved: nil, date_created: nil, money_release_date: nil, payment_type: nil, qr_code: nil, qr_code_base_64: nil, transaction_id: nil, ticket_url: nil, status: nil, token: nil, issuer_id: nil, installments: nil, items: nil, statement_descriptor: nil, error: nil, internal_error: nil, capture: nil, date_of_expiration: nil, saved_card: false, customer_id: nil)
-      @id = id
-      @description = description
-      @date_approved = date_approved
-      @date_created = date_created
-      @money_release_date = money_release_date
-      @payer_email = payer_email
-      @payer_identification_type = payer_identification_type
-      @payer_identification_number = payer_identification_number
-      @payment_method = payment_method
-      @last_four_digits = last_four_digits
-      @payment_type = payment_type
-      @qr_code = qr_code
-      @qr_code_base_64 = qr_code_base_64
-      @transaction_id = transaction_id
-      @ticket_url = ticket_url
-      @status = status
-      @amount = amount
-      @token = token
-      @issuer_id = issuer_id
-      @installments = installments
-      @three_d_secure_mode = three_d_secure_mode
-      @three_ds_info_external_resource_url = three_ds_info_external_resource_url
-      @three_ds_info_creq = three_ds_info_creq
-      @status_detail = status_detail
-      @statement_descriptor = statement_descriptor
-      @items = items
-      @error = error
-      @internal_error = internal_error
-      @capture = capture
-      @date_of_expiration = date_of_expiration
-      @saved_card = saved_card
-      @customer_id = customer_id
-    end
-
-    def build_json
-      send("build_json_#{(payment_method == "pix") ? "pix" : "credit_card"}").except(:description)
-    end
-
-    def build_update_json
-      {
-        # capture: capture,
-        status: status
-        # date_of_expiration: date_of_expiration,
-        # transaction_amount: amount
-      }.compact
-    end
-
-    def build_json_pix
-      {
-        date_of_expiration: date_of_expiration,
-        transaction_amount: amount,
-        description: description,
-        statement_descriptor: statement_descriptor,
-        additional_info: {
-          items: items
-        },
-        payment_method_id: payment_method,
-        payer: {
-          email: payer_email,
-          identification: {
-            type: payer_identification_type,
-            number: payer_identification_number
-          }
-        }
-      }.compact
-    end
-
-    def build_json_credit_card
-      if saved_card
-        {
-          transaction_amount: amount,
-          token: token,
-          installments: installments,
-          payer: {
-            type: "customer",
-            id: customer_id
-          }
-        }
-      else
-        build_json_pix.merge({
-          capture: capture,
-          token: token,
-          issuer_id: issuer_id,
-          installments: installments,
-          three_d_secure_mode: three_d_secure_mode ? "optional" : "not_supported"
-        }.compact)
-      end
-    end
-
-    def create
-      response = Client.new.create_payment(JSON.dump(build_json))
-      self.class.new(**self.class.build_hash(response.json))
-    end
-
-    def pix_paid? external_value = nil
-      external_value = @amount if external_value.nil?
-      @status == "approved" && external_value.to_d == @amount.to_d
-    end
-
-    def update attributes
-      attributes.each do |key, value|
-        instance_variable_set(:"@#{key}", value)
-      end
-      Client.new.update_payment(id, JSON.dump(build_update_json))
-      self.class.find_by_id(id)
-    end
-
-    def invalidate_pix!
-      update(status: "cancelled")
-    end
-
-    def self.find_by_id(payment_id)
-      response = Client.new.get_payment(payment_id)
-      new(**build_hash(response.json))
-    end
-
-    def self.build_hash json_response
-      payment_error = PaymentError.new(json_response: json_response)
-      {
-        id: json_response.dig("id"),
-        description: json_response.dig("description"),
-        date_approved: json_response.dig("date_approved"),
-        date_created: json_response.dig("date_created"),
-        money_release_date: json_response.dig("money_release_date"),
-        payer_email: json_response.dig("payer", "email"),
-        payer_identification_type: json_response.dig("payer", "identification", "type"),
-        payer_identification_number: json_response.dig("payer", "identification", "number"),
-        payment_method: json_response.dig("payment_method_id"),
-        last_four_digits: json_response.dig("card", "last_four_digits"),
-        payment_type: json_response.dig("payment_type_id"),
-        qr_code: json_response.dig("point_of_interaction", "transaction_data", "qr_code"),
-        qr_code_base_64: json_response.dig("point_of_interaction", "transaction_data", "qr_code_base64"),
-        three_ds_info_external_resource_url: json_response.dig("three_ds_info", "external_resource_url"),
-        three_ds_info_creq: json_response.dig("three_ds_info", "creq"),
-        transaction_id: json_response.dig("point_of_interaction", "transaction_data", "transaction_id"),
-        ticket_url: json_response.dig("point_of_interaction", "transaction_data", "ticket_url"),
-        status: json_response.dig("status"),
-        status_detail: json_response.dig("status_detail"),
-        amount: json_response.dig("transaction_amount"),
-        error: payment_error.error,
-        internal_error: payment_error.internal_error
-      }
-    end
-  end
-end

data/lib/mp_api/payment_error.rb

@@ -1,49 +0,0 @@
-module MpApi
-  class PaymentError
-    attr_reader :json_response
-    def initialize(json_response:)
-      @json_response = json_response
-    end
-
-    def error
-      return nil unless json_response["error"] || ["rejected"].include?(json_response["status"])
-      rejected_payment_error || failed_payment_error || "Pagamento recusado."
-    end
-
-    def internal_error
-      return nil unless json_response["error"]
-      json_response["cause"]&.first["description"]
-    end
-
-    private
-
-    def rejected_payment_error
-      message_by_status_detail(json_response["status_detail"])
-    end
-
-    def failed_payment_error
-      message_by_error_message(json_response.dig("cause", 0, "description"))
-    end
-
-    def message_by_status_detail(status_detail)
-      {
-        "cc_rejected_bad_filled_other" => "Pagamento recusado.",
-        "cc_rejected_bad_filled_date" => "Pagamento recusado. Confira a data de validade do cartão.",
-        "cc_rejected_bad_filled_security_code" => "Pagamento recusado. Confira o código de segurança (CVV) do cartão.",
-        "cc_rejected_insufficient_amount" => "Pagamento recusado. Limite insuficiente.",
-        "cc_rejected_call_for_authorize" => "Pagamento recusado.",
-        "cc_rejected_other_reason" => "Pagamento recusado.",
-        "cc_rejected_high_risk" => "Pagamento recusado."
-      }[status_detail]
-    end
-
-    def message_by_error_message(error_message)
-      {
-        "Invalid user identification number" => "CPF inválido.",
-        "payer.email must be a valid email" => "E-mail inválido."
-        # "Payer email forbidden" => "E-mail inválido.", Caso do erro no email test_user_2147198029@testuser.com (Nao sei se da pra causar com email valido)
-      }[error_message]
-    end
-
-  end
-end

data/lib/mp_api/payment_method.rb

@@ -1,35 +0,0 @@
-module MpApi
-  class PaymentMethod
-    attr_reader :payment_method_id, :issuer_id, :installments, :errors
-    def initialize(payment_method_id:, issuer_id:, installments:, errors: nil)
-      @payment_method_id = payment_method_id
-      @issuer_id = issuer_id
-      @installments = installments
-      @errors = errors
-    end
-
-    def self.find_by_first_six_digits(first_six_digits, credit: true)
-      response = Client.new.search_payment_methods(build_query(first_six_digits))
-      new(**build_hash(response.json, credit))
-    end
-
-    def self.build_query(first_six_digits)
-      {
-        marketplace: "NONE",
-        status: "active",
-        bins: first_six_digits
-      }
-    end
-
-    def self.build_hash(response, credit)
-      payment_type_id = credit ? "credit_card" : "debit_card"
-      payment_method = response.dig("results")&.find { |pm| pm["payment_type_id"] == payment_type_id }
-      {
-        payment_method_id: payment_method&.dig("id"),
-        issuer_id: payment_method&.dig("issuer", "id"),
-        installments: payment_method&.dig("payer_costs"),
-        errors: response.dig("message")
-      }
-    end
-  end
-end

data/lib/mp_api/token.rb

@@ -1,43 +0,0 @@
-module MpApi
-  class Token
-    attr_reader :card_number, :expiration_year, :expiration_month, :security_code, :cardholder_name, :id, :errors
-    def initialize(card_number:, expiration_year:, expiration_month:, security_code:, cardholder_name:, id: nil, errors: nil)
-      @card_number = card_number
-      @expiration_year = expiration_year
-      @expiration_month = expiration_month
-      @security_code = security_code
-      @cardholder_name = cardholder_name
-      @id = id
-      @errors = errors
-    end
-
-    def build_json
-      {
-        card_number: card_number,
-        expiration_year: expiration_year,
-        expiration_month: expiration_month,
-        security_code: security_code,
-        cardholder: {
-          name: cardholder_name
-        }
-      }
-    end
-
-    def create
-      response = Client.new.create_token(JSON.dump(build_json))
-      self.class.new(**self.class.build_hash(response.json))
-    end
-
-    def self.build_hash(response)
-      {
-        id: response["id"],
-        expiration_year: response["expiration_year"],
-        expiration_month: response["expiration_month"],
-        cardholder_name: response.dig("cardholder", "name"),
-        card_number: response["card_number"],
-        security_code: response["security_code"],
-        errors: response["error"]
-      }
-    end
-  end
-end