solidus_sicoob 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7fcf5044fe4d6d1f222b2b32e21b1c1e303095db40abc0649bed5c90f4584db
-  data.tar.gz: 19343e81cf137feeeca2ad983693c1546e73c0bcf24e80af503307eb0dfdf6a7
+  metadata.gz: c7a4f9670199d754eaa022b29ea83a32fb129dfa21f2ed1f73e3f76801012154
+  data.tar.gz: 0aa13e2ac755ad8057db230b794a7d00a91b5d1d0b0a4e2788e97d13f4615aa5
 SHA512:
-  metadata.gz: 55fab3f1438a118eb526f579045796a84f25687e293fb834dc5177e979ee2827213e6630b3b056c8422cee19e5665fe6a4948b251d8ffdb51c31b6bb6112c0fe
-  data.tar.gz: d4d6342d73b071398c580d9fb33603bad64dc339c1ea4fab6e5ece96603b10a01cba25214a9b3da493649d38b58719e069431aa206cfcdaf03fbbabf59cce925
+  metadata.gz: c59f36b5cc30bc52b1bf7e1af12030b81a838b17a02df27a88c11bce71d84e54a82910465fec933d57c11d903fc8bfb4798f954137518a26bf931c6c8a5fdce1
+  data.tar.gz: 43c49c1ee24e96c535007c66bcd5f71108e5755cfd3a0c361824f45ec7f43a58e9f5fa9264e059b487410fb6addf1b27fbd44e2c6227459ddd730fe49e091169

data/app/models/solidus_sicoob/gateway.rb

@@ -3,21 +3,33 @@ module SolidusSicoob
     def initialize(options)
     end
 
-    def purchase(_money, source, _options = {})
-      sicoob_payment = source.retrieve_from_api
-      if sicoob_payment.paid?
-        source.update(status: "approved", paid_amount: sicoob_payment.valor_pago, e2e_id: sicoob_payment.end_to_end_id)
-        successful_response("Pagamento realizado", sicoob_payment.txid)
-      end
+    def void(transaction_id, options = {})
+      # Respondendo com falha pois atualmente todo pedido concluido ja teve seu pagamento processado
+      # e nesse caso o credit é mais adequado (Ao cancelar um pedido pela interface, o 'void' é chamado, se ele retornar falha o Solidus chama o 'credit')
+      failure_response("Pagamento já processado")
     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)
+    def credit(money, transaction_id, options = {})
+      payment = Spree::Payment.find_by(response_code: transaction_id)
+      payment_source = payment.source
+      refund = payment_source.refund!(amount: converted_money(money))
+      if refund.status == "DEVOLVIDO"
+        response = successful_response("Pagamento reembolsado (#{refund.status})", transaction_id)
+        payment.log_entries.create(parsed_payment_response_details_with_fallback: response)
+        successful_response("Reembolso realizado", refund.id)
+      else
+        response = successful_response("Pagamento não reembolsado - #{refund.status} - #{refund.try(:motivo)}", transaction_id)
+        payment.log_entries.create(parsed_payment_response_details_with_fallback: response)
+        successful_response("Erro ao reembolsar", refund.id)
+      end
     end
 
     private
 
+    def converted_money(money)
+      money / 100.0
+    end
+
     def successful_response(message, transaction_id)
       ActiveMerchant::Billing::Response.new(
         true,
@@ -27,10 +39,12 @@ module SolidusSicoob
       )
     end
 
-    def failure_response(message)
+    def failure_response(message, transaction_id = nil)
       ActiveMerchant::Billing::Response.new(
         false,
-        message
+        message,
+        {},
+        authorization: transaction_id
       )
     end
   end

data/app/models/solidus_sicoob/pix_payment_source.rb

@@ -1,21 +1,5 @@
 module SolidusSicoob
   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.nil? || expiration.past?
     end
@@ -29,12 +13,24 @@ module SolidusSicoob
     end
 
     def paid?
-      sicoob_payment = retrieve_from_api
-      sicoob_payment.paid?
+      payment_method.pix_paid?(payments.sole)
+    end
+
+    def void!
+      payment_method.invalidate_payment(payments.sole)
+    end
+
+    def refund!(amount: nil)
+      payment_method.refund_payment(payments.sole, amount: amount)
     end
 
-    def invalidate
-      payment_method.invalidate_payment(self)
+    # Definir para sempre false pois atualmente não implementados o void do Solidus
+    def can_void?(payment)
+      false
+    end
+
+    def can_credit?(payment)
+      payment.completed? && payment.credit_allowed > 0
     end
   end
 end

data/app/models/solidus_sicoob/sicoob_client.rb

@@ -0,0 +1,54 @@
+module SolidusSicoob
+  class SicoobClient
+    def self.for_payment_method(payment_method)
+      client_class = payment_method.preferred_test_mode ? SicoobClientSandbox : SicoobClientProduction
+      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,
+        chave_pix: payment_method.preferred_chave_pix,
+        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 SicoobClientSandbox < ::SicoobApi::ClientSandbox
+    include PaymentMethodSyncable
+  end
+
+  class SicoobClientProduction < ::SicoobApi::ClientProduction
+    include PaymentMethodSyncable
+  end
+end

data/app/models/solidus_sicoob/sicoob_pix.rb

@@ -4,6 +4,8 @@ module SolidusSicoob
     preference :chave_pix, :string
     preference :crt, :text
     preference :key, :text
+    preference :access_token, :string
+    preference :token_expires_at, :string
 
     def payment_source_class
       PixPaymentSource
@@ -26,24 +28,22 @@ module SolidusSicoob
     end
 
     def find_payment(txid)
-      client = set_api_client
-      client.get_payment(txid)
+      sicoob_client.get_payment(txid)
     end
 
     def webhook
-      client = set_api_client
-      client.get_webhook
+      sicoob_client.get_webhook
     end
 
     def update_webhook(url)
-      client = set_api_client
-      client.update_webhook(url)
-      client.get_webhook
+      sicoob_client.update_webhook(url)
+      sicoob_client.get_webhook
     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)
@@ -54,31 +54,52 @@ module SolidusSicoob
       payment
     end
 
-    def invalidate_payment(payment_source)
-      return false unless payment_source&.txid
+    def purchase(money, source, _options = {})
+      sicoob_payment = source.retrieve_from_api
+      sync(source.payments.sole, sicoob_payment)
+      if sicoob_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
 
-      sicoob_payment = find_payment(payment_source.txid)
-      return false if sicoob_payment.paid?
+    def invalidate_payment(payment)
+      txid = payment.source&.txid
+      return false if txid.nil?
+      sicoob_payment = find_payment(payment.source.txid)
+      sync(payment, sicoob_payment)
+      return false unless payment.checkout?
 
-      sicoob_payment.invalidate!
-      payment_source.payments[0].log_entries.create!(parsed_payment_response_details_with_fallback: failure_response("Pagamento cancelado"))
-      true
+      sicoob_payment = sicoob_client.update_payment(payment_id: txid, status: "REMOVIDA_PELO_USUARIO_RECEBEDOR")
+      sync(payment, sicoob_payment)
+    end
+
+    def pix_paid? payment
+      return false unless payment.source&.txid
+      sicoob_payment = find_payment(payment.source.txid)
+      paid_amount = total_paid(sicoob_payment)
+      sicoob_payment.status == "CONCLUIDA" && paid_amount >= payment.amount
     end
 
-    def purchase(money, source, options = {})
-      gateway.purchase(money, source, options)
+    def refund_payment(payment, amount: nil, refund_nature: nil, description: nil)
+      amount ||= payment.amount
+      refund_nature ||= "ORIGINAL"
+      sicoob_client.refund_payment(end_to_end_id: payment.source.e2e_id, amount: amount, refund_nature: refund_nature, description: description)
     end
 
-    def should_skip_processing?(source)
-      inter_payment = find_payment(source.txid)
-      !inter_payment.paid?
+    def puts_qrcode(payment)
+      puts RQRCode::QRCode.new(payment.pix_code).to_s(dark: "██", light: "  ")
     end
 
     private
 
+    def sicoob_client
+      SicoobClient.for_payment_method(self)
+    end
+
     def create_sicoob_payment(payment_source)
-      client = set_api_client
-      client.create_payment(
+      sicoob_client.create_payment(
         amount: payment_source.amount,
         payer_tax_id: payment_source.payer_tax_id,
         payer_name: payment_source.payer_name,
@@ -87,7 +108,8 @@ module SolidusSicoob
     end
 
     def find_existing_payment(order)
-      pix_payments = order.payments.checkout
+      available_payments = order.payments.where(state: ["checkout", "pending"])
+      pix_payments = available_payments.where(payment_method: self)
       raise "More than one valid payment for #{order.number}" if pix_payments.count > 1
 
       pix_payments.first
@@ -99,73 +121,105 @@ module SolidusSicoob
       payment.source.active? && payment.amount == order.total
     end
 
+    def init_source(order)
+      PixPaymentSource.new(
+        amount: order.total,
+        payer_name: order.ship_address.name,
+        payer_tax_id: order.tax_id,
+        payment_method: self
+      )
+    end
+
     def process_payment_response(payment, sicoob_payment)
       payment.update(response_code: sicoob_payment.txid)
       payment.source.update(
         txid: sicoob_payment.txid,
-        pix_code: sicoob_payment.copia_e_cola,
-        qr_code_svg: sicoob_payment.qr_code,
+        pix_code: sicoob_payment.brcode || sicoob_payment.qrCode,
+        qr_code_svg: qr_code(sicoob_payment),
         status: sicoob_payment.status,
-        expiration: sicoob_payment.expiracao
+        expiration: expiration_date(sicoob_payment)
       )
-
-      update_payment_status(payment, sicoob_payment)
+      payment.update(response_code: sicoob_payment.txid)
+      sync(payment, sicoob_payment)
     end
 
-    def update_payment_status(payment, inter_payment)
-      status = case inter_payment.status
-      when "ATIVA" then "pending"
+    def sync(payment, sicoob_payment)
+      paid_amount = total_paid(sicoob_payment)
+      payment.source.update!(status: sicoob_payment.status, paid_amount: paid_amount, e2e_id: end_to_end(sicoob_payment))
+
+      if sicoob_payment.status == "CONCLUIDA" && paid_amount >= payment.amount
+        approve_payment(payment)
+      elsif sicoob_payment.status == "CONCLUIDA"
+        raise "Payment paid with value less than the created - #{sicoob_payment.txid}"
+      elsif sicoob_payment.status != "ATIVA" || payment.source.expired?
+        invalid_payment(payment)
       end
-      payment.source.update(status: status)
     end
 
-    def init_source(order)
-      PixPaymentSource.new(
-        amount: order.total,
-        payer_name: order.ship_address.name,
-        payer_tax_id: order.tax_id,
-        payment_method: self
-      )
+    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 set_api_client
-      account = SolidusSicoob::Account.find_by(chave_pix: preferences[:chave_pix])
-      client = ::SicoobApi::Client.new(
-        client_id: preferences[:client_id],
-        chave_pix: preferences[:chave_pix],
-        crt: temp_file(preferences[:crt]).path,
-        key: temp_file(preferences[:key]).path,
-        access_token: account&.token,
-        token_expires_at: account&.expires_at
-      )
-      SolidusSicoob::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
+    def invalid_payment payment
+      return false unless payment.checkout?
+      if payment.checkout?
+        payment.invalidate!
+      else
+        payment.failure!
+      end
+
+      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(sicoob_payment, module_size: 4)
+      code = sicoob_payment.brcode || sicoob_payment.qrCode
+      qr = RQRCode::QRCode.new(code, size: 10, level: :l)
+      qr.as_svg(module_size: module_size)
+    end
+
+    def expiration_date(sicoob_payment)
+      return nil unless sicoob_payment.calendario.criacao
+      Time.new(sicoob_payment.calendario.criacao) + sicoob_payment.calendario.expiracao
+    end
+
+    def total_paid(sicoob_payment)
+      return nil unless sicoob_payment["pix"] && sicoob_payment.pix.any?
+      Float(sicoob_payment.pix[0].valor)
+    end
+
+    def end_to_end(sicoob_payment)
+      return nil unless sicoob_payment["pix"] && sicoob_payment.pix.any?
+      sicoob_payment.pix[0].endToEndId
+    end
   end
 end

data/lib/solidus_sicoob/version.rb

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

data/lib/solidus_sicoob.rb

@@ -3,6 +3,7 @@
 require "solidus_sicoob/version"
 require "solidus_sicoob/engine"
 require "sicoob_api"
+require "rqrcode"
 
 module SolidusSicoob
   class Error < StandardError; end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solidus_sicoob
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Hamilton
@@ -65,6 +65,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !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: ''
 email: hamilton@todasessascoisas.com.br
 executables: []
@@ -72,9 +86,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - README.md
-- app/models/solidus_sicoob/account.rb
 - app/models/solidus_sicoob/gateway.rb
 - app/models/solidus_sicoob/pix_payment_source.rb
+- app/models/solidus_sicoob/sicoob_client.rb
 - app/models/solidus_sicoob/sicoob_pix.rb
 - app/views/spree/admin/payments/source_forms/_sicoob_pix.html.erb
 - app/views/spree/admin/payments/source_views/_sicoob_pix.html.erb

data/app/models/solidus_sicoob/account.rb

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