saasy 0.0.1

data/lib/saucy/projects_controller.rb

@@ -0,0 +1,94 @@
+module Saucy
+  module ProjectsController
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :current_project?
+      before_filter :authorize
+      before_filter :authorize_member,      :only   => :show
+      before_filter :authorize_admin,       :except => [:show]
+      before_filter :ensure_active_account, :only   => [:show, :destroy, :index]
+      before_filter :ensure_account_within_projects_limit, :only => [:new, :create]
+      before_filter :ensure_admin_for_project_account, :only => [:edit, :create, :update]
+      layout Saucy::Layouts.to_proc
+    end
+
+    module InstanceMethods
+      def new
+        @project = current_account.projects.build_with_default_permissions
+        if @project.keyword.blank?
+          @project.keyword = 'keyword'
+        end
+      end
+
+      def create
+        @project = current_account.projects.build(params[:project])
+        if @project.save
+          flash[:notice] = "Project successfully created"
+          redirect_to project_url(@project)
+        else
+          render :action => :new
+        end
+      end
+
+      def edit
+        @project = current_project
+        set_project_account_if_moving
+      end
+
+      def update
+        @project = current_project
+        set_project_account_if_moving
+        if @project.update_attributes params[:project]
+          flash[:success] = 'Project was updated.'
+          redirect_to account_projects_url(@project.account)
+        else
+          render :action => :edit
+        end
+      end
+
+      def show
+        current_project
+      end
+
+      def destroy
+        current_project.destroy
+        flash[:success] = "Project has been deleted"
+        redirect_to account_projects_url(current_project.account)
+      end
+
+      def index
+        @active_projects = current_account.projects.active
+        @archived_projects = current_account.projects.archived
+      end
+
+      private
+
+      def set_project_account_if_moving
+        if params[:project] && params[:project][:account_id]
+          @project.account_id = params[:project][:account_id]
+        end
+      end
+
+      def current_project
+        @project ||= current_account.projects.find_by_keyword!(params[:id])
+      end
+
+      def current_project?
+        params[:id].present?
+      end
+
+      def ensure_account_within_projects_limit
+        ensure_account_within_limit("projects")
+      end
+
+      def ensure_admin_for_project_account
+        if params[:project] && params[:project][:account_id]
+          if !current_user.admin_of?(::Account.find(params[:project][:account_id]))
+            redirect_to account_projects_url(current_account), :alert => t('account.permission_denied', :default => "You do not have permission to this account.")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/saucy/railties/tasks.rake

@@ -0,0 +1,28 @@
+namespace :saucy do
+  desc "Updates subscription status and delivers receipt/problem notices"
+  task :update_subscriptions => :environment do
+    Account.update_subscriptions!
+  end
+
+  desc "Deliver notifications for users that have signed up and aren't activated"
+  task :ask_users_to_activate => :environment do
+    Account.deliver_new_unactivated_notifications
+  end
+
+  desc "Deliver notifications to users with expiring trial accounts"
+  task :deliver_expiring_trial_notifications => :environment do
+    Account.deliver_expiring_trial_notifications
+  end
+
+  desc "Deliver notifications to users with completed trial accounts"
+  task :deliver_completed_trial_notifications => :environment do
+    Account.deliver_completed_trial_notifications
+  end
+
+  desc "Run all daily tasks"
+  task :daily => [:update_subscriptions,
+                  :ask_users_to_activate,
+                  :deliver_expiring_trial_notifications,
+                  :deliver_completed_trial_notifications]
+end
+

data/lib/saucy/routing_extensions.rb

@@ -0,0 +1,121 @@
+# This set of hacks extends Rails routing so that we can define pretty, unique,
+# urls for account resources without having to specify every nested resource
+# every time we generate a url.
+#
+# For example, you can generate /accounts/thoughtbot/projects/hoptoad from
+# project_path(@project), because the account can be inferred from the project.
+module Saucy
+  module MapperExtensions
+    def initialize(*args)
+      @through_scope = []
+      super
+    end
+
+    def through(parent, &block)
+      @through_scope << parent
+      resources(parent, :only => [], &block)
+      @through_scope.pop
+    end
+
+  end
+
+  class ThroughAlias
+    attr_reader :route, :through
+
+    def initialize(route, through)
+      @route = route
+      @through = through
+    end
+
+    def to_method(kind)
+      return <<-RUBY
+        def #{alias_name}_#{kind}(#{arguments.last}, options = {})
+          #{route_name}_#{kind}(#{arguments.join(', ')}, options)
+        end
+      RUBY
+    end
+
+    private
+
+    def alias_name
+      @alias_name ||= through.inject(route_name) do |name, through|
+        prefix = "#{through.to_s.singularize}_"
+        name.sub(/^(new_|edit_|)#{Regexp.escape(prefix)}/, '\1')
+      end
+    end
+
+    def arguments
+      @arguments ||= build_arguments
+    end
+
+    def build_arguments
+      other_segments = segments.dup
+      first_segment = other_segments.shift
+      other_segments.inject([first_segment]) { |result, member|
+        result << "#{result.last}.#{member}"
+      }.reverse
+    end
+
+    def segments
+      parent_segments = through.map { |parent| parent.to_s.singularize }.reverse
+      if include_self?
+        [alias_name] + parent_segments
+      else
+        parent_segments
+      end
+    end
+
+    def route_name
+      route.name
+    end
+
+    def include_self?
+      route.segment_keys.include?(:id)
+    end
+  end
+end
+
+ActionDispatch::Routing::Mapper.class_eval do
+  include Saucy::MapperExtensions
+end
+
+ActionDispatch::Routing::Mapper::Base.class_eval do
+  def match_with_through(path, options=nil)
+    match_without_through(path, options)
+    unless @through_scope.empty?
+      route = @set.routes.last
+      @set.named_routes.add_through_alias(route, @through_scope) if route.name
+    end
+    self
+  end
+
+  alias_method_chain :match, :through
+end
+
+ActionDispatch::Routing::RouteSet::NamedRouteCollection.class_eval do
+  attr_reader :through_aliases
+
+  def clear_with_through_aliases!
+    clear_without_through_aliases!
+    @through_aliases = []
+  end
+  alias_method_chain :clear!, :through_aliases
+
+  def reset_with_through_aliases!
+    old_through_aliases = through_aliases.dup
+    reset_without_through_aliases!
+    old_through_aliases.each do |through_alias|
+      add_through_alias through_alias.route, through_alias.through
+    end
+  end
+  alias_method_chain :reset!, :through_aliases
+
+  def add_through_alias(route, through)
+    @through_aliases ||= []
+    through_alias = Saucy::ThroughAlias.new(route, through)
+    @through_aliases << through_alias
+    @module.module_eval through_alias.to_method('path')
+    @module.module_eval through_alias.to_method('url')
+  end
+end
+

data/lib/saucy/subscription.rb

@@ -0,0 +1,237 @@
+module Saucy
+  module Subscription
+    extend ActiveSupport::Concern
+
+    included do
+      require "rubygems"
+      require "braintree"
+
+      extend ActiveSupport::Memoizable
+
+      CUSTOMER_ATTRIBUTES = { :cardholder_name => :cardholder_name, 
+                              :billing_email => :email, 
+                              :card_number => :number, 
+                              :expiration_month => :expiration_month, 
+                              :expiration_year => :expiration_year, 
+                              :verification_code => :cvv }
+
+      attr_accessor *CUSTOMER_ATTRIBUTES.keys
+
+      CUSTOMER_ATTRIBUTES.keys.each do |attribute|
+        validates_presence_of attribute, :if => :switching_to_billed?
+      end
+      before_create :create_customer
+      before_create :create_subscription, :if => :billed?
+      after_destroy :destroy_customer
+
+      memoize :customer
+      memoize :subscription
+    end
+
+    module InstanceMethods
+      def customer
+        Braintree::Customer.find(customer_token) if customer_token
+      end
+
+      def credit_card
+        customer.credit_cards[0] if customer && customer.credit_cards.any?
+      end
+
+      def subscription
+        Braintree::Subscription.find(subscription_token) if subscription_token
+      end
+
+      def save_customer_and_subscription!(attributes)
+        successful = true
+        self.plan = ::Plan.find(attributes[:plan_id]) if changing_plan?(attributes)
+        if changing_customer_attributes?(attributes)
+          successful = update_customer(attributes)
+        end
+        if successful && past_due?
+          successful = retry_subscription_charge!
+        end
+        if successful && changing_plan?(attributes)
+          save_subscription
+          flush_cache :subscription
+        end
+        successful && save
+      end
+
+      def can_change_plan_to?(new_plan)
+        within_limits_for?(new_plan) && !past_trial_for?(new_plan)
+      end
+
+      def past_due?
+        subscription_status == Braintree::Subscription::Status::PastDue
+      end
+
+      private
+
+      def within_limits_for?(new_plan)
+        new_plan.limits.where(:value_type => :number).all? do |limit|
+          new_plan.limit(limit.name).value >= send(:"#{limit.name}_count")
+        end
+      end
+
+      def past_trial_for?(new_plan)
+        new_plan.trial? && past_trial?
+      end
+
+      def retry_subscription_charge!
+        authorized_transaction = Braintree::Subscription.retry_charge(subscription.id).transaction
+        result = Braintree::Transaction.submit_for_settlement(authorized_transaction.id)
+        handle_errors(authorized_transaction, result.errors) if !result.success?
+        update_subscription_cache!
+        result.success?
+      end
+
+      def update_subscription_cache!
+        flush_cache :subscription
+        update_attribute(:subscription_status, subscription.status)
+        update_attribute(:next_billing_date, subscription.next_billing_date)
+      end
+
+      def changing_plan?(attributes)
+        attributes[:plan_id].present?
+      end
+
+      def changing_customer_attributes?(attributes)
+        CUSTOMER_ATTRIBUTES.keys.any? { |attribute| attributes[attribute].present? }
+      end
+
+      def set_customer_attributes(attributes)
+        CUSTOMER_ATTRIBUTES.keys.each do |attribute|
+          send("#{attribute}=", attributes[attribute]) if attributes[attribute].present?
+        end
+      end
+
+      def update_customer(attributes)
+        set_customer_attributes(attributes)
+        if valid?
+          result = Braintree::Customer.update(customer_token, customer_attributes)
+          handle_customer_result(result)
+          result.success?
+        end
+      end
+
+      def save_subscription
+        if subscription
+          Braintree::Subscription.update(subscription_token, :plan_id => plan_id)
+        elsif plan.billed?
+          valid? && create_subscription
+        end
+      end
+
+      def customer_attributes
+        {
+          :email => billing_email,
+          :credit_card => credit_card_attributes
+        }
+      end
+
+      def credit_card_attributes
+        if plan.billed?
+          card_attributes = { :cardholder_name => cardholder_name,
+                              :number => card_number,
+                              :expiration_month => expiration_month,
+                              :expiration_year => expiration_year,
+                              :cvv => verification_code }
+          if credit_card
+            card_attributes.merge!(:options => credit_card_options)
+          end
+          card_attributes
+        else 
+          {}
+        end
+      end
+
+      def credit_card_options
+        if customer && customer.credit_cards.any?
+          { :update_existing_token => credit_card.token }
+        else
+          {}
+        end
+      end
+
+      def create_customer
+        result = Braintree::Customer.create(customer_attributes)
+        handle_customer_result(result)
+      end
+
+      def destroy_customer
+        Braintree::Customer.delete(customer_token)
+      end
+
+      def handle_customer_result(result)
+        if result.success?
+          self.customer_token = result.customer.id
+          flush_cache :customer
+        else
+          handle_errors(result.credit_card_verification, result.errors)
+        end
+        result.success?
+      end
+
+      def handle_errors(result, remote_errors)
+        if result && result.status == "processor_declined"
+          errors[:card_number] << "was denied by the payment processor with the message: #{result.processor_response_text}"
+        elsif result && result.status == "gateway_rejected"
+          errors[:verification_code] << "did not match"
+        elsif remote_errors.any?
+          remote_errors.each do |error|
+            if error.attribute == "number"
+              errors[:card_number] << error.message.gsub("Credit card number ", "")
+            elsif error.attribute == "CVV"
+              errors[:verification_code] << error.message.gsub("CVV ", "")
+            elsif error.attribute == "expiration_month"
+              errors[:expiration_month] << error.message.gsub("Expiration month ", "")
+            elsif error.attribute == "expiration_year"
+              errors[:expiration_year] << error.message.gsub("Expiration year ", "")
+            end
+          end
+        end
+      end
+
+      def create_subscription
+        result = Braintree::Subscription.create(subscription_attributes)
+        if result.success?
+          self.subscription_token = result.subscription.id
+          self.next_billing_date = result.subscription.next_billing_date
+          self.subscription_status = result.subscription.status
+        else
+          false
+        end
+      end
+
+      def subscription_attributes
+        {
+          :payment_method_token => credit_card.token,
+          :plan_id              => plan_id,
+          :merchant_account_id  => Saucy::Configuration.merchant_account_id
+        }.tap do |attributes|
+          attributes.reject! { |key, value| value.nil? }
+        end
+      end
+
+      def switching_to_billed?
+        plan_id && plan.billed? && subscription_token.blank?
+      end
+    end
+
+    module ClassMethods
+      def update_subscriptions!
+        recently_billed = where("next_billing_date <= ?", Time.now)
+        recently_billed.each do |account|
+          account.subscription_status = account.subscription.status
+          account.next_billing_date = account.subscription.next_billing_date
+          account.save!
+          if account.past_due?
+            BillingMailer.problem(account, account.subscription.transactions.last).deliver!
+          else
+            BillingMailer.receipt(account, account.subscription.transactions.last).deliver!
+          end
+        end
+      end
+    end
+  end
+end