Class: Pay::PaddleClassic::Subscription

Inherits:
Subscription show all
Defined in:
app/models/pay/paddle_classic/subscription.rb

Constant Summary

Constants inherited from Subscription

Subscription::STATUSES

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Subscription

#active?, #canceled?, #cancelled?, #ended?, find_by_processor_and_id, #generic_trial?, #has_incomplete_payment?, #has_trial?, #incomplete?, #no_prorate, #on_trial?, #past_due?, #skip_trial, #swap_and_invoice, #sync!, #trial_ended?, #unpaid?

Class Method Details

.sync(subscription_id, object: nil, name: Pay.default_product_name) ⇒ Object

[View source]

4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 4

def self.sync(subscription_id, object: nil, name: Pay.default_product_name)
  # Passthrough is not return from this API, so we can't use that
  object ||= PaddleClassic.client.users.list(subscription_id: subscription_id).data.try(:first)

  pay_customer = Pay::Customer.find_by(processor: :paddle_classic, processor_id: object.user_id)

  # If passthrough exists (only on webhooks) we can use it to create the Pay::Customer
  if pay_customer.nil? && object.passthrough
    owner = Pay::PaddleClassic.owner_from_passthrough(object.passthrough)
    pay_customer = owner&.set_payment_processor(:paddle_classic, processor_id: object.user_id)
  end

  return unless pay_customer

  attributes = {
    paddle_cancel_url: object.cancel_url,
    paddle_update_url: object.update_url,
    processor_plan: object.plan_id || object.subscription_plan_id,
    quantity: object.quantity || 1,
    status: object.state || object.status
  }

  case attributes[:status]
  when "trialing"
    attributes[:trial_ends_at] = Time.zone.parse(object.next_bill_date)
    attributes[:ends_at] = nil
  when "active", "past_due"
    attributes[:trial_ends_at] = nil
    attributes[:ends_at] = nil
  when "paused", "deleted"
    # If paused or delete while on trial, set ends_at to match
    attributes[:trial_ends_at] = nil
    attributes[:ends_at] = Time.zone.parse(object.next_bill_date)
  end

  # Update or create the subscription
  if (pay_subscription = pay_customer.subscriptions.find_by(processor_id: object.subscription_id))
    pay_subscription.with_lock do
      pay_subscription.update!(attributes)
    end
    pay_subscription
  else
    pay_customer.subscriptions.create!(attributes.merge(name: name, processor_id: object.subscription_id))
  end
end

Instance Method Details

#api_record(**options) ⇒ Object

[View source]

50
51
52
53
54
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 50

def api_record(**options)
  PaddleClassic.client.users.list(subscription_id: processor_id).data.try(:first)
rescue ::Paddle::Error => e
  raise Pay::PaddleClassic::Error, e
end

#cancel(**options) ⇒ Object

Paddle subscriptions are canceled immediately, however we still want to give the user access to the end of the period they paid for

[View source]

57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 57

def cancel(**options)
  return if canceled?

  ends_at = if on_trial?
    trial_ends_at
  elsif paused?
    pause_starts_at
  else
    Time.parse(api_record.next_payment.date)
  end

  PaddleClassic.client.users.cancel(subscription_id: processor_id)
  update(
    status: (ends_at.future? ? :active : :canceled),
    ends_at: ends_at
  )

  # Remove payment methods since customer cannot be reused after cancelling
  Pay::PaymentMethod.where(customer_id: customer_id).destroy_all
rescue ::Paddle::Error => e
  raise Pay::PaddleClassic::Error, e
end

#cancel_now!(**options) ⇒ Object

[View source]

80
81
82
83
84
85
86
87
88
89
90
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 80

def cancel_now!(**options)
  return if canceled?

  PaddleClassic.client.users.cancel(subscription_id: processor_id)
  update(status: :canceled, ends_at: Time.current)

  # Remove payment methods since customer cannot be reused after cancelling
  Pay::PaymentMethod.where(customer_id: customer_id).destroy_all
rescue ::Paddle::Error => e
  raise Pay::PaddleClassic::Error, e
end

#change_quantity(quantity, **options) ⇒ Object

Raises:

  • (NotImplementedError)
[View source]

92
93
94
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 92

def change_quantity(quantity, **options)
  raise NotImplementedError, "Paddle does not support setting quantity on subscriptions"
end

#on_grace_period? ⇒ Boolean

A subscription could be set to cancel or pause in the future It is considered on grace period until the cancel or pause time begins

Returns:

  • (Boolean)
[View source]

98
99
100
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 98

def on_grace_period?
  (canceled? && Time.current < ends_at) || (paused? && pause_starts_at? && Time.current < pause_starts_at)
end

#pause ⇒ Object

[View source]

106
107
108
109
110
111
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 106

def pause
  response = PaddleClassic.client.users.pause(subscription_id: processor_id)
  update(status: :paused, pause_starts_at: Time.zone.parse(response.dig(:next_payment, :date)))
rescue ::Paddle::Error => e
  raise Pay::PaddleClassic::Error, e
end

#paused? ⇒ Boolean

Returns:

  • (Boolean)
[View source]

102
103
104
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 102

def paused?
  status == "paused"
end

#resumable? ⇒ Boolean

Returns:

  • (Boolean)
[View source]

113
114
115
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 113

def resumable?
  paused?
end

#resume ⇒ Object

[View source]

117
118
119
120
121
122
123
124
125
126
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 117

def resume
  unless resumable?
    raise Error, "You can only resume paused subscriptions."
  end

  PaddleClassic.client.users.unpause(subscription_id: processor_id)
  update(ends_at: nil, status: :active, pause_starts_at: nil)
rescue ::Paddle::Error => e
  raise Pay::PaddleClassic::Error, e
end

#retry_failed_payment ⇒ Object

Retries the latest invoice for a Past Due subscription

[View source]

141
142
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 141

def retry_failed_payment
end

#swap(plan, **options) ⇒ Object

[View source]

128
129
130
131
132
133
134
135
136
137
138
 
# File 'app/models/pay/paddle_classic/subscription.rb', line 128

def swap(plan, **options)
  raise ArgumentError, "plan must be a string" unless plan.is_a?(String)

  attributes = {plan_id: plan, prorate: prorate}
  attributes[:quantity] = quantity if quantity?
  PaddleClassic.client.users.update(subscription_id: processor_id, **attributes)

  update(processor_plan: plan, ends_at: nil, status: :active)
rescue ::Paddle::Error => e
  raise Pay::PaddleClassic::Error, e
end