pay-abacatepay 0.1.0.pre.1

data/lib/pay/abacatepay/payment_method.rb

@@ -0,0 +1,21 @@
+module Pay
+  module Abacatepay
+    # Stub STI class for Pay::PaymentMethod scoped to AbacatePay.
+    #
+    # AbacatePay does not (yet) expose tokenized payment methods that we can
+    # store and reuse — every transparent transaction needs full card data.
+    # This class exists so that:
+    #
+    #   1. `Pay::Abacatepay::Customer has_many :payment_methods` resolves
+    #      correctly (avoids `Missing model class` error on customer destroy).
+    #   2. We can persist tokenized payment methods later without breaking
+    #      existing data when transparent checkout lands (Fase 5).
+    #
+    # Until transparent checkout is implemented, instances of this class
+    # are not created — the relation is empty for every customer.
+    class PaymentMethod < Pay::PaymentMethod
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks :pay_abacatepay_payment_method, Pay::Abacatepay::PaymentMethod

data/lib/pay/abacatepay/processed_webhook.rb

@@ -0,0 +1,19 @@
+module Pay
+  module Abacatepay
+    class ProcessedWebhook < ActiveRecord::Base
+      self.table_name = "pay_abacatepay_processed_webhooks"
+
+      validates :event_type, :event_id, presence: true
+
+      def self.process!(event_type:, event_id:)
+        transaction(requires_new: true) do
+          create!(event_type: event_type, event_id: event_id, processed_at: Time.current)
+          yield if block_given?
+        end
+        nil
+      rescue ActiveRecord::RecordNotUnique
+        :already_processed
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/subscription.rb

@@ -0,0 +1,88 @@
+module Pay
+  module Abacatepay
+    class Subscription < Pay::Subscription
+      STATUS_FROM_EVENT = {
+        "subscription.completed" => "active",
+        "subscription.renewed" => "active",
+        "subscription.cancelled" => "canceled"
+      }.freeze
+
+      def self.sync(processor_id, event: nil)
+        return if processor_id.blank?
+
+        subscription = Pay::Abacatepay::Subscription.find_by(processor_id: processor_id)
+        customer = subscription&.customer
+        customer ||= Pay::Customer.find_by(processor: "abacatepay", processor_id: event&.customer_id) if event
+
+        if customer.nil?
+          Rails.logger.warn("[pay-abacatepay] cannot sync subscription #{processor_id}: Pay::Customer not found")
+          return
+        end
+
+        subscription ||= Pay::Abacatepay::Subscription.new(customer: customer, processor_id: processor_id)
+        assign_attributes_from(subscription, event) if event
+        subscription.save!
+        subscription
+      end
+
+      def self.assign_attributes_from(subscription, event)
+        status = STATUS_FROM_EVENT[event.type] || subscription.status || "active"
+        period_start = event.paid_at || event.subscription_created_at || Time.current
+        interval = event.interval
+
+        subscription.assign_attributes(
+          name: event.product_id || subscription.name || "default",
+          processor_plan: event.product_id || subscription.processor_plan || "default",
+          status: status,
+          current_period_start: period_start,
+          current_period_end: interval ? period_start + interval : subscription.current_period_end,
+          ends_at: (status == "canceled") ? (event.canceled_at || Time.current) : subscription.ends_at
+        )
+      end
+      private_class_method :assign_attributes_from
+
+      def cancel(**options)
+        Rails.logger.warn(
+          "[pay-abacatepay] AbacatePay does not support cancel-at-period-end; cancelling immediately"
+        )
+        cancel_now!(**options)
+      end
+
+      def cancel_now!(**_options)
+        ::AbacatePay.subscriptions.send(:request, "POST", "cancel", params: {id: processor_id})
+        update!(status: "canceled", ends_at: Time.current)
+      rescue ::AbacatePay::Error => e
+        raise Pay::Abacatepay::Error, e.message
+      end
+
+      def resume
+        raise NotImplementedError,
+          "AbacatePay does not support resuming cancelled subscriptions; create a new subscription"
+      end
+
+      def swap(_plan, **_options)
+        raise NotImplementedError,
+          "AbacatePay does not support plan swap; cancel the subscription and create a new one"
+      end
+
+      def change_quantity(_quantity, **_options)
+        raise NotImplementedError,
+          "AbacatePay does not support quantity changes"
+      end
+
+      # AbacatePay does not emit payment-failure events, so we cannot observe
+      # a past_due state. Always false.
+      def past_due?
+        false
+      end
+
+      def api_record
+        ::AbacatePay.subscriptions.send(:request, "GET", "get", params: {id: processor_id})
+      rescue ::AbacatePay::Error => e
+        raise Pay::Abacatepay::Error, e.message
+      end
+    end
+  end
+end
+
+ActiveSupport.run_load_hooks :pay_abacatepay_subscription, Pay::Abacatepay::Subscription

data/lib/pay/abacatepay/version.rb

@@ -0,0 +1,5 @@
+module Pay
+  module Abacatepay
+    VERSION = "0.1.0.pre.1"
+  end
+end

data/lib/pay/abacatepay/webhooks/checkout_completed.rb

@@ -0,0 +1,52 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class CheckoutCompleted
+        def call(event_hash)
+          event = Pay::Abacatepay::Webhooks::Event.new(event_hash)
+          result = Pay::Abacatepay::ProcessedWebhook.process!(event_type: event.type, event_id: event.id) do
+            handle(event)
+          end
+          log_already_processed(event) if result == :already_processed
+        end
+
+        private
+
+        def handle(event)
+          if event.checkout_frequency && event.checkout_frequency != "ONE_TIME"
+            Rails.logger.debug(
+              "[pay-abacatepay] checkout.completed for #{event.checkout_id} is a subscription payment " \
+              "(frequency=#{event.checkout_frequency}); skipping — subscription.renewed handles it"
+            )
+            return
+          end
+
+          customer = Pay::Customer.find_by(processor: "abacatepay", processor_id: event.customer_id)
+          if customer.nil?
+            Rails.logger.warn(
+              "[pay-abacatepay] checkout.completed for unknown customer #{event.customer_id}; " \
+              "Pay::Customer must be created via the app signup flow before the webhook arrives"
+            )
+            return
+          end
+
+          charge = Pay::Abacatepay::Charge.find_or_initialize_by(
+            customer: customer,
+            processor_id: event.checkout_id
+          )
+          charge.amount = event.checkout_paid_amount_cents || event.checkout_amount_cents
+          charge.currency ||= "BRL"
+          charge.application_fee_amount = event.checkout_platform_fee_cents
+          charge.status = "paid"
+          charge.checkout_url = event.checkout_url if event.checkout_url
+          charge.created_at = event.paid_at if charge.new_record? && event.paid_at
+          charge.save!
+        end
+
+        def log_already_processed(event)
+          Rails.logger.info("[pay-abacatepay] #{event.type} #{event.id} already processed")
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/checkout_disputed.rb

@@ -0,0 +1,11 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class CheckoutDisputed
+        # TODO: Fase 5 — dispute handling
+        def call(event)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/checkout_lost.rb

@@ -0,0 +1,11 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class CheckoutLost
+        # TODO: Fase 5 — lost dispute handling
+        def call(event)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/checkout_refunded.rb

@@ -0,0 +1,38 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class CheckoutRefunded
+        def call(event_hash)
+          event = Pay::Abacatepay::Webhooks::Event.new(event_hash)
+          result = Pay::Abacatepay::ProcessedWebhook.process!(event_type: event.type, event_id: event.id) do
+            handle(event)
+          end
+          log_already_processed(event) if result == :already_processed
+        end
+
+        private
+
+        def handle(event)
+          charge = Pay::Abacatepay::Charge.find_by(processor_id: event.checkout_id)
+          if charge.nil?
+            Rails.logger.warn(
+              "[pay-abacatepay] checkout.refunded for unknown checkout #{event.checkout_id}; " \
+              "no Pay::Abacatepay::Charge to update"
+            )
+            return
+          end
+
+          refund_amount = event.checkout_paid_amount_cents || charge.amount
+          charge.update!(
+            amount_refunded: refund_amount,
+            status: "refunded"
+          )
+        end
+
+        def log_already_processed(event)
+          Rails.logger.info("[pay-abacatepay] #{event.type} #{event.id} already processed")
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/event.rb

@@ -0,0 +1,95 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class Event
+        FREQUENCY_TO_INTERVAL = {
+          "WEEKLY" => 1.week,
+          "MONTHLY" => 1.month,
+          "SEMIANNUALLY" => 6.months,
+          "ANNUALLY" => 1.year
+        }.freeze
+
+        def initialize(raw)
+          @raw = raw.is_a?(Hash) ? raw : {}
+        end
+
+        attr_reader :raw
+
+        def id = @raw["id"]
+
+        def type = @raw["event"] || @raw["type"]
+
+        def data = @raw["data"] || {}
+
+        def api_version = @raw["apiVersion"]
+
+        def dev_mode? = @raw["devMode"] == true
+
+        def subscription_id = data.dig("subscription", "id")
+
+        def subscription_status = data.dig("subscription", "status")
+
+        def subscription_amount_cents = data.dig("subscription", "amount")
+
+        def subscription_currency = data.dig("subscription", "currency") || "BRL"
+
+        def frequency = data.dig("subscription", "frequency")
+
+        def subscription_created_at = parse_time(data.dig("subscription", "createdAt"))
+
+        def subscription_updated_at = parse_time(data.dig("subscription", "updatedAt"))
+
+        def canceled_at = parse_time(data.dig("subscription", "canceledAt"))
+
+        def customer_id = data.dig("customer", "id")
+
+        def customer_email = data.dig("customer", "email")
+
+        def customer_name = data.dig("customer", "name")
+
+        def customer_tax_id = data.dig("customer", "taxId")
+
+        def charge_id = data.dig("payment", "id")
+
+        def charge_amount_cents = data.dig("payment", "amount")
+
+        def paid_amount_cents = data.dig("payment", "paidAmount")
+
+        def platform_fee_cents = data.dig("payment", "platformFee")
+
+        def charge_status = data.dig("payment", "status")
+
+        def paid_at = parse_time(data.dig("payment", "updatedAt"))
+
+        def checkout_id = data.dig("checkout", "id")
+
+        def checkout_frequency = data.dig("checkout", "frequency")
+
+        def checkout_status = data.dig("checkout", "status")
+
+        def checkout_url = data.dig("checkout", "url")
+
+        def checkout_amount_cents = data.dig("checkout", "amount")
+
+        def checkout_paid_amount_cents = data.dig("checkout", "paidAmount")
+
+        def checkout_platform_fee_cents = data.dig("checkout", "platformFee")
+
+        def checkout_methods = data.dig("checkout", "methods")
+
+        def product_id = data.dig("checkout", "items", 0, "id")
+
+        def interval
+          FREQUENCY_TO_INTERVAL[frequency]
+        end
+
+        private
+
+        def parse_time(value)
+          return nil if value.nil? || value.to_s.empty?
+          Time.zone ? Time.zone.parse(value.to_s) : Time.parse(value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/payout_completed.rb

@@ -0,0 +1,11 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class PayoutCompleted
+        # TODO: later — payout tracking (not tied to Pay::Charge/Subscription)
+        def call(event)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/payout_failed.rb

@@ -0,0 +1,11 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class PayoutFailed
+        # TODO: later — payout tracking (not tied to Pay::Charge/Subscription)
+        def call(event)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/subscription_cancelled.rb

@@ -0,0 +1,34 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class SubscriptionCancelled
+        def call(event_hash)
+          event = Pay::Abacatepay::Webhooks::Event.new(event_hash)
+          result = Pay::Abacatepay::ProcessedWebhook.process!(event_type: event.type, event_id: event.id) do
+            handle(event)
+          end
+          log_already_processed(event) if result == :already_processed
+        end
+
+        private
+
+        def handle(event)
+          subscription = Pay::Abacatepay::Subscription.find_by(processor_id: event.subscription_id)
+
+          if subscription.nil?
+            Rails.logger.warn(
+              "[pay-abacatepay] subscription.cancelled for unknown subscription #{event.subscription_id}; no-op"
+            )
+            return
+          end
+
+          subscription.update!(status: "canceled", ends_at: event.canceled_at || Time.current)
+        end
+
+        def log_already_processed(event)
+          Rails.logger.info("[pay-abacatepay] #{event.type} #{event.id} already processed")
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/subscription_completed.rb

@@ -0,0 +1,53 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class SubscriptionCompleted
+        def call(event_hash)
+          event = Pay::Abacatepay::Webhooks::Event.new(event_hash)
+          result = Pay::Abacatepay::ProcessedWebhook.process!(event_type: event.type, event_id: event.id) do
+            handle(event)
+          end
+          log_already_processed(event) if result == :already_processed
+        end
+
+        private
+
+        def handle(event)
+          customer = find_customer(event)
+          return if customer.nil?
+
+          subscription = Pay::Abacatepay::Subscription.sync(event.subscription_id, event: event)
+          create_initial_charge(customer, subscription, event) if subscription && event.charge_id
+        end
+
+        def find_customer(event)
+          return nil if event.customer_id.blank?
+
+          customer = Pay::Customer.find_by(processor: "abacatepay", processor_id: event.customer_id)
+          if customer.nil?
+            Rails.logger.warn(
+              "[pay-abacatepay] subscription.completed for unknown customer #{event.customer_id}; " \
+              "Pay::Customer must be created via the app signup flow before the webhook arrives"
+            )
+          end
+          customer
+        end
+
+        def create_initial_charge(customer, subscription, event)
+          Pay::Abacatepay::Charge.find_or_create_by!(customer: customer, processor_id: event.charge_id) do |charge|
+            charge.amount = event.paid_amount_cents || event.charge_amount_cents
+            charge.currency = event.subscription_currency
+            charge.application_fee_amount = event.platform_fee_cents
+            charge.subscription_id = subscription.id
+            charge.status = "paid"
+            charge.created_at = event.paid_at if event.paid_at
+          end
+        end
+
+        def log_already_processed(event)
+          Rails.logger.info("[pay-abacatepay] #{event.type} #{event.id} already processed")
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/subscription_renewed.rb

@@ -0,0 +1,45 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class SubscriptionRenewed
+        def call(event_hash)
+          event = Pay::Abacatepay::Webhooks::Event.new(event_hash)
+          result = Pay::Abacatepay::ProcessedWebhook.process!(event_type: event.type, event_id: event.id) do
+            handle(event)
+          end
+          log_already_processed(event) if result == :already_processed
+        end
+
+        private
+
+        def handle(event)
+          existing = Pay::Abacatepay::Subscription.find_by(processor_id: event.subscription_id)
+
+          if existing.nil?
+            Rails.logger.warn(
+              "[pay-abacatepay] subscription.renewed before subscription.completed for #{event.subscription_id}; " \
+              "creating subscription on-the-fly"
+            )
+          end
+
+          subscription = Pay::Abacatepay::Subscription.sync(event.subscription_id, event: event)
+          return if subscription.nil?
+          return if event.charge_id.blank?
+
+          Pay::Abacatepay::Charge.find_or_create_by!(customer: subscription.customer, processor_id: event.charge_id) do |charge|
+            charge.amount = event.paid_amount_cents || event.charge_amount_cents
+            charge.currency = event.subscription_currency
+            charge.application_fee_amount = event.platform_fee_cents
+            charge.subscription_id = subscription.id
+            charge.status = "paid"
+            charge.created_at = event.paid_at if event.paid_at
+          end
+        end
+
+        def log_already_processed(event)
+          Rails.logger.info("[pay-abacatepay] #{event.type} #{event.id} already processed")
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/subscription_trial_started.rb

@@ -0,0 +1,13 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class SubscriptionTrialStarted
+        def call(_event_hash)
+          raise NotImplementedError,
+            "subscription.trial_started is not listed in AbacatePay::Enums::Webhooks::EventTypes. " \
+            "Confirm the event exists in the AbacatePay API before enabling trial support."
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/transfer_completed.rb

@@ -0,0 +1,11 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class TransferCompleted
+        # TODO: later — transfer tracking (not tied to Pay::Charge/Subscription)
+        def call(event)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/transfer_failed.rb

@@ -0,0 +1,11 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class TransferFailed
+        # TODO: later — transfer tracking (not tied to Pay::Charge/Subscription)
+        def call(event)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/transparent_completed.rb

@@ -0,0 +1,11 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class TransparentCompleted
+        # TODO: Fase 4 — transparent checkout lifecycle (charge creation)
+        def call(event)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/transparent_disputed.rb

@@ -0,0 +1,11 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class TransparentDisputed
+        # TODO: Fase 5 — dispute handling
+        def call(event)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/transparent_lost.rb

@@ -0,0 +1,11 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class TransparentLost
+        # TODO: Fase 5 — lost dispute handling
+        def call(event)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks/transparent_refunded.rb

@@ -0,0 +1,11 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      class TransparentRefunded
+        # TODO: Fase 4 — transparent checkout refund
+        def call(event)
+        end
+      end
+    end
+  end
+end

data/lib/pay/abacatepay/webhooks.rb

@@ -0,0 +1,23 @@
+module Pay
+  module Abacatepay
+    module Webhooks
+      autoload :Event, "pay/abacatepay/webhooks/event"
+      autoload :CheckoutCompleted, "pay/abacatepay/webhooks/checkout_completed"
+      autoload :CheckoutRefunded, "pay/abacatepay/webhooks/checkout_refunded"
+      autoload :CheckoutDisputed, "pay/abacatepay/webhooks/checkout_disputed"
+      autoload :CheckoutLost, "pay/abacatepay/webhooks/checkout_lost"
+      autoload :TransparentCompleted, "pay/abacatepay/webhooks/transparent_completed"
+      autoload :TransparentRefunded, "pay/abacatepay/webhooks/transparent_refunded"
+      autoload :TransparentDisputed, "pay/abacatepay/webhooks/transparent_disputed"
+      autoload :TransparentLost, "pay/abacatepay/webhooks/transparent_lost"
+      autoload :SubscriptionCompleted, "pay/abacatepay/webhooks/subscription_completed"
+      autoload :SubscriptionCancelled, "pay/abacatepay/webhooks/subscription_cancelled"
+      autoload :SubscriptionRenewed, "pay/abacatepay/webhooks/subscription_renewed"
+      autoload :SubscriptionTrialStarted, "pay/abacatepay/webhooks/subscription_trial_started"
+      autoload :PayoutCompleted, "pay/abacatepay/webhooks/payout_completed"
+      autoload :PayoutFailed, "pay/abacatepay/webhooks/payout_failed"
+      autoload :TransferCompleted, "pay/abacatepay/webhooks/transfer_completed"
+      autoload :TransferFailed, "pay/abacatepay/webhooks/transfer_failed"
+    end
+  end
+end