billingly 0.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= RailsSubscriptionBilling
+test
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,24 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RailsSubscriptionBilling'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+

data/app/controllers/billingly/subscriptions_controller.rb

@@ -0,0 +1,48 @@
+# This controller takes care of managing subscriptions.
+class Billingly::SubscriptionsController < ::ApplicationController
+  before_filter :requires_customer, only: [:index, :reactivate]
+  before_filter :requires_active_customer, except: [:index, :reactivate]
+
+  # Index shows the current subscription to customers while they are active.
+  # It's also the page that prompts them to reactivate their account when deactivated.
+  # It's likely the only reachable page for deactivated customers.
+  def index
+    @subscription = current_customer.active_subscription
+    redirect_to(action: :new) unless @subscription
+  end
+  
+  # Should let customers choose a plan to subscribe to, wheter they are subscribing
+  # for the first time or upgrading their plan.
+  def new
+    @plans = Billingly::Plan.all
+  end
+
+  # Subscribe the customer to a plan, or change his current plan.
+  def create
+    plan = Billingly::Plan.find(params[:plan_id])
+    current_customer.subscribe_to_plan(plan)
+    on_subscription_success
+  end
+
+  # Action to reactivate an account for a customer that left voluntarily and does
+  # not owe any money to us.
+  # Their account will be reactivated to their old subscription plan immediately.
+  # They can change plans afterwards.
+  def reactivate
+    return render nothing: true, status: 403 unless current_customer.reactivate
+    on_reactivation_success
+  end
+
+  # When a subscription is sucessful this callback is triggered.
+  # Host applications should override it by subclassing this subscriptionscontroller,
+  # and include their own behaviour, and for example grant the privileges associated
+  # to the subscription plan.
+  def on_subscription_success
+    redirect_to(action: :index) 
+  end
+  
+  def on_reactivation_success
+    on_subscription_success
+  end
+  
+end

data/app/mailers/billingly_mailer.rb

@@ -0,0 +1,20 @@
+class BillinglyMailer < ActionMailer::Base
+  default from: 'example@example.com'
+
+  def pending_notification(invoice)
+    @invoice = invoice
+    @cash = invoice.customer.ledger[:cash]
+    mail(to: invoice.customer.email, subject: I18n.t('billingly.your_invoice_is_available'))
+  end
+  
+  def overdue_notification(invoice)
+    @invoice = invoice
+    @cash = invoice.customer.ledger[:cash]
+    mail(to: invoice.customer.email, subject: I18n.t('billingly.your_account_was_suspended'))
+  end
+  
+  def paid_notification(invoice)
+    @invoice = invoice
+    mail(to: invoice.customer.email, subject: I18n.t('billingly.payment_receipt'))
+  end
+end

data/app/models/billingly/customer.rb

@@ -0,0 +1,116 @@
+# A Customer is the main entity of Billingly:
+#   * Customers are subscribed to plans
+#   * Customers are charged for one-time expenses.
+#   * Payments are received on a Customer's behalf and credited to their account.
+#   * Invoices are generated periodically calculating charges a Customer incurred in.
+#   * Receipts are sent to Customers when their invoices are paid.
+
+require 'validates_email_format_of'
+
+module Billingly
+  class Customer < ActiveRecord::Base
+    has_many :subscriptions
+    has_many :one_time_charges
+    has_many :invoices
+    has_many :ledger_entries
+    
+    attr_accessible :email
+    validates_email_format_of :email
+    
+    # Customers subscribe to the service and perform periodic payments to continue using it.
+    # We offer common plans stating how much and how often they should pay, also, if the
+    # payment is to be done at the beginning or end of the period (upfront or due-month)
+    # Every customer can potentially get a special deal, but we offer common
+    # deals as 'plans' from which a proper subscription is created.
+    def subscribe_to_plan(plan) 
+      subscriptions.last.terminate if subscriptions.last
+
+      subscriptions.build.tap do |new|
+        [:payable_upfront, :description, :periodicity, :amount].each do |k|
+          new[k] = plan[k]
+        end
+        new.subscribed_on = Time.now
+        new.save!
+        new.generate_next_invoice  
+      end
+    end
+    
+    # Returns the actual subscription of the customer. while working with the 
+    # customer API a customer should only have 1 active subscription at a time.
+    def active_subscription
+      subscriptions.last
+    end 
+    
+    # Every transaction is registered in the journal from where a general ledger can
+    # be retrieved.
+    # Due to silly rounding errors on sqlite we need to convert decimals to float and then to
+    # decimals again. :S
+    def ledger
+      Hash.new(0.0).tap do |all|
+        ledger_entries.group_by(&:account).collect do |account, entries|
+          values = entries.collect(&:amount).collect(&:to_f)
+          all[account.to_sym] = values.inject(0.0) do |sum,item|
+            (BigDecimal.new(sum.to_s) + BigDecimal.new(item.to_s)).to_f
+          end
+        end
+      end
+    end
+    
+    # Shortcut for adding ledger_entries for a particular customer.
+    def add_to_ledger(amount, *accounts, extra)
+      accounts = [] if accounts.nil?
+      unless extra.is_a?(Hash)
+        accounts << extra
+        extra = {}
+      end
+      
+      accounts.each do |account|
+        ledger_entries.create!(extra.merge(amount: amount, account: account.to_s))
+      end
+    end
+    
+    # This class method is run periodically deactivate all customers who have overdue invoices.
+    def self.deactivate_all_debtors
+      debtors.where(deactivated_since: nil).all.each{|debtor| debtor.deactivate }
+    end
+    
+    def self.debtors
+       joins(:invoices).readonly(false)
+        .where("#{Billingly::Invoice.table_name}.due_on < ?", Time.now)
+        .where(billingly_invoices: {deleted_on: nil, receipt_id: nil})
+    end
+
+    # Credits a payment for a customer, settling invoices if possible.
+    def credit_payment(amount)
+      Billingly::Payment.credit_for(self, amount)
+      Billingly::Invoice.charge_all(self.invoices)
+      reactivate
+    end
+    
+    def deactivate
+      return if deactivated?
+      active_subscription.terminate
+      update_attribute(:deactivated_since, Time.now)
+      return self
+    end
+
+    # Reactivates a customer that was deactivated when missed a previous payment.
+    # The new subscription is parametrized the same as the old one. The old subscription
+    # is terminated.
+    def reactivate(new_plan = active_subscription)
+      return unless deactivated?
+      return if debtor?
+      update_attribute(:deactivated_since, nil)
+      subscribe_to_plan(new_plan)
+      return self
+    end
+    
+    def deactivated?
+      not deactivated_since.nil?
+    end
+    
+    def debtor?
+      not self.class.debtors.find_by_id(self.id).nil?
+    end
+  end
+end

data/app/models/billingly/invoice.rb

@@ -0,0 +1,120 @@
+module Billingly
+  class Invoice < ActiveRecord::Base
+    belongs_to :subscription
+    belongs_to :customer
+    belongs_to :receipt
+    has_many :ledger_entries 
+    attr_accessible :customer, :amount, :due_on, :period_start, :period_end
+    
+    def paid?
+      not receipt.nil?
+    end
+    
+    def deleted?
+      not deleted_on.nil?
+    end
+    
+    # Settle an invoice by moving money from the cash balance into an expense,
+    # generating a receipt and marking the invoice as paid.
+    def charge
+      return if paid?
+      return unless deleted_on.nil?
+      return if customer.ledger[:cash] < amount
+
+      receipt = create_receipt!(customer: customer, paid_on: Time.now)
+      extra = {receipt: receipt, subscription: subscription}
+      customer.add_to_ledger(-(amount), :cash, extra)
+      customer.add_to_ledger(amount, :spent, extra)
+
+      save! # save receipt
+      return receipt
+    end
+    
+    # When a subscription terminates, it's last invoice gets truncated so that it does
+    # not extend beyond the duration of the subscription.
+    def truncate
+      return if Time.now > self.period_end
+      old_amount = self.amount
+      new_amount = if self.period_start < Time.now 
+        whole_period = self.period_end - self.period_start
+        used_period = Time.now - self.period_start
+        self.period_end = Time.now
+        used_period.round * old_amount / whole_period.round
+      else
+        self.deleted_on = Time.now
+        0
+      end
+      self.amount = BigDecimal.new(new_amount.round(2).to_s)
+      if paid?
+        reimburse = (old_amount - self.amount).round(2)
+        extra = {invoice: self, subscription: subscription}
+        customer.add_to_ledger(reimburse, :cash, extra)
+        customer.add_to_ledger(-(reimburse), :spent, extra)
+      end
+      save!
+      self.charge
+      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, receipt_id: nil).order('period_start').each do |invoice|
+        invoice.charge
+      end
+    end
+    
+    # Send the email notifying that this invoice is due soon and should be paid.
+    def self.notify_all_pending
+      where('due_on < ?', Billingly::Subscription::GRACE_PERIOD.from_now)
+        .where(deleted_on: nil, receipt_id: 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 > Billingly::Subscription::GRACE_PERIOD.from_now
+      BillinglyMailer.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, receipt_id: 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!
+      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('receipt_id 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!
+      update_attribute(:notified_paid_on, Time.now)
+    end
+  end
+end

data/app/models/billingly/invoice_item.rb

@@ -0,0 +1,4 @@
+module Billingly
+  class InvoiceItem < ActiveRecord::Base
+  end
+end

data/app/models/billingly/ledger_entry.rb

@@ -0,0 +1,16 @@
+module Billingly
+  class LedgerEntry < ActiveRecord::Base
+    belongs_to :customer
+    belongs_to :invoice
+    belongs_to :payment
+    belongs_to :receipt
+    belongs_to :subscription
+
+    validates :amount, presence: true
+    validates :customer, presence: true
+    validates :account, presence: true, inclusion: %w(paid cash spent)
+    
+    attr_accessible :customer, :account, :invoice, :payment, :receipt, :subscription, :amount 
+    
+  end
+end

data/app/models/billingly/one_time_charge.rb

@@ -0,0 +1,5 @@
+module Billingly
+  class OneTimeCharge < ActiveRecord::Base
+    attr_accessible :charge_on, :amount, :description
+  end
+end

data/app/models/billingly/payment.rb

@@ -0,0 +1,19 @@
+# Processes payments
+module Billingly
+  class Payment < ActiveRecord::Base
+    belongs_to :customer
+    has_many :ledger_entries
+    attr_accessible :amount, :customer
+    
+    # Process a new payment done by a customer.
+    # Payments can be credited at any point and they are bound to increase
+    # a customer's balance. Payments are not mapped 1 to 1 with invoices,
+    # instead, invoices are deemed as paid whenever the customer's balance
+    # is enough to cover them.
+    def self.credit_for(customer, amount) 
+      create!(amount: amount, customer: customer).tap do |payment|
+        customer.add_to_ledger(amount, :cash, :paid, payment: payment)
+      end
+    end
+  end
+end

data/app/models/billingly/plan.rb

@@ -0,0 +1,5 @@
+module Billingly
+  class Plan < ActiveRecord::Base
+    attr_accessible :name, :description, :periodicity, :amount, :payable_upfront
+  end
+end

data/app/models/billingly/receipt.rb

@@ -0,0 +1,9 @@
+module Billingly
+  class Receipt < ActiveRecord::Base
+    belongs_to :customer
+    has_one :invoice
+    has_many :ledger_entries
+
+    attr_accessible :customer, :paid_on
+  end
+end

data/app/models/billingly/subscription.rb

@@ -0,0 +1,82 @@
+module Billingly
+  class Subscription < ActiveRecord::Base
+    has_many :ledger_entries
+    # If a subscription is payable_upfront, then the customer effectively owes us
+    # since the day in which a given period starts.
+    # If a subscription is payable on 'due-month', then the customer effectively
+    # owes us money since the date in which a given period ended.
+    # When we invoice for a given period we will set the due_date a few days
+    # ahead of the date in which the debt was made effective, we call this
+    # a GRACE_PERIOD.
+    GRACE_PERIOD = 10.days
+    
+    # Invoices will be generated before their due_date, as soon as possible,
+    # but not sooner than GENERATE_AHEAD days.
+    GENERATE_AHEAD = 3.days
+
+    # Subscriptions are to be charged periodically. Their periodicity is
+    # stored semantically on the database, but we want to convert it
+    # to actual ruby time ranges to do date arithmetic.
+    PERIODICITIES = {'monthly' => 1.month, 'yearly' => 1.year}
+
+    belongs_to :customer
+    has_many :invoices
+   
+    validates :periodicity, inclusion: PERIODICITIES.keys
+
+    # The periodicity can be set using a symbol, for convenience.
+    # It's still a string under the hood.
+    def periodicity=(value)
+      self[:periodicity] = value.to_s if value
+    end
+    
+    def period_size
+      case periodicity
+      when 'monthly' then 1.month
+      when 'yearly' then 1.year
+      else
+        raise ArgumentError.new 'Cannot get period size without periodicity'
+      end 
+    end
+    
+    # The invoice generation process should run frequently, at least on a daily basis.
+    # It will create invoices some time before they are due, to give customers a chance
+    # to pay and settle them.
+    # This method is idempotent, if an upcoming invoice for a subscription already exists,
+    # it does not create yet another one.
+    def generate_next_invoice
+      return if terminated?
+      from = invoices.empty? ? subscribed_on : invoices.last.period_end
+      to = from + period_size
+      due_on = (payable_upfront ? from : to) + GRACE_PERIOD
+      return if GENERATE_AHEAD.from_now < from
+
+      invoice = invoices.create!(customer: customer, amount: amount,
+        due_on: due_on, period_start: from, period_end: to)
+      invoice.charge
+      return invoice
+    end
+    
+    # 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
+      return if terminated?
+      update_attribute(:unsubscribed_on, Time.now)
+      invoices.last.truncate
+      return self
+    end
+    
+    def terminated?
+      not unsubscribed_on.nil?
+    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(unsubscribed_on: nil).each do |subscription|
+        subscription.generate_next_invoice
+      end
+    end
+  end
+end

data/app/views/billingly/subscriptions/create.html.erb

@@ -0,0 +1 @@
+placeholder!

data/app/views/billingly/subscriptions/index.html.erb

@@ -0,0 +1,2 @@
+<%= @subscription.inspect %>
+

data/app/views/billingly/subscriptions/new.html.erb

@@ -0,0 +1 @@
+placeholder!

data/app/views/billingly_mailer/overdue_notification.html.erb

@@ -0,0 +1,21 @@
+<%=t 'billingly.make_sure_to_pay' %>
+
+<%=t 'billingly.you_can_reactivate_your_account_by_visiting' %> http://payments_page
+
+----- <%=t 'billingly.your_overdue_invoice_is_detailed_below' %> -----
+
+<%=t 'billingly.invoice_number' %>: <%= '%.10i' % @invoice.id %>
+
+<%=t 'billingly.due_date' %>: <%= @invoice.due_on.to_date %>
+
+<%= "#{t('billingly.covering_from')} #{@invoice.period_start.to_date} #{t('billingly.until')} #{@invoice.period_end.to_date}" %>
+
+<%=t 'billingly.detail' %>
+<%= '-' * 70 %>
+<%= '%-55s%15s' % [@invoice.subscription.description, "$#{@invoice.amount} USD"] %>
+<% if @cash > 0 %>
+<%= '%-55s%15s' % [t('billingly.balance_in_your_favour'), "-$#{@cash} USD"] %>
+<% end %>
+
+<%= '%-55s%15s' % [t('billingly.you_should_pay'), "$#{@invoice.amount - @cash} USD"] %>
+

data/app/views/billingly_mailer/paid_notification.html.erb

@@ -0,0 +1,10 @@
+<%=t 'billingly.receipt_greeting' %>:
+
+<%=t 'billingly.receipt_text' %>
+
+<%= '-' * 70 %>
+<%=t 'billingly.invoice_number' %>: <%= '%.10i' % @invoice.id %>
+<%=t 'billingly.paid_on' %>: <%= @invoice.receipt.paid_on.to_date %>
+<%=t 'billingly.plan' %>: <%= @invoice.subscription.description %>
+<%=t 'billingly.amount' %>: $<%= @invoice.amount %> USD
+

data/app/views/billingly_mailer/pending_notification.html.erb

@@ -0,0 +1,17 @@
+<%=t 'billingly.invoice_number' %>: <%= '%.10i' % @invoice.id %>
+
+<%=t 'billingly.due_date' %>: <%= @invoice.due_on.to_date %>
+
+<%= "#{t('billingly.covering_from')} #{@invoice.period_start.to_date} #{t('billingly.until')} #{@invoice.period_end.to_date}" %>
+
+<%=t 'billingly.detail' %>
+<%= '-' * 70 %>
+<%= '%-55s%15s' % [@invoice.subscription.description, "$#{@invoice.amount} USD"] %>
+<% if @cash > 0 %>
+<%= '%-55s%15s' % [t('billingly.balance_in_your_favour'), "-$#{@cash} USD"] %>
+<% end %>
+
+<%= '%-55s%15s' % [t('billingly.you_should_pay'), "$#{@invoice.amount - @cash} USD"] %>
+
+<%=t 'billingly.you_can_pay_this_invoice_by_visiting' %> http://payments_page
+

data/app/views/billingly_mailer/pending_notification.plain.erb

@@ -0,0 +1,17 @@
+<%=t 'billingly.invoice_number' %>: <%= '%.10i' % @invoice.id %>
+
+<%=t 'billingly.due_date' %>: <%= @invoice.due_on.to_date %>
+
+<%= "#{t('billingly.covering_from')} #{@invoice.period_start.to_date} #{t('billingly.until')} #{@invoice.period_end.to_date}" %>
+
+<%=t 'billingly.detail' %>
+<%= '-' * 70 %>
+<%= '%-55s%15s' % [@invoice.subscription.description, "$#{@invoice.amount} USD"] %>
+<% if @cash > 0 %>
+<%= '%-55s%15s' % [t('billingly.balance_in_your_favour'), "-$#{@cash} USD"] %>
+<% end %>
+
+<%= '%-55s%15s' % [t('billingly.you_should_pay'), "$#{@invoice.amount - @cash} USD"] %>
+
+<%=t 'billingly.you_can_pay_this_invoice_by_visiting' %> http://payments_page
+

data/app/views/billingly_mailer/pending_notification.text.erb

@@ -0,0 +1,17 @@
+<%=t 'billingly.invoice_number' %>: <%= '%.10i' % @invoice.id %>
+
+<%=t 'billingly.due_date' %>: <%= @invoice.due_on.to_date %>
+
+<%= "#{t('billingly.covering_from')} #{@invoice.period_start.to_date} #{t('billingly.until')} #{@invoice.period_end.to_date}" %>
+
+<%=t 'billingly.detail' %>
+<%= '-' * 70 %>
+<%= '%-55s%15s' % [@invoice.subscription.description, "$#{@invoice.amount} USD"] %>
+<% if @cash > 0 %>
+<%= '%-55s%15s' % [t('billingly.balance_in_your_favour'), "-$#{@cash} USD"] %>
+<% end %>
+
+<%= '%-55s%15s' % [t('billingly.you_should_pay'), "$#{@invoice.amount - @cash} USD"] %>
+
+<%=t 'billingly.you_can_pay_this_invoice_by_visiting' %> http://payments_page
+

data/config/locales/en.yml

@@ -0,0 +1,23 @@
+en:
+  billingly:
+    your_account_was_suspended: Your account was suspended
+    your_invoice_is_available: Your invoice is available
+    payment_receipt: Payment Receipt
+    invoice_number: Invoice Number
+    covering_from: For period starting on
+    until: until
+    due_date: Due Date
+    detail: Detail
+    balance_in_your_favour: Balance in your favour
+    you_should_pay: You should pay
+    you_can_pay_this_invoice_by_visiting: You can pay this invoice by visiting
+    you_can_reactivate_your_account_by_visiting: You can reactivate your account by visiting
+    make_sure_to_pay:
+      Your account was suspended. Make sure to pay your overdue invoices to reactivate it.
+    your_overdue_invoice_is_detailed_below: Your overdue invoice is detailed below
+    receipt_greeting: Dear customer
+    receipt_text:
+      "This is a receipt for your subscription.\nThis is only a receipt, no payment is due.\nThank you for your business!"
+    paid_on: Paid on
+    plan: Plan
+    amount: Amount

data/lib/billingly.rb

@@ -0,0 +1,4 @@
+module Billingly
+end
+require 'billingly/engine'
+require 'billingly/rails/routes'

data/lib/billingly/engine.rb

@@ -0,0 +1,45 @@
+module Billingly
+  def self.table_name_prefix
+    'billingly_'
+  end
+
+  class Engine < Rails::Engine
+    
+    # Extends the ApplicationController with all the
+    # billingly before_filters and helper methods
+    initializer 'billingly.app_controller' do |app|
+      ActiveSupport.on_load(:action_controller) do
+        class_eval do
+          def current_customer
+            nil
+          end
+
+          def requires_customer
+            on_empty_customer if current_customer.nil? 
+          end
+
+          # This method is call on a before filter when a customer was required
+          # but none was found. It's reccommended that this method redirects to
+          # a login url or out of the site.
+          def on_empty_customer
+            redirect_to(root_path)
+          end
+          
+          # This before filter should apply to all actions that require an active
+          # customer. Usually this would mean all your non-public pages.
+          # The billingly controllers already apply this before filter, you should
+          # use it in your own controllers too.
+          def requires_active_customer
+            if requires_customer.nil? && current_customer.deactivated?
+              redirect_to(controller: 'billingly/subscriptions', action: 'index')
+            end
+          end
+        end
+
+        helper_method :current_customer
+      end
+    end
+  end
+end
+
+

data/lib/billingly/rails/routes.rb

@@ -0,0 +1,12 @@
+class ActionDispatch::Routing::Mapper
+  def add_billingly_routes(skope=nil, controller='billingly/subscriptions')
+    route = lambda do 
+      resources :subscriptions, controller: controller do
+        collection do
+          post :reactivate
+        end
+      end
+    end
+    if skope then scope(skope, as: skope, &route) else route.call end
+  end
+end

data/lib/billingly/version.rb

@@ -0,0 +1,3 @@
+module Billingly
+  VERSION = "0.0.0"
+end

data/lib/generators/billingly_migration_generator.rb

@@ -0,0 +1,20 @@
+require 'rails/generators/migration'
+require 'rails/generators'
+
+class BillinglyMigrationGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  def create_billingly_migration
+    migration_template 'create_billingly_tables.rb', "db/migrate/create_billingly_tables.rb"
+  end
+
+private
+
+  def source_paths
+    [File.expand_path("../templates", __FILE__)]
+  end
+
+  def self.next_migration_number(path)
+    Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+end

data/lib/generators/templates/create_billingly_tables.rb

@@ -0,0 +1,71 @@
+class CreateBillinglyTables < ActiveRecord::Migration
+  def self.up
+    create_table :billingly_customers do |t|
+      t.datetime 'deactivated_since'
+      t.string 'email', null: false
+    end
+    
+    create_table :billingly_invoices do |t|
+      t.references :customer, null: false
+      t.references :receipt
+      t.references :subscription
+      t.decimal 'amount', precision: 11, scale: 2, default: 0.0, null: false
+      t.datetime 'due_on', null: false
+      t.datetime 'period_start', null: false
+      t.datetime 'period_end', null: false
+      t.datetime 'deleted_on'
+      t.datetime 'notified_pending_on'
+      t.datetime 'notified_overdue_on'
+      t.datetime 'notified_paid_on'
+      t.text 'comment'
+      t.timestamps
+    end
+
+    create_table :billingly_payments do |t|
+      t.references :customer, null: false
+      t.decimal 'amount', precision: 11, scale: 2, default: 0.0, null: false
+    end
+    
+    create_table :billingly_receipts do |t|
+      t.references :customer, null: false
+      t.datetime 'paid_on'
+      t.timestamps
+    end
+
+    create_table :billingly_ledger_entries do |t|
+      t.references :customer, null: false
+      t.string :account, null: false
+      t.decimal 'amount', precision: 11, scale: 2, default: 0.0, null: false
+      t.references :subscription
+      t.references :invoice
+      t.references :payment
+      t.references :receipt
+      t.timestamps
+    end
+    
+    create_table :billingly_subscriptions do |t|
+      t.references :customer, null: false
+      t.string 'description', null: false
+      t.datetime 'subscribed_on', null: false
+      t.string 'periodicity', null: false
+      t.decimal 'amount', precision: 11, scale: 2, default: 0.0, null: false
+      t.datetime 'unsubscribed_on'
+      t.boolean 'payable_upfront', null: false, default: false
+      t.timestamps
+    end
+    
+    create_table :billingly_plans do |t|
+      t.string 'name' # Pro 50
+      t.string 'description' # 50GB for 9,99 a month.
+      t.string 'periodicity'
+      t.decimal 'amount', precision: 11, scale: 2, default: 0.0, null: false # 9.99
+      t.boolean 'payable_upfront' # true
+      t.timestamps
+    end
+      
+  end
+  
+  def self.down
+  end
+end
+

data/lib/tasks/billingly_tasks.rake

@@ -0,0 +1,21 @@
+desc """
+Run all periodic billing tasks like generating new invoices,
+deactivating debtors, and emailing.
+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 '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
+  end
+end

metadata

@@ -0,0 +1,143 @@
+--- !ruby/object:Gem::Specification
+name: billingly
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Nubis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: &70238504847900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70238504847900
+- !ruby/object:Gem::Dependency
+  name: validates_email_format_of
+  requirement: &70238504847400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70238504847400
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70238504846940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70238504846940
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70238504846520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70238504846520
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: &70238504846080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70238504846080
+- !ruby/object:Gem::Dependency
+  name: factory_girl_rails
+  requirement: &70238504845640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70238504845640
+description: Engine for subscriptions billing - still alpha - contact me if you want
+  to use it
+email:
+- nubis@woobiz.com.ar
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- app/controllers/billingly/subscriptions_controller.rb
+- app/mailers/billingly_mailer.rb
+- app/models/billingly/customer.rb
+- app/models/billingly/invoice.rb
+- app/models/billingly/invoice_item.rb
+- app/models/billingly/ledger_entry.rb
+- app/models/billingly/one_time_charge.rb
+- app/models/billingly/payment.rb
+- app/models/billingly/plan.rb
+- app/models/billingly/receipt.rb
+- app/models/billingly/subscription.rb
+- app/views/billingly/subscriptions/create.html.erb
+- app/views/billingly/subscriptions/index.html.erb
+- 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
+- lib/billingly/version.rb
+- lib/billingly.rb
+- lib/generators/billingly_migration_generator.rb
+- lib/generators/templates/create_billingly_tables.rb
+- lib/tasks/billingly_tasks.rake
+- MIT-LICENSE
+- Rakefile
+- README.rdoc
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: Engine for subscriptions billing - still alpha - contact me if you want to
+  use it
+test_files: []