saasy 0.0.1

data/app/controllers/memberships_controller.rb

@@ -0,0 +1,45 @@
+class MembershipsController < ApplicationController
+  before_filter :authorize_admin
+  layout Saucy::Layouts.to_proc
+
+  def index
+    @memberships = current_account.memberships_by_name
+    render
+  end
+
+  def edit
+    find_membership
+    @projects = current_account.projects_by_name
+    render
+  end
+
+  def update
+    find_membership.update_attributes!(params[:membership])
+    flash[:success] = "Permissions updated."
+    redirect_to account_memberships_url(current_account)
+  end
+
+  def destroy
+    find_membership.destroy
+    flash[:success] = "User removed."
+    if @membership.user == current_user
+      redirect_to edit_profile_url
+    else
+      redirect_to account_memberships_url(current_account)
+    end
+  end
+
+  private
+
+  def find_membership
+    @membership ||= Membership.find(params[:id], :include => :account)
+  end
+
+  def current_account
+    if params[:id]
+      find_membership.account
+    else
+      super
+    end
+  end
+end

data/app/controllers/plans_controller.rb

@@ -0,0 +1,24 @@
+class PlansController < ApplicationController
+  layout Saucy::Layouts.to_proc
+
+  def index
+    @plans = Plan.ordered
+  end
+
+  def edit
+    @plans = Plan.ordered
+    @account = current_account
+  end
+
+  def update
+    @plans = Plan.ordered
+    @account = current_account
+    Saucy::Configuration.notify("plan_upgraded", :account => @account,
+                                                 :request => request)
+    if @account.save_customer_and_subscription!(params[:account])
+      redirect_to edit_account_path(@account), :notice => t('.update.notice', :default => "Plan changed successfully")
+    else
+      render :edit
+    end
+  end
+end

data/app/controllers/profiles_controller.rb

@@ -0,0 +1,19 @@
+class ProfilesController < ApplicationController
+  layout Saucy::Layouts.to_proc
+
+  before_filter :authorize
+
+  def edit
+    @user = current_user
+  end
+
+  def update
+    @user = current_user
+    if @user.update_attributes(params[:user])
+      flash[:notice] = "Your user account has been updated."
+      redirect_to edit_profile_url
+    else
+      render :action => :edit
+    end
+  end
+end

data/app/helpers/limits_helper.rb

@@ -0,0 +1,13 @@
+module LimitsHelper
+  def current_percentage(limit, account)
+    number_to_percentage((limit.current_count(account).to_f / limit.value) * 100)
+  end
+
+  def render_limit_meter(limit)
+    if FileTest.exist?(File.join(Rails.root, 'app', 'views', 'limits' , "_#{limit.name}_meter.html.erb"))
+      render "limits/#{limit.name}_meter", :limit => limit
+    else
+      render "limits/meter", :limit => limit
+    end
+  end
+end

data/app/mailers/billing_mailer.rb

@@ -0,0 +1,53 @@
+class BillingMailer < ActionMailer::Base
+  def receipt(account, transaction)
+    @account = account
+    @transaction = transaction
+    mail(:to       => account.customer.email,
+         :subject  => I18n.t(:subject,
+                             :scope   => [:saucy, :mailers, :billing_mailer, :receipt],
+                             :default => "Subscription receipt"),
+         :reply_to => Saucy::Configuration.support_email_address,
+         :from     => Saucy::Configuration.support_email_address)
+  end
+
+  def problem(account, transaction)
+    @account = account
+    mail(:to       => account.customer.email,
+         :subject  => I18n.t(:subject,
+                             :scope   => [:saucy, :mailers, :billing_mailer, :problem],
+                             :default => "Problem with subscription billing"),
+         :reply_to => Saucy::Configuration.support_email_address,
+         :from     => Saucy::Configuration.support_email_address)
+  end
+
+  def expiring_trial(account)
+    @account = account
+    mail(:to       => account.admin_emails,
+         :subject  => I18n.t(:subject,
+                            :scope   => [:billing_mailer, :expiring_trial],
+                            :default => "Your trial is expiring soon"),
+         :reply_to => Saucy::Configuration.support_email_address,
+         :from     => Saucy::Configuration.manager_email_address)
+  end
+
+  def new_unactivated(account)
+    @account = account
+    mail(:to       => account.admin_emails,
+         :subject  => I18n.t(:subject,
+                            :scope    => [:billing_mailer, :new_unactivated],
+                            :default  => "A check in from %{app_name}",
+                            :app_name => t("app_name")),
+         :reply_to => Saucy::Configuration.support_email_address,
+         :from     => Saucy::Configuration.manager_email_address)
+  end
+
+  def completed_trial(account)
+    @account = account
+    mail(:to       => account.admin_emails,
+         :subject  => I18n.t(:subject,
+                            :scope   => [:billing_mailer, :completed_trial],
+                            :default => "Your trial has ended"),
+         :reply_to => Saucy::Configuration.support_email_address,
+         :from     => Saucy::Configuration.manager_email_address)
+  end
+end

data/app/mailers/invitation_mailer.rb

@@ -0,0 +1,18 @@
+class InvitationMailer < ActionMailer::Base
+  def invitation(invitation)
+    @invitation = invitation
+    subject = I18n.t(:subject,
+                     :scope   => [:saucy, :mailers, :invitation_mailer, :invititation],
+                     :default => "Invitation")
+    mail :to       => invitation.email,
+         :subject  => subject,
+         :reply_to => invitation.sender_email,
+         :from     => sender_name_and_support_address
+  end
+
+  private
+
+  def sender_name_and_support_address
+    %{"#{@invitation.sender_name}" <#{Saucy::Configuration.support_email_address}>}
+  end
+end

data/app/models/invitation.rb

@@ -0,0 +1,113 @@
+class Invitation < ActiveRecord::Base
+  belongs_to :account
+  belongs_to :sender, :class_name => 'User'
+  validates_presence_of :account_id
+  validates_presence_of :email
+  has_and_belongs_to_many :projects
+
+  before_create :generate_code
+  after_create :deliver_invitation
+
+  attr_accessor :new_user_name, :new_user_password, :authenticating_user_password, :existing_user
+  attr_writer :new_user_email, :authenticating_user_email
+  attr_protected :account_id, :used
+  attr_reader :user
+
+  validate :validate_accepting_user, :on => :update
+
+  def account_name
+    account.name
+  end
+
+  def accept(attributes)
+    self.attributes = attributes
+    self.used = true
+    @user = existing_user || authenticating_user || new_user
+    if valid?
+      transaction do
+        save!
+        @user.save!
+        @user.memberships.create!(:account  => account,
+                                  :admin    => admin,
+                                  :projects => projects)
+      end
+    end
+  end
+
+  def new_user_email
+    @new_user_email ||= email
+  end
+
+  def authenticating_user_email
+    @authenticating_user_email ||= email
+  end
+
+  def to_param
+    code
+  end
+
+  def sender_name
+    sender.name
+  end
+
+  def sender_email
+    sender.email
+  end
+
+  private
+
+  def deliver_invitation
+    InvitationMailer.invitation(self).deliver
+  end
+
+  def existing_user?
+    existing_user.present?
+  end
+
+  def authenticating_user
+    if authenticating_user?
+      User.find_by_email(authenticating_user_email)
+    end
+  end
+
+  def authenticating_user?
+    authenticating_user_password.present?
+  end
+
+  def new_user
+    User.new(
+      :email                 => new_user_email,
+      :password              => new_user_password,
+      :name                  => new_user_name
+    )
+  end
+
+  def validate_accepting_user
+    if authenticating_user?
+      validate_authenticating_user
+    elsif existing_user?
+      true
+    else
+      validate_new_user
+    end
+  end
+
+  def validate_new_user
+    user.valid?
+    user.errors.each do |field, message|
+      errors.add("new_user_#{field}", message)
+    end
+  end
+
+  def validate_authenticating_user
+    if authenticating_user.nil?
+      errors.add(:authenticating_user_email, "isn't signed up")
+    elsif !authenticating_user.authenticated?(authenticating_user_password)
+      errors.add(:authenticating_user_password, "is incorrect")
+    end
+  end
+
+  def generate_code
+    self.code = SecureRandom.hex(8)
+  end
+end

data/app/models/limit.rb

@@ -0,0 +1,49 @@
+class Limit < ActiveRecord::Base
+  belongs_to :plan
+
+  validates_presence_of :name, :value
+
+  def self.numbered
+    where(:value_type => :number)
+  end
+
+  def self.boolean
+    where(:value_type => :boolean)
+  end
+
+  def self.named(name)
+    where(:name => name).first
+  end
+
+  def self.within?(limit_name, account)
+    if account.plan.limit(limit_name)
+      account.plan.limit(limit_name).within?(account)
+    else
+      true
+    end
+  end
+
+  def self.can_add_one?(limit_name, account)
+    if account.plan.limit(limit_name)
+      account.plan.limit(limit_name).can_add_one?(account)
+    else
+      true
+    end
+  end
+
+  def allowed?
+    value != 0
+  end
+
+  def within?(account)
+    current_count(account) <= value
+  end
+
+  def can_add_one?(account)
+    (current_count(account) + 1) <= value
+  end
+
+  def current_count(account)
+    account.send(:"#{name}_count")
+  end
+end

data/app/models/membership.rb

@@ -0,0 +1,26 @@
+class Membership < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :account
+  has_many :permissions, :dependent => :destroy
+  has_many :projects, :through => :permissions
+
+  validates_presence_of :user_id
+  validates_presence_of :account_id
+  validates_uniqueness_of :user_id, :scope => :account_id
+
+  def self.admin
+    where(:admin => true)
+  end
+
+  def name
+    user.name
+  end
+
+  def email
+    user.email
+  end
+
+  def self.by_name
+    joins(:user).order('users.name')
+  end
+end

data/app/models/permission.rb

@@ -0,0 +1,19 @@
+class Permission < ActiveRecord::Base
+  belongs_to :membership
+  belongs_to :project
+  belongs_to :user
+
+  before_validation :assign_user_id_from_membership
+
+  validates_uniqueness_of :membership_id, :scope => :project_id
+
+  def user=(ignored)
+    raise NotImplementedError, "Use Permission#membership= instead"
+  end
+
+  private
+
+  def assign_user_id_from_membership
+    self.user_id = membership.user_id
+  end
+end

data/app/models/signup.rb

@@ -0,0 +1,163 @@
+# Responsible for handling the combo User/Account creation. Also deals with
+# Account creation when signing in as an existing User.
+class Signup
+  extend ActiveModel::Naming
+  include ActiveModel::Conversion
+  include ActiveModel::Validations
+
+  FIELDS = {
+    :account => {
+      :cardholder_name => :cardholder_name, 
+      :billing_email => :billing_email, 
+      :card_number => :card_number, 
+      :expiration_month => :expiration_month, 
+      :expiration_year => :expiration_year,
+      :verification_code => :verification_code,
+      :plan => :plan
+    },
+    :user => {
+      :email    => :email,
+      :password => :password,
+    }
+  }.freeze
+
+  attr_accessor :billing_email, :password, :cardholder_name, :email, 
+    :card_number, :expiration_month, :expiration_year, :plan, :verification_code
+
+  def initialize(attributes = {})
+    if attributes
+      attributes.each do |attribute, value|
+        send(:"#{attribute}=", value)
+      end
+    end
+    @check_password = true
+  end
+
+  # used by ActiveModel
+  def persisted?
+    false
+  end
+
+  def save
+    delegate_attributes_for(:account)
+    populate_additional_account_fields
+
+    if !existing_user
+      delegate_attributes_for(:user) 
+      populate_additional_user_fields
+    end
+
+    if valid?
+      begin
+        save!
+        true
+      rescue ActiveRecord::RecordNotSaved
+        delegate_errors_for(:account)
+        delegate_errors_for(:user)
+        false
+      end
+    else
+      false
+    end
+  end
+
+  def account
+    @account ||= Account.new
+  end
+
+  def user
+    existing_user || new_user
+  end
+
+  def user=(signed_in_user)
+    @check_password = false
+    @existing_user  = signed_in_user
+  end
+
+  def new_user
+    @new_user ||= User.new
+  end
+
+  def existing_user
+    @existing_user ||= User.find_by_email(email)
+  end
+
+  def membership
+    @membership ||= Membership.new(:user    => user,
+                                   :account => account,
+                                   :admin   => true)
+  end
+
+  def valid?
+    errors.clear
+    validate
+    errors.empty?
+  end
+
+  private
+
+  def short_name
+    if email.present?
+      email.split(/@/).first.parameterize
+    elsif user && user.email.present?
+      existing_user.email.split(/@/).first.parameterize
+    end
+  end
+
+  def populate_additional_account_fields
+    account.name = "#{short_name}"
+    account.keyword = "#{short_name}#{SecureRandom.hex(3)}"
+  end
+
+  def populate_additional_user_fields
+    user.name = short_name
+  end
+
+  def delegate_attributes_for(model_name)
+    FIELDS[model_name].each do |target, source|
+      send(model_name).send(:"#{target}=", send(source))
+    end
+  end
+
+  def delegate_errors
+    FIELDS.each do |model_name, fields|
+      delegate_errors_for(model_name, fields)
+    end
+  end
+
+  def delegate_errors_for(model_name)
+    fields = FIELDS[model_name]
+    send(model_name).errors.each do |field, message|
+      errors.add(fields[field], message) if fields[field]
+    end
+  end
+
+  def validate
+    account.valid?
+    delegate_errors_for(:account)
+    if existing_user
+      validate_existing_user
+    else
+      validate_new_user
+    end
+  end
+
+  def validate_new_user
+    new_user.valid?
+    delegate_errors_for(:user)
+  end
+
+  def validate_existing_user
+    if @check_password && !existing_user.authenticated?(password)
+      errors.add(:password, "is incorrect")
+    end
+  end
+
+  def save!
+    Account.transaction do
+      account.save!
+      user.save!
+      membership.save!
+    end
+  end
+end