droom 0.0.1 → 0.2.1

data/app/models/droom/folder.rb

@@ -0,0 +1,134 @@
+require 'zip/zip'
+require 'open-uri'
+
+module Droom
+  class Folder < ActiveRecord::Base
+    attr_accessible :name, :parent, :parent_id
+
+    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"
+
+    validates :slug, :presence => true, :uniqueness => { :scope => :parent_id }
+
+    before_validation :set_properties
+    before_validation :ensure_slug
+    
+    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
+      #   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])
+      #     .group('droom_folders.id')
+      # else
+      #   all_public
+      # end
+      not_private
+    }
+    
+    def visible_to?(person)
+      true
+    end
+
+    # A root folders is created automatically for each class that has_folder, 
+    # 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)
+    }
+
+    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
+
+    def empty?
+      !populated?
+    end
+    
+    def simple?
+      children.empty? && documents.count <= 2
+    end
+    
+    # If we start to get deep folder trees we'll have to use ancestry instead of acts_as_tree.
+    def family
+      self_and_children
+    end
+    
+    def loose?
+      !parent
+    end
+    
+    def ancestor_of?(folder)
+      folder && folder.ancestors.include?(self)
+    end
+
+    def copy_to_dropbox(user)
+      Rails.logger.warn ">>> creating dropbox subfolder #{slug} for user #{user.name}"
+      documents.each { |doc| doc.copy_to_dropbox(user) }
+    end
+    
+    def dropboxed_for?(user)
+      # user.person && dropbox_documents.for_person(person).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?
+    end
+
+  protected
+
+    def set_properties
+      if holder
+        self.name ||= holder.name
+        self.slug ||= holder.slug
+      end
+      # folders originally only had slugs, so this happens from time to time
+      self.name ||= self.slug
+      self.public = !holder && (!parent || parent.public?)
+      true
+    end
+
+    def ensure_slug
+      ensure_presence_and_uniqueness_of(:slug, name.parameterize)
+    end
+
+  end
+end

data/app/models/droom/group.rb

@@ -2,53 +2,77 @@ module Droom
   class Group < ActiveRecord::Base
     attr_accessible :name, :leader_id, :description
 
-    belongs_to :created_by, :class_name => 'User'
+    belongs_to :created_by, :class_name => "Droom::User"
     belongs_to :leader, :class_name => 'Person'
 
+    has_folder
+
     has_many :group_invitations, :dependent => :destroy, :uniq => true
     has_many :events, :through => :group_invitations
 
     has_many :memberships, :dependent => :destroy
     has_many :people, :through => :memberships, :uniq => true
-  
-    has_many :document_attachments, :as => :attachee, :dependent => :destroy
-    has_many :documents, :through => :document_attachments
-  
-    before_save :check_slug
-
-    scope :with_documents, 
-      select("droom_groups.*")
-        .joins("INNER JOIN droom_document_attachments ON droom_groups.id = droom_document_attachments.attachee_id AND droom_document_attachments.attachee_type = 'Droom::Group'")
-        .group("droom_groups.id")
-
-  
-    scope :name_matching, lambda { |fragment| 
+
+    before_validation :ensure_slug
+    before_validation :ensure_mailing_list_name
+
+    validates :slug, :uniqueness => true, :presence => true
+    validates :mailing_list_name, :uniqueness => true, :presence => true
+
+    searchable do
+      text :name, :boost => 10, :stored => true
+      text :description, :stored => true
+    end
+
+    handle_asynchronously :solr_index
+
+    def self.highlight_fields
+      [: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 :visible_to, lambda { |person|
+      if person
+        if person.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])
+            .group('droom_groups.id')
+        end
+      else
+        where("1=0")
+      end
+    }
+
+    scope :matching, lambda { |fragment| 
       fragment = "%#{fragment}%"
       where('droom_groups.name like ?', fragment)
     }
-    
+
     default_scope order("droom_groups.created_at ASC")
-    
-    def identifier
-      'group'
-    end
-  
+
     def admit(person)
       self.people << person
     end
-    
+
     def attach(doc)
-      self.documents << doc
+      # self.documents << doc
     end
 
     def membership_for(person)
       self.memberships.for(person).first
     end
-    
+
     def invite_to(event)
       group_invitations.find_or_create_by_event_id(event.id)
     end
-    
+
     def uninvite_from(event)
       group_invitation = group_invitations.find_by_event_id(event.id)
       group_invitation.invitations.to_event(event).each do |invitation|
@@ -57,10 +81,27 @@ module Droom
       group_invitation.destroy!
     end
     
+    def invited_to?(event)
+      group_invitations.to_event(event).any?
+    end
+
+    def as_suggestion
+      {
+        :type => 'group',
+        :prompt => name,
+        :value => name,
+        :id => id
+      }
+    end
+
   protected
-  
-    def check_slug
+
+    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)
+    end
   end
-end
+end

data/app/models/droom/group_invitation.rb

@@ -6,18 +6,27 @@ module Droom
     belongs_to :group
     belongs_to :event
     has_many :invitations, :dependent => :destroy
-    after_create :create_personal_invitations
+    after_save :create_personal_invitations
     validates_uniqueness_of :group_id, :scope => :event_id
     
     scope :to_event, lambda { |event|
-      where("group_invitations.event_id = ?", event.id)
+      where("droom_group_invitations.event_id = ?", event.id)
     }
     
+    scope :for_group, lambda { |group|
+      where("droom_group_invitations.group_id = ?", group.id)
+    }
+    
+    
     def create_personal_invitations
       group.people.each do |person|
-        invitations.find_or_create_by_person_id_and_event_id(person.id, event.id)
+        create_personal_invitation_for(person)
       end
     end
+
+    def create_personal_invitation_for(person)
+      event.invitations.find_or_create_by_person_id(person.id) if person.member_of?(group)
+    end
     
   end
 end

data/app/models/droom/invitation.rb

@@ -7,24 +7,66 @@ module Droom
     belongs_to :group_invitation
     belongs_to :created_by, :class_name => "User"
 
-    after_create :link_documents
-    after_destroy :unlink_documents
+    after_create :link_folder
+    after_destroy :unlink_folder
+    # after_destroy :delete_similar
 
     validates_uniqueness_of :person_id, :scope => [:event_id, :group_invitation_id]
 
     scope :to_event, lambda { |event|
       where(["event_id = ?", event.id])
     }
-
-  protected
+    
+    scope :for_person, lambda { |person|
+      where("droom_invitations.person_id = ?", person.id)
+    }
+    
+    scope :future, lambda {
+      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")
   
-    def link_documents
-      person.document_attachments << event.document_attachments
+    def link_folder
+      person.add_personal_folders(event.folder)
+    end
+    
+    def unlink_folder
+      person.remove_personal_folders(event.folder)
     end
     
-    def unlink_documents
-      person.document_attachments -= event.document_attachments
+    def status
+      if response < 1
+        "refused"
+      elsif response == 1
+        "maybe"
+      else
+        "accepted"
+      end
+    end
+    
+    def accepted?
+      response && response > 1
     end
 
+    def refused?
+      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

@@ -0,0 +1,128 @@
+# This class has the awkward job of giving access to the mailing list membership records stored in
+# legacy mailman mysql tables. They're likely to be held in another database, and they have an extremely
+# un-rails-like schema, so our main job is to translate between their and our conventions.
+#
+# This whole mechanism and its configuration requirements can safely be ignored unless you want to 
+# use it, in which case you should set `Droom.enable_mailing_lists` to true in an initializer and read on.
+#
+# If you don't set `enable_mailing_lists` then some database activity will still go on, but with no
+# consequence, and the mailing list interface controls will not appear.
+#
+## Requirements
+# 
+# The MailingListMembership class is able to interface directly with your existing mailman data, with 
+# the addition of a couple of columns to support activerecord associations. It's mostly just a case of 
+# configuring access to the old data.
+# 
+# ### Mailman data held in MySQL tables with the 'flat' data structure
+#
+# There are two options here. Either you can use the standard table that has already been created here, 
+# or you can define a `mailman_[env]` connection in database.yml that points to an external mailman
+# database. In that case see the notes below about adding a couple of columns.
+#
+# ### Mailman configured to use MySQL
+#
+# If you don't have an existing mailmanmysql setup, it takes a few steps to point your mailman installation 
+# at this database and table. It can be done either globally or on a per-list basis, so it is possible
+# to keep your existing mailman installation but add a new database-backed mailing list.
+#
+# Mysql storage is considered modern and a bit racy in the mailman community, having only been available
+# since the early 2000s.  It's not officially supported until mailman 3 coalesces out of the ether but if 
+# you speak any python it's easy to make it work with 2.x. Two sets of dusty patches are available here:
+#
+#   http://wiki.list.org/pages/viewpage.action?pageId=15564884
+#
+# and I've found the slightly less ancient version from rezo.net works well:
+#
+#   http://trac.rezo.net/trac/rezo/browser/Mailman
+#
+# In order that we can store membership of different lists in the same table, please make sure that
+# mailman is using the 'flat' data structure. If you want to enable mysql just for selected lists,
+# put an `extend.py` in each list directory and leave the rest of your configuration as it is.
+#
+# It is currently a good idea to avoid reserved words in your mailing list names. They'll work in rails 
+# but not in python, where the quoting of some database queries seems to be less than perfect.
+#
+# ### Minor changes to the mailman table
+#
+# The local table is already set up in a way that should work equally well with rails and mailman. 
+# If you're using a remote mailman table, it will need a couple of small changes:
+#
+# **An id column as primary key.** Strictly speaking we should define a composite primary key based 
+# on address & listname, but it's much easier just to add an auto_incrementing id column and make 
+# that the primary key. Mailman doesn't care as long as its columns are there. You probably also want
+# to create a unique index on address+listname so that mailman gets the benefit and sees the expected 
+# behaviour.
+#
+# **A membership_id column** We could (and used to) twist Activerecord out of shape by defining 
+# associations with address and listname primary keys between mailing list memberships and people 
+# and groups, but again it's much easier just to belong_to a group membership. For that we need a 
+# membership_id column. Again, you will want an index on that column.
+
+module Droom
+  class MailingListMembership < ActiveRecord::Base
+    attr_accessible :address, :listname, :digest, :not_metoo, :nomail, :plain, :ack
+    #
+    ## Configuration
+    #
+    # A dedicated mailman database connection can be defined in the host app's config/database.yml as 
+    # `mailman_development` or `mailman_production` if you want us to use an existing mailman database. 
+    # We can only work with the 'flat' database structure, where all the list memberships are held in 
+    # one table.
+    #
+    # If no such connection is defined, we will use the local `droom_mailing_list_memberships` table.
+    #
+    begin
+      establish_connection :"mailman_#{Rails.env}"
+      set_table_name Droom.mailman_table_name
+    rescue ActiveRecord::AdapterNotSpecified
+      Rails.logger.warn "Droom: No mailman connection configured. Using #{Rails.env} database."
+    end
+
+    ## Associations
+    #
+    # Giving membership of a group will create a mailing list membership automatically. 
+    # The activity status of the created mlm depends on the `Droom.mailing_lists_active_by_default` 
+    # setting, and its effect depends of course on your mailman setup.
+    #
+    belongs_to :membership
+    before_create :set_defaults
+
+    validates :address, :uniqueness => {:scope => :listname}
+
+    ## Translation
+    #
+    # Mailman's boolean columns are held as Y/N so we intervene to translate.
+    #
+    [:digest, :not_metoo, :nomail, :plain, :ack].each do |col|
+      define_method(col) do
+        read_attribute(col) == 'Y'
+      end
+      define_method("#{col}?") do
+        read_attribute(col) == 'Y'
+      end
+      define_method("#{col}=") do |value|
+        write_attribute(col, to_yesno(value))
+      end
+      define_method("#{col}_before_type_cast") do
+        read_attribute(col) == 'Y' ? 1 : 0
+      end
+    end
+
+  private
+
+    def set_defaults
+      self.bi_lastnotice = 0
+      self.bi_date = 0
+      self.ack = true
+      self.nomail = !Droom.mailing_lists_active_by_default?
+      self.digest = Droom.mailing_lists_digest_by_default?
+      true
+    end
+
+    def to_yesno(value)
+      (value && value != 0 && value != "0" && value != "N") ? 'Y' : 'N'
+    end
+  
+  end
+end