solidus_inter 2.0.0 → 3.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f26d5961715115c68b93397ab535656b57c57d69005409c9a62a21f67ee735ff
-  data.tar.gz: a781c0a4133a46af79b2a92c930f3fd5165bbe582efa61698d93c6449a81e5cc
+  metadata.gz: 68978582e05c3a6391cc622865892b77ca8b28e2d98388213bf6d58a489ef446
+  data.tar.gz: 7759c7ac13c686895ed6a8848f33875d2bac0fd4f0c1045fafa3ae487ab5b807
 SHA512:
-  metadata.gz: 68ded17e92681541c0feadd0149edd8daa29594184c404af8c5c043d751101043721ba93816b420d329106b5930cc5b5f5d6a384698226923bf924d54b7304b4
-  data.tar.gz: 28a3d4bf964f59cc37a2cadcbac9ca9913823dc4c2944f1aaa31901986db7b58eb8bba321fbefbb0a30615191df81572111c8ec76c97fb04ed1c700ec3465813
+  metadata.gz: 3508d43d52924bbdde45b088cd81c44dd65d8c7697535f1bb8c8e39a6a98f98e97c8470eb6ed81d1a34d1c715b79e93134df2940ad9950f7546f8764586ca593
+  data.tar.gz: d6851bf2cd670b75074668824d9bdba9ae9522b073fb58abe51496864f7816d9cfcd671f1b7a8a59fe4135df1fc3c62b7bc5846f582fb2fbc7eb0ab5569b10b9

data/README.md

@@ -1,16 +1,152 @@
-# Solidus Inter
-<!-- Explain what your extension does. -->
+# SolidusInter
 
-## Installation
+Integração do Banco Inter com o Solidus para pagamentos via PIX.
 
-Add solidus_inter to your Gemfile:
+## Sobre
+
+SolidusInter é uma extensão para o Solidus que permite integração com a API do Banco Inter para processamento de pagamentos via PIX. A gem oferece uma solução completa para gerar códigos PIX, QR codes e processar pagamentos em tempo real.
+
+## Funcionalidades
+
+- ✅ Geração automática de códigos PIX
+- ✅ Criação de QR codes para pagamento
+- ✅ Validação de pagamentos em tempo real
+- ✅ Integração completa com o admin do Solidus
+- ✅ Suporte para diferentes chaves PIX
+- ✅ Interface responsiva para mobile e desktop
+- ✅ Webhooks para confirmação automática de pagamentos
+
+## Instalação
+
+Adicione esta linha ao Gemfile da sua aplicação:
 
 ```ruby
 gem 'solidus_inter'
 ```
 
-Bundle your dependencies and run the installation generator:
+Execute:
 
-```shell
-bin/rails generate solidus_inter:install
+```bash
+$ bundle install
 ```
+
+Execute o gerador de instalação:
+
+```bash
+$ rails generate solidus_inter:install
+```
+
+Isso irá:
+- Copiar as migrações necessárias
+- Executar as migrações (se você confirmar)
+
+## Configuração
+
+### 1. Credenciais do Banco Inter
+
+Você precisará das seguintes credenciais do Banco Inter:
+
+- **Client ID**: ID do cliente fornecido pelo Banco Inter
+- **Client Secret**: Chave secreta fornecida pelo Banco Inter
+- **Chave PIX**: Sua chave PIX cadastrada no Banco Inter
+- **Conta Corrente**: Número da conta corrente
+- **Certificados**: Certificado (.crt) e chave privada (.key) fornecidos pelo Banco Inter
+
+### 2. Configuração do Payment Method
+
+No admin do Solidus, vá para:
+
+1. `Settings` → `Payment Methods`
+2. Clique em `New Payment Method`
+3. Selecione `SolidusInter::InterPix` como tipo
+4. Configure as preferências:
+   - **Client ID**: Seu client ID do Banco Inter
+   - **Client Secret**: Seu client secret do Banco Inter
+   - **Chave PIX**: Sua chave PIX
+   - **Conta Corrente**: Número da sua conta corrente
+   - **CRT**: Conteúdo do certificado (.crt)
+   - **Key**: Conteúdo da chave privada (.key)
+
+## Uso
+
+### Fluxo de Pagamento
+
+1. **Checkout**: O cliente seleciona PIX como método de pagamento
+2. **Geração**: A gem gera automaticamente o código PIX e QR code
+3. **Pagamento**: O cliente usa o app do banco para pagar
+4. **Confirmação**: O pagamento é confirmado via webhook ou polling
+5. **Finalização**: O pedido é processado automaticamente
+
+### Códigos de Estado
+
+A gem controla automaticamente os seguintes estados de pagamento:
+
+- `pending`: Pagamento aguardando confirmação
+- `paid`: Pagamento confirmado
+- `expired`: Pagamento expirado
+- `cancelled`: Pagamento cancelado
+
+## API
+
+### Principais Classes
+
+#### `SolidusInter::InterPix`
+
+Classe principal do método de pagamento que herda de `Spree::PaymentMethod`:
+
+```ruby
+payment_method = SolidusInter::InterPix.new
+payment_method.create_payment(order) # Cria pagamento PIX
+payment_method.find_payment(txid)    # Busca pagamento por txid
+```
+
+#### `SolidusInter::PixPaymentSource`
+
+Representa a fonte de pagamento PIX:
+
+```ruby
+source = SolidusInter::PixPaymentSource.new
+source.paid?      # Verifica se foi pago
+source.expired?   # Verifica se expirou
+source.active?    # Verifica se está ativo
+```
+
+#### `SolidusInter::InterClient`
+
+Cliente para comunicação com a API do Banco Inter:
+
+```ruby
+client = SolidusInter::InterClient.new(payment_method)
+client.get_payment(txid)    # Busca pagamento
+client.create_payment(data) # Cria novo pagamento
+```
+
+## Personalização
+
+### Views
+
+As views podem ser customizadas copiando-as para sua aplicação:
+
+```
+app/views/spree/admin/payments/source_forms/_inter_pix.html.erb
+app/views/spree/admin/payments/source_views/_inter_pix.html.erb
+app/views/spree/api/payments/source_views/_inter_pix.jbuilder
+```
+
+## Desenvolvimento
+
+### Configuração do Ambiente
+
+```bash
+git clone https://github.com/todasessascoisas/solidus_inter.git
+cd solidus_inter
+bundle install
+```
+
+## Dependências
+
+- **Ruby**: >= 2.5, < 4
+- **Solidus**: Compatível com versões atuais
+- **[inter_api](https://github.com/todasessascoisas/inter_api)**: API client para o Banco Inter
+- **[solidus_brazilian_adaptations](https://github.com/todasessascoisas/solidus_brazilian_adaptations)**: Adaptações brasileiras para Solidus
+- **rqrcode**: Geração de QR codes

data/app/models/solidus_inter/gateway.rb

@@ -3,14 +3,6 @@ module SolidusInter
     def initialize(options)
     end
 
-    def purchase(_money, source, _options = {})
-      inter_payment = source.retrieve_from_api
-      if inter_payment.paid?
-        source.update(status: "approved", paid_amount: inter_payment.valor_pago, e2e_id: inter_payment.end_to_end_id)
-        successful_response("Pagamento realizado", inter_payment.txid)
-      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)

data/app/models/solidus_inter/inter_client.rb

@@ -0,0 +1,56 @@
+module SolidusInter
+  class InterClient
+    def self.for_payment_method(payment_method)
+      client_class = payment_method.preferred_test_mode ? InterClientSandbox : InterClientProduction
+      client_class.new(payment_method)
+    end
+  end
+
+  module PaymentMethodSyncable
+    attr_accessor :payment_method
+
+    def initialize(payment_method)
+      @payment_method = payment_method
+      super(
+        client_id: payment_method.preferred_client_id,
+        client_secret: payment_method.preferred_client_secret,
+        chave_pix: payment_method.preferred_chave_pix,
+        conta_corrente: payment_method.preferred_conta_corrente,
+        crt: temp_file(payment_method.preferred_crt).path,
+        key: temp_file(payment_method.preferred_key).path,
+        access_token: payment_method.preferred_access_token,
+        token_expires_at: payment_method.preferred_token_expires_at.to_datetime,
+        test_mode: payment_method.preferred_test_mode
+      )
+    end
+
+    def refresh_token
+      super
+      sync_payment_method_tokens
+    end
+
+    private
+
+    def sync_payment_method_tokens
+      payment_method.update!(
+        preferred_access_token: access_token,
+        preferred_token_expires_at: token_expires_at
+      )
+    end
+
+    def temp_file(content)
+      t = Tempfile.new
+      t << content
+      t.close
+      t
+    end
+  end
+
+  class InterClientSandbox < ::InterApi::ClientSandbox
+    include PaymentMethodSyncable
+  end
+
+  class InterClientProduction < ::InterApi::ClientProduction
+    include PaymentMethodSyncable
+  end
+end

data/app/models/solidus_inter/inter_pix.rb

@@ -6,6 +6,8 @@ module SolidusInter
     preference :conta_corrente, :string
     preference :crt, :text
     preference :key, :text
+    preference :access_token, :string
+    preference :token_expires_at, :string
 
     def payment_source_class
       PixPaymentSource
@@ -28,13 +30,13 @@ module SolidusInter
     end
 
     def find_payment(txid)
-      client = set_api_client
-      client.get_payment(txid)
+      inter_client.get_payment(txid)
     end
 
     def create_payment(order)
       existing_payment = find_existing_payment(order)
       return existing_payment if payment_is_usable?(existing_payment, order)
+      invalidate_valid_payments(order, existing_payment&.id)
 
       payment = order.payments.new(amount: order.total, payment_method: self)
       payment.source = init_source(order)
@@ -45,38 +47,61 @@ module SolidusInter
       payment
     end
 
-    def invalidate_payment(payment_source)
-      return false unless payment_source&.txid
+    def invalidate_payment(payment)
+      txid = payment.source&.txid
+      return false if txid.nil?
+      inter_payment = find_payment(payment.source.txid)
+      sync(payment, inter_payment)
+      return false unless payment.checkout?
 
-      inter_payment = find_payment(payment_source.txid)
-      return false if inter_payment.paid?
-
-      inter_payment.invalidate!
-      payment_source.payments[0].log_entries.create!(parsed_payment_response_details_with_fallback: failure_response("Pagamento cancelado"))
-      true
+      inter_payment = inter_client.update_payment(payment_id: txid, status: "REMOVIDA_PELO_USUARIO_RECEBEDOR")
+      sync(payment, inter_payment)
     end
 
-    def pay_test_payment(payment_source)
-      return false unless payment_source&.txid
+    def pay_test_payment(payment, amount: nil)
+      return false unless inter_client.class == InterClientSandbox
+
+      amount ||= payment.amount
+      txid = payment.source&.txid
+      return false if txid.nil?
+      inter_payment = find_payment(payment.source.txid)
+      sync(payment, inter_payment)
+      return false unless payment.checkout?
 
-      inter_payment = find_payment(payment_source.txid)
-      return false if inter_payment.paid?
+      inter_client.pay_pix(payment_id: payment.source.txid, amount: amount)
+      sync(payment, inter_payment)
+    end
 
-      client = set_api_client
-      client.pay_pix(inter_payment.txid, inter_payment.valor_original)
+    def purchase(money, source, _options = {})
+      inter_payment = source.retrieve_from_api
+      sync(source.payments.sole, inter_payment)
+      if inter_payment.status == "CONCLUIDA"
+        successful_response("Pagamento realizado", status: source.status, internal_detail: "")
+      else
+        failure_response("Pagamento não realizado", status: source.status, internal_detail: "")
+      end
     end
 
-    def purchase(money, source, options = {})
-      gateway.purchase(money, source, options)
+    # Não da pra chamar o sync aqui pq ele da payment.complete e isso faz nao chamar o purchase
+    def pix_paid? payment
+      return false unless payment.source&.txid
+      inter_payment = find_payment(payment.source.txid)
+      paid_amount = total_paid(inter_payment)
+      inter_payment.status == "CONCLUIDA" && paid_amount >= payment.amount
     end
 
-    def should_skip_processing?(source)
-      inter_payment = find_payment(source.txid)
-      !inter_payment.paid?
+    def payment_valid? payment
+      return false unless payment.source&.txid
+      purchase(payment)
+      payment.checkout?
     end
 
     private
 
+    def inter_client
+      InterClient.for_payment_method(self)
+    end
+
     def init_source(order)
       PixPaymentSource.new(
         amount: order.total,
@@ -87,8 +112,7 @@ module SolidusInter
     end
 
     def create_inter_payment(payment_source)
-      client = set_api_client
-      client.create_payment(
+      inter_client.create_payment(
         amount: payment_source.amount,
         payer_tax_id: payment_source.payer_tax_id,
         payer_name: payment_source.payer_name,
@@ -110,66 +134,93 @@ module SolidusInter
     end
 
     def process_payment_response(payment, inter_payment)
-      payment.update(response_code: inter_payment.txid)
       payment.source.update(
         txid: inter_payment.txid,
-        pix_code: inter_payment.copia_e_cola,
-        qr_code_svg: inter_payment.qr_code,
+        pix_code: inter_payment.pixCopiaECola,
+        qr_code_svg: qr_code(inter_payment),
         status: inter_payment.status,
-        expiration: inter_payment.expiracao
+        expiration: expiration_date(inter_payment)
       )
+      payment.update(response_code: inter_payment.txid)
+      sync(payment, inter_payment)
+    end
+
+    def sync(payment, inter_payment)
+      paid_amount = total_paid(inter_payment)
+      payment.source.update!(status: inter_payment.status, paid_amount: paid_amount, e2e_id: end_to_end(inter_payment))
+      if inter_payment.status == "CONCLUIDA" && paid_amount >= payment.amount
+        approve_payment(payment)
+      elsif inter_payment.status == "CONCLUIDA"
+        raise "Payment paid with value less than the created - #{inter_payment.txid}"
+      elsif inter_payment.status != "ATIVA" || payment.source.expired?
+        invalid_payment(payment)
+      end
+    end
 
-      update_payment_status(payment, inter_payment)
+    def approve_payment(payment)
+      payment.complete
+      payment_source = payment.source
+      payment_source.update! status: payment.state
+      response = successful_response("Pagamento realizado", status: payment_source.status, internal_detail: "")
+      payment.log_entries.create(parsed_payment_response_details_with_fallback: response)
     end
 
-    def update_payment_status(payment, inter_payment)
-      status = case inter_payment.status
-      when "ATIVA" then "pending"
+    def invalid_payment payment
+      return false unless payment.checkout?
+      if payment.checkout?
+        payment.invalidate!
+      else
+        payment.failure!
       end
-      payment.source.update(status: status)
-    end
-
-    def set_api_client
-      account = SolidusInter::Account.find_by(chave_pix: preferences[:chave_pix])
-      client = ::InterApi::Client.new(
-        client_id: preferences[:client_id],
-        client_secret: preferences[:client_secret],
-        chave_pix: preferences[:chave_pix],
-        conta_corrente: preferences[:conta_corrente],
-        crt: temp_file(preferences[:crt]).path,
-        key: temp_file(preferences[:key]).path,
-        access_token: account&.token,
-        token_expires_at: account&.expires_at,
-        test_mode: preferences[:test_mode]
-      )
-      SolidusInter::Account.upsert(
-        {token: client.access_token, expires_at: client.token_expires_at, chave_pix: client.chave_pix,
-         spree_payment_method_id: id}, unique_by: :chave_pix
-      )
-      client
+
+      payment_source = payment.source
+      payment_source.update!(status: payment.state)
+      response = failure_response("Pagamento invalidado", status: payment_source.status, internal_detail: "")
+      payment.log_entries.create(parsed_payment_response_details_with_fallback: response)
     end
 
-    def temp_file(content)
-      t = Tempfile.new
-      t << content
-      t.close
-      t
+    def invalidate_valid_payments order, existing_payment_id
+      available_payments = order.payments.where(state: ["checkout", "pending"])
+      available_payments.where.not(id: existing_payment_id).each do |payment|
+        payment.source.void!
+      end
     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 qr_code(inter_payment, module_size: 4)
+      return unless inter_payment.pixCopiaECola
+      qr = RQRCode::QRCode.new(inter_payment.pixCopiaECola, size: 10, level: :l)
+      qr.as_svg(module_size: module_size)
+    end
+
+    def expiration_date(inter_payment)
+      return unless inter_payment.calendario.criacao
+      Time.new(inter_payment.calendario.criacao) + inter_payment.calendario.expiracao
+    end
+
+    def total_paid(inter_payment)
+      return unless inter_payment["pix"] && inter_payment.pix.any?
+      Float(inter_payment.pix[0].valor)
+    end
+
+    def end_to_end(inter_payment)
+      return unless inter_payment["pix"] && inter_payment.pix.any?
+      inter_payment.pix[0].endToEndId
+    end
   end
 end

data/app/models/solidus_inter/pix_payment_source.rb

@@ -1,27 +1,11 @@
 module SolidusInter
   class PixPaymentSource < Spree::PaymentSource
-    def actions
-      %w[]
-    end
-
-    def can_capture?(payment)
-      payment.pending? || payment.checkout?
-    end
-
-    def can_void?(payment)
-      payment.can_void?
-    end
-
-    def can_credit?(payment)
-      payment.completed? && payment.credit_allowed > 0
-    end
-
     def expired?
-      expiration.past?
+      expiration.nil? || expiration.past?
     end
 
     def active?
-      expiration.future?
+      expiration.present? && expiration.future?
     end
 
     def retrieve_from_api
@@ -29,12 +13,11 @@ module SolidusInter
     end
 
     def paid?
-      inter_payment = retrieve_from_api
-      inter_payment.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/lib/solidus_inter/version.rb

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

data/lib/solidus_inter.rb

@@ -3,6 +3,7 @@
 require "solidus_inter/version"
 require "solidus_inter/engine"
 require "inter_api"
+require "rqrcode"
 
 module SolidusInter
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solidus_inter
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 3.0.1
 platform: ruby
 authors:
 - ulysses
@@ -37,15 +37,31 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: ''
+- !ruby/object:Gem::Dependency
+  name: rqrcode
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Extensão para o Solidus que permite integração completa com a API do
+  Banco Inter para processamento de pagamentos via PIX, incluindo geração de QR codes
+  e validação automática de pagamentos.
 email: ulyssesh.20@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- app/models/solidus_inter/account.rb
 - app/models/solidus_inter/gateway.rb
+- app/models/solidus_inter/inter_client.rb
 - app/models/solidus_inter/inter_pix.rb
 - app/models/solidus_inter/pix_payment_source.rb
 - app/views/spree/admin/payments/source_forms/_inter_pix.html.erb
@@ -81,5 +97,5 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: ''
+summary: Integração do Banco Inter com Solidus para pagamentos via PIX
 test_files: []

data/app/models/solidus_inter/account.rb

@@ -1,5 +0,0 @@
-module SolidusInter
-  class Account < ApplicationRecord
-    belongs_to :spree_payment_method, class_name: "Spree::PaymentMethod"
-  end
-end