radiant-reader-extension 1.3.13 → 2.0.0.rc4

data/app/helpers/reader_helper.rb

@@ -1,11 +1,12 @@
 require 'sanitize'
+require "sanitize/config/generous"
 
 module ReaderHelper
   def standard_gravatar_for(reader=nil, url=nil)
     size = Radiant::Config['forum.gravatar_size'] || 40
     url ||= reader_url(reader)
     gravatar = gravatar_for(reader, {:size => size}, {:class => 'gravatar offset', :width => size, :height => size})
-    link_to gravatar, url
+    content_tag(:div, link_to(gravatar, url), :class => "speaker")
   end
 
   def gravatar_for(reader=nil, gravatar_options={}, img_options ={})
@@ -25,28 +26,21 @@ module ReaderHelper
     link_to home_page.title, home_page.url, options
   end
 
-  def clean_textilize(text)
-    Sanitize.clean(textilize(text), Sanitize::Config::RELAXED)
+  def scrub_html(text)
+    Sanitize.clean(textilize(text))
   end
 
-  def clean_textilize_without_paragraph(text)
-    textiled = clean_textilize(text)
-    if textiled[0..2] == "<p>" then textiled = textiled[3..-1] end
-    if textiled[-4..-1] == "</p>" then textiled = textiled[0..-5] end
-    textiled
+  def clean_html(text)
+    Sanitize.clean(textilize(text), Sanitize::Config::GENEROUS)
   end
 
-  def truncate_words(text='', length=64, omission="...")
+  def truncate_words(text='', length=24, omission="...")
     return '' if text.blank?
     words = text.split
     omission = '' unless words.size > length
     words[0..(length-1)].join(" ") + omission
   end 
   
-  def truncate_and_textilize(text, length=64)
-    clean_textilize( truncate_words(text, length) )
-  end
-
   def pagination_and_summary_for(list, name='')
     %{<div class="pagination">
         #{will_paginate list, :container => false}
@@ -60,18 +54,52 @@ module ReaderHelper
   def pagination_summary(list, name='')
     total = list.total_entries
     if list.empty?
-      %{#{t('no')} #{name.pluralize}}
+      %{#{t('reader_extension.no')} #{name.pluralize}}
     else      
       name ||= t(list.first.class.to_s.underscore.gsub('_', ' '))
       if total == 1
-        %{#{t('showing')} #{t('one')} #{name}}
+        %{#{t('reader_extension.showing')} #{t('reader_extension.one')} #{name}}
       elsif list.current_page == 1 && total < list.per_page
-        %{#{t('all')} #{total} #{name.pluralize}}
+        %{#{t('reader_extension.all')} #{total} #{name.pluralize}}
       else
         start = list.offset + 1
         finish = ((list.offset + list.per_page) < list.total_entries) ? list.offset + list.per_page : list.total_entries
-        %{#{start} #{t('to')} #{finish} #{t('of')} #{total} #{name.pluralize}}
+        %{#{start} #{t('reader_extension.to')} #{finish} #{t('reader_extension.of')} #{total} #{name.pluralize}}
+      end
+    end
+  end
+  
+  def message_preview(subject, body, reader)
+    preview = <<EOM
+From: #{current_user.name} &lt;#{current_user.email}&gt;
+To: #{reader.name} &lt;#{reader.email}&gt;
+Date: #{Time.now.to_date.to_s :long}
+<strong>Subject: #{subject}</strong>
+
+Dear #{reader.name},
+
+#{body}
+
+EOM
+  simple_format(preview)
+  end
+
+  def choose_page(object, field, select_options={})
+    root = Page.respond_to?(:homepage) ? Page.homepage : Page.find_by_parent_id(nil)
+    options = page_option_branch(root)
+    options.unshift ['<none>', nil]
+    select object, field, options, select_options
+  end
+
+  def page_option_branch(page, depth=0)
+    options = []
+    unless page.title.first == '_'
+      options << ["#{". " * depth}#{h(page.title)}", page.id]
+      page.children.each do |child|
+        options += page_option_branch(child, depth + 1)
       end
     end
+    options
   end
+
 end

data/app/models/group.rb

@@ -0,0 +1,80 @@
+class Group < ActiveRecord::Base
+
+  has_site if respond_to? :has_site
+  default_scope :order => 'name'
+
+  belongs_to :created_by, :class_name => 'User'
+  belongs_to :updated_by, :class_name => 'User'
+  belongs_to :homepage, :class_name => 'Page'
+
+  has_many :messages
+  has_many :permissions
+  has_many :pages, :through => :permissions
+  has_many :memberships
+  has_many :readers, :through => :memberships
+  
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  
+  named_scope :with_home_page, { :conditions => "homepage_id IS NOT NULL", :include => :homepage }
+  named_scope :subscribable, { :conditions => "public = 1" }
+  named_scope :unsubscribable, { :conditions => "public = 0" }
+
+  named_scope :from_list, lambda { |ids|
+    { :conditions => ["groups.id IN (#{ids.map{"?"}.join(',')})", *ids] }
+  }
+
+  named_scope :attached_to, lambda { |objects|
+    conditions = objects.map{|o| "(pp.permitted_type = ? AND pp.permitted_id = ?)" }.join(" OR ")
+    binds = objects.map{|o| [o.class.to_s, o.id]}.flatten
+    {
+      :select => "groups.*, count(pp.group_id) AS pcount",
+      :joins => "INNER JOIN permissions as pp on pp.group_id = groups.id", 
+      :conditions => [conditions, *binds],
+      :having => "pcount > 0",    # otherwise attached_to([]) returns all groups
+      :group => column_names.map { |n| self.table_name + '.' + n }.join(','),
+      :readonly => false
+    }
+  }
+
+  def url
+    homepage.url if homepage
+  end
+  
+  def send_welcome_to(reader)
+    if reader.activated?                                                             # welcomes are also triggered on activation
+      if message = Message.belonging_to(self).for_function('group_welcome').first    # only if a group_welcome message exists *belonging to this group*
+        message.deliver_to(reader)
+      end
+    end
+  end
+
+  def admit(reader)
+    self.readers << reader
+  end
+
+  def permission_for(object)
+    self.permissions.for(object).first
+  end
+
+  def membership_for(reader)
+    self.memberships.for(reader).first
+  end
+  
+  # we can't has_many through the polymorphic permission relationship, so this is called from has_groups
+  # and for eg. Page, it defines:
+  # Permission.for_pages named_scope
+  # Group.page_permissions  => set of permission objects
+  # Group.pages             => set of page objects
+  
+  def self.define_retrieval_methods(classname)
+    type_scope = "for_#{classname.downcase.pluralize}".intern
+    Permission.send :named_scope, type_scope, :conditions => { :permitted_type => classname }
+    define_method("#{classname.downcase}_permissions") { self.permissions.send type_scope }
+    define_method("#{classname.downcase.pluralize}") { self.send("#{classname.to_s.downcase}_permissions".intern).map(&:permitted) }
+  end
+  
+  
+
+end
+

data/app/models/membership.rb

@@ -0,0 +1,13 @@
+class Membership < ActiveRecord::Base
+
+  belongs_to :group
+  belongs_to :reader
+  
+  named_scope :for, lambda { |reader|
+    {
+      :conditions => ["memberships.reader_id = ?", reader.id]
+    }
+  }
+  
+end
+

data/app/models/message.rb

@@ -1,14 +1,12 @@
 class Message < ActiveRecord::Base
 
+  has_groups
   has_site if respond_to? :has_site
 
   belongs_to :layout
   belongs_to :created_by, :class_name => 'User'
   belongs_to :updated_by, :class_name => 'User'
 
-  has_many :message_readers
-  has_many :readers, :through => :message_readers
-
   has_many :deliveries, :class_name => 'MessageReader', :conditions => ["message_readers.sent_at IS NOT NULL and message_readers.sent_at <= ?", Time.now.to_s(:db)]
   has_many :recipients, :through => :deliveries, :source => :reader
 
@@ -29,7 +27,7 @@ class Message < ActiveRecord::Base
 
   # has to return a named_scope for chainability
   def possible_readers
-    Reader.active
+    groups.any? ? Reader.in_groups(groups) : Reader.scoped({})
   end
 
   def undelivered_readers
@@ -57,15 +55,20 @@ class Message < ActiveRecord::Base
   end
 
   def preview(reader=nil)
-    reader ||= possible_readers.first || Reader.find_or_create_for_user(created_by)
+    reader ||= possible_readers.first || Reader.for_user(created_by)
     ReaderNotifier.create_message(reader, self)
   end
   
   def function
     MessageFunction[self.function_id]
   end
-  def self.functional(function)
-    for_function(MessageFunction[function]).first
+  def self.functional(function, group=nil)
+    messages = for_function(function)
+    if group
+      messages.belonging_to(group).first
+    else
+      messages.ungrouped.first
+    end
   end
   def has_function?
     !function.nil?

data/app/models/permission.rb

@@ -0,0 +1,11 @@
+class Permission < ActiveRecord::Base
+
+  belongs_to :group
+  belongs_to :permitted, :polymorphic => true
+  
+  named_scope :for, lambda { |object|
+    { :conditions => ["permissions.permitted_id = ? and permissions.permitted_type = ?", object.id, object.class.to_s] }
+  }
+  
+end
+

data/app/models/reader.rb

@@ -5,37 +5,39 @@ class Reader < ActiveRecord::Base
   @@user_columns = [:name, :email, :login, :created_at, :password, :notes]
   cattr_accessor :user_columns
   cattr_accessor :current
-  default_scope :order => 'name ASC'
-
-  has_site if respond_to? :has_site
+  attr_accessor :email_field        # used in blocking spam registrations
 
   acts_as_authentic do |config|
     config.validations_scope = :site_id if defined? Site
     config.transition_from_restful_authentication = true
     config.validate_email_field = false
     config.validate_login_field = false
+    config.validate_password_field = false
   end
 
   belongs_to :user
   belongs_to :created_by, :class_name => 'User'
   belongs_to :updated_by, :class_name => 'User'
-
   has_many :message_readers
   has_many :messages, :through => :message_readers
+  has_many :memberships
+  has_many :groups, :through => :memberships
+  accepts_nested_attributes_for :memberships
 
-  attr_accessor :current_password   # used for authentication on update
-  attr_accessor :email_field        # used in blocking spam registrations
-  
   before_update :update_user
 
-  validates_presence_of :name, :email, :message => 'is required'
-  validates_uniqueness_of :login, :message => "is already in use here", :allow_blank => true
+  validates_presence_of :name, :email
+  validates_length_of :name, :maximum => 100, :allow_nil => true
+  validates_length_of :password, :minimum => 6, :allow_nil => false, :unless => :existing_reader_keeping_password?
+  # validates_format_of :password, :with => /[^A-Za-z]/, :unless => :existing_reader_keeping_password?  # we have to match radiant so that users can log in both ways
+  validates_confirmation_of :password, :unless => :existing_reader_keeping_password?
+  validates_uniqueness_of :login, :allow_blank => true
   validate :email_must_not_be_in_use
 
   include RFC822
-  validates_format_of :email, :with => RFC822_valid, :message => 'appears not to be an email address'
-  validates_length_of :name, :maximum => 100, :allow_nil => true
+  validates_format_of :email, :with => RFC822_valid
 
+  default_scope :order => 'name ASC'
   named_scope :any
   named_scope :active, :conditions => "activated_at IS NOT NULL"
   named_scope :inactive, :conditions => "activated_at IS NULL"
@@ -49,9 +51,34 @@ class Reader < ActiveRecord::Base
     end
   }
 
+  named_scope :in_groups, lambda { |groups| 
+    {
+      :select => "readers.*",
+      :joins => "INNER JOIN memberships as mm on mm.reader_id = readers.id", 
+      :conditions => ["mm.group_id IN (#{groups.map{'?'}.join(',')})", *groups.map{|g| g.is_a?(Group) ? g.id : g}],
+      :group => "mm.reader_id"
+    }
+  }
+
   def self.find_by_login_or_email(login_or_email)
     reader = find(:first, :conditions => ["login = ? OR email = ?", login_or_email, login_or_email])
   end
+  
+  def self.for_user(user)
+    if user.respond_to?(:site) && site = Page.current_site
+      reader = self.find_or_create_by_site_id_and_user_id(site.id, user.id)
+    else
+      reader = self.find_or_create_by_user_id(user.id)
+    end
+    if reader.new_record?
+      user_columns.each { |att| reader.send("#{att.to_s}=", user.send(att)) }
+      reader.crypted_password = user.password
+      reader.password_salt = user.salt
+      reader.activated_at = reader.created_at
+      reader.save(false)
+    end
+    reader
+  end
 
   def forename
     read_attribute(:forename) || name.split(/\s/).first
@@ -60,7 +87,8 @@ class Reader < ActiveRecord::Base
   def activate!
     self.activated_at = Time.now.utc
     self.save!
-    self.send_welcome_message
+    send_welcome_message
+    send_group_welcomes
   end
 
   def activated?
@@ -81,9 +109,9 @@ class Reader < ActiveRecord::Base
     }
   end
 
-  def send_functional_message(function)
+  def send_functional_message(function, group=nil)
     reset_perishable_token!
-    message = Message.functional(function)
+    message = Message.functional(function, group)   # returns the standard functional message if no group is supplied, or no group message exists
     raise StandardError, "No #{function} message could be found" unless message
     message.deliver_to(self)
   end
@@ -99,46 +127,54 @@ class Reader < ActiveRecord::Base
   def is_admin?
     is_user? && self.user.admin?
   end
-
-  def self.find_or_create_for_user(user)
-    if user.respond_to?(:site) && site = Page.current_site
-      reader = self.find_or_create_by_site_id_and_user_id(site.id, user.id)
-    else
-      reader = self.find_or_create_by_user_id(user.id)
-    end
-    if reader.new_record?
-      user_columns.each { |att| reader.send("#{att.to_s}=", user.send(att)) }
-      reader.crypted_password = user.password
-      reader.password_salt = user.salt
-      reader.activated_at = reader.created_at
-      reader.save(false)
-    end
-    reader
-  end
-
+  
   def create_password!
     self.clear_password = self.randomize_password # randomize_password is provided by authlogic
     self.save! unless self.new_record?
     self.clear_password
   end
 
+  def find_homepage
+    if homegroup = groups.with_home_page.first
+      homegroup.homepage
+    end
+  end
+
+  def can_see? (this)
+    permitted_groups = this.permitted_groups
+    permitted_groups.empty? or in_any_of_these_groups?(permitted_groups)
+  end
+    
+  def in_any_of_these_groups? (grouplist)
+    (grouplist & groups).any?
+  end
+
+  def is_in? (group)
+    groups.include?(group)
+  end
+  
+  # has_group? is ambiguous: with no argument it means 'is this reader grouped at all?'.
+  def has_group?(group=nil)
+    group.nil? ? groups.any? : is_in?(group)
+  end
+  
 private
 
   def email_must_not_be_in_use
     reader = Reader.find_by_email(self.email)   # the finds will be site-scoped if appropriate
     user = User.find_by_email(self.email)
     if user && user != self.user
-      errors.add(:email, "belongs to an author already known here")
+      errors.add :value, :taken_by_author
     elsif reader && reader != self
-      errors.add(:email, "is already registered here")
+      errors.add :value, :taken
     else
       return true
     end
     return false
   end
 
-  def validate_length_of_password?
-    new_record? or not password.to_s.empty?
+  def existing_reader_keeping_password?
+    !new_record? && !password_changed?
   end
 
   def update_user
@@ -148,5 +184,13 @@ private
       self.user.save! if self.user.changed?
     end
   end
+  
+  def send_group_welcomes
+    groups.each { |g| g.send_welcome_to(self) }
+  end
+
+  def send_group_invitation_message(group=nil)
+    send_functional_message('invitation', group)
+  end
 
 end

data/app/models/reader_notifier.rb

@@ -23,6 +23,7 @@ class ReaderNotifier < ActionMailer::Base
       :host => host,
       :title => message.subject,
       :message => message.filtered_body,
+      :group => message.group,
       :sender => sender,
       :reply_to => sender_address,
       :reader => reader,

data/app/views/admin/group_invitations/new.html.haml

@@ -0,0 +1,31 @@
+- include_stylesheet('admin/reader_group')
+
+%h1 
+  = t('reader_extension.invite_into_group', :name => @group.name)
+
+- if message = @group.messages.for_function('invitation').first
+
+  - form_for :group, @group, :url => admin_group_group_invitations_url(@group), :html => {:id => 'preview_form', :method => 'post'} do
+    .form-area
+      %p
+        %label{:for => "readerlist"}
+          List of people
+          %span.formnote
+            - if Radiant::Config['reader.use_honorifics?']
+              title or rank, 
+            name, email, [login], [phone]
+        = text_area_tag "readerlist", params[:readerlist], :class => "textarea", :style => "width: 100%; height: 240px;"
+
+      %p.buttons
+        = submit_tag 'preview import', :class => 'button'
+        or
+        = link_to "Cancel", admin_group_url(@group)
+
+  %p 
+    = t('reader_extension.invitation_instructions')
+
+- else
+  %p
+    = t('reader_extension.no_invitation_message')
+    = link_to image('plus') + ' ' + t("reader_extension.create_invitation_message"), new_admin_group_message_url(@group, :function => 'invitation'), :class => "action"
+  

data/app/views/admin/group_invitations/preview.html.haml

@@ -0,0 +1,58 @@
+- include_stylesheet('admin/reader_group')
+
+%h1 
+  = t('reader_extension.check_invitation_list', :name => @group.name)
+
+- form_for :group, @group, :url => admin_group_group_invitations_url(@group), :html => {:id => 'confirmation_form', :method => 'post'} do
+  %p
+    = t('reader_extension.invitation_preview_instructions')
+
+  %table#import
+    %thead
+      %tr
+        %th
+        - if Radiant::Config['reader.use_honorifics?']
+          %th= t('reader_extension.honorific')
+        %th= t('reader_extension.full_name')
+        %th= t('reader_extension.email')
+        %th= t('reader_extension.optional_login')
+        %th= t('reader_extension.optional_phone')
+    %tbody
+      - i = 0
+      - @readers.each do |reader| 
+        - if reader.new_record?
+          %tr.import
+            %td
+              = check_box_tag "import_reader[]", i, reader.valid?
+            - if Radiant::Config['reader.use_honorifics?']
+              %td 
+                = text_field_tag "reader_#{i}[honorific]", reader.honorific, :class => "preview#{ ' with_error' if reader.errors.on(:honorific)}", :title => reader.errors.on(:honorific)
+            %td 
+              = text_field_tag "reader_#{i}[name]", reader.name, :class => "preview#{ ' with_error' if reader.errors.on(:name)}", :title => reader.errors.on(:name)
+            %td 
+              = text_field_tag "reader_#{i}[email]", reader.email, :class => "preview#{ ' with_error' if reader.errors.on(:email)}", :title => reader.errors.on(:email)
+            %td 
+              = text_field_tag "reader_#{i}[login]", reader.login, :class => "preview#{ ' with_error' if reader.errors.on(:login)}", :title => reader.errors.on(:login)
+            %td 
+              = text_field_tag "reader_#{i}[phone]", reader.phone, :class => "preview#{ ' with_error' if reader.errors.on(:phone)}", :title => reader.errors.on(:phone)
+        - else
+          %tr.invite
+            %td
+              = check_box_tag "invite_reader[]", reader.id, {:checked => true}
+            - if Radiant::Config['reader.use_honorifics?']
+              %td
+                = text_field_tag "reader_#{i}[honorific]", reader.honorific, :class => "preview#{ ' with_error' if reader.errors.on(:honorific)}", :title => reader.errors.on(:honorific), :disabled => true
+            %td 
+              = text_field_tag "reader_#{i}[name]", reader.name, :class => "preview#{ ' with_error' if reader.errors.on(:name)}", :title => reader.errors.on(:name), :disabled => true
+            %td 
+              = text_field_tag "reader_#{i}[email]", reader.email, :class => "preview#{ ' with_error' if reader.errors.on(:email)}", :title => reader.errors.on(:email), :disabled => true
+            %td 
+              = text_field_tag "reader_#{i}[login]", reader.login, :class => "preview#{ ' with_error' if reader.errors.on(:login)}", :title => reader.errors.on(:login), :disabled => true
+            %td 
+              = text_field_tag "reader_#{i}[phone]", reader.phone, :class => "preview#{ ' with_error' if reader.errors.on(:phone)}", :title => reader.errors.on(:phone)
+        - i = i + 1
+
+  %p.buttons
+    = submit_tag 'Invite these people into the group', :name => 'confirm', :class => 'button'
+    or 
+    = link_to 'start again', new_admin_group_group_invitation_url(@group)

data/app/views/admin/groups/_form.html.haml

@@ -0,0 +1,26 @@
+- form_for [:admin, @group] do |f|
+  .form-area
+    = render_region :form_top
+    = hidden_field 'group', 'lock_version'
+
+    - render_region :form do |form|
+      - form.edit_group do
+        #group
+          %p.title
+            = f.label :name
+            = f.text_field 'name', :maxlength => 100, :class => "textbox"
+          %p.description
+            = f.label :description
+            = f.text_area 'description'
+          %p.homepage
+            = f.label :homepage_id, "Group home page:"
+            = choose_page 'group', 'homepage_id', {:selected =>@group.homepage_id}
+
+      - form.edit_timestamp do
+        = updated_stamp @group  
+      - form.edit_buttons do
+        %p.buttons
+          = save_model_button @group
+          = save_model_and_continue_editing_button @group
+          or
+          = link_to "Cancel", admin_groups_url

data/app/views/admin/groups/_list_head.html.haml

@@ -0,0 +1,12 @@
+%tr
+  - render_region :thead do |thead|
+    - thead.name_header do
+      %th.group Name
+    - thead.home_header do
+      %th.home Home page
+    - thead.members_header do
+      %th.members Members
+    - thead.pages_header do
+      %th.pages Pages
+    - thead.modify_header do
+      %th.modify Modify

data/app/views/admin/groups/edit.html.haml

@@ -0,0 +1,9 @@
+- include_stylesheet('admin/reader_group')
+
+- render_region :main do |main|
+  - main.edit_header do
+    %h1 
+      Edit group
+      
+  - main.edit_form do
+    = render :partial => 'form'

data/app/views/admin/groups/index.html.haml

@@ -0,0 +1,44 @@
+- include_stylesheet('admin/reader_group')
+
+= render_region :top
+
+#groups_table.outset      
+  %table#groups.index{:cellspacing=>"0", :border=>"0", :cellpadding=>"0"}
+    %thead
+      = render :partial => 'list_head'
+    %tbody
+      - @groups.each do |group|
+        %tr
+          - render_region :tbody do |tbody|
+            - tbody.name_cell do
+              %td.name
+                %p
+                  = link_to group.name, admin_group_url(group)
+                  %br
+                  %span.notes
+                    = group.description
+            - tbody.home_cell do
+              %td.home
+                - if group.homepage
+                  = link_to group.homepage.title, edit_admin_page_url(group.homepage)
+                - else
+                  = t('reader_extension.none')
+            - tbody.members_cell do
+              %td.members
+                = group.readers.count
+            - tbody.pages_cell do
+              %td.pages
+                = group.pages.count
+            - tbody.modify_cell do
+              %td.actions
+                = link_to_unless_current image('plus') + ' ' + t('reader_extension.add_members'), new_admin_group_group_invitation_url(group), :class => 'action'
+                = link_to_unless_current image('delta') + ' ' + t('reader_extension.edit_group'), edit_admin_group_url(group), :class => 'action'
+                = link_to_unless_current image('minus') + ' ' + t('reader_extension.delete_group'), admin_group_url(group), :method => 'delete', :confirm => t("reader_extension.really_delete_group", :name => group.name), :class => 'action'
+        
+- render_region :bottom do |bottom|
+  - bottom.buttons do
+    #actions
+      = pagination_for @readers
+      %ul
+        %li
+          = link_to image('plus') + " " + t("reader_extension.new_group"), new_admin_group_url

data/app/views/admin/groups/new.html.haml

@@ -0,0 +1,7 @@
+- include_stylesheet('admin/reader_group')
+
+- render_region :main do |main|
+  - main.edit_header do
+    %h1 New group
+  - main.edit_form do
+    = render :partial => "form"