droom 0.4.3 → 0.5.3

data/app/assets/stylesheets/lib/_kalendae.css.sass

@@ -1,139 +0,0 @@
-.kalendae
-  position: relative
-  display: inline-block
-  background: white
-  padding: 0
-  width: 210px
-  cursor: default
-  &.k-floating
-    position: absolute
-    top: 0
-    left: 0
-    z-index: 100
-    margin: 0
-    +box-shadow
-  .k-btn-close
-    display: none
-  .k-calendar
-    display: inline-block
-    overflow: hidden
-  .k-title
-    text-align: center
-    white-space: nowrap
-    position: relative
-    height: 32px
-    font-size: 18px
-    line-height: 32px
-  .k-btn-previous-month, .k-btn-next-month
-    display: block
-    position: absolute
-    width: 32px
-    height: 32px
-    overflow: hidden
-    text-indent: 50px
-    cursor: pointer
-    top: 0
-    background:
-      position: -5px 5px
-      repeat: no-repeat
-      image: image-url('droom/minimonth.png')
-  .k-btn-previous-year, .k-btn-next-year
-    display: none
-  .k-btn-previous-month
-    left: 0
-    background-position: 0 -91px
-    &:hover
-      background-position: 0 -139px
-  .k-btn-next-month
-    right: 0
-    background-position: 0 5px
-    &:hover
-      background-position: 0 -43px
-  .k-btn-previous-month:after
-    content: "\2039"
-  .k-btn-next-month:after
-    content: "\203A"
-  .k-btn-previous-year:after
-    content: "\00AB"
-  .k-btn-next-year:after
-    content: "\00BB"
-  .k-btn-previous-month:hover, .k-btn-next-month:hover
-    color: white
-    background-color: $verypale
-  .k-btn-previous-month:active, .k-btn-next-month:active
-    color: white
-    background-color: $link
-  .k-btn-previous-year:hover, .k-btn-next-year:hover
-    color: #6FDF81
-  .k-title, .k-header, .k-days
-    display: block
-    overflow: hidden
-  &.k-disable-next-month-btn .k-btn-next-month, &.k-disable-previous-month-btn .k-btn-previous-month, &.k-disable-next-year-btn .k-btn-next-year, &.k-disable-previous-year-btn .k-btn-previous-year
-    display: none
-  .k-header span, .k-days span
-    float: left
-    margin: 0
-    border: 0
-    width: 22px
-    padding: 5px 5px 5px 3px
-  .k-header span
-    text-align: center
-    color: $pale
-  .k-days span
-    text-align: right
-    height: 1.1em
-    line-height: 1em
-    color: #999
-  .k-today
-    font-weight: bold
-  .k-days span
-    &.k-active
-      background-color: #fff
-      cursor: pointer
-      color: $dark
-      &:hover
-        background: $verypale
-    &.k-selected
-      background-color: $link
-      font-weight: bold
-      color: white
-    &.k-range
-      background: none
-      border-color: #6DD4FE
-      &.k-active
-        background: #C4D4F1
-        border-color: #19AEFE
-        color: #333
-    &.k-active:hover
-      border-color: #666
-    &.k-out-of-month
-      color: #ddd
-      
-  &.ie8
-    &.k-floating
-      border: 1px solid #ccc
-    .k-btn-close
-      width: 20px
-      height: 20px
-      border: none
-      background: url('close.png') no-repeat top left
-      &:after
-        display: none
-    .k-btn-previous-month, .k-btn-next-month, .k-btn-previous-year, .k-btn-next-year
-      width: 16px
-      height: 16px
-      cursor: pointer
-      background: #777777 url('arrows.png') no-repeat center left
-      position: absolute
-      top: 0
-    .k-btn-next-month, .k-btn-next-year
-      background-position: center right
-    .k-btn-previous-month:hover, .k-btn-next-month:hover
-      background-color: #7EA0E2
-    .k-btn-previous-year, .k-btn-next-year
-      background-color: #333
-    .k-btn-previous-year:hover, .k-btn-next-year:hover
-      background-color: #6FDF81
-    .k-btn-previous-month:after, .k-btn-next-month:after, .k-btn-previous-year:after, .k-btn-next-year:after
-      display: none
-

data/app/controllers/droom/pages_controller.rb

@@ -1,61 +0,0 @@
-module Droom
-  class PagesController < Droom::EngineController
-    respond_to :html
-    before_filter :require_admin!, :except => [:index, :show]
-    before_filter :get_pages
-    before_filter :get_page, :only => [:show, :edit, :update, :destroy]
-    before_filter :build_page, :only => [:new, :create]
-    layout :no_layout_if_pjax
-  
-    def index
-      respond_with(@pages) do |format|
-        format.js {
-          render :partial => 'droom/pages/pages'
-        }
-      end
-    end
-
-    def show
-      respond_with(@page)
-    end
-
-    def new
-      respond_with(@page)
-    end
-
-    def create
-      if @event.save
-        render :partial => "created"
-      else
-        respond_with @event
-      end
-    end
-    
-    def edit
-      
-    end
-
-    def update
-      @page.update_attributes(params[:page])
-      if @page.save
-        render :partial => "full_page"
-      else
-        respond_with @page
-      end
-    end
-
-  protected
-
-    def get_pages
-      @pages = Page.all
-    end
-  
-    def get_page
-      @page = Page.find_by_slug(params[:slug]) || Page.find(params[:id])
-    end
-
-    def build_page
-      @page = Page.new(params[:page])
-    end
-  end
-end

data/app/controllers/droom/people_controller.rb

@@ -1,111 +0,0 @@
-module Droom
-  class PeopleController < Droom::EngineController
-    respond_to :json, :html, :js, :vcf
-    layout :no_layout_if_pjax
-    
-    before_filter :authenticate_user! 
-    before_filter :find_people, :only => :index
-    before_filter :get_groups
-    before_filter :get_person, :only => [:show, :edit, :update, :destroy, :invite]
-    before_filter :build_person, :only => [:new, :create]
-    before_filter :confine_to_self, :except => [:index, :show]
-    
-    def index
-      respond_with @people do |format|
-        format.js { render :partial => 'droom/people/people' }
-        format.vcf { render :vcf => @people.map(&:to_vcf) }
-      end
-    end
-    
-    def show
-      respond_with @person do |format|
-        format.js { 
-          @invitation = Droom::Invitation.find_by_id(params[:invitation_id])
-          render :partial => 'droom/people/person' 
-        }
-      end
-    end
-
-    def create
-      if @person.update_attributes(params[:person])
-        respond_with @person do |format|
-          format.js { render :partial => "droom/users/user_or_person" }
-          format.html { render :partial => "droom/people/person" }
-        end
-      else
-        respond_with @person
-      end
-    end
-
-    def update
-      if @person.update_attributes(params[:person])
-        respond_with @person do |format|
-          format.js { render :partial => "droom/users/user_or_person" }
-          format.html { render :partial => "droom/people/person" }
-        end
-      else
-        respond_with @person
-      end
-    end
-    
-    def destroy
-      @user = @person.user
-      @person.destroy
-      if @user
-        respond_with @user do |format|
-          format.js { render :partial => "droom/users/user_or_person"}
-          format.html { head :ok }
-        end
-      else
-        head :ok 
-      end
-    end
-    
-    def invite
-      @user = @person.invite!
-      render :partial => "droom/users/user_or_person", :locals => {:user_or_person => @person}
-    end
-    
-  protected
-    
-    def build_person
-      @organisation = Droom::Organisation.find(params[:organisation_id]) if params[:organisation_id]
-      @person = Droom::Person.new(params[:person])
-      @person.organisation = @organisation if @organisation
-    end
-
-    def get_person
-      @person = Person.find(params[:id])
-    end
-    
-    def get_groups
-      @groups = Droom::Group.all
-    end
-    
-    def find_people
-      if current_user.admin?
-        @people = Person.scoped({})
-      else
-        @people = Person.visible_to(current_person)
-      end
-      
-      if params[:not_group_id]
-        @people = @people.not_in_group(Droom::Group.find(params[:not_group_id]))
-      end
-
-      unless params[:q].blank?
-        @searching = true
-        @people = @people.matching(params[:q])
-      end
-      
-      @show = params[:show] || 10
-      @page = params[:page] || 1
-      @people = @people.page(@page).per(@show)
-    end
- 
-    def confine_to_self
-      @person = current_user.person unless current_user.admin?
-    end
-  
-  end
-end

data/app/models/droom/document_attachment.rb

@@ -1,37 +0,0 @@
-module Droom
-  class DocumentAttachment < ActiveRecord::Base
-    attr_accessible :attachee, :document, :agenda_section, :category_id
-    
-    belongs_to :document
-    belongs_to :attachee, :polymorphic => true
-    belongs_to :category
-    belongs_to :created_by, :class_name => "Droom::User"
-
-    def slug
-      if attachee 
-        attachee.slug
-      else
-        'Unattached'
-      end
-    end
-    
-    def category_name
-      category ? category.name : "uncategorised"
-    end
-  
-    def move_document_to_folder
-      recipient = if category
-        # attachee will be an event
-        attachee.find_or_create_agenda_category(category)
-      else
-        attachee
-      end
-      if document
-        document.folder = nil
-        recipient.receive_document(document)
-        document.save
-      end
-    end
-  
-  end
-end

data/app/models/droom/page.rb

@@ -1,26 +0,0 @@
-# Pages are currently just minimal text-holders. The text is entered in markdown, 
-# rendered on save and placed into the usual layout.
-#
-module Droom
-  class Page < ActiveRecord::Base
-    attr_accessible :title, :slug, :summary, :body, :video_id
-    
-    before_validation :ensure_slug
-    before_save :render_body
-    validates :slug, :uniqueness => true, :presence => true
-    validates :title, :presence => true
-    default_scope order('title ASC')
-  
-  protected
-
-    def ensure_slug
-      ensure_presence_and_uniqueness_of(:slug, title.parameterize)
-    end
-
-    def render_body
-      Rails.logger.warn ">>> rendering body: #{self.body.inspect}"
-      markdown = RDiscount.new(self.body)
-      self.rendered_body = markdown.to_html
-    end
-  end
-end

data/app/models/droom/person.rb

@@ -1,309 +0,0 @@
-# This has been pulled from the yearbook and simplified. Docs need updating to match.
-require 'vcard'
-
-module Droom
-  class Person < ActiveRecord::Base
-    attr_accessible :name, :forename, :email, :phone, :description, :user, :user_id, :title, :invite_on_creation, :admin_user, :position, :post_line1, :post_line2, :post_city, :post_region, :post_code, :mobile, :dob, :organisation_id
-    attr_accessor :invite_on_creation, :admin_user
-    acts_as_list
-
-    belongs_to :organisation
-    belongs_to :created_by, :class_name => "Droom::User"
-    has_many :organisations, :foreign_key => :owner_id
-
-    ### Group memberships
-    #
-    has_many :memberships, :dependent => :destroy
-    has_many :groups, :through => :memberships
-    has_many :mailing_list_memberships, :through => :memberships
-    
-    has_many :dropbox_documents
-    
-    has_many :preferences, :dependent => :destroy, :foreign_key => :created_by_id
-    accepts_nested_attributes_for :preferences
-
-    # The data requirements are minimal, with the idea that the directory will be populated gradually.
-    validates :name, :presence => true
-
-    def admit_to(group)
-      memberships.find_or_create_by_group_id(group.id) if group
-    end
-    
-    def expel_from(group)
-      memberships.of_group(group).destroy_all
-    end
-
-    def member_of?(group)
-      group && memberships.of_group(group).any?
-    end
-
-    ### Event invitations
-    #
-    has_many :invitations, :dependent => :destroy
-    has_many :events, :through => :invitations
-
-    def invite_to(event)
-      invitations.find_or_create_by_event_id(event.id) if event
-    end
-    
-    def uninvite_from(event)
-      invitations.to_event(event).destroy_all
-    end
-
-    def invited_to?(event)
-      event && !!invitation_to(event)
-    end
-    
-    def invitation_to(event)
-      invitations.to_event(event).first
-    end
-
-    ## Folder permissions
-    #
-    # To simplify the business of showing and listing documents, we have adopted the convention that all
-    # documents live in a folder. Person accounts have links to those folders through the very thin
-    # PersonalFolder joining class, and at the view level we only ever show folder and subfolder lists.
-    # The only place we ever need a list of all the documents visible to this person is when searching, and
-    # for that we use the Document.visible_to scope, usually by way of the #documents method defined below.
-    #
-    # Personal folders are created and destroyed along with invitations and memberships..
-    #
-    has_many :personal_folders
-    has_many :folders, :through => :personal_folders
-
-    def add_personal_folders(folders=[])
-      self.folders << folders if folders
-    end
-    
-    def remove_personal_folders(folders=[])
-      self.folders.delete(folders) if folders
-    end
-    
-    def documents
-      Document.visible_to(self)
-    end
-    
-    ## User accounts
-    #
-    # The `user` is this person's administrative account for logging in and out and forgetting her password.
-    # A person can be listed without ever having a user, and a user account can exist (for an administrator) 
-    # without having a person.
-    belongs_to :user, :class_name => "Droom::User"
-    before_save :update_user
-
-    after_create :invite_if_instructed
-
-    scope :unusered, where("user_id IS NULL")
-    scope :usered, where("user_id IS NOT NULL")
-
-    # some magic glue to allow slightly indiscriminate use of user and person objects.
-    
-    def person
-      self
-    end
-    
-    def admin?
-      user && user.admin?
-    end
-
-    def has_admin_user?
-      user && user.admin?
-    end
-
-
-    ### Images
-    #
-    has_upload :image, 
-               :geometry => "520x520#",
-               :styles => {
-                 :icon => "32x32#",
-                 :thumb => "130x130#",
-                 :precrop => "1200x1200<"
-               }
-
-    ## Scopes
-    
-    default_scope order("droom_people.#{Droom.people_sort}")
-
-    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 :matching, lambda { |fragment| 
-      fragment = "%#{fragment}%"
-      where('droom_people.name LIKE :f OR droom_people.forename LIKE :f OR droom_people.email LIKE :f OR droom_people.phone LIKE :f OR CONCAT(droom_people.forename, " ", droom_people.name) LIKE :f', :f => fragment)
-    }
-    
-    # warning! won't work in SQLite.
-    scope :visible_to, lambda { |person|
-      if person
-        if person.admin?
-          scoped({})
-        else
-          select('droom_people.*')
-            .joins('LEFT OUTER JOIN droom_memberships as dm1 on droom_people.id = dm1.person_id')
-            .joins('LEFT OUTER JOIN droom_memberships as dm2 on dm1.group_id = dm2.group_id')
-            .where(['(dm2.person_id = ?) OR (droom_people.private <> 1)', person.id])
-            .group('droom_people.id')
-        end
-      else
-        all_public
-      end
-    }
-    
-    scope :personally_invited_to_event, lambda { |event|
-      joins('LEFT OUTER JOIN droom_invitations on droom_people.id = droom_invitations.person_id').where('droom_invitations.group_invitation_id is null AND droom_invitations.event_id = ?', event.id)
-    }
-
-
-    def membership_of(group)
-      memberships.find_by_group_id(group.id)
-    end
-
-
-
-
-
-    
-
-    def full_name
-      [forename, name].compact.join(' ').strip
-    end
-
-    def formal_name
-      [title, forename, name].compact.join(' ').strip
-    end
-    
-    def informal_name
-      if Droom.use_forenames
-        forename
-      else
-        name
-      end
-    end
-
-    # *for_selection* returns a list of people in options_for_select format with which to populate a select box.
-    # 
-    def self.for_selection
-      self.published.map{|p| [p.name, p.id] }
-    end
-
-
-    
-
-
-
-
-
-    
-    
-    
-    
-    # Snail is a library that abstracts away - as far as possible - the vagaries of international address formats. Here we map our data columns onto Snail's abstract representations so that they can be rendered into the correct format for their country.
-    def address
-      Snail.new(
-        :line_1 => post_line1,
-        :line_2 => post_line2,
-        :city => post_city,
-        :region => post_region,
-        :postal_code => post_code,
-        :country => post_country
-      )
-    end
-    
-    def address?
-      post_line1? && post_city
-    end
-    
-    def to_vcf
-      @vcard ||= Vcard::Vcard::Maker.make2 do |maker|
-        maker.add_name do |n|
-          n.given = name || ""
-        end
-        maker.add_addr {|a| 
-          a.location = 'home' # until we do this properly with multiple contact sets
-          a.country = post_country || ""
-          a.region = post_region || ""
-          a.locality = post_city || ""
-          a.street = "#{post_line1}, #{post_line2}"
-          a.postalcode = post_code || ""
-        }
-        maker.add_tel phone { |t| t.location = 'home' } unless phone.blank?
-        # maker.add_tel mobile { |t| t.location = 'cell' } unless mobile.blank?
-        maker.add_email email { |e| t.location = 'home' }
-      end
-      @vcard.to_s
-    end
-    
-    def self.vcards_for(people=[])
-      people.map(&:vcf).join("\n")
-    end
-    
-    def as_suggestion
-      {
-        :type => 'person',
-        :prompt => formal_name,
-        :value => formal_name,
-        :id => id
-      }
-    end
-
-    def as_search_result
-      {
-        :type => 'person',
-        :prompt => name,
-        :value => name,
-        :id => id
-      }
-    end
-
-    def invitable?
-      name? && email?
-    end
-    
-    def invite!
-      invite_user
-    end
-
-  protected
-
-    def invite_if_instructed
-      invite_user if invite_on_creation?
-    end
-    
-    # ### Administration & callbacks
-    #
-    # At some point we may want to create a user to log in and look after this person. 
-    # This usually has the side effect of sending out a confirmation message.
-    #
-    
-    def invite_on_creation?
-      !!invite_on_creation && invite_on_creation != 0 && invite_on_creation != "0"
-    end
-    
-    def invite_user
-      if self.user
-        self.user.send_confirmation_instructions
-      elsif invitable?
-        user = self.create_user(:forename => forename, :name => name, :email => email)
-        self.save
-      end
-      self.user
-    end
-  
-    def update_user
-      if self.user && self.user.persisted?
-        self.user.update_column(:email, self.email) if email_changed?
-        self.user.update_column(:name, self.name) if name_changed?
-        self.user.update_column(:forename, self.forename) if forename_changed?
-      end
-    end
-    
-    def update_status
-      update_column(:privileged, memberships.privileged.any?)
-    end
-        
-  end
-end
-