radiant-reader-extension 0.9.2

data/app/controllers/reader_action_controller.rb

@@ -0,0 +1,84 @@
+class ReaderActionController < ApplicationController
+  helper_method :current_site, :current_site=, :logged_in?, :logged_in_user?, :logged_in_admin?
+  
+  no_login_required
+  before_filter :set_site_title
+  
+  # reader session is normally required for modifying actions
+  before_filter :require_reader, :except => [:index, :show]
+  
+  radiant_layout { |controller| Radiant::Config['reader.layout'] }
+
+  # authorisation helpers
+
+  def logged_in?
+    true if current_reader
+  end
+
+  def logged_in_user?
+    true if logged_in? && current_reader.is_user?
+  end
+
+  def logged_in_admin?
+    true if logged_in_user? && current_reader.admin?
+  end
+
+  def permission_denied
+    session[:return_to] ||= request.referer
+    @title = flash[:error] || "Sorry: permission denied"
+    render
+  end
+
+protected
+  
+  # context-setters
+
+  def set_site_title
+    if defined? Site && current_site
+      @site_title = current_site.name
+      @short_site_title = current_site.abbreviation || @site_title
+      @site_url = current_site.base_domain
+    else
+      @site_title = Radiant::Config['site.title']
+      @short_site_title = Radiant::Config['site.abbreviation'] || @site_title
+      @site_url = request.host
+    end
+  end
+
+  def require_reader
+    unless set_reader     # set_reader is in ControllerExtension and sets Reader.current while checking for current_reader
+      store_location
+      respond_to do |format|
+        format.html { redirect_to reader_login_url }
+        format.js { 
+          @inline = true
+          render :partial => 'reader_sessions/login_form' 
+        }
+      end
+      false
+    end
+  end
+
+  def require_activated_reader
+    unless current_reader && current_reader.activated?
+      respond_to do |format|
+        format.html { redirect_to reader_activation_url }
+        format.js { 
+          @inline = true
+          render :partial => 'reader_activations/activation_required' 
+        }
+      end
+      false
+    end
+  end
+
+  def require_no_reader
+    if set_reader
+      store_location
+      flash[:notice] = "Please log out first"
+      redirect_back_or_to url_for(current_reader)
+      return false
+    end
+  end
+
+end

data/app/controllers/reader_activations_controller.rb

@@ -0,0 +1,60 @@
+class ReaderActivationsController < ReaderActionController
+
+  no_login_required
+  skip_before_filter :require_reader
+  before_filter :authenticate_reader, :only => [:update]
+  before_filter :check_reader_inactive
+  
+  radiant_layout { |controller| Radiant::Config['reader.layout'] }
+
+  # this is just fake REST: we're actually working on the reader, not an activation object, but in a usefully restricted way:
+  # .show sends out an activation message if we can identify the current reader
+  # .update activates the reader, if the token is correct
+
+  def show
+    render
+  end
+  
+  def new
+    if current_reader
+      @reader = current_reader
+      @reader.send_activation_message
+      flash[:notice] = "Account activation instructions have been emailed to you."
+    end
+    render :action => 'show'
+  end
+  
+  def update
+    if @reader
+      @reader.activate!
+      self.current_reader = @reader
+      flash[:notice] = "Thank you! Your account has been activated."
+      redirect_back_or_to default_activated_url
+      
+    else
+      @error = "Sorry: something was wrong in that link. Please check your email message."
+      flash[:error] = "Activation failed."
+      render :action => 'show'
+    end
+  end
+
+protected
+
+  def authenticate_reader
+    # not using authlogic's find_using_perishable_token because I don't want the token to expire
+    @reader = Reader.find_by_id_and_perishable_token(params[:id], params[:activation_code])
+  end
+
+  def check_reader_inactive
+    if @reader && @reader.activated?
+      flash[:notice] = "Hello #{@reader.name}! Your account is already active."
+      redirect_back_or_to default_activated_url
+      false
+    end
+  end
+
+  def default_activated_url
+    reader_url(@reader)
+  end
+
+end

data/app/controllers/reader_sessions_controller.rb

@@ -0,0 +1,56 @@
+class ReaderSessionsController < ReaderActionController
+
+  before_filter :require_reader, :only => :destroy
+  radiant_layout { |controller| Radiant::Config['reader.layout'] }
+  
+  def new
+    @reader_session = ReaderSession.new
+  end
+  
+  def create
+    @reader_session = ReaderSession.new(params[:reader_session])
+    if @reader_session.save
+      if @reader_session.reader.activated? && @reader_session.reader.clear_password        
+        @reader_session.reader.clear_password = ""                          # we forget the cleartext version on the first successful login after activation
+        @reader_session.reader.save(false)
+      end
+      respond_to do |format|
+        format.html {
+          flash[:notice] = "Hello #{@reader_session.reader.name}. Welcome back."
+          redirect_back_or_to default_loggedin_url
+        }
+        format.js { 
+          redirect_back_with_format(:js) 
+        }
+      end
+      
+    else
+      respond_to do |format|
+        format.html { 
+          flash[:error] = "Sorry: that combination of login and password is not known here."
+          render :action => :new 
+        }
+        format.js { render :action => :new, :layout => false }
+      end
+    end
+  end
+  
+  def destroy
+    current_reader_session.destroy
+    if current_user
+      cookies[:session_token] = { :expires => 1.day.ago }
+      current_user.forget_me
+      session['user_id'] = nil
+      current_user = nil
+    end
+    flash[:notice] = "You are logged out. Bye!"
+    redirect_back_or_to reader_login_url
+  end
+  
+protected
+
+  def default_loggedin_url
+    reader_url(@reader_session.reader)
+  end
+
+end

data/app/controllers/readers_controller.rb

@@ -0,0 +1,131 @@
+class ReadersController < ReaderActionController
+  @@extended_form_partials = []
+  cattr_accessor :extended_form_partials
+  
+  before_filter :check_registration_allowed, :only => [:new, :create]
+  before_filter :initialize_form_partials, :only => [:new, :edit, :update, :create]
+  before_filter :i_am_me, :only => [:show]
+  before_filter :require_reader, :except => [:index, :new, :create, :activate]
+  before_filter :restrict_to_self, :only => [:edit, :update, :resend_activation]
+  before_filter :no_removing, :only => [:remove, :destroy]
+  before_filter :require_password, :only => [:update]
+
+  def index
+    @readers = Reader.paginate(:page => params[:page], :order => 'readers.created_at desc')
+  end
+
+  def show
+    @reader = Reader.find(params[:id])
+    respond_to do |format|
+      format.html { 
+        if @reader.inactive? && @reader == current_reader
+          redirect_to reader_activation_url
+        else
+          render
+        end
+      }
+      format.js { 
+        @inline = true
+        render :partial => 'readers/controls'
+      }
+    end
+    
+  end
+
+  def new
+    if current_reader
+      flash[:error] = "You're already logged in!"
+      redirect_to url_for(current_reader) and return
+    end
+    @reader = Reader.new
+    session[:return_to] = request.referer
+    session[:email_field] = @email_field = @reader.generate_email_field_name
+  end
+  
+  def edit
+  end
+  
+  def create
+    @reader = Reader.new(params[:reader])
+    @reader.clear_password = params[:reader][:password]
+
+    unless @reader.email.blank?
+      flash[:error] = "Please don't fill in the spam trap field."
+      @reader.email = ''
+      @reader.errors.add(:trap, "must be empty")
+      render :action => 'new' and return
+    end
+
+    unless @email_field = session[:email_field]
+      flash[:error] = "Please use the registration form."
+      redirect_to new_reader_url and return
+    end
+
+    @reader.email = params[@email_field.intern]
+    if (@reader.valid?)
+      @reader.save!
+      @reader.send_activation_message
+      self.current_reader = @reader
+      redirect_to reader_activation_url
+    else
+      render :action => 'new'
+    end
+  end
+
+  def update
+    @reader.attributes = params[:reader]
+    @reader.clear_password = params[:reader][:password] if params[:reader][:password]
+    if @reader.save
+      flash[:notice] = "Your account has been updated"
+      redirect_to url_for(@reader)
+    else
+      render :action => 'edit'
+    end
+  end
+  
+protected
+
+  def i_am_me
+    params[:id] = current_reader.id if params[:id] == 'me' && current_reader
+  end
+
+  def restrict_to_self
+    flash[:error] = "Sorry. You are not allowed to edit other people's accounts." if params[:id] && params[:id] != current_reader.id
+    @reader = current_reader
+  end
+  
+  def require_password
+    return true if @reader.valid_password?(params[:reader][:current_password])
+
+    # might as well get any other validation messages while we're at it
+    @reader.attributes = params[:reader]
+    @reader.valid?
+    
+    flash[:error] = 'Sorry. Wrong password.'
+    @reader.errors.add(:current_password, "was not correct")
+    render :action => 'edit' and return false
+  end
+  
+  def no_removing
+    flash[:error] = "You can't delete readers here. Please log in to the admin interface."
+    redirect_to admin_readers_url
+  end
+  
+  def check_registration_allowed
+    unless Radiant::Config['reader.allow_registration?']
+      flash[:error] = "Sorry. This site does not allow public registration."
+      redirect_to reader_login_url
+      false
+    end
+  end
+  
+  def self.add_form_partial(path)
+    extended_form_partials.push(path)
+  end
+
+private
+  def initialize_form_partials
+    @form_partials = extended_form_partials
+  end
+
+end

data/app/helpers/admin/reader_settings_helper.rb

@@ -0,0 +1,36 @@
+module Admin::ReaderSettingsHelper
+
+  def editable_setting(setting)
+    setting = Radiant::Config.find_by_key(setting) unless setting.is_a? Radiant::Config
+    domkey = setting.key.gsub('?', '_')
+    containerid = "set_#{domkey}"
+    link = link_to_remote setting.value, 
+      :url => edit_admin_reader_setting_url(setting.id), 
+      :method => 'get', 
+      :update => containerid,
+      :loading => "$('#{containerid}').addClassName('waiting');", 
+      :loaded => "$('#{containerid}').removeClassName('waiting');"
+    %{
+  #{link}
+    }
+  end
+
+  def checkbox_for_setting(setting, label)
+    setting = Radiant::Config.find_by_key(setting) unless setting.is_a? Radiant::Config
+    domkey = setting.key.gsub('?', '_')
+    containerid = "set_#{domkey}"
+    checkbox = check_box_tag setting.key.to_sym, 1, setting.value, :class => 'fancy', :id => domkey, :onchange => remote_function(
+      :url => admin_reader_setting_path(setting.id),
+      :with => %{'value=' + (this.checked ? 'true' : 'false')},
+      :method => 'put',
+      :loading => "$('#{containerid}').addClassName('waiting');",
+      :success => "$('#{containerid}').removeClassName('waiting').toggleClassName('true').toggleClassName('false');"
+    )
+    %{
+  #{checkbox}
+  <label for="#{domkey}">#{label}</label>
+    }
+    
+  end
+
+end

data/app/models/message.rb

@@ -0,0 +1,108 @@
+class Message < ActiveRecord::Base
+
+  is_site_scoped if defined? ActiveRecord::SiteNotFound
+
+  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
+
+  validates_presence_of :subject
+  validates_presence_of :body
+
+  object_id_attr :filter, TextFilter
+
+  default_scope :order => 'updated_at DESC, created_at DESC'
+  named_scope :for_function, lambda { |f| {:conditions => ["function_id = ?", f.to_s]} }
+  named_scope :administrative, { :conditions => "function_id IS NOT NULL" }
+  named_scope :ordinary, { :conditions => "function_id IS NULL" }
+  named_scope :published, { :conditions => "status_id >= 100" }
+
+  def filtered_body
+    filter.filter(body)
+  end
+
+  # has to return a named_scope for chainability
+  def possible_readers
+    Reader.active
+  end
+
+  def undelivered_readers
+    possible_readers - recipients
+  end
+
+  def inactive_readers
+    possible_readers.inactive
+  end
+
+  def active_readers
+    possible_readers.active
+  end
+
+  def delivered?
+    deliveries.any?
+  end
+
+  def delivered_to?(reader)
+    recipients.include?(reader)
+  end
+
+  def preview(reader=nil)
+    reader ||= possible_readers.first || Reader.find_or_create_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
+  end
+  def has_function?
+    !function.nil?
+  end
+  def administrative?
+    has_function?
+  end
+
+  def status
+    Status.find(self.status_id)
+  end
+  def status=(value)
+    self.status_id = value.id
+  end
+  def published?
+    status == Status[:published]
+  end
+  def published!
+    status = Status[:published]
+  end
+
+  def deliver(readers)
+    failures = []
+    readers.each do |reader|
+      failures.push(reader) unless deliver_to(reader)
+    end
+    self.published!
+    failures
+  end
+
+  def deliver_to(reader, sender=nil)
+    ReaderNotifier.deliver_message(reader, self, sender)
+    record_delivery(reader)
+    true
+  rescue => e
+    logger.warn "@@  delivery failed: #{e.inspect}"
+    raise
+  end
+
+  def record_delivery(reader)
+    MessageReader.find_or_create_by_message_id_and_reader_id(self.id, reader.id).update_attribute(:sent_at, Time.now)
+  end
+
+end