Module: EffectiveOrders

Defined in:
lib/effective_orders.rb,
lib/effective_orders/engine.rb,
lib/effective_orders/version.rb,
lib/generators/effective_orders/install_generator.rb

Defined Under Namespace

Modules: Generators Classes: AlreadyPurchasedException, Engine, SoldOutException

Constant Summary collapse

PENDING =

New orders are created in a pending state

'pending'.freeze
CONFIRMED =

Once the order has passed checkout step 1

'confirmed'.freeze
DEFERRED =

Deferred providers. Cheque or Phone was selected.

'deferred'.freeze
PURCHASED =

Purchased by provider

'purchased'.freeze
DECLINED =

Declined by provider

'declined'.freeze
STATES = 
{ PENDING => PENDING, CONFIRMED => CONFIRMED, DEFERRED => DEFERRED, PURCHASED => PURCHASED, DECLINED => DECLINED }
ACTIVE =

Subscription statuses (as per stripe)

'active'.freeze
PAST_DUE = 
'past_due'.freeze
CANCELED = 
'canceled'.freeze
STATUSES = 
{ ACTIVE => ACTIVE, PAST_DUE => PAST_DUE, CANCELED => CANCELED }
VERSION = 
'4.4.2'.freeze

Class Method Summary collapse

Class Method Details

.authorize!(controller, action, resource) ⇒ Object

Raises:



85
86
87
 
# File 'lib/effective_orders.rb', line 85

def self.authorize!(controller, action, resource)
  raise Effective::AccessDenied.new('Access Denied', action, resource) unless authorized?(controller, action, resource)
end

.authorized?(controller, action, resource) ⇒ Boolean

Returns:

  • (Boolean) 


72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/effective_orders.rb', line 72

def self.authorized?(controller, action, resource)
  @_exceptions ||= [Effective::AccessDenied, (CanCan::AccessDenied if defined?(CanCan)), (Pundit::NotAuthorizedError if defined?(Pundit))].compact

  return !!authorization_method unless authorization_method.respond_to?(:call)
  controller = controller.controller if controller.respond_to?(:controller)

  begin
    !!(controller || self).instance_exec((controller || self), action, resource, &authorization_method)
  rescue *@_exceptions
    false
  end
end

.can_skip_checkout_step1? ⇒ Boolean

Returns:

  • (Boolean) 


171
172
173
174
175
176
177
 
# File 'lib/effective_orders.rb', line 171

def self.can_skip_checkout_step1?
  return false if require_billing_address
  return false if require_shipping_address
  return false if collect_note
  return false if terms_and_conditions
  true
end

.cheque? ⇒ Boolean

Returns:

  • (Boolean) 


98
99
100
 
# File 'lib/effective_orders.rb', line 98

def self.cheque?
  cheque.kind_of?(Hash)
end

.deferred? ⇒ Boolean

Returns:

  • (Boolean) 


106
107
108
 
# File 'lib/effective_orders.rb', line 106

def self.deferred?
  deferred_providers.present?
end

.deferred_providers ⇒ Object 



167
168
169
 
# File 'lib/effective_orders.rb', line 167

def self.deferred_providers
  [('cheque' if cheque?), ('phone' if phone?)].compact
end

.free? ⇒ Boolean

Returns:

  • (Boolean) 


102
103
104
 
# File 'lib/effective_orders.rb', line 102

def self.free?
  free_enabled == true
end

.mark_as_paid? ⇒ Boolean

Returns:

  • (Boolean) 


110
111
112
 
# File 'lib/effective_orders.rb', line 110

def self.mark_as_paid?
  mark_as_paid_enabled == true
end

.moneris? ⇒ Boolean

Returns:

  • (Boolean) 


114
115
116
 
# File 'lib/effective_orders.rb', line 114

def self.moneris?
  moneris.kind_of?(Hash)
end

.payment_providers ⇒ Object

The Effective::Order.payment_provider value must be in this collection



151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/effective_orders.rb', line 151

def self.payment_providers
  [
    ('cheque' if cheque?),
    ('credit card' if mark_as_paid?),
    ('free' if free?),
    ('moneris' if moneris?),
    ('paypal' if paypal?),
    ('phone' if phone?),
    ('pretend' if pretend?),
    ('refund' if refund?),
    ('stripe' if stripe?),
    ('other' if mark_as_paid?),
    'none'
  ].compact
end

.paypal? ⇒ Boolean

Returns:

  • (Boolean) 


118
119
120
 
# File 'lib/effective_orders.rb', line 118

def self.paypal?
  paypal.kind_of?(Hash)
end

.permitted_params ⇒ Object 



89
90
91
92
93
94
95
96
 
# File 'lib/effective_orders.rb', line 89

def self.permitted_params
  [
    :note, :terms_and_conditions, :confirmed_checkout,
    billing_address: EffectiveAddresses.permitted_params,
    shipping_address: EffectiveAddresses.permitted_params,
    subscripter: [:stripe_plan_id, :stripe_token]
  ]
end

.phone? ⇒ Boolean

Returns:

  • (Boolean) 


122
123
124
 
# File 'lib/effective_orders.rb', line 122

def self.phone?
  phone.kind_of?(Hash)
end

.pretend? ⇒ Boolean

Returns:

  • (Boolean) 


126
127
128
 
# File 'lib/effective_orders.rb', line 126

def self.pretend?
  pretend_enabled == true
end

.refund? ⇒ Boolean

Returns:

  • (Boolean) 


130
131
132
 
# File 'lib/effective_orders.rb', line 130

def self.refund?
  refund.kind_of?(Hash)
end

.setup {|_self| ... } ⇒ Object

Yields:

  • (_self)

Yield Parameters:



68
69
70
 
# File 'lib/effective_orders.rb', line 68

def self.setup
  yield self
end

.single_payment_processor? ⇒ Boolean

Returns:

  • (Boolean) 


146
147
148
 
# File 'lib/effective_orders.rb', line 146

def self.single_payment_processor?
  [moneris?, paypal?, stripe?].select { |enabled| enabled }.length == 1
end

.stripe? ⇒ Boolean

Returns:

  • (Boolean) 


134
135
136
 
# File 'lib/effective_orders.rb', line 134

def self.stripe?
  stripe.kind_of?(Hash)
end

.stripe_plans ⇒ Object 



179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/effective_orders.rb', line 179

def self.stripe_plans
  return [] unless (stripe? && subscriptions?)

  @stripe_plans ||= (
    Rails.logger.info '[STRIPE] index plans'

    plans = begin
      Stripe::Plan.all
    rescue => e
      raise e if Rails.env.production?
      Rails.logger.info "[STRIPE ERROR]: #{e.message}"
      Rails.logger.info "[STRIPE ERROR]: effective_orders continuing with empty stripe plans. This would fail loudly in Rails.env.production."
      []
    end

    plans = plans.map do |plan|
      {
        id: plan.id,
        product_id: plan.product,
        name: plan.nickname,
        amount: plan.amount,
        currency: plan.currency,
        description: ("$#{'%0.2f' % (plan.amount / 100.0)}" + ' ' + plan.currency.upcase + '/' +  plan.interval.to_s),
        interval: plan.interval,
        interval_count: plan.interval_count
      }
    end.sort do |x, y|
      val ||= (x[:interval] <=> y[:interval])
      val = nil if val == 0

      val ||= (x[:amount] <=> y[:amount])
      val = nil if val == 0

      val ||= (x[:name] <=> y[:name])
      val = nil if val == 0

      val || (x[:id] <=> y[:id])
    end

    # Calculate savings for any yearly per user plans, based on their matching monthly plans
    plans.select { |plan| plan[:interval] == 'year' }.each do |yearly|
      monthly_name = yearly[:name].downcase.gsub('year', 'month')
      monthly = plans.find { |plan| plan[:interval] == 'month' && plan[:name].downcase == monthly_name }
      next unless monthly

      savings = (monthly[:amount].to_i * 12) - yearly[:amount].to_i
      next unless savings > 0

      yearly[:savings] = savings
    end

    plans
  )
end

.stripe_plans_collection ⇒ Object 



234
235
236
 
# File 'lib/effective_orders.rb', line 234

def self.stripe_plans_collection
  stripe_plans.map { |plan| [plan[:name], plan[:id]] }
end

.subscriptions? ⇒ Boolean

Returns:

  • (Boolean) 


138
139
140
 
# File 'lib/effective_orders.rb', line 138

def self.subscriptions?
  subscriptions.kind_of?(Hash)
end

.trial? ⇒ Boolean

Returns:

  • (Boolean) 


142
143
144
 
# File 'lib/effective_orders.rb', line 142

def self.trial?
  trial.kind_of?(Hash)
end