billingly 0.1.1 → 0.1.4

data/README.md

@@ -1,5 +1,7 @@
 # Billingly
 
+![Travis Build Status](https://secure.travis-ci.org/nubis/billingly.png)
+
 Billingly is a rails 3 engine that manages paid subscriptions and free trials to your web application. 
 
 Billingly can:

data/app/mailers/{billingly_mailer.rb → billingly/base_mailer.rb}

@@ -1,5 +1,8 @@
-class BillinglyMailer < ActionMailer::Base
+class Billingly::BaseMailer < ActionMailer::Base
   default from: 'example@example.com'
+  
+  cattr_accessor :admin_emails
+  self.admin_emails = 'admin@example.com'
 
   def pending_notification(invoice)
     @invoice = invoice
@@ -17,4 +20,16 @@ class BillinglyMailer < ActionMailer::Base
     @invoice = invoice
     mail(to: invoice.customer.email, subject: I18n.t('billingly.payment_receipt'))
   end
+  
+  def task_results(runner)
+    @runner = runner
+    mail to: self.class.admin_emails, subject: "Your Billingly Status Report"
+  end
+  
+  # Sends the email about an expired trial.
+  # param trial [Subscription] a trial which should be expired.
+  def trial_expired_notification(subscription)
+    @subscription = subscription
+    mail to: subscription.customer.email, subject: I18n.t('billingly.your_trial_has_expired')
+  end
 end

data/app/mailers/billingly/mailer.rb

@@ -0,0 +1,3 @@
+# (see Billingly::BaseMailer)
+class Billingly::Mailer < Billingly::BaseMailer
+end

data/app/models/billingly/base_customer.rb

@@ -21,7 +21,7 @@ module Billingly
     # we won't try to reactivate their account when we receive a payment from them.
     # The message shown to them when they reactivate will also be different depending on
     # how they left.
-    DEACTIVATION_REASONS = [:trial_expired, :debtor, :left_voluntarily]
+    DEACTIVATION_REASONS = %w(trial_expired debtor left_voluntarily)
 
     # The Date and Time in which the Customer's account was deactivated (see {#deactivated?}).
     # This field denormalizes the date in which this customer's last subscription was ended.
@@ -101,7 +101,7 @@ module Billingly
     # @return [Integer] 
     def trial_days_left
       return unless doing_trial?
-      (active_subscription.is_trial_expiring_on.to_date - Date.today).to_i
+      (active_subscription.is_trial_expiring_on.to_date - Time.now.utc.to_date).to_i
     end
     
     # Customers subscribe to the service under certain conditions referred to as a {Plan},
@@ -115,7 +115,7 @@ module Billingly
     # @param [Plan, Subscription] 
     # @return [Subscription] The newly created {Subscription}
     def subscribe_to_plan(plan, is_trial_expiring_on = nil) 
-      subscriptions.last.terminate if subscriptions.last
+      subscriptions.last.terminate_changed_subscription if subscriptions.last
 
       subscriptions.build.tap do |new|
         [:payable_upfront, :description, :periodicity,
@@ -173,12 +173,6 @@ module Billingly
       end
     end
     
-    # This method will deactivate all customers who have overdue {Invoice Invoices}.
-    # It's run periodically through Billingly's Rake Task.
-    def self.deactivate_all_debtors
-      debtors.where(deactivated_since: nil).all.each{|debtor| debtor.deactivate_debtor }
-    end
-    
     # A customer who has overdue invoices at the time of asking this question is
     # considered a debtor.
     #
@@ -210,8 +204,8 @@ module Billingly
     # @param amount [BigDecimal, float] the amount to be credited.
     def credit_payment(amount)
       Billingly::Payment.credit_for(self, amount)
-      Billingly::Invoice.charge_all(self.invoices)
-      reactivate if deactivated? && deactivation_reason == :debtor
+      charge_pending_invoices
+      reactivate if deactivated? && deactivation_reason == 'debtor'
     end
     
     # Terminate a customer's subscription to the service.
@@ -226,10 +220,10 @@ module Billingly
     # @return [self, nil] nil if the account was already deactivated, self otherwise.
     def deactivate(reason)
       return if deactivated?
-      active_subscription.terminate
+      active_subscription.terminate(reason)
       self.deactivated_since = Time.now
       self.deactivation_reason = reason
-      self.save!
+      save!
       return self
     end
     
@@ -241,17 +235,17 @@ module Billingly
 
     # @see #deactivate
     def deactivate_left_voluntarily
-      deactivate(:left_voluntarily)
+      deactivate('left_voluntarily')
     end
     
     # @see #deactivate
     def deactivate_trial_expired
-      deactivate(:trial_expired)
+      deactivate('trial_expired')
     end
 
     # @see #deactivate
     def deactivate_debtor
-      deactivate(:debtor)
+      deactivate('debtor')
     end
 
     # Customers whose account has been {#deactivate deactivated} can always re-join the service
@@ -266,25 +260,18 @@ module Billingly
       subscribe_to_plan(new_plan)
       return self
     end
-
-    # Customers may be subscribed for a trial period, and they are supposed to re-subscribe
-    # before their trial expires.
-    #
-    # When their trial expires and they have not yet subscribed to another plan, we
-    # deactivate their account immediately.
+    
+    # Charges all invoices for which the customer has enough balance.
+    # Oldest invoices are charged first, newer invoices should not be charged until
+    # the oldest ones are paid.
     #
-    # This method will deactivate all customers whose trial has expired.
-    # It's run periodically through Billingly's Rake Task.
-    def self.deactivate_all_expired_trials
-       customers = joins(:subscriptions).readonly(false)
-        .where("#{Billingly::Subscription.table_name}.is_trial_expiring_on < ?", Time.now)
-        .where(billingly_subscriptions: {unsubscribed_on: nil})
-        
-      customers.each do |customer|
-        customer.deactivate_trial_expired
-      end
+    # See {Billingly::Invoice#charge Invoice#charge} for more information
+    # on how invoices are charged from the customer's balance.
+    def charge_pending_invoices
+      invoices.where(deleted_on: nil, paid_on: nil).order('period_start')
+        .each{|invoice| break unless invoice.charge}
     end
-
+    
     # Can this customer subscribe to a plan?.
     # You may want to prevent customers from upgrading or downgrading to other plans
     # depending on their usage of your service.

data/app/models/billingly/base_subscription.rb

@@ -25,7 +25,38 @@ module Billingly
     # @property subscribed_on
     # @return [DateTime]
     validates :subscribed_on, presence: true
+    
+    # Subscriptions are terminated for a reason which could be:
+    #   * trial_expired: Subscription was a trial and it just expired.
+    #   * debtor: The customer owed an invoice for this subscription and did not pay.
+    #   * changed_subscription: This subscription was immediately replaced by another one.
+    #   * left_voluntarily: This subscription was terminated because the customer left.
+    #
+    # TERMINATION_REASONS are important for auditing and for the mailing tasks to notify
+    # about subscriptions terminated automatically by the system.
+    TERMINATION_REASONS = %w(trial_expired debtor changed_subscription left_voluntarily)
+
+    # The date in which this subscription ended.
+    #
+    # Every ended subscription ended for a reason, look at {TERMINATION_REASONS}.
+    # @property unsubscribed_on
+    # @return [DateTime]
+    validates :unsubscribed_on, presence: true, if: :unsubscribed_because
 
+    # The reason why this subscription ended.
+    #
+    # Every ended subscription ended for a reason, look at {TERMINATION_REASONS}.
+    # @property unsubscribed_because
+    # @return [DateTime]
+    validates :unsubscribed_because, inclusion: TERMINATION_REASONS, if: :terminated?
+
+    # Was this subscription terminated?
+    # @property [r] terminated?
+    # @return [Boolean] Whether the subscription was terminated or not.
+    def terminated?
+      not unsubscribed_on.nil?
+    end
+    
     # The grace period we use when calculating an invoices due date.
     # If a subscription is payable_upfront, then the customer effectively owes us
     # since the day in which a given period starts.
@@ -58,7 +89,7 @@ module Billingly
     belongs_to :plan
     
     # (see #is_trial_expiring_on)
-    # @property trial?
+    # @property [r] trial?
     # @return [Boolean]
     def trial?
       not is_trial_expiring_on.nil?
@@ -95,24 +126,38 @@ module Billingly
     
     # Terminates this subscription, it could be either because we deactivate a debtor
     # or because the customer decided to end his subscription on his own terms.
-    def terminate
+    #
+    # Use the shortcuts:
+    #   {#terminate_left_voluntarily}, {#terminate_trial_expired},
+    #   {#terminate_debtor}, {#terminate_changed_subscription}
+    # 
+    # Once terminated, a subscription cannot be re-open, just create a new one.
+    # @param reason [Symbol] the reason to terminate this subscription, see {TERMINATION_REASONS}
+    # @return [self, nil] nil if the account was already terminated, self otherwise.
+    def terminate(reason)
       return if terminated?
-      update_attribute(:unsubscribed_on, Time.now)
+      self.unsubscribed_on = Time.now
+      self.unsubscribed_because = reason
       invoices.last.truncate unless trial?
+      save!
       return self
     end
-    
-    def terminated?
-      not unsubscribed_on.nil?
+
+    TERMINATION_REASONS.each do |reason|
+      define_method("terminate_#{reason}") do
+        terminate(reason)
+      end
     end
     
-    # This class method is called from a cron job, it creates invoices for all the subscriptions
-    # that still need their invoice created.
-    # TODO: This goes through all the active subscriptions, make it smarter so that the batch job runs quicker.
-    def self.generate_next_invoices
-      where(is_trial_expiring_on: nil, unsubscribed_on: nil).each do |subscription|
-        subscription.generate_next_invoice
-      end
+    # When a trial subscription ends the customer is notified about it via email.
+    # @return [self, nil] not nil means the notification was sent successfully.
+    def notify_trial_expired
+      return unless trial?
+      return unless terminated? && unsubscribed_because == 'trial_expired'
+      return unless notified_trial_expired_on.nil?
+      Billingly::Mailer.trial_expired_notification(self).deliver!
+      update_attribute(:notified_trial_expired_on, Time.now)
+      return self
     end
   end
 end

data/app/models/billingly/invoice.rb

@@ -55,64 +55,29 @@ module Billingly
       return self
     end
 
-    # Charges all invoices that can be charged from the existing customer cash balances
-    def self.charge_all(collection = self)
-      collection.where(deleted_on: nil, paid_on: nil).order('period_start').each do |invoice|
-        invoice.charge
-      end
-    end
-    
-    # This method is called by Billingly's recurring task to notify all pending invoices.
-    def self.notify_all_pending
-      where(deleted_on: nil, paid_on: nil, notified_pending_on: nil)
-        .each do |invoice|
-          invoice.notify_pending
-        end
-    end
-
     def notify_pending
       return unless notified_pending_on.nil?
       return if paid?
       return if deleted?
       return if due_on > subscription.grace_period.from_now
-      BillinglyMailer.pending_notification(self).deliver!
+      Billingly::Mailer.pending_notification(self).deliver!
       update_attribute(:notified_pending_on, Time.now)
     end
 
-    # Send the email notifying that this invoice being overdue and the subscription
-    # being cancelled
-    def self.notify_all_overdue
-      where('due_on <= ?', Time.now)
-        .where(deleted_on: nil, paid_on: nil, notified_overdue_on: nil)
-        .each do |invoice|
-          invoice.notify_overdue
-        end
-    end
-
     def notify_overdue
       return unless notified_overdue_on.nil?
       return if paid?
       return if deleted?
       return if due_on > Time.now
-      BillinglyMailer.overdue_notification(self).deliver!
+      Billingly::Mailer.overdue_notification(self).deliver!
       update_attribute(:notified_overdue_on, Time.now)
     end
 
-    # Notifies that the invoice has been charged successfully.
-    # Send the email notifying that this invoice being overdue and the subscription
-    # being cancelled
-    def self.notify_all_paid
-      where('paid_on is not null')
-        .where(deleted_on: nil, notified_paid_on: nil).each do |invoice|
-          invoice.notify_paid
-        end
-    end
-
     def notify_paid
       return unless paid?
       return unless notified_paid_on.nil?
       return if deleted?
-      BillinglyMailer.paid_notification(self).deliver!
+      Billingly::Mailer.paid_notification(self).deliver!
       update_attribute(:notified_paid_on, Time.now)
     end
   end

data/app/models/billingly/tasks.rb

@@ -0,0 +1,200 @@
+# The Tasks model has all the tasks that should be run periodically through rake.
+# A special log is created for the tasks being run and the results are reported
+# back to the website administrator.
+class Billingly::Tasks
+  # The date in which the tasks started running.
+  # @!attribute started
+  # @return [DateTime] 
+  attr_accessor :started
+
+  # The date in which the tasks ended
+  # @!attribute ended
+  # @return [DateTime] 
+  attr_accessor :ended
+
+  # A summary of all the tasks that were run and their overall results.
+  # @!attribute summary
+  # @return [String]
+  attr_accessor :summary
+
+  # A detailed description of errors that ocurred while running all the tasks.
+  #
+  # @!attribute extended
+  # @return [File]
+  attr_accessor :extended
+
+  # Runs all of Billingly's periodic tasks and creates a report with the results at the end.
+  def run_all
+    self.started = Time.now
+
+    generate_next_invoices
+    charge_invoices
+    deactivate_all_debtors
+    deactivate_all_expired_trials
+    notify_all_paid
+    notify_all_pending
+    notify_all_overdue
+
+    self.ended = Time.now
+    self.extended.close unless self.extended.nil?
+    Billingly::Mailer.task_results(self).deliver
+  end
+  
+  # Writes a line to the {#extended} section of this tasks results report.
+  # @param text [String]
+  def log_extended(text)
+    if self.extended.nil?
+      time = Time.now.utc.strftime("%Y%m%d%H%M%S")
+      self.extended = File.open("#{Rails.root}/log/billingly_#{time}.log", 'w')
+    end
+    self.extended.write("#{text}\n\n")
+  end
+  
+  # Writes a line to the {#summary} section of this task results report.
+  # @param text [String]
+  def log_summary(text)
+    self.summary ||= ''
+    self.summary += "#{text}\n"
+  end
+  
+  # The batch runner is a helper function for running a method on each item of a
+  # collection logging the results, without aborting excecution if calling the rest of the
+  # items if any of them fails.
+  # 
+  # The method called on each item will not receive parameters and should return
+  # a Truthy value if successfull, or raise an exception otherwise.
+  # Returning nil means that there was nothing to be done on that item.
+  #
+  # The collection to be used should be returned by a block provided to this method.
+  # Any problem fetching the collection will also be universally captured
+  #
+  # See {#generate_next_invoices} for an example use.
+  #
+  # @param task_name [String] the name to use for this task in the generated log.
+  # @param method [Symbol] the method to call on each one of the given items.
+  # @param collection_getter [Proc] a block which should return the collection to use.
+  def batch_runner(task_name, method, &collection_getter)
+    collection = begin
+      collection_getter.call
+    rescue Exception => e
+      failure += 1
+      log_extended("#{task_name}:\nCollection getter failed\n#{e.message}\n\n#{e.backtrace}")
+      return
+    end
+
+    success = 0
+    failure = 0
+
+    collection.each do |item|
+      begin
+        success += 1 if item.send(method)
+      rescue Exception => e
+        failure += 1
+        log_extended("#{task_name}:\n#{e.message}\n#{item.inspect}\n\n#{e.backtrace}")
+      end
+    end
+
+    if failure == 0
+      log_summary("Success: #{task_name}, #{success} OK.")
+    else
+      log_summary("Failure: #{task_name}, #{success} OK, #{failure} failed.")
+    end
+  end
+  
+  # Invoices for running subscriptions which are not trials are generated by this task.
+  # See {Billingly::Subscription#generate_next_invoice} for more information about
+  # how the next invoice for a subscription is created.
+  def generate_next_invoices
+    batch_runner('Generating Invoices', :generate_next_invoice) do
+      Billingly::Subscription
+        .where(is_trial_expiring_on: nil, unsubscribed_on: nil)
+        .readonly(false)
+    end
+  end
+
+  # Charges all invoices for which the customer has enough balance.
+  # Oldest invoices are charged first, newer invoices should not be charged until
+  # the oldest ones are paid.
+  # See {Billingly::Invoice#charge Invoice#Charge} for more information on
+  # how invoices are charged from the customer's balance.
+  # @param collection [Array<Invoice>] The list of invoices to attempt charging.
+  #   Defaults to all invoices in the system.
+  def charge_invoices
+    batch_runner('Charging pending invoices', :charge_pending_invoices) do
+      Billingly::Customer
+        .joins(:invoices)
+        .where(billingly_invoices: {deleted_on: nil, paid_on: nil})
+        .readonly(false)
+    end
+  end
+
+  # Notifies invoices that have been charged successfully, sending a receipt.
+  # See {Billingly::Invoice#notify_paid Invoice#notify_paid} for more information on
+  # how receipts are sent for paid invoices.
+  def notify_all_paid
+    batch_runner('Notifying Paid Invoices', :notify_paid) do
+      Billingly::Invoice
+        .where('paid_on is not null')
+        .where(deleted_on: nil, notified_paid_on: nil)
+        .readonly(false)
+    end
+  end
+  
+  # Customers are notified about their pending invoices by this task.
+  # See {Billingly::Invoice#notify_pending Invoice#notify_pending} for more info
+  # on how pending invoices are notified.
+  def notify_all_pending
+    batch_runner('Notifying Pending Invoices', :notify_pending) do
+      Billingly::Invoice
+        .where(deleted_on: nil, paid_on: nil, notified_pending_on: nil)
+        .readonly(false)
+    end
+  end
+
+  # This task notifies customers when one of their invoices is overdue.
+  # Overdue invoices go together with account deactivations so the email sent
+  # by this task also includes the deactivation notice.
+  #
+  # This task does not perform the actual deactivation, {#deactivate_all_debtors} does.
+  #
+  # See {Billingly::Invoice#notify_overdue Invoice#notify_overdue} for more info
+  # on how overdue invoices are notified.
+  def notify_all_overdue
+    batch_runner('Notifying Pending Invoices', :notify_overdue) do
+      Billingly::Invoice
+        .where('due_on <= ?', Time.now)
+        .where(deleted_on: nil, paid_on: nil, notified_overdue_on: nil)
+        .readonly(false)
+    end
+  end
+
+  # This method will deactivate all customers who have overdue {Billingly::Invoice Invoices}.
+  #
+  # This only deactivates the debtor, it does not notify them via email.
+  # Look at {#notify_all_overdue} to see the email notification customers receive.
+  #
+  # See {Billingly::Customer#deactivate_debtor Customer#deactivate_debtor} for more info
+  # on how debtors are deactivated.
+  def deactivate_all_debtors
+    batch_runner('Deactivating Debtors', :deactivate_debtor) do
+      Billingly::Customer.debtors.where(deactivated_since: nil).readonly(false)
+    end
+  end
+
+  # Customers may be subscribed for a trial period, and they are supposed to re-subscribe
+  # before their trial expires.
+  #
+  # When their trial expires and they have not yet subscribed to another plan, we
+  # deactivate their account immediately. This method does not email them about the
+  # expired trial.
+  #
+  # See {Billingly::Customer#deactivate_trial_expired Customer#deactivate_trial_expired}
+  # for more info on how trials are deactivated.
+  def deactivate_all_expired_trials
+    batch_runner('Deactivating Expired Trials', :deactivate_trial_expired) do
+      Billingly::Customer.joins(:subscriptions).readonly(false)
+        .where("#{Billingly::Subscription.table_name}.is_trial_expiring_on < ?", Time.now)
+        .where(billingly_subscriptions: {unsubscribed_on: nil})
+    end
+  end
+end

data/app/views/billingly/mailer/task_results.text.erb

@@ -0,0 +1,9 @@
+This is a report on Billingly's activity.
+Started on "<%= @runner.started %>" and ended on "<%= @runner.ended %>"
+
+Summary:
+<%= @runner.summary %>:
+
+Extended description:
+<%= @runner.extended %>:
+

data/app/views/billingly/mailer/trial_expired_notification.text.erb

@@ -0,0 +1,4 @@
+<%= t( 'billingly.your_trial_has_expired_please_choose_a_plan') % { end_date: @subscription.unsubscribed_on.to_date} %>
+
+<%=t 'billingly.please_visit' %> <%= url_for subscriptions_path %>
+

data/config/locales/en.yml

@@ -21,3 +21,8 @@ en:
     paid_on: Paid on
     plan: Plan
     amount: Amount
+    your_trial_has_expired: Your trial period has expired
+    your_trial_has_expired_please_choose_a_plan:
+      "Your trial period has ended on %{end_date} please choose a plan and sign up again."
+    please_visit: Please visit
+    

data/lib/billingly/version.rb

@@ -1,3 +1,3 @@
 module Billingly
-  VERSION = "0.1.1"
+  VERSION = "0.1.4"
 end

data/lib/generators/templates/create_billingly_tables.rb

@@ -46,7 +46,10 @@ class CreateBillinglyTables < ActiveRecord::Migration
       t.boolean 'payable_upfront', null: false, default: false
       t.decimal 'amount', precision: 11, scale: 2, default: 0.0, null: false
       t.datetime 'unsubscribed_on'
+      t.string 'unsubscribed_because'
       t.datetime 'is_trial_expiring_on'
+      t.datetime 'notified_trial_will_expire_on'
+      t.datetime 'notified_trial_expired_on'
       t.references :plan
       t.timestamps
     end

data/lib/tasks/billingly_tasks.rake

@@ -5,19 +5,6 @@ You can run it as often as you want.
 """
 namespace :billingly do
   task all: :environment do
-    puts 'Generating invoices'
-    Billingly::Subscription.generate_next_invoices
-    puts 'Charging invoices if possible'
-    Billingly::Invoice.charge_all
-    puts 'Deactivating debtors'
-    Billingly::Customer.deactivate_all_debtors
-    puts 'Deactivating all expired trials'
-    Billingly::Customer.deactivate_all_expired_trials
-    puts 'Sending payment receipts'
-    Billingly::Invoice.notify_all_paid
-    puts 'Notifying pending invoices'
-    Billingly::Invoice.notify_all_pending
-    puts 'Notifying deactivated debtors'
-    Billingly::Invoice.notify_all_overdue
+    Billingly::Tasks.new.run_all
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: billingly
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-04 00:00:00.000000000 Z
+date: 2012-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
-  requirement: &70322875786160 !ruby/object:Gem::Requirement
+  requirement: &70310037569740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 3.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *70322875786160
+  version_requirements: *70310037569740
 - !ruby/object:Gem::Dependency
   name: validates_email_format_of
-  requirement: &70322875785740 !ruby/object:Gem::Requirement
+  requirement: &70310037569280 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70322875785740
+  version_requirements: *70310037569280
 - !ruby/object:Gem::Dependency
   name: has_duration
-  requirement: &70322875785280 !ruby/object:Gem::Requirement
+  requirement: &70310037568740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70322875785280
+  version_requirements: *70310037568740
 - !ruby/object:Gem::Dependency
   name: timecop
-  requirement: &70322875784860 !ruby/object:Gem::Requirement
+  requirement: &70310037568220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70322875784860
+  version_requirements: *70310037568220
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70322875784440 !ruby/object:Gem::Requirement
+  requirement: &70310037608420 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70322875784440
+  version_requirements: *70310037608420
 - !ruby/object:Gem::Dependency
   name: rspec-rails
-  requirement: &70322875784020 !ruby/object:Gem::Requirement
+  requirement: &70310037607540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70322875784020
+  version_requirements: *70310037607540
 - !ruby/object:Gem::Dependency
   name: factory_girl_rails
-  requirement: &70322875783600 !ruby/object:Gem::Requirement
+  requirement: &70310037607120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,7 +87,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70322875783600
+  version_requirements: *70310037607120
 description: Rails Engine for SaaS subscription management. Manage subscriptions,
   plan changes, free trials and more!!!
 email:
@@ -97,7 +97,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - app/controllers/billingly/subscriptions_controller.rb
-- app/mailers/billingly_mailer.rb
+- app/mailers/billingly/base_mailer.rb
+- app/mailers/billingly/mailer.rb
 - app/models/billingly/base_customer.rb
 - app/models/billingly/base_plan.rb
 - app/models/billingly/base_subscription.rb
@@ -111,6 +112,14 @@ files:
 - app/models/billingly/plan.rb
 - app/models/billingly/receipt.rb
 - app/models/billingly/subscription.rb
+- app/models/billingly/tasks.rb
+- app/views/billingly/mailer/overdue_notification.html.erb
+- app/views/billingly/mailer/paid_notification.html.erb
+- app/views/billingly/mailer/pending_notification.html.erb
+- app/views/billingly/mailer/pending_notification.plain.erb
+- app/views/billingly/mailer/pending_notification.text.erb
+- app/views/billingly/mailer/task_results.text.erb
+- app/views/billingly/mailer/trial_expired_notification.text.erb
 - app/views/billingly/subscriptions/_current_subscription.html.haml
 - app/views/billingly/subscriptions/_deactivation_notice.html.haml
 - app/views/billingly/subscriptions/_invoice_details.html.haml
@@ -120,11 +129,6 @@ files:
 - app/views/billingly/subscriptions/index.html.haml
 - app/views/billingly/subscriptions/invoice.html.haml
 - app/views/billingly/subscriptions/new.html.erb
-- app/views/billingly_mailer/overdue_notification.html.erb
-- app/views/billingly_mailer/paid_notification.html.erb
-- app/views/billingly_mailer/pending_notification.html.erb
-- app/views/billingly_mailer/pending_notification.plain.erb
-- app/views/billingly_mailer/pending_notification.text.erb
 - config/locales/en.yml
 - lib/billingly/engine.rb
 - lib/billingly/rails/routes.rb
@@ -141,7 +145,21 @@ files:
 - TUTORIAL.rdoc
 homepage: http://billing.ly
 licenses: []
-post_install_message: 
+post_install_message: ! "    Add the following migration:\n    \n    class CreateBillinglyTables
+  < ActiveRecord::Migration\n      def up\n        add_column :billingly_subscriptions,
+  :notified_trial_will_expire_on, :datetime\n        add_column :billingly_subscriptions,
+  :notified_trial_expired_on, :datetime\n        add_column :billingly_subscriptions,
+  :unsubscribed_because, :string\n        \n        Billingly::Subscription.where('unsubscribed_on
+  IS NOT NULL').find_each do |s|\n          # Notice: You should pre-populate unsubscribed
+  because\n          # with an appropriate value for each terminated subscription.\n
+  \         # \n          reason = if s == s.customer.subscriptions.last && s.customer.deactivation_reason\n
+  \           s.deactivation_reason\n          elsif s.trial? && s.is_trial_expiring_on
+  <= s.unsubscribed_on\n            'trial_expired'\n          else\n            'changed_subscription'\n
+  \         end\n          s.update_attribute(unsubscribed_because: reason)\n        end\n
+  \     end\n      \n      def down\n        remove_column :billingly_subscriptions,
+  :notified_trial_will_expire_on\n        remove_column :billingly_subscriptions,
+  :notified_trial_expired_on\n        remove_column :billingly_subscriptions, :unsubscribed_because\n
+  \     end\n    end\n"
 rdoc_options: []
 require_paths:
 - lib