droom 0.4.3 → 0.5.3

data/app/models/droom/event_type.rb

@@ -0,0 +1,25 @@
+module Droom
+  class EventType < ActiveRecord::Base
+    include Droom::Concerns::Slugged
+
+    has_many :events, :dependent => :nullify
+    has_folder within: "Events" # here the within arguments sets the name of our parent folder
+
+    before_validation :slug_from_name
+    default_scope -> {order(:name)}
+  
+    def self.for_selection
+      self.all.map {|et| [et.name, et.id]}
+    end
+    
+    def self.default
+      default_type = self.where(:slug => "other_events").first_or_initialize
+      if default_type.new_record?
+        default_type.name = "Other Events"
+        default_type.save
+      end
+      default_type
+    end
+
+  end
+end

data/app/models/droom/folder.rb

@@ -1,74 +1,66 @@
-require 'zip/zip'
 require 'open-uri'
+require 'acts_as_tree'
 
 module Droom
   class Folder < ActiveRecord::Base
-    attr_accessible :name, :parent, :parent_id
+    include ActsAsTree
+    include Droom::Concerns::Slugged
 
     belongs_to :created_by, :class_name => "Droom::User"
     belongs_to :holder, :polymorphic => true
     has_many :documents, :dependent => :destroy
     has_many :personal_folders, :dependent => :destroy
-    acts_as_tree :order => "name ASC"
+    acts_as_tree :order => "droom_folders.name ASC"
 
     validates :slug, :presence => true, :uniqueness => { :scope => :parent_id }
 
     before_validation :set_properties
-    before_validation :ensure_slug
+    before_validation :slug_from_name
     
-    default_scope includes(:documents)
-
-    scope :all_private, where("#{table_name}.private = 1")
-    scope :not_private, where("#{table_name}.private <> 1 OR #{table_name}.private IS NULL")
-    scope :all_public, where("#{table_name}.public = 1 AND #{table_name}.private <> 1 OR #{table_name}.private IS NULL")
-    scope :not_public, where("#{table_name}.public <> 1 OR #{table_name}.private = 1)")
-    scope :by_name, order("#{table_name}.name ASC")
-    scope :visible_to, lambda { |person|
-      if person
+    default_scope -> { includes(:documents) }
+
+    scope :all_private, -> { where("#{table_name}.private = 1") }
+    scope :not_private, -> { where("#{table_name}.private <> 1 OR #{table_name}.private IS NULL") }
+    scope :all_public, -> { where("#{table_name}.public = 1 AND #{table_name}.private <> 1 OR #{table_name}.private IS NULL") }
+    scope :not_public, -> { where("#{table_name}.public <> 1 OR #{table_name}.private = 1)") }
+    scope :by_name, -> { order("#{table_name}.name ASC") }
+    scope :visible_to, -> user {
+      if user
         select('droom_folders.*')
           .joins('LEFT OUTER JOIN droom_personal_folders AS dpf ON droom_folders.id = dpf.folder_id')
-          .where(["(droom_folders.public = 1 OR dpf.person_id = ?)", person.id])
+          .where(["(droom_folders.public = 1 OR dpf.user_id = ?)", user.id])
           .group('droom_folders.id')
       else
         all_public
       end
     }
     
-    def visible_to?(person)
-      true
+    def visible_to?(user)
+      return true if self.public?
+      return false unless user
+      return true if user.admin?
+      return true if user.has_folder?(self)
+      return false if self.private?
+      return true
     end
 
     # A root folder is created automatically for each class that has_folders,
     # the first time something in that class asks for its folder.
     # scope :roots, where('droom_folders.holder_type IS NULL AND droom_folders.parent_id IS NULL')
 
-    scope :loose, where('parent_id IS NULL')
-
-    scope :populated, select('droom_folders.*')
-      .joins('LEFT OUTER JOIN droom_documents AS dd ON droom_folders.id = dd.folder_id LEFT OUTER JOIN droom_folders AS df ON droom_folders.id = df.parent_id')
-      .having('count(dd.id) > 0 OR count(df.id) > 0')
-      .group('droom_folders.id')
-
-    scope :latest, lambda {|limit|
-      order("updated_at DESC, created_at DESC").limit(limit)
+    scope :loose, -> { where('parent_id IS NULL') }
+    scope :latest, -> limit { order("updated_at DESC, created_at DESC").limit(limit) }
+    scope :populated, -> { 
+      select('droom_folders.*')
+        .joins('LEFT OUTER JOIN droom_documents AS dd ON droom_folders.id = dd.folder_id LEFT OUTER JOIN droom_folders AS df ON droom_folders.id = df.parent_id')
+        .having('count(dd.id) > 0 OR count(df.id) > 0')
+        .group('droom_folders.id')
     }
 
     def path
       "#{parent.path if parent}/#{slug}"
     end
 
-    def documents_zipped
-      if self.documents.any?
-        tempfile = Tempfile.new("droom-temp-#{slug}-#{Time.now}.zip")
-        Zip::ZipOutputStream.open(tempfile.path) do |z|
-          self.documents.each do |doc|
-            z.add(doc.file_file_name, doc.original_file)
-          end
-        end
-        tempfile
-      end
-    end
-
     def populated?
       children.any? || documents.any?
     end
@@ -78,7 +70,7 @@ module Droom
     end
     
     def simple?
-      children.empty? && documents.count <= 2
+      children.empty? && documents.count <= 3
     end
     
     # If we start to get deep folder trees we'll have to use ancestry instead of acts_as_tree.
@@ -100,13 +92,9 @@ module Droom
     end
     
     def dropboxed_for?(user)
-      # user.person && dropbox_documents.for_person(person).any?
+      # dropbox_documents.for_user(user).any?
     end
 
-    def copy_to_dav
-      Rails.logger.warn ">>> copy folder #{@folder.inspect} to DAV"
-    end
-    
     def get_name_from_holder
       send :set_properties
       self.save if self.changed?
@@ -116,7 +104,11 @@ module Droom
 
     def set_properties
       if holder
-        self.name ||= holder.name
+        if holder.respond_to?(:folder_name)
+          self.name ||= holder.folder_name
+        else
+          self.name ||= holder.name
+        end
         self.slug ||= holder.slug
       end
       # folders originally only had slugs, so this happens from time to time
@@ -125,9 +117,5 @@ module Droom
       true
     end
 
-    def ensure_slug
-      ensure_presence_and_uniqueness_of(:slug, name.parameterize)
-    end
-
   end
 end

data/app/models/droom/group.rb

@@ -1,19 +1,22 @@
 module Droom
   class Group < ActiveRecord::Base
-    attr_accessible :name, :leader_id, :description
+    include Droom::Concerns::Slugged
 
     belongs_to :created_by, :class_name => "Droom::User"
-    belongs_to :leader, :class_name => 'Person'
+    belongs_to :leader, :class_name => 'Droom::User'
 
     has_folder
 
-    has_many :group_invitations, :dependent => :destroy, :uniq => true
-    has_many :events, :through => :group_invitations
+    has_many :group_invitations, :dependent => :destroy
+    has_many :events, -> { uniq }, :through => :group_invitations
 
     has_many :memberships, :dependent => :destroy
-    has_many :people, :through => :memberships, :uniq => true
+    has_many :users, -> { uniq.order("family_name ASC, given_name ASC") }, :through => :memberships
 
-    before_validation :ensure_slug
+    has_many :group_permissions, :dependent => :destroy
+    has_many :permissions, -> { uniq }, :through => :group_permissions
+    
+    before_validation :slug_from_name
     before_validation :ensure_mailing_list_name
 
     validates :slug, :uniqueness => true, :presence => true
@@ -23,19 +26,19 @@ module Droom
       [:name, :description]
     end
 
-    scope :all_private, where("private = 1")
-    scope :not_private, where("private <> 1 OR private IS NULL")
-    scope :all_public, where("public = 1 AND private <> 1 OR private IS NULL")
-    scope :not_public, where("public <> 1 OR private = 1)")
+    scope :all_private, -> { where("private = 1") }
+    scope :not_private, -> { where("private <> 1 OR private IS NULL") }
+    scope :all_public, -> { where("public = 1 AND private <> 1 OR private IS NULL") }
+    scope :not_public, -> { where("public <> 1 OR private = 1)") }
 
-    scope :visible_to, lambda { |person|
-      if person
-        if person.admin?
+    scope :visible_to, -> user {
+      if user
+        if user.admin?
           scoped({})
         else
           select('droom_groups.*')
             .joins('INNER JOIN droom_memberships as dm on droom_groups.id = dm.group_id')
-            .where(['dm.person_id = ?', person.id])
+            .where(['dm.user_id = ?', user.id])
             .group('droom_groups.id')
         end
       else
@@ -43,31 +46,40 @@ module Droom
       end
     }
 
-    scope :matching, lambda { |fragment| 
+    scope :matching, -> fragment {
       fragment = "%#{fragment}%"
       where('droom_groups.name like ?', fragment)
     }
+    
+    scope :not_shown_in_directory, -> {
+      where(:directory => false)
+    }
+    
+    scope :shown_in_directory, -> {
+      where(:directory => true)
+    }
 
-    default_scope order("droom_groups.created_at ASC")
+    default_scope -> { order("droom_groups.created_at ASC") }
 
-    def admit(person)
-      self.people << person
+    def admit(users)
+      users = *[users].flatten
+      self.users << users
     end
 
     def attach(doc)
       # self.documents << doc
     end
 
-    def membership_for(person)
-      self.memberships.for(person).first
+    def membership_for(user)
+      self.memberships.for(user).first
     end
 
     def invite_to(event)
-      group_invitations.find_or_create_by_event_id(event.id)
+      group_invitations.where(event_id: event.id).first_or_create
     end
 
     def uninvite_from(event)
-      group_invitation = group_invitations.find_by_event_id(event.id)
+      group_invitation = group_invitations.find_by(event_id: event.id)
       group_invitation.invitations.to_event(event).each do |invitation|
         invitation.destroy!
       end
@@ -89,12 +101,8 @@ module Droom
 
   protected
 
-    def ensure_slug
-      ensure_presence_and_uniqueness_of(:slug, name.parameterize)
-    end
-
     def ensure_mailing_list_name
-      ensure_presence_and_uniqueness_of(:mailing_list_name, slug)
+      ensure_presence_of_unique(:mailing_list_name, slug)
     end
   end
 end

data/app/models/droom/group_invitation.rb

@@ -1,7 +1,5 @@
 module Droom
   class GroupInvitation < ActiveRecord::Base
-    attr_accessible :event_id, :group_id
-    
     belongs_to :created_by, :class_name => "User"
     belongs_to :group
     belongs_to :event
@@ -9,24 +7,23 @@ module Droom
     after_save :create_personal_invitations
     validates_uniqueness_of :group_id, :scope => :event_id
     
-    scope :to_event, lambda { |event|
+    scope :to_event, -> event {
       where("droom_group_invitations.event_id = ?", event.id)
     }
     
-    scope :for_group, lambda { |group|
+    scope :for_group, -> group {
       where("droom_group_invitations.group_id = ?", group.id)
     }
     
-    
     def create_personal_invitations
-      group.people.each do |person|
-        create_personal_invitation_for(person)
+      group.users.each do |user|
+        create_personal_invitation_for(user)
       end
     end
 
-    def create_personal_invitation_for(person)
-      event.invitations.find_or_create_by_person_id(person.id) if person.member_of?(group)
+    def create_personal_invitation_for(user)
+      invitations.where(:user_id => user.id, :event_id => event.id).first_or_create
     end
-    
+
   end
 end

data/app/models/droom/group_permission.rb

@@ -0,0 +1,29 @@
+module Droom
+  class GroupPermission < ActiveRecord::Base
+    belongs_to :group
+    belongs_to :permission
+    has_many :user_permissions, :dependent => :destroy
+    after_save :create_user_permissions
+    
+    # This is set up such that a personal permission created by group membership can be deleted
+    # while still leaving in place a personal permission that was granted separately.
+    #
+    def create_user_permissions
+      group.users.each do |user|
+        create_permission_for(user)
+      end
+    end
+
+    def create_permission_for(user)
+      user_permissions.where(:user_id => user.id, :permission_id => permission.id).first_or_create
+    end
+    
+    def self.by_group_id
+      all.each_with_object({}) do |gp, hash|
+        hash[gp.group_id] ||= {}
+        hash[gp.group_id][gp.permission.id] = gp
+      end
+    end
+    
+  end
+end

data/app/models/droom/invitation.rb

@@ -1,46 +1,44 @@
 module Droom
   class Invitation < ActiveRecord::Base
-    attr_accessible :event_id, :person_id
         
-    belongs_to :person
+    belongs_to :user
     belongs_to :event
     belongs_to :group_invitation
     belongs_to :created_by, :class_name => "User"
 
     after_create :link_folder
     after_destroy :unlink_folder
-    # after_destroy :delete_similar
 
-    validates_uniqueness_of :person_id, :scope => [:event_id, :group_invitation_id]
+    validates_uniqueness_of :user_id, :scope => [:event_id, :group_invitation_id]
 
-    scope :to_event, lambda { |event|
+    scope :to_event, -> event {
       where(["event_id = ?", event.id])
     }
     
-    scope :for_person, lambda { |person|
-      where("droom_invitations.person_id = ?", person.id)
+    scope :for_user, -> user {
+      where("droom_invitations.user_id = ?", user.id)
     }
     
-    scope :future, lambda {
+    scope :future, -> {
       select('droom_invitations.*')
         .joins('inner join droom_events as de on droom_invitations.event_id = de.id')
         .where(['de.start > :now', :now => Time.now])
         .group('droom_invitations.id')
     }
     
-    scope :refused, where("response < 1")
-    scope :accepted, where("response > 1")
-    scope :not_refused, where("response > 0")
-    scope :not_accepted, where("response < 2")
-    scope :responded, where("response <> 1")
-    scope :not_responded, where("response == 1")
+    scope :refused, -> { where("response < 1") }
+    scope :accepted, -> { where("response > 1") }
+    scope :not_refused, -> { where("response > 0") }
+    scope :not_accepted, -> { where("response < 2") }
+    scope :responded, -> { where("response <> 1") }
+    scope :not_responded,-> {  where("response == 1") }
   
     def link_folder
-      person.add_personal_folders(event.folder)
+      user.add_personal_folders(event.folder)
     end
     
     def unlink_folder
-      person.remove_personal_folders(event.folder)
+      user.remove_personal_folders(event.folder) if user
     end
     
     def status
@@ -61,12 +59,5 @@ module Droom
       response && response < 1
     end
   
-  protected
-  
-    def delete_similar
-      Droom::Invitation.for_person(person).to_event(event).delete_all
-    end
-    
   end
-  
 end

data/app/models/droom/mailing_list_membership.rb

@@ -61,7 +61,6 @@
 
 module Droom
   class MailingListMembership < ActiveRecord::Base
-    attr_accessible :address, :listname, :digest, :not_metoo, :nomail, :plain, :ack
     #
     ## Configuration
     #

data/app/models/droom/membership.rb

@@ -1,33 +1,29 @@
 module Droom
   class Membership < ActiveRecord::Base
-    attr_accessible :group_id, :person_id
-
-    belongs_to :person
+    belongs_to :user
     belongs_to :group
     belongs_to :created_by, :class_name => "User"
 
     has_one :mailing_list_membership, :dependent => :destroy
 
     after_create :link_folder
-    after_create :make_mailing_list_membership
-    after_create :update_person_status
+    after_create :create_mailing_list_membership
     after_create :create_invitations
+    after_create :create_permissions
+
     after_destroy :unlink_folder
-    after_destroy :update_person_status
     after_destroy :destroy_invitations
+    after_destroy :destroy_permissions
     after_destroy :destroy_similar
     
-    validates :person, :presence => true
-    validates :group, :presence => true
+    accepts_nested_attributes_for :user
 
-    scope :of_group, lambda { |group|
+    # validates :user, :presence => true
+    # validates :group, :presence => true
+
+    scope :of_group, -> group {
       where(["group_id = ?", group.id])
     }
-    
-    scope :privileged, select('droom_memberships.*')
-                         .joins('inner join droom_groups as dg on droom_memberships.group_id = dg.id')
-                         .where('dg.privileged' => true)
-                         .group('droom_memberships.id')
 
     def current?
       expires and expires > Time.now
@@ -43,46 +39,51 @@ module Droom
     # This is sometimes useful if a configuration change means we're looking at a different mailman table.
     #
     def self.repair_mailing_list_memberships
-      self.all.each { |m| m.send :make_mailing_list_membership }
+      self.all.each { |m| m.send :create_mailing_list_membership }
     end
 
   protected
 
     def link_folder
-      person.add_personal_folders(group.folder)
+      user.add_personal_folders(group.folder)
     end
 
     def unlink_folder
-      person.remove_personal_folders(group.folder)
-    end
-
-    def unlink_folder
-      person.remove_personal_folders(group.folder)
+      user.remove_personal_folders(group.folder) if user
     end
     
-    def make_mailing_list_membership
-      self.mailing_list_membership = Droom::MailingListMembership.find_or_create_by_address_and_listname(person.email, group.mailing_list_name)
-    end
-
-    def update_person_status
-      person.send :update_status
+    def create_mailing_list_membership
+      self.mailing_list_membership = Droom::MailingListMembership.where(address: user.email, listname: group.mailing_list_name).first_or_create
     end
 
     def create_invitations
       group.group_invitations.each do |gi|
-        gi.create_personal_invitation_for(person)
+        gi.create_personal_invitation_for(user)
+      end
+    end
+
+    def create_permissions
+      group.group_permissions.each do |gp|
+        gp.create_permission_for(user)
       end
     end
 
     def destroy_invitations
       group.group_invitations.each do |gi|
-        gi.invitations.for_person(person).destroy_all
+        gi.invitations.for_user(user).destroy_all
+      end
+    end
+
+    def destroy_permissions
+      group.group_permissions.each do |gp|
+        gp.user_permissions.for_user(user).destroy_all
       end
     end
 
-    # it's easy to end up with multiple similar membership objects.
+    # it's possible to end up with multiple similar membership objects: here we
+    # assume that when one is deleted, all should be.
     def destroy_similar
-      group.memberships.where(:person_id => person.id).destroy_all
+      group.memberships.where(:user_id => user.id).destroy_all
     end
 
   end