simple_teams 0.1.0

data/app/forms/simple_teams/invitation_forms/create_bulk.rb

@@ -0,0 +1,125 @@
+module SimpleTeams
+  class InvitationForms::CreateBulk < ApplicationForm
+
+    attr_accessor :team, :current_user, :single_vs_multiple, :select2_emails, :accessible_emails, :emails, :role
+
+    def initialize(team, current_user)
+      @team = team
+      @current_user = current_user
+      @emails = []
+    end
+
+    def perform(params)
+      self.assign_attributes(params)
+      if accessible?
+        self.emails = accessible_emails.split(",").map(&:strip).uniq.reject(&:empty?)
+      else
+        self.emails = select2_emails.map(&:strip).uniq.reject(&:empty?)
+      end
+
+      if valid?
+        create_invitations
+        generate_notification
+      else
+        false
+      end
+    end
+
+    # Attributes
+    def available_roles
+      SimpleTeams::Membership.roles
+    end
+
+    private
+
+    def accessible?
+      single_vs_multiple == "accessible"
+    end
+
+    def address_attribute
+      accessible? ? :accessible_emails : :select2_emails
+    end
+
+    def valid?
+      self.errors.clear
+      validate_attributes_present
+      validate_invitations
+      validate_role_is_available
+      validate_current_user_has_rights_to_invite_an_owner
+      !self.errors.present?
+    end
+
+    def validate_attributes_present
+      [:team, :current_user, :role].each do |a|
+        unless self.send(a).present?
+          self.errors.add(a, "can't be blank")
+        end
+      end
+      unless self.emails.present?
+        self.errors.add(address_attribute, "can't be blank")
+      end
+    end
+
+    def validate_invitations
+      emails.each do |email|
+        invitation = SimpleTeams::Invitation.new(
+          :team => team,
+          :inviter => current_user,
+          :role => role,
+          :email => email
+        )
+        unless invitation.valid?
+          invitation.errors[:email].each do |error|
+            if error == "is invalid"
+              error_message = "#{email} is not a valid email address"
+            else
+              error_message = error.gsub("this email address", email)
+            end
+            self.errors.add(address_attribute, error_message)
+          end
+        end
+      end
+    end
+
+    def validate_role_is_available
+      # Note: Users will never see this error message unless they hack the form
+      if role.present?
+        unless available_roles.keys.include? role
+          self.errors.add(:role, "that role is not available for this resource")
+        end
+      end
+    end
+
+    def validate_current_user_has_rights_to_invite_an_owner
+      if role == "owner"
+        unless current_user.membership_for_team(team).owner?
+          self.errors.add(:role, "you must be an owner yourself to add add another owner")
+        end
+      end
+    end
+
+    def create_invitations
+      ActiveRecord::Base.transaction do
+        emails.each do |email|
+          SimpleTeams::Invitation.create!(
+            :team => team,
+            :inviter => current_user,
+            :role => role,
+            :email => email
+          )
+        end
+      end
+    end
+
+    def generate_notification
+      SimpleTeams::BulkInvitationsNotification.with(
+        :team_id => team.id,
+        :user_id => current_user.id,
+        :team_name => team.name,
+        :user_name => current_user.full_name,
+        :invitation_names => self.emails,
+      ).deliver_later(team.members)
+    end
+
+  end
+end

data/app/forms/simple_teams/invitation_forms/create_combo.rb

@@ -0,0 +1,75 @@
+module SimpleTeams
+  class InvitationForms::CreateCombo < ApplicationForm
+
+    attr_accessor :team, :current_user, :single_vs_multiple, :email, :emails, :select2_emails, :accessible_emails, :role, :form_instance
+
+    def initialize(team, current_user)
+      @team = team
+      @current_user = current_user
+    end
+
+    def perform(params)
+      # Store input
+      self.assign_attributes(params)
+
+      # Set form instance from input
+      @form_instance = selected_form_klass.new(team, current_user)
+
+      # Perform 
+      if form_instance.perform(filter_params(params))
+        return true
+      else
+        reassign_errors
+        unless single?
+          self.emails = form_instance.emails
+        end
+        false
+      end
+    end
+
+    def available_roles
+      SimpleTeams::Membership.roles
+    end
+
+    private
+    
+    def single?
+      !multiple? and !accessible?
+    end
+
+    def multiple?
+      single_vs_multiple == "multiple"
+    end
+
+    def accessible? 
+      single_vs_multiple == "accessible"
+    end
+
+    def selected_form_klass
+      if single?
+        SimpleTeams::InvitationForms::Create
+      else
+        SimpleTeams::InvitationForms::CreateBulk
+      end
+    end
+
+    def filter_params(params)
+      if single?
+        params.except(:single_vs_multiple, :select2_emails, :accessible_emails)
+      else
+        params.except(:email)
+      end
+    end
+
+    def reassign_errors
+      [:team, :current_user, :email, :select2_emails, :accessible_emails, :role].each do |a|
+        if form_instance.errors[a].present?
+          form_instance.errors[a].each do |error|
+            self.errors.add(a, error)
+          end
+        end
+      end
+    end
+
+  end
+end

data/app/forms/simple_teams/invitation_forms/update.rb

@@ -0,0 +1,29 @@
+module SimpleTeams
+  class InvitationForms::Update < SimpleTeams::InvitationForm
+
+    def initialize(invitation, current_user)
+      @invitation = invitation
+      @team = @invitation.team
+      @current_user = current_user
+
+      # Get existing attributes
+      self.class.invitation_attributes.each do |a|
+        self.assign_attributes(a => @invitation.send(a))
+      end
+    end
+
+    private
+
+    def generate_notification
+      SimpleTeams::Invitations::UpdatedNotification.with(
+        :team_id => team.id,
+        :invitation_id => invitation.id,
+        :user_id => current_user.id,
+        :team_name => team.name,
+        :invitation_name => invitation.email,
+        :user_name => current_user.full_name
+      ).deliver_later(team.members)
+    end
+
+  end
+end

data/app/forms/simple_teams/membership_form.rb

@@ -0,0 +1,91 @@
+module SimpleTeams
+  class MembershipForm < ApplicationForm
+
+    attr_accessor :membership, :current_user, :role
+
+    def initialize(membership, current_user)
+      @membership = membership
+      @current_user = current_user
+
+      # Get existing attributes
+      @role = @membership.role
+    end
+
+    def valid?
+      self.errors.clear
+      validate_role_is_available
+      validate_current_user_has_rights_to_modify_an_existing_owner
+      validate_current_user_has_rights_to_add_an_owner
+      validate_not_last_owner
+      !self.errors.present?
+    end
+
+    def perform(params)
+      self.assign_attributes(params)
+
+      if valid?
+        membership.update(params)
+        generate_notification
+      else
+        false
+      end
+    end
+
+    def available_roles
+      SimpleTeams::Membership.roles
+    end
+
+    private
+
+    def validate_role_is_available
+      # Note: Users will never see this error message unless they hack the form
+      if role.present?
+        unless available_roles.keys.include? role
+          self.errors.add(:role, "that role is not available for this resource")
+        end
+      end
+    end
+
+    def validate_not_last_owner
+      if membership.owner? and only_one_owner? and role != "owner"
+        self.errors.add(:role, "you can't remove the last owner of a team")
+      end
+    end
+
+    def validate_current_user_has_rights_to_modify_an_existing_owner
+      if membership.owner?
+        unless current_user.membership_for_team(team).owner?
+          self.errors.add(:role, "you must be an owner yourself to modify another owner")
+        end
+      end
+    end
+
+    def validate_current_user_has_rights_to_add_an_owner
+      if role == "owner" and !membership.owner?
+        unless current_user.membership_for_team(team).owner?
+          self.errors.add(:role, "you must be an owner yourself to add add another owner")
+        end
+      end
+    end
+
+    def only_one_owner?
+      team.memberships.where(:role => :owner).count == 1
+    end
+
+    def team
+      membership.team
+    end
+
+    def generate_notification
+      SimpleTeams::Memberships::UpdatedNotification.with(
+        :team_id => team.id,
+        :member_id => membership.member.id,
+        :user_id => current_user.id,
+        :team_name => team.name,
+        :member_name => membership.member.full_name,
+        :user_name => current_user.full_name
+      ).deliver_later(team.members)
+    end
+
+  end
+end

data/app/helpers/simple_teams/application_helper.rb

@@ -0,0 +1,4 @@
+module SimpleTeams
+  module ApplicationHelper
+  end
+end

data/app/helpers/simple_teams/invitations_helper.rb

@@ -0,0 +1,4 @@
+module SimpleTeams
+  module InvitationsHelper
+  end
+end

data/app/helpers/simple_teams/memberships_helper.rb

@@ -0,0 +1,4 @@
+module SimpleTeams
+  module MembershipsHelper
+  end
+end

data/app/helpers/simple_teams/teams_helper.rb

@@ -0,0 +1,4 @@
+module SimpleTeams
+  module TeamsHelper
+  end
+end

data/app/jobs/simple_teams/application_job.rb

@@ -0,0 +1,4 @@
+module SimpleTeams
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/simple_teams/application_mailer.rb

@@ -0,0 +1,6 @@
+module SimpleTeams
+  class ApplicationMailer < ActionMailer::Base
+    default from: "from@example.com"
+    layout "mailer"
+  end
+end

data/app/mailers/simple_teams/mailer.rb

@@ -0,0 +1,17 @@
+module SimpleTeams
+  class Mailer < ApplicationMailer
+
+    def invitation_notification(invitation)
+      @invitation = invitation
+      @name = invitation.team.name
+      @resource_name = invitation.team.teamable.class.model_name.human
+      @invitation_url = accept_team_invitation_url(@invitation.token)
+
+      mail(
+        to: (@invitation.email),
+        subject: "Invitation to #{@name} #{@resource_name}"
+      )
+    end
+
+  end
+end

data/app/models/concerns/simple_teams/member_object.rb

@@ -0,0 +1,22 @@
+module SimpleTeams::MemberObject
+  extend ActiveSupport::Concern
+
+  included do
+    has_many :team_memberships, :class_name => "SimpleTeams::Membership", :foreign_key => :member_id, :dependent => :destroy
+    has_many :teams, :through => :team_memberships, :class_name => "SimpleTeams::Team"
+    has_many :team_members, :through => :teams, :source => :members, :class_name => SimpleTeams.member_class.to_s
+  end
+
+  def member_of_team?(team)
+    team_memberships.where(team: team).present?
+  end
+
+  def membership_for_team(team)
+    team_memberships.find_by(:team_id => team.id)
+  end
+
+  def role_for_team(team)
+    membership_for_team(team).role if membership_for_team(team).present?
+  end
+
+end

data/app/models/concerns/simple_teams/team_object.rb

@@ -0,0 +1,23 @@
+module SimpleTeams::TeamObject
+  extend ActiveSupport::Concern
+
+  included do
+    attr_accessor :team_owner
+
+    has_one :team, :as => :teamable, :class_name => "SimpleTeams::Team", :dependent => :destroy
+
+    after_create :generate_team
+
+    def self.team_object?
+      true
+    end
+
+  end
+
+  private
+
+  def generate_team
+    self.create_team!
+  end
+
+end

data/app/models/simple_teams/ability.rb

@@ -0,0 +1,34 @@
+module SimpleTeams
+  class Ability
+    include ::CanCan::Ability
+
+    def initialize(user)
+
+      return unless user.present?
+
+      can :create, Team
+
+      # Team
+      can :read, Team do |team|
+        user.member_of_team?(team)
+      end
+
+      can [:update], Team do |team|
+          %w"owner administrator".include? user.role_for_team(team)
+      end
+
+      can [:destroy], Team do |team|
+          %w"owner".include? user.role_for_team(team)
+      end
+
+      # Team Memberships/Invitations
+      can :read, [Membership, Invitation] do |object|
+        user.member_of_team?(object.team)
+      end
+
+      can :manage, [Membership, Invitation] do |object|
+        %w"owner administrator".include? user.role_for_team(object.team)
+      end
+    end
+  end
+end

data/app/models/simple_teams/application_record.rb

@@ -0,0 +1,5 @@
+module SimpleTeams
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/simple_teams/invitation.rb

@@ -0,0 +1,85 @@
+module SimpleTeams
+  class Invitation < ApplicationRecord
+    belongs_to :team
+    belongs_to :inviter, :class_name => SimpleTeams.member_class.to_s
+    belongs_to :membership, :optional => true
+
+    # validations
+    validates_presence_of :email, :role
+    validates_format_of :email, :with => URI::MailTo::EMAIL_REGEXP
+    validate :email_uninvited, :on => :create
+
+    # callbacks
+    before_validation :format_email
+    before_create :generate_token
+    before_create :set_expires_at
+    after_create :send_invitation_notification
+    after_update :send_invitation_notification, :if => :saved_change_to_email?
+
+    # scopes
+    scope :expired, -> { where("? > expires_at", Time.now) }
+    scope :unexpired, -> { where("? <= expires_at", Time.now) }
+
+    # enums
+    enum :role, [:member, :administrator, :owner]
+    enum :status, [:initial, :accepted, :declined]
+
+    def expired?
+      Time.now > expires_at
+    end
+
+    def unexpired?
+      Time.now <= expires_at
+    end
+
+    def reset_invitation_token
+      generate_token
+      set_expires_at
+      self.save
+    end
+
+    def resend_invitation_notification(options = {})
+      if Time.now > expires_at - self.class.expiration_window + 1.day
+        reset_invitation_token
+      end
+      send_invitation_notification(options)
+    end
+
+    def self.expiration_window
+      2.weeks
+    end
+
+    private
+
+    def format_email
+      self.email = self.email.downcase.strip if email.present?
+    end
+
+    def generate_token
+      self.token = SecureRandom.hex(32)
+    end
+
+    def set_expires_at
+      self.expires_at = Time.now + self.class.expiration_window
+    end
+
+    def send_invitation_notification(options = {})
+      if options[:now] == true
+        SimpleTeams::Mailer.invitation_notification(self).deliver_now
+      else
+        SimpleTeams::Mailer.invitation_notification(self).deliver_later
+      end
+    end
+
+    def email_uninvited
+      if team.members.map { |m| m.email }.include?(email)
+        self.errors.add :email, "A person with this email address is already a member of this team."
+        return false
+      elsif team.invitations.initial.where(:email => email).present?
+        self.errors.add :email, "A person with this email address has already been invited to this team."
+        return false
+      end
+    end
+
+  end
+end

data/app/models/simple_teams/membership.rb

@@ -0,0 +1,16 @@
+module SimpleTeams
+  class Membership < ApplicationRecord
+    belongs_to :team
+    belongs_to :member, :class_name => SimpleTeams.member_class.to_s
+    has_one :invitation, :dependent => :nullify
+
+    enum :role, [:member, :administrator, :owner]
+
+    validates_presence_of :role
+
+    def role_to_s
+      role.humanize.capitalize
+    end
+
+  end
+end

data/app/models/simple_teams/team.rb

@@ -0,0 +1,23 @@
+module SimpleTeams
+  class Team < ApplicationRecord
+
+    # Polymorphic relationship
+    belongs_to :teamable, polymorphic: true
+
+    # Team Relationships
+    has_many :invitations, :dependent => :destroy
+    has_many :memberships, :dependent => :destroy
+    has_many :members, :through => :memberships
+
+    delegate :name, :to => :teamable
+
+    def membership_for(member)
+      memberships.find_by(:member_id => member.id)
+    end
+
+    def remove_member(member)
+      memberships.find_by(:member_id => member.id).destroy
+    end
+
+  end
+end

data/app/notifications/application_notification.rb

@@ -0,0 +1,4 @@
+class ApplicationNotification < Noticed::Base
+  deliver_by :database
+
+end

data/app/notifications/simple_teams/bulk_invitations_notification.rb

@@ -0,0 +1,51 @@
+module SimpleTeams
+  class BulkInvitationsNotification < ApplicationNotification
+
+    param :team_id, :user_id, :team_name, :user_name, :invitation_names
+
+    def message
+      "#{user_name} invited #{invitation_names.to_sentence} to #{team_name}."
+    end
+
+    def subject
+      "Users Invited"
+    end
+
+    def url
+      if team.present? and team.members.include? recipient
+        "/teams/#{team.id}"
+      end
+    end
+
+    def link_text
+      "View Invitations"
+    end
+
+    # Objects
+    def team
+      Team.find_by(id: params[:team_id])
+    end
+
+    def user
+      SimpleTeams.member_class.find_by(id: params[:user_id])
+    end
+
+    # Names (fallback)
+    def team_name
+      team.present? ? team.name : params[:team_name]
+    end
+
+    def invitation_names
+      params[:invitation_names]
+    end
+
+    def user_name
+      if recipient.id == params[:user_id]
+        "You"
+      else
+        user.present? ? user.full_name : params[:user_name]
+      end
+    end
+
+  end
+end