Class: Caboose::Subscription

Inherits:
ActiveRecord::Base
  • Object
show all
Defined in:
app/models/caboose/subscription.rb

Constant Summary collapse

STATUS_ACTIVE = 
'active'
STATUS_INACTIVE = 
'inactive'

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.create_invoices ⇒ Object

Static methods



135
136
137
138
139
 
# File 'app/models/caboose/subscription.rb', line 135

def Subscription.create_invoices
  Subscription.where(:status => Subscription::STATUS_ACTIVE).all.each do |s|
    s.create_invoices
  end
end

Instance Method Details

#calculate_date_started_full ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'app/models/caboose/subscription.rb', line 20

def calculate_date_started_full
  
  v = self.variant
  if !v.subscription_start_on_day
    self.date_started_full = self.date_started
    self.save
  end
        
  d = nil
  if v.subscription_interval == Variant::SUBSCRIPTION_INTERVAL_YEARLY        
    d = Date.new(self.date_started.year, v.subscription_start_month, v.subscription_start_day)
    d = d + 1.year if d < self.date_started        
  elsif v.subscription_interval == Variant::SUBSCRIPTION_INTERVAL_MONTHLY        
    d = Date.new(self.date_started.year, v.subscription_start_month, v.subscription_start_day)
    d = d + 1.month if d < self.date_started                
  end
  self.date_started_full = d
  self.save
  
end

#create_invoices ⇒ Object

Verify invoices exist for the entire subscription period up until today



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'app/models/caboose/subscription.rb', line 46

def create_invoices
  
  self.calculate_date_started_full if self.date_started_full.nil?
  
  v  = self.variant
  interval = case v.subscription_interval
    when Variant::SUBSCRIPTION_INTERVAL_MONTHLY then 1.month
    when Variant::SUBSCRIPTION_INTERVAL_YEARLY  then 1.year
  end      
  sc = v.product.site.store_config      
  unit_price = v.clearance && v.clearance_price ? v.clearance_price : (v.on_sale? ? v.sale_price : v.price)
  
  # Special case if the subscription starts on specific day
  if v.subscription_start_on_day && (Date.today > self.date_started_full)
    li = self.line_items.where("date_starts = ? date_ends = ?", self.date_started, self.date_started_full - 1.day).first
    if li.nil?
      prorated_unit_price = unit_price + 0.00          
      if v.subscription_prorate             
        prorated_unit_price = case v.subscription_prorate_method
          when Variant::SUBSCRIPTION_PRORATE_METHOD_FLAT       then v.subscription_prorate_flat_amount
          when Variant::SUBSCRIPTION_PRORATE_METHOD_PERCENTAGE then unit_price * ((self.date_started_full - self.date_started).to_f / ((self.date_started_full + interval) - self.date_started_full).to_f)
          when Variant::SUBSCRIPTION_PRORATE_METHOD_CUSTOM     then self.custom_prorate                                            
        end
      end
      invoice = Caboose::Invoice.create(        
        :site_id          => v.product.site_id,
        :status           => Caboose::Invoice::STATUS_PENDING,
        :financial_status => Caboose::Invoice::STATUS_PENDING,
        :date_created     => DateTime.now,                                    
        :payment_terms    => sc.default_payment_terms,
        :invoice_number   => sc.next_invoice_number
      )          
      LineItem.create(
        :invoice_id       => invoice.id,
        :variant_id       => v.id,
        :quantity         => 1,
        :unit_price       => prorated_unit_price,
        :subtotal         => prorated_unit_price,
        :status           => 'pending',
        :subscription_id  => self.id,            
        :date_starts      => d,
        :date_ends        => d + interval - 1.day
      )
      invoice.calculate
      invoice.save                    
    end
  end        

  d2 = self.date_started_full + 1.day - 1.day
  while d2 <= Date.today do
    d2 = d2 + interval
  end
  d  = self.date_started + 1.day - 1.day
  while d <= d2 do
    # See if an invoice has already been created for today      
    li = self.line_items.where("date_starts = ? AND date_ends = ?", d, d + interval - 1.day).first
    if li.nil?
      invoice = Caboose::Invoice.create(        
        :site_id          => v.product.site_id,
        :customer_id      => self.user_id,
        :status           => Caboose::Invoice::STATUS_PENDING,
        :financial_status => Caboose::Invoice::STATUS_PENDING,
        :date_created     => DateTime.now,                                    
        :payment_terms    => sc.default_payment_terms,
        :invoice_number   => sc.next_invoice_number
      )          
      LineItem.create(
        :invoice_id       => invoice.id,
        :variant_id       => v.id,
        :quantity         => 1,
        :unit_price       => unit_price,
        :subtotal         => unit_price,
        :status           => 'pending',
        :subscription_id  => self.id,            
        :date_starts      => d,
        :date_ends        => d + interval - 1.day
      )
      invoice.calculate
      invoice.save                    
    end
    d = d + interval
  end        
  return true      
end

#custom_prorate ⇒ Object 



41
42
43
 
# File 'app/models/caboose/subscription.rb', line 41

def custom_prorate          
  return eval(self.variant.subscription_prorate_function)    
end