droom 0.0.1 → 0.2.1

data/app/controllers/droom/users_controller.rb

@@ -0,0 +1,69 @@
+module Droom
+  class UsersController < Droom::EngineController
+    helper Droom::DroomHelper
+    respond_to :html, :js
+    layout :no_layout_if_pjax
+    before_filter :authenticate_user!
+    before_filter :require_admin!, :only => [:index, :new, :create, :destroy]
+    before_filter :require_self_or_admin!, :only => [:edit, :update]
+    before_filter :remember_token_auth
+    before_filter :get_user, :only => :edit
+    before_filter :get_user, :only => [:show, :edit, :update, :destroy, :welcome]
+
+    def index
+      @everyone = Droom::Person.all + Droom::User.unpersoned
+    end
+  
+    def edit
+      respond_with @user
+    end
+    
+    # This has to handle small preference updates over js and large account-management forms over html.
+    #
+    def update
+      if @user.update_attributes(params[:user])
+        sign_in(@user, :bypass => true) if @user == current_user        # changing the password invalidates the session unless we refresh it with the new one
+        respond_to do |format|
+          format.js { 
+            partial = params[:response_partial] || "confirmation"
+            render :partial => "droom/users/#{partial}"
+          }
+          format.html {
+            if current_user.admin? && @user != current_user
+              flash[:notice] = t(:user_updated, :name => @user.name)
+            else
+              flash[:notice] = t(:your_preferences_saved)
+            end
+            redirect_to droom.dashboard_url
+          }
+        end
+      else
+        render :edit
+      end
+    end
+
+  protected
+
+    def get_user
+      if current_user.admin? && params[:id]
+        @user = User.find(params[:id])
+      else
+        @user = current_user
+      end
+    end
+  
+  private
+
+    def require_self_or_admin!
+      raise Droom::PermissionDenied unless current_user && (current_user.admin? || @user == current_user)
+    end
+
+    def remember_token_auth
+      if params[:auth_token] && user_signed_in?
+        current_user.remember_me = true 
+        sign_in current_user
+      end
+    end
+
+  end
+end

data/app/controllers/droom/venues_controller.rb

@@ -3,7 +3,6 @@ module Droom
     respond_to :json, :html
   
     before_filter :authenticate_user!  
-    before_filter :get_current_person
     before_filter :get_venues, :only => ["index"]
     before_filter :get_venue, :only => [:show, :update]
 
@@ -32,7 +31,7 @@ module Droom
 
     def get_venue
       @venue = Venue.find(params[:id])
-      @events = @venue.events.visible_to(@current_person).future_and_current
+      @events = @venue.events.visible_to(current_person).future_and_current
     end
 
   end

data/app/controllers/droom/youtube_controller.rb

@@ -0,0 +1,22 @@
+module Droom
+  class YoutubeController < Droom::EngineController
+    respond_to :js, :json
+    before_filter :authenticate_user!
+    layout nil
+
+    def show
+      @video = Droom.yt_client.video_by(params[:yt_id])
+      respond_with @video
+    end
+
+    def index
+      fragment = params[:term]
+      max = params[:limit] || 10
+      @suggestions = []
+      unless fragment.blank?
+        @suggestions = Droom.yt_client.videos_by(:query => fragment, :per_page => max).videos
+      end
+      respond_with @suggestions
+    end
+  end
+end

data/app/helpers/droom/droom_helper.rb

@@ -1,6 +1,94 @@
+require 'dropbox_sdk'
+
 module Droom
   module DroomHelper
+
+    def action_menulink(thing, html_options={})
+      classname = thing.class.to_s.downcase.underscore.split('/').last
+      html_options.reverse_merge!({
+        :class => "",
+        :data => {:menu => "#{classname}_#{thing.id}"}
+      })
+      html_options[:class] << " menu"
+      link_to t(:edit), "#", html_options if editable?(thing)
+    end
+    
+    def action_menu(thing, locals={})
+      if editable?(thing)
+        type = thing.class.to_s.downcase.underscore
+        classname = type.split('/').last
+        locals[classname.to_sym] = thing
+        render :partial => "#{type.pluralize}/action_menu", :locals => locals
+      end
+    end
     
+    def dropbox_link(folder)
+      if dropbox? && current_user.pref('dropbox.strategy') == 'clicked' && folder.populated? && !folder.dropboxed_for?(current_user)
+        link_to t(:copy_to_dropbox), droom.dropbox_folder_url(folder), :id => "dropbox_folder_#{folder.id}", :class => 'dropboxer minimal', :data => {:action => "remove", :removed => "#dropbox_folder_#{folder.id}"}
+      end
+    end
+
+    def dropbox_session
+      # note that we usually don't want to pick up an existing dropbox session. That happens in the dropbox_tokens_controller, when
+      # following up an access token round trip, but in the view any existing session has probably expired and we're better off with a new one.
+      DropboxSession.new(Droom.dropbox_app_key, Droom.dropbox_app_secret)
+    end
+
+    def current_person
+      current_user.person if current_user
+    end
+
+    def admin?
+      current_user and current_user.admin?
+    end
+
+    def pageclass
+      controller.controller_name
+    end
+
+    def preference_checkbox(key)
+      render :partial => "droom/preferences/checkbox", :locals => {:key => key}
+    end
+
+    def preference_radio_set(key, *values)
+      render :partial => "droom/preferences/radio_set", :locals => {:key => key, :values => values}
+    end
+
+    def shorten(text, length=64)
+      length = length[:length] if length.is_a?(Hash)
+      truncate(strip_tags(text), {:length => length, :separator => " "})
+    end
+
+    def dropbox?
+      current_user and !!current_user.dropbox_token
+    end
+    
+    def show_dropbox_links?
+      dropbox?# && preference is 'clicked'
+    end
+    
+    def dropbox_auth_url
+      dbs = dropbox_session
+      # get an auth link address, with our register action as the callback
+      authorization_url = dbs.get_authorize_url(droom.register_dropbox_tokens_url)
+      # store the requesting dropbox session, serialized, in our user's session cookie
+      # if the oauth confirmation is successful, we will need it.
+      session[:dropbox_session] = dbs.serialize
+      authorization_url
+    end
+    
+    def visible?(thing)
+      admin? || privileged? || current_user.can_see?(thing)
+    end
+    
+    def editable?(thing)
+      admin? || current_user == thing.created_by
+    end
+
+    def deletable?(thing)
+      admin? || current_user == thing.created_by
+    end
+
     def nav_link_to(name, url, options={})
       options[:class] ||= ""
       options[:class] << "here" if (request.path == url) || (request.path =~ /^#{url}/ && url != "/")
@@ -57,18 +145,18 @@ module Droom
         end
       end
     end
-    
+
     def url_for_month(date)
-      calendar_url(:year => date.year, :month => date.month)
+      droom.events_url(:year => date.year, :month => date.month)
     end
 
     def url_for_date(date)
-      calendar_url(:year => date.year, :month => date.month, :mday => date.day)      
+      droom.events_url(:year => date.year, :month => date.month, :mday => date.day)
     end
-    
+
     def day_names
       ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
     end
-    
+
   end
 end

data/app/models/droom/agenda_category.rb

@@ -3,6 +3,13 @@ module Droom
     attr_accessible :event_id, :category_id
     belongs_to :category
     belongs_to :event
-    belongs_to :created_by, :class_name => Droom.user_class
+    belongs_to :created_by, :class_name => "Droom::User"
+    has_folder :within => :event
+    accepts_nested_attributes_for :category
+    
+    validates :event, :presence => true
+    validates :category, :presence => true
+    
+    delegate :slug, :name, :to => :category
   end
 end

data/app/models/droom/calendar.rb

@@ -0,0 +1,19 @@
+module Droom
+  class Calendar < ActiveRecord::Base
+    attr_accessible :name, :created_by_id, :events_private, :documents_private
+    belongs_to :created_by, :class_name => "Droom::User"
+
+    before_save :ensure_slug
+
+    has_many :events
+    
+    def self.for_selection
+      self.all.map{|c| [c.name, c.id] }
+    end
+
+    def ensure_slug
+      ensure_presence_and_uniqueness_of(:slug, name.parameterize)
+    end
+
+  end
+end

data/app/models/droom/category.rb

@@ -2,24 +2,22 @@ module Droom
   class Category < ActiveRecord::Base
     attr_accessible :name, :description, :slug
     
-    belongs_to :created_by, :class_name => 'User'
+    belongs_to :created_by, :class_name => "Droom::User"
     has_many :document_attachments
     
-    before_validation :check_slug
+    before_validation :ensure_slug
     validates :slug, :presence => true, :uniqueness => true
     
     default_scope order("droom_categories.name ASC")
         
     # *for_selection* returns a set of [name, id] pairs suitable for use as select options.
     def self.for_selection
-      categories = self.all.map{|c| [c.name, c.id] }
-      categories.unshift(['', ''])
-      categories
+      self.all.map{|c| [c.name, c.id] }
     end
 
   protected
   
-    def check_slug
+    def ensure_slug
       ensure_presence_and_uniqueness_of(:slug, name.parameterize)
     end
 

data/app/models/droom/document.rb

@@ -1,91 +1,86 @@
+require 'open-uri'
+require 'dropbox_sdk'
+require 'yomu'
+
 module Droom
   class Document < ActiveRecord::Base
-    attr_accessible :name, :file, :description, :attachment_category_id, :event_id
+    attr_accessible :name, :file, :description, :folder, :folder_id
 
-    # attachment_category and event_id are used on document creation to create an associated attachment
-    # this is a temporary shortcut 
-    attr_accessor :old_version, :attachment_category_id, :event_id
+    belongs_to :created_by, :class_name => "Droom::User"
+    belongs_to :folder
+    has_many :dropbox_documents
+    has_attached_file :file
 
-    belongs_to :created_by, :class_name => 'User'
+    after_create :read_and_reindex
+
+    after_save :update_dropbox_documents
+    after_destroy :mark_dropbox_documents_deleted
 
-    has_many :document_attachments, :dependent => :destroy
-    has_many :document_links, :through => :document_attachments
-    has_many :people, :through => :document_links
-    
-    has_attached_file :file
-    
-    before_save :set_version
     validates :file, :presence => true
 
-    scope :all_private, where("secret = 1")
-    scope :not_private, where("secret <> 1")
-    scope :all_public, where("public = 1 AND secret <> 1")
-    scope :not_public, where("public <> 1 OR secret = 1)")
-    
+    searchable :auto_index => false, :auto_remove => true do
+      text :name, :boost => 10, :stored => true
+      text :description, :stored => true
+      text :extracted_text, :stored => true
+    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
         select('droom_documents.*')
-          .joins('LEFT OUTER JOIN droom_document_attachments ON droom_documents.id = droom_document_attachments.document_id')
-          .joins('LEFT OUTER JOIN droom_document_links ON droom_document_attachments.id = droom_document_links.document_attachment_id')
-          .where(["(droom_documents.public = 1 OR droom_document_links.person_id = ?)", person.id])
+          .joins('LEFT OUTER JOIN droom_folders AS df ON droom_documents.folder_id = df.id')
+          .joins('LEFT OUTER JOIN droom_personal_folders AS dpf ON df.id = dpf.folder_id')
+          .where(["(droom_documents.public = 1 OR dpf.person_id = ?)", person.id])
           .group('droom_documents.id')
       else
         all_public
       end
     }
-    
-    scope :name_matching, lambda { |fragment|
+
+    scope :matching, lambda { |fragment|
       fragment = "%#{fragment}%"
-      where('droom_documents.name like ?', fragment)
-    }
-    
-    scope :attached_to_these_groups, lambda { |groups|
-      placeholders = groups.map{'?'}.join(',')
-      select('droom_documents.*')
-        .joins('INNER JOIN droom_document_attachments ON droom_documents.id = droom_document_attachments.document_id AND droom_document_attachments.attachee_type = "Droom::Group"')
-        .where(["droom_document_attachments.attachee_id IN(#{placeholders})", *groups.map(&:id)])
+      where('droom_documents.name LIKE :f OR droom_documents.file_file_name LIKE :f', :f => fragment)
     }
     
-    scope :with_latest_event, 
-      select('droom_documents.*, droom_categories.name AS category_name, droom_events.id AS latest_event_id, droom_events.name AS latest_event_name')
-        .joins('LEFT OUTER JOIN droom_document_attachments AS dda ON droom_documents.id = dda.document_id 
-                LEFT OUTER JOIN droom_categories ON dda.category_id = droom_categories.id
-                LEFT OUTER JOIN droom_events ON dda.attachee_id = droom_events.id AND dda.attachee_type = "Droom::Event"')
-        .group('droom_documents.id')
-
-    # so that we can apply the joined finders above to an existing object
-    #
-    scope :this_document, lambda { |doc|
-      where(["droom_documents.id = ?", doc.id])
+    scope :in_folders, lambda{ |folders|
+      placeholders = folders.map { "?" }.join(',')
+      where(["folder_id IN(#{placeholders})", *folders.map(&:id)])
     }
 
     scope :by_date, order("droom_documents.updated_at DESC, droom_documents.created_at DESC")
 
-    def identifier
-      'document'
+    def self.highlight_fields
+      [:name, :description, :extracted_text]
+    end
+
+    def attach_to(holder)
+      self.folder = holder.folder
+    end
+
+    def detach_from(holder)
+      self.folder = nil if self.folder == holder.folder
     end
 
     def file_ok?
       file.exists?
     end
     
-    def changed_since_creation?
-      file_updated_at > created_at
-    end
-    
-    def attachment_category_id=(id)
-      attach_to(Droom::Event.find(event_id), {:category_id => id})
+    def original_file
+      open(self.file.url)
     end
 
-    def attach_to(attachee, attributes={})
-      save!
-      document_attachments.create(attributes.merge(:attachee => attachee))
+    def full_path
+      "#{folder.path if folder}/#{file_file_name}"
     end
     
-    def detach_from(attachee)
-      document_attachments.attached_to(attachee).destroy_all
+    def changed_since_creation?
+      file_updated_at > created_at
     end
-    
+
     def file_extension
       if file_file_name
         File.extname(file_file_name).sub(/^\./, '')
@@ -93,16 +88,60 @@ module Droom
         ""
       end
     end
-    
-    def with_event
-      self.class.this_document(self).with_latest_event.first
+
+    def as_suggestion
+      {
+        :type => 'document',
+        :prompt => name,
+        :value => name,
+        :id => id
+      }
     end
-    
-  protected
-    
-    def set_version
-      if file.dirty?
-        self.version = (version || 0) + 1
+
+    def as_search_result
+      {
+        :type => 'document',
+        :prompt => name,
+        :value => name,
+        :id => id
+      }
+    end
+
+    def copy_to_dropbox(user)
+      dropbox_documents.create(:person_id => user.person.id)
+    end
+
+    def read_and_reindex
+      temp = Paperclip.io_adapters.for(self.file)
+      data = File.read(temp.path)
+      begin
+        self.extracted_text = Yomu.read :text, data
+        self.extracted_metadata = Yomu.read :metadata, data
+      rescue Exception => e
+        Rails.logger.warn "Failed to parse document text or metadata from #{file_file_name}: #{e}"
+      end
+      if self.extracted_text or self.extracted_metadata
+        solr_index
+      end
+      save
+    end
+    handle_asynchronously :read_and_reindex, :priority => 20
+
+    def mark_dropbox_documents_deleted
+      dropbox_documents.each do |dd|
+        dd.mark_deleted(true)
+      end
+    end
+
+    def create_dropbox_documents
+      # after create, in a delayed job
+      # for each user who is syncing our folder, create a dropbox document
+      # that is: everyone who has the sync everything preference or who is associated with the holder of this folder
+    end
+
+    def update_dropbox_documents
+      dropbox_documents.each do |dd|
+        dd.update
       end
     end