solidus_mp_dois 2.2.2 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2c3187a7e497cd255cf9661e338603946221b2d7cdc4dde18d707c4b636baac
-  data.tar.gz: c4593ccb461d7f9ef9fc20967db9410878bb2d2e3537cecc846fc49365ace42e
+  metadata.gz: 0f47d658a64a40e54735865036c9331ff4b27c0740789c9afd9074ebce5553f6
+  data.tar.gz: 595b3dc81627c86ca7c9e5d76214acd727afd78716cd2e376d555e9ba06a2f1d
 SHA512:
-  metadata.gz: 4f574a527dd9609a70a13793d359f94b1aad0cf9e6b6b5868b0a5ee1042603d6ee953881355a962282bc974941993814255d686e84b83c64e9a169853847d183
-  data.tar.gz: 27a4cb0baeb08e06ca551b352a7c0763f32ef6d961f499751a8cd582bdd5d4be08d6a77afea5679d839a0a33ce1d40d78d3e76240bbc34f6561fed65a7195dfa
+  metadata.gz: 5d38025a7d3d9097863ddad2cf466a31a522ae5094e4f558a72c8af99593d2ea758d5592d5b57ee47887b340787bbdca30cc7f913328058fa1fe769e1955d3cf
+  data.tar.gz: f5a1439538d3d45b38d39effa81537c310d74f34e279a3a0875676cfb0f194a08bd196dff57525f62c5bafb14818e02e2fdec550254fc7d78eef61d8e0db52a4

data/README.md

@@ -0,0 +1,250 @@
+# Solidus Mercado Pago 2 🇧🇷
+
+[![Version](https://img.shields.io/badge/version-2.2.2-blue.svg)](https://github.com/todasessascoisas/solidus_mp_dois)
+[![Ruby](https://img.shields.io/badge/ruby-%3E%3D%202.7-red.svg)](https://ruby-lang.org)
+[![Rails](https://img.shields.io/badge/rails-%3E%3D%206.0-red.svg)](https://rubyonrails.org)
+
+Integração moderna do Mercado Pago com Solidus, oferecendo suporte completo para pagamentos via **cartão de crédito** e **PIX**, com interface otimizada e recursos avançados.
+
+## 🚀 Funcionalidades
+
+- ✅ **Pagamentos com Cartão de Crédito**
+  - Integração com Mercado Pago SDK-JS
+  - Suporte a cartões salvos
+  - Autenticação 3D Secure
+  - Múltiplas parcelas
+  - Interface responsiva com Payment Brick
+
+- ✅ **Pagamentos via PIX**
+  - Geração automática de QR Code
+  - Código copia e cola
+  - Verificação automática de status
+  - Expiração configurável
+
+- ✅ **Recursos Avançados**
+  - Gerenciamento de clientes
+  - Sincronização automática de status
+  - Interface administrativa completa
+  - Logs detalhados de transações
+  - Suporte a reembolsos e cancelamentos
+
+- ✅ **Compatibilidade**
+  - Solidus 3.0+
+  - Rails 6.0+
+  - Ruby 2.7+
+  - Suporte a User e Spree::User
+
+## 📦 Instalação
+
+### 1. Adicione a gem ao seu Gemfile
+
+```ruby
+gem 'solidus_mp_dois'
+```
+
+### 2. Execute o bundle install
+
+```bash
+bundle install
+```
+
+### 3. Execute o gerador de instalação
+
+```bash
+rails generate solidus_mp_dois:install
+```
+
+Este comando irá:
+- Instalar a gem `mp_api`
+- Adicionar as migrações necessárias
+- Configurar o Importmap para o SDK do Mercado Pago
+- Copiar os controladores Stimulus necessários
+- Executar as migrações (opcional)
+
+### 4. Execute as migrações (se não executadas automaticamente)
+
+```bash
+bin/rails railties:install:migrations FROM=solidus_mp_dois
+```
+
+## ⚙️ Configuração
+
+### 1. Adicione os métodos de pagamento no painel administrativo
+
+Acesse o painel administrativo do Solidus:
+1. Vá para **Configurações > Métodos de Pagamento**
+2. Clique em **Novo Método de Pagamento**
+3. Selecione o tipo desejado:
+   - `SolidusMpDois::MpCard` para cartão de crédito
+   - `SolidusMpDois::MpPix` para PIX
+
+### 2. Configure as credenciais do Mercado Pago
+
+Para cada método de pagamento, configure:
+
+- **Public Key**: Sua chave pública do Mercado Pago
+- **Access Token**: Seu token de acesso do Mercado Pago
+- **Statement Descriptor**: Descrição que aparece na fatura (opcional)
+
+### 3. Configure o frontend (Stimulus)
+
+Se você estiver usando Importmap, os controladores já foram configurados. Para outros bundlers:
+
+```javascript
+// application.js
+import "controllers/card_payment_brick_controller"
+import "controllers/payment_brick_controller"
+import "controllers/three_ds_controller"
+```
+
+## 🎯 Uso
+
+### Pagamentos com Cartão de Crédito
+
+#### Payment Brick (múltiplos métodos)
+```erb
+<div data-controller="payment-brick"
+     data-payment-brick-public-key-value="<%= payment_method.preferences[:public_key] %>"
+     data-payment-brick-amount-value="<%= order.total %>"
+     data-payment-brick-email-value="<%= order.email %>"
+     data-payment-brick-customer-id-value="<%= customer_id %>"
+     data-payment-brick-cards-ids-value="<%= customer_cards_ids %>">
+  <div id="paymentBrick_container"></div>
+</div>
+```
+
+#### Card Payment Brick (apenas cartão)
+```erb
+<div data-controller="card-payment-brick"
+     data-card-payment-brick-public-key-value="<%= payment_method.preferences[:public_key] %>"
+     data-card-payment-brick-amount-value="<%= order.total %>"
+     data-card-payment-brick-email-value="<%= order.email %>">
+  <div id="cardPaymentBrick_container"></div>
+</div>
+```
+
+#### Autenticação 3D Secure
+```erb
+<div data-controller="three-ds"
+     data-three-ds-three-ds-url-value="<%= payment.source.three_ds_url %>"
+     data-three-ds-three-ds-creq-value="<%= payment.source.three_ds_creq %>">
+</div>
+```
+
+### Pagamentos via PIX
+
+O PIX é processado automaticamente. Após a criação do pagamento, o sistema:
+1. Gera o QR Code e código copia e cola
+2. Monitora o status automaticamente
+3. Atualiza o pedido quando o pagamento é confirmado
+
+## 🗄️ Estrutura do Banco de Dados
+
+### Tabelas Criadas
+
+- `solidus_mp_dois_credit_card_sources` - Fontes de pagamento por cartão
+- `solidus_mp_dois_pix_sources` - Fontes de pagamento PIX
+- `solidus_mp_dois_customers` - Clientes do Mercado Pago
+- `solidus_mp_dois_cards` - Cartões salvos
+
+### Campos Principais
+
+#### Credit Card Sources
+- `external_id` - ID do pagamento no Mercado Pago
+- `status` - Status do pagamento
+- `amount` - Valor do pagamento
+- `installments` - Número de parcelas
+- `three_ds_url` - URL para autenticação 3DS
+- `saved_card` - Indica se é cartão salvo
+
+#### PIX Sources
+- `external_id` - ID do pagamento no Mercado Pago
+- `qr_code` - Código copia e cola
+- `qr_code_base64` - QR Code em base64
+- `expiration` - Data de expiração
+- `ticket_url` - URL do ticket de pagamento
+
+## 🔧 API
+
+### Métodos Principais
+
+#### MpCard
+```ruby
+# Criar pagamento
+payment = mp_card.create_payment(order, source_params)
+
+# Processar pagamento
+response = mp_card.purchase(payment)
+
+# Cancelar pagamento
+mp_card.cancel!(payment)
+```
+
+#### MpPix
+```ruby
+# Criar pagamento PIX
+payment = mp_pix.create_payment(order)
+
+# Verificar se foi pago
+paid = mp_pix.pix_paid?(payment)
+
+# Invalidar pagamento
+mp_pix.invalidate_payment(payment)
+```
+
+### Sincronização de Status
+
+Os pagamentos são sincronizados automaticamente com o Mercado Pago:
+
+```ruby
+# Buscar status atualizado
+mp_payment = payment.source.retrieve_from_api
+
+# Sincronizar manualmente
+payment_method.purchase(payment)
+```
+
+## 🎨 Interface Administrativa
+
+A gem inclui views administrativas completas:
+
+- **Visualização de pagamentos** com todos os detalhes
+- **QR Codes** para pagamentos PIX
+- **Informações do cartão** (últimos 4 dígitos, bandeira, etc.)
+- **Status detalhado** e logs de transação
+
+## 🔒 Segurança
+
+- ✅ Tokens seguros para cartões
+- ✅ Autenticação 3D Secure automática
+- ✅ Validação de documentos (CPF/CNPJ)
+- ✅ Criptografia end-to-end via Mercado Pago
+- ✅ Logs detalhados para auditoria
+
+## 🌐 Localização
+
+A gem inclui traduções em português brasileiro:
+
+```yaml
+pt-BR:
+  activerecord:
+    models:
+      solidus_mp_dois/mp_pix: "Pix (Mercado Pago 2)"
+      solidus_mp_dois/mp_card: "Cartão de Crédito (Mercado Pago 2)"
+```
+
+## 🧪 Testes
+
+```bash
+# Executar todos os testes
+bundle exec rake
+
+# Executar testes específicos
+bundle exec rspec spec/models/
+```
+
+## 📋 Dependências
+
+- [`solidus_brazilian_adaptations`](https://github.com/solidusio/solidus_brazilian_adaptations) - Adaptações para o mercado brasileiro
+- [`mp_api`](https://github.com/todasessascoisas/mp_api) - Cliente Ruby para API do Mercado Pago
+- `@mercadopago/sdk-js` - SDK JavaScript oficial do Mercado Pago

data/app/models/solidus_mp_dois/card.rb

@@ -3,8 +3,7 @@ module SolidusMpDois
     belongs_to :customer
 
     def delete_from_api(access_token)
-      request = Typhoeus.delete("https://api.mercadopago.com/v1/customers/#{customer.external_id}/cards/#{external_id}", headers: { "Authorization" => "Bearer #{access_token}", "Content-Type" => "application/json" })
-      request.success?
+      MpApi::Client.new(access_token).delete_card(customer_id: customer.external_id, card_id: external_id)
     end
   end
 end

data/app/models/solidus_mp_dois/credit_card_source.rb

@@ -4,8 +4,8 @@ module SolidusMpDois
       payment_method.find_payment(external_id)
     end
 
-    def cancel
-      payment_method.cancel!(external_id)
+    def void!
+      payment_method.cancel!(payments.sole)
     end
   end
 end

data/app/models/solidus_mp_dois/mp_card.rb

@@ -8,10 +8,6 @@ module SolidusMpDois
       CreditCardSource
     end
 
-    def gateway_class
-      MpGateway
-    end
-
     def supports?(source)
       source.is_a?(payment_source_class)
     end
@@ -25,38 +21,54 @@ module SolidusMpDois
     end
 
     def find_payment external_id
-      MpApi.configuration.access_token = preferences[:access_token]
-      MpApi::Payment.find_by_id(external_id)
+      mp_client.get_payment(external_id)
     end
 
     def create_payment order, source_params
       customer = find_or_create_customer(order, source_params)
       save_credit_card(source_params[:token], customer) if customer && source_params[:saved_card] == "false" # Se o cartão usado ja for um cartão salvo, não é necessario executar save_credit_card
+      invalidate_valid_payments(order)
 
       payment = order.payments.new(amount: order.total, payment_method: self)
       payment.source = init_source(order, source_params, customer)
       payment.save
 
-      mp_payment = create_mp_payment(payment.source, customer.try(:external_id))
+      mp_payment = if payment.source.saved_card
+        create_payment_with_saved_card(payment.source, customer.try(:external_id))
+      else
+        create_payment_with_new_card(payment.source)
+      end
       process_payment_response(payment, mp_payment)
       payment
     end
 
-    def purchase money, source, options = {}
-      gateway.purchase(money, source, options)
+    def purchase(payment)
+      return unless payment.source&.external_id
+      10.times do
+        mp_payment = find_payment(payment.source.external_id)
+        break if ["approved", "rejected"].include? mp_payment.status
+      end
+      mp_payment = find_payment(payment.source.external_id)
+      sync(payment, mp_payment)
     end
 
-    def cancel!(mp_payment_id)
-      MpApi.configuration.access_token = preferences[:access_token]
+    def cancel!(payment)
+      external_id = payment.source&.external_id
+      return unless external_id
       sleep(1)
-      mp_payment = MpApi::Payment.find_by_id(mp_payment_id)
-      if !mp_payment.status.in?(["rejected", "cancelled"])
-        mp_payment.update(status: "cancelled")
-      end
+      purchase
+      return unless ["checkout", "pending"].include? payment.state
+
+      mp_payment = mp_client.update_payment(payment_id: external_id, status: "cancelled")
+      sync(payment, mp_payment)
     end
 
     private
 
+    def mp_client
+      MpApi::Client.new(preferences[:access_token])
+    end
+
     def init_source order, source_params, customer
       tax_id = customer&.tax_id || source_params[:tax_id]
       document_type = (tax_id.gsub(/\D/, "").length == 11) ? "CPF" : "CNPJ"
@@ -76,10 +88,19 @@ module SolidusMpDois
       )
     end
 
-    def create_mp_payment payment_source, customer_id
-      MpApi.configuration.access_token = preferences[:access_token]
-      MpApi::Payment.new(
+    def create_payment_with_saved_card payment_source, customer_id
+      mp_client.create_saved_credit_card_payment(
         amount: payment_source.amount.to_f,
+        token: payment_source.token,
+        installments: payment_source.installments,
+        customer_id: customer_id
+      )
+    end
+
+    def create_payment_with_new_card payment_source
+      mp_client.create_credit_card_payment(
+        amount: payment_source.amount.to_f,
+        statement_descriptor: preferences[:statement_descriptor],
         payment_method: payment_source.card_brand,
         payer_email: payment_source.email,
         payer_identification_type: payment_source.payer_identification_type,
@@ -87,76 +108,56 @@ module SolidusMpDois
         token: payment_source.token,
         issuer_id: payment_source.issuer_id,
         installments: payment_source.installments,
-        three_d_secure_mode: true,
-        statement_descriptor: preferences[:statement_descriptor],
-        saved_card: payment_source.saved_card,
-        customer_id: customer_id
-      ).create
+        three_d_secure_mode: true
+      )
     end
 
     def find_or_create_customer(order, source_params)
       order_user = order.try(:store_user) || order&.user # Para suportar lojas que usam Spree::User e User
       return unless order_user
 
-      mp_customer = find_mp_customer(order_user)
-      if mp_customer
-        # Pode ser que exista na API mas nao no banco de dados
-        SolidusMpDois::Customer.upsert({
-            external_id: mp_customer.external_id,
-            email: mp_customer.email,
-            first_name: mp_customer.first_name,
-            identification_type: mp_customer.identification_type,
-            tax_id: mp_customer.identification_number,
-            spree_user_id: order_user.id
-          }, unique_by: [:external_id]
-        )
-      else
-        created_mp_customer = create_mp_customer(order, source_params, order_user)
-        if created_mp_customer.error.blank?
-          SolidusMpDois::Customer.create(
-            external_id: created_mp_customer.external_id,
-            email: created_mp_customer.email,
-            first_name: created_mp_customer.first_name,
-            identification_type: created_mp_customer.identification_type,
-            tax_id: created_mp_customer.identification_number,
-            spree_user_id: order_user.id
-          )
-        end
+      email = source_params[:payer_email].present? ? source_params[:payer_email] : (order_user.try(:email) || order_user.try(:email_address))
+      mp_customer = find_mp_customer(email).results[0]
+
+      if mp_customer.nil?
+        mp_customer = create_mp_customer(order, source_params, email)
       end
-      SolidusMpDois::Customer.find_by(spree_user_id: order_user.id)
+
+      SolidusMpDois::Customer.upsert(
+        {
+          external_id: mp_customer.id,
+          email: mp_customer.email,
+          first_name: mp_customer.first_name,
+          identification_type: mp_customer.identification.type,
+          tax_id: mp_customer.identification.number,
+          spree_user_id: order_user.id
+        }, unique_by: [:external_id]
+      )
+
+      SolidusMpDois::Customer.find_by(external_id: mp_customer.id)
     end
 
-    def create_mp_customer(order, source_params, user)
-      MpApi.configuration.access_token = preferences[:access_token]
-      email = user.try(:email) || user.try(:email_address)
-      MpApi::Customer.new(
+    def create_mp_customer(order, source_params, email)
+      mp_client.create_customer(
         email: email,
         first_name: order.ship_address.name,
         identification_type: source_params[:payer_identification_type],
         identification_number: source_params[:tax_id]
-      ).create
+      )
     end
 
-    # A versão da MpApi nessa gem é limitada ("< 1.3.0") então não posso atualizar a mp_api.
-    # Por conta disso, precisei definir esse metodo aqui
-    # A limitação da versao foi removida, entao esse metodo pode ser implementado na mp_api
-    def find_mp_customer(user)
-      email = user.try(:email) || user.try(:email_address)
-      search_req = Typhoeus.get("https://api.mercadopago.com/v1/customers/search?email=#{email}", headers: { "Authorization" => "Bearer #{preferences[:access_token]}" })
-      search_response = JSON.parse(search_req.body)
-      customer_json = search_response["results"].find { |r| r.dig("email") == email }
-      MpApi::Customer.new(**MpApi::Customer.build_hash(customer_json)) if customer_json
+    def find_mp_customer(email)
+      mp_client.get_customer(email)
     end
 
     def save_credit_card(card_token, customer)
       return if customer.nil?
-      MpApi.configuration.access_token = preferences[:access_token]
-      mp_credit_card = MpApi::Card.new(token: card_token, customer_id: customer.external_id).create
+      mp_credit_card = mp_client.create_card(customer_id: customer.external_id, token: card_token)
       SolidusMpDois::Card.upsert(
         {
-          external_id: mp_credit_card.external_id,
+          external_id: mp_credit_card.id,
           last_four_digits: mp_credit_card.last_four_digits,
-          mp_payment_method_id: mp_credit_card.mp_payment_method_id,
+          mp_payment_method_id: mp_credit_card.payment_method.id,
           customer_id: customer.id
         }, unique_by: :external_id
       )
@@ -165,49 +166,112 @@ module SolidusMpDois
     def process_payment_response(payment, mp_payment)
       payment.source.update(
         external_id: mp_payment.id,
-        three_ds_url: mp_payment.three_ds_info_external_resource_url,
-        three_ds_creq: mp_payment.three_ds_info_creq,
-        last_four_digits: mp_payment.last_four_digits
+        three_ds_url: mp_payment["three_ds_info"]&.external_resource_url,
+        three_ds_creq: mp_payment["three_ds_info"]&.creq,
+        last_four_digits: mp_payment.card.last_four_digits
       )
-      if mp_payment.id.blank? || mp_payment.error || mp_payment.internal_error || mp_payment.status_detail == "pending_review_manual"
-        handle_payment_error(payment, mp_payment)
+      payment.order.update(email: payment.source.email)
+      sync(payment, mp_payment)
+    end
+
+    def sync(payment, mp_payment)
+      paid_amount = Float(mp_payment.transaction_details.total_paid_amount)
+      payment.source.update!(status: mp_payment.status, internal_details: mp_payment.status_detail)
+
+      if mp_payment.status == "approved" && paid_amount >= payment.amount
+        approve_payment(payment, paid_amount)
+      elsif mp_payment.status == "approved"
+        raise "Payment paid with value less than the created - #{mp_payment.id}"
+      elsif (mp_payment.status == "pending" && mp_payment.status_detail == "pending_challenge")
+        pend_payment(payment)
+      else
+        invalid_payment(payment)
+      end
+    end
+
+    def approve_payment payment, paid_amount
+      payment.complete!
+      payment_source = payment.source
+      payment_source.update!(status: payment.state, total_paid_amount: paid_amount)
+      response = successful_response("Pagamento aprovado", status: payment_source.status, internal_detail: payment_source.internal_details)
+      payment.log_entries.create(parsed_payment_response_details_with_fallback: response)
+    end
+
+    def invalid_payment payment
+      if payment.checkout?
+        payment.invalidate!
       else
-        payment.order.update(email: payment.source.email)
-        update_payment_status(payment, mp_payment)
+        payment.failure!
       end
+
+      payment_source = payment.source
+      payment_source.update!(status: payment.state)
+      error_message = internal_error(payment_source.internal_details)
+      handle_payment_error(payment, error_message:)
+    end
+
+    def pend_payment payment
+      payment.pend! unless payment.pending?
+      payment.source.update!(status: payment.state)
+      error_message = "Pagamento aguardando 3ds"
+      handle_payment_error(payment, error_message:)
     end
 
-    def update_payment_status(payment, mp_payment)
-      status = case mp_payment.status
-      when "approved" then "success"
-      when "pending" then "pending"
+    def internal_error internal_detail
+      case internal_detail
+      when "by_collector"
+        "Pagamento cancelado"
+      when "refunded"
+        "Pagamento reembolsado"
+      when "reimbursed"
+        "Pagamento reembolsado"
+      when "cc_amount_rate_limit_exceeded"
+        "O pagamento foi rejeitado porque superou o limite do meio de pagamento"
+      when "cc_rejected_bad_filled_date"
+        "Data de vencimento inválida"
+      when "cc_rejected_bad_filled_card_number"
+        "Número do cartão inválido"
+      when "cc_rejected_bad_filled_security_code"
+        "Código de segurança do cartão (CVV) inválido"
+      when "cc_rejected_call_for_authorize"
+        "Pagamento recusado. Você deve autorizar o pagamento no seu banco"
+      when "cc_rejected_card_disabled"
+        "Pagamento recusado. Você deve ativar seu cartão"
+      when "cc_rejected_insufficient_amount"
+        "Limite insuficiente"
+      else
+        "Pagamento recusado"
       end
-      payment.source.update!(status: status, internal_details: mp_payment.status_detail)
     end
 
-    def handle_payment_error(payment, mp_payment)
-      payment.invalidate
-      error_message = mp_payment.error || mp_payment.status_detail || "Erro ao criar o pagamento"
-      response = failure_response(error_message)
+    def invalidate_valid_payments order
+      order.payments.valid.each do |payment|
+        payment.source.void!
+      end
+    end
+
+    def handle_payment_error(payment, error_message:)
+      payment_source = payment.source
+      response = failure_response(error_message, status: payment_source.status, internal_detail: payment_source.internal_details)
       payment.log_entries.create(parsed_payment_response_details_with_fallback: response)
-      payment.source.cancel if mp_payment.id.present? && mp_payment.status_detail == "pending_review_manual"
-      payment.source.update(internal_error: error_message, status: "error", internal_details: mp_payment.status_detail)
+      payment_source.update!(internal_error: error_message)
     end
 
-    def successful_response message, transaction_id
+    def successful_response message, status:, internal_detail:
+      full_message = message + " - " + status + ": " + internal_detail
       ActiveMerchant::Billing::Response.new(
         true,
-        message,
-        {},
-        authorization: transaction_id
+        full_message
       )
     end
 
-    def failure_response message
+    def failure_response message, status:, internal_detail:
+      full_message = message + " - " + status + ": " + internal_detail
       ActiveMerchant::Billing::Response.new(
         false,
-        message
+        full_message
       )
     end
+
   end
 end

data/app/models/solidus_mp_dois/mp_pix.rb

@@ -8,10 +8,6 @@ module SolidusMpDois
       PixSource
     end
 
-    def gateway_class
-      MpGateway
-    end
-
     def supports?(source)
       source.is_a?(payment_source_class)
     end
@@ -25,40 +21,62 @@ module SolidusMpDois
     end
 
     def find_payment external_id
-      MpApi.configuration.access_token = preferences[:access_token]
-      MpApi::Payment.find_by_id(external_id)
+      mp_client.get_payment(external_id)
     end
 
     def create_payment order
       existing_payment = find_existing_payment(order)
       return existing_payment if payment_usable?(order, existing_payment)
+      invalidate_valid_payments(order, existing_payment&.id)
 
       payment = order.payments.new(amount: order.total, payment_method: self)
       payment.source = init_source(order)
       payment.save
+      payment_source = payment.source
+      identification_type = (payment_source.tax_id.length > 14) ? "CNPJ" : "CPF"
+
+      mp_payment = mp_client.create_pix_payment(
+        amount: payment_source.amount.to_f,
+        description: payment_source.description,
+        statement_descriptor: preferences[:statement_descriptor],
+        payment_method: "pix",
+        payer_email: payment_source.email,
+        payer_identification_type: identification_type,
+        payer_identification_number: payment_source.tax_id
+      )
 
-      mp_payment = create_mp_payment(payment.source)
       process_payment_response(payment, mp_payment)
       payment
     end
 
-    def invalidate_payment payment_source
-      return false unless payment_source&.external_id
-      MpApi.configuration.access_token = preferences[:access_token]
-      mp_payment = find_payment(payment_source.external_id)
-      return false if mp_payment.pix_paid?
-      mp_payment.invalidate_pix!
-      payment_source.payments[0].log_entries.create!(parsed_payment_response_details_with_fallback: failure_response("Pagamento cancelado"))
-      payment_source.update(status: "cancelled")
-      true
+    def purchase(payment)
+      return unless payment.source&.external_id
+      10.times do
+        mp_payment = find_payment(payment.source.external_id)
+        break if ["approved", "rejected"].include? mp_payment.status
+      end
+      mp_payment = find_payment(payment.source.external_id)
+      sync(payment, mp_payment)
+    end
+
+    def pix_paid? payment
+      purchase(payment)
+      payment.completed?
     end
 
-    def purchase(money, source, options = {})
-      gateway.purchase(money, source, options)
+    def invalidate_payment payment
+      external_id = payment.source&.external_id
+      return if external_id.nil? || pix_paid?(payment)
+      mp_payment = mp_client.update_payment(payment_id: external_id, status: "cancelled")
+      sync(payment, mp_payment)
     end
 
     private
 
+    def mp_client
+      MpApi::Client.new(preferences[:access_token])
+    end
+
     def init_source(order)
       PixSource.new(
         amount: order.total,
@@ -69,22 +87,8 @@ module SolidusMpDois
       )
     end
 
-    def create_mp_payment payment_source
-      MpApi.configuration.access_token = preferences[:access_token]
-      identification_type = (payment_source.tax_id.length > 14) ? "CNPJ" : "CPF"
-      MpApi::Payment.new(
-        payer_email: payment_source.email,
-        payer_identification_type: identification_type,
-        payer_identification_number: payment_source.tax_id,
-        payment_method: "pix",
-        amount: payment_source.amount.to_f,
-        statement_descriptor: preferences[:statement_descriptor],
-        description: payment_source.description
-      ).create
-    end
-
     def find_existing_payment(order)
-      pix_payments = order.payments.checkout.where(source_type: "SolidusMpDois::PixSource")
+      pix_payments = order.payments.valid.where(source_type: "SolidusMpDois::PixSource")
       raise "More than one valid payment for #{order.number}" if pix_payments.count > 1
       pix_payments.first
     end
@@ -95,49 +99,102 @@ module SolidusMpDois
     end
 
     def process_payment_response(payment, mp_payment)
-      payment.update(response_code: mp_payment.id)
       payment.source.update(
         external_id: mp_payment.id,
-        qr_code: mp_payment.qr_code,
-        qr_code_base64: mp_payment.qr_code_base_64,
-        ticket_url: mp_payment.ticket_url
+        qr_code: mp_payment.point_of_interaction.transaction_data.qr_code,
+        qr_code_base64: mp_payment.point_of_interaction.transaction_data.qr_code_base64,
+        ticket_url: mp_payment.point_of_interaction.transaction_data.ticket_url
       )
-      if mp_payment.error || mp_payment.internal_error
-        handle_payment_error(payment, mp_payment)
+      sync(payment, mp_payment)
+    end
+
+    def sync(payment, mp_payment)
+      paid_amount = Float(mp_payment.transaction_details.total_paid_amount)
+      payment.source.update!(status: mp_payment.status, internal_details: mp_payment.status_detail)
+
+      if mp_payment.status == "approved" && paid_amount >= payment.amount
+        approve_payment(payment)
+      elsif mp_payment.status == "approved"
+        raise "Payment paid with value less than the created - #{mp_payment.id}"
+      elsif mp_payment.status == "pending" && mp_payment.status_detail == "pending_waiting_transfer"
+        pend_payment(payment)
+      else
+        invalid_payment(payment)
+      end
+    end
+
+    def approve_payment payment
+      payment.complete!
+      payment_source = payment.source
+      payment_source.update!(status: payment.state)
+      response = successful_response("Pagamento aprovado", status: payment_source.status, internal_details: payment_source.internal_details)
+      payment.log_entries.create(parsed_payment_response_details_with_fallback: response)
+    end
+
+    def invalid_payment payment
+      if payment.checkout?
+        payment.invalidate!
       else
-        update_payment_status(payment, mp_payment)
+        payment.failure!
       end
+
+      payment_source = payment.source
+      payment_source.update!(status: payment.state)
+      error_message = internal_error(payment_source.internal_details)
+      handle_payment_error(payment, error_message:)
+    end
+
+    def pend_payment payment
+      payment.pend! unless payment.pending?
+      payment.source.update!(status: payment.state)
+      error_message = "Aguardando pagamento"
+      handle_payment_error(payment, error_message:)
     end
 
-    def update_payment_status(payment, mp_payment)
-      status = case mp_payment.status
-      when "pending" then "pending"
+    def invalidate_valid_payments order, existing_payment_id
+      order.payments.valid.where.not(id: existing_payment_id).each do |payment|
+        payment.source.void!
       end
-      payment.source.update!(status: status)
     end
 
-    def handle_payment_error(payment, mp_payment)
-      payment.invalidate
-      error_message = mp_payment.error || "Erro ao criar o pagamento"
-      response = failure_response(error_message)
+    def handle_payment_error(payment, error_message:)
+      payment_source = payment.source
+      response = failure_response(error_message, status: payment_source.status, internal_detail: payment_source.internal_details)
       payment.log_entries.create(parsed_payment_response_details_with_fallback: response)
-      payment.source.update(internal_error: error_message, status: "error")
+      payment_source.update!(internal_error: error_message)
     end
 
-    def successful_response message, transaction_id
+    def successful_response message, status:, internal_detail:
+      full_message = message + " - " + status + ": " + internal_detail
       ActiveMerchant::Billing::Response.new(
         true,
-        message,
-        {},
-        authorization: transaction_id
+        full_message
       )
     end
 
-    def failure_response message
+    def failure_response message, status:, internal_detail:
+      full_message = message + " - " + status + ": " + internal_detail
       ActiveMerchant::Billing::Response.new(
         false,
-        message
+        full_message
       )
     end
+
+    def internal_error internal_detail
+      case internal_detail
+      when "by_collector"
+        "Pagamento cancelado"
+      when "refunded"
+        "Pagamento reembolsado"
+      when "reimbursed"
+        "Pagamento reembolsado"
+      when "cc_amount_rate_limit_exceeded"
+        "O pagamento foi rejeitado porque superou o limite do meio de pagamento"
+      when "cc_rejected_insufficient_amount"
+        "Saldo insuficiente"
+      else
+        "Pagamento recusado"
+      end
+    end
   end
 end

data/app/models/solidus_mp_dois/pix_source.rb

@@ -9,12 +9,11 @@ module SolidusMpDois
     end
 
     def paid?
-      mp_payment = retrieve_from_api
-      mp_payment.pix_paid?
+      payment_method.pix_paid?(payments.sole)
     end
 
-    def invalidate
-      payment_method.invalidate_payment(self)
+    def void!
+      payment_method.invalidate_payment(payments.sole)
     end
   end
 end

data/app/views/spree/admin/payments/source_views/_mercado_pago_card.html.erb

@@ -22,8 +22,8 @@
         </div>
 
         <div class="field">
-          <%= label_tag :amount, "Valor" %>
-          <%= text_field_tag :amount, number_to_currency(payment.source.amount), class:"fullwidth", disabled: true %>
+          <%= label_tag :amount, "Valor pago" %>
+          <%= text_field_tag :amount, number_to_currency(payment.source.total_paid_amount), class:"fullwidth", disabled: true %>
         </div>
 
         <div class="field">

data/db/migrate/20250801180726_add_internal_details_in_solidus_mp_dois_pix_sources.rb

@@ -0,0 +1,5 @@
+class AddInternalDetailsInSolidusMpDoisPixSources < ActiveRecord::Migration[7.1]
+  def change
+    add_column :solidus_mp_dois_pix_sources, :internal_details, :string
+  end
+end

data/db/migrate/20250804120023_add_total_paid_amount_on_solidus_mp_dois_credit_card_sources.rb

@@ -0,0 +1,5 @@
+class AddTotalPaidAmountOnSolidusMpDoisCreditCardSources < ActiveRecord::Migration[7.1]
+  def change
+    add_column :solidus_mp_dois_credit_card_sources, :total_paid_amount, :decimal
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solidus_mp_dois
 version: !ruby/object:Gem::Version
-  version: 2.2.2
+  version: 3.0.0
 platform: ruby
 authors:
 - Todas Essas Coisas
@@ -44,11 +44,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
 - app/models/solidus_mp_dois/card.rb
 - app/models/solidus_mp_dois/credit_card_source.rb
 - app/models/solidus_mp_dois/customer.rb
 - app/models/solidus_mp_dois/mp_card.rb
-- app/models/solidus_mp_dois/mp_gateway.rb
 - app/models/solidus_mp_dois/mp_pix.rb
 - app/models/solidus_mp_dois/pix_source.rb
 - app/views/spree/admin/payments/source_forms/_mercado_pago_card.html.erb
@@ -64,6 +64,8 @@ files:
 - db/migrate/20241209174725_create_solidus_mp_dois_pix_sources.rb
 - db/migrate/20250214170355_add_internal_details_to_solidus_mp_dois_credit_card_sources.rb
 - db/migrate/20250722183651_remove_solidus_mp_dois_customer_foreign_key.rb
+- db/migrate/20250801180726_add_internal_details_in_solidus_mp_dois_pix_sources.rb
+- db/migrate/20250804120023_add_total_paid_amount_on_solidus_mp_dois_credit_card_sources.rb
 - lib/generators/solidus_mp_dois/install/install_generator.rb
 - lib/generators/solidus_mp_dois/install/templates/app/javascript/controllers/card_payment_brick_controller.js
 - lib/generators/solidus_mp_dois/install/templates/app/javascript/controllers/payment_brick_controller.js

data/app/models/solidus_mp_dois/mp_gateway.rb

@@ -1,44 +0,0 @@
-module SolidusMpDois
-  class MpGateway
-    def initialize(options)
-      MpApi.configuration.access_token = options[:access_token]
-    end
-
-    def purchase money, source, options = {}
-      mp_payment = source.retrieve_from_api
-      10.times do
-        break if ["approved", "rejected"].include? mp_payment.status
-        mp_payment = source.retrieve_from_api
-      end
-      if mp_payment.status == "approved"
-        source.update(status: "approved")
-        successful_response("Pagamento realizado", mp_payment.id)
-      else
-        failure_response(mp_payment.status_detail || mp_payment.status)
-      end
-    end
-
-    def void(transaction_id, options = {})
-      # Respondendo sempre com successful_response para funcionar o botão de "Cancelar" do pedido. Reembolso deve ser feito por fora.
-      successful_response("Pagamento cancelado. Se necessário, realize o reembolso.", transaction_id)
-    end
-
-    private
-
-    def successful_response message, transaction_id
-      ActiveMerchant::Billing::Response.new(
-        true,
-        message,
-        {},
-        authorization: transaction_id
-      )
-    end
-
-    def failure_response message
-      ActiveMerchant::Billing::Response.new(
-        false,
-        message
-      )
-    end
-  end
-end