tylerrick-bcms_blog 1.0.5

data/README.markdown

@@ -0,0 +1,63 @@
+# Blog Module for BrowserCMS
+
+A simple blog module that lets you create one or more blogs. It features:
+
+* Blog posts can be tagged and categorized
+* The ability for users to leave comments on a blog post (stores the user name, email, url and comment)
+* Support for multiple blogs
+* Blog block can be added to any container in any page
+
+## Installation
+To install this module, do the following:
+
+### A. Build and install the gem from source
+This assumes you have the latest copy of the code from github on your machine.
+
+        gem build bcms_blog.gemspec
+        sudo gem install bcms_blog-1.x.x.gem
+
+At this point, the Page Comments gem should be installed as a gem on your system, and can be added to your projects.
+
+### B. Adding the Page Comments to your project
+In your BrowserCMS application, do the following steps.
+
+#### 1. Edit the confing/environment.rb file
+
+		config.gem 'browsercms'
+
+		# Add this next line after the browsercms gem
+		config.gem "bcms_page_comments"
+
+#### 2. Edit the routes.rb file
+
+		# Add this route. It must be before the core browser_cms route.
+		map.routes_for_bcms_page_comments
+		map.routes_for_browser_cms
+
+#### 3. Install the new module code
+From the root directory of your cms project, run:
+
+		script/generate browser_cms
+
+This will copy all the necessary views and migrations from the gems into your local project. You should messages checking to see if files already exist or were created.
+
+#### 4. Run migrations and start the server
+Modules will often add new data types, like content blocks, so you need to run the migrations to add them to your project.
+
+		rake db:migrate
+		script/server
+
+#### 5. Create a Comments portlet and embed into your templates
+* Open your browser to localhost:3000/cms/portlets and login 
+* Click 'Add New Content', and select 'Page Comments Portlet'
+* Set the name to 'Page Comments' and click save.
+* Now go to Administration -> Page Templates -> Sub Page -> Edit
+* Add the following line to your template, somewhere in the body (preferably after your main content area)
+
+		<%= render_portlet "Page Comments" %>
+
+This will render embed the portlet named "Page Comments" into any page which uses the Sub Page template. 
+
+* Now add a new page using the "Sub Page" template and you should see the comments form. Adding a new comment will display on that page.
+
+

data/app/controllers/application_controller.rb

@@ -0,0 +1,10 @@
+# Filters added to this controller apply to all controllers in the application.
+# Likewise, all the methods added will be available for all controllers.
+
+class ApplicationController < ActionController::Base
+  helper :all # include all helpers, all the time
+  protect_from_forgery # See ActionController::RequestForgeryProtection for details
+
+  # Scrub sensitive parameters from your log
+  # filter_parameter_logging :password
+end

data/app/controllers/cms/blog_comments_controller.rb

@@ -0,0 +1,3 @@
+class Cms::BlogCommentsController < Cms::ContentBlockController
+  
+end

data/app/controllers/cms/blog_posts_controller.rb

@@ -0,0 +1,35 @@
+class Cms::BlogPostsController < Cms::ContentBlockController
+  before_filter :show_no_access_if_none_editable
+  
+  def build_block
+    super
+    ensure_blog_editable
+    @block.author = current_user
+  end
+  
+  def load_block
+    super
+    ensure_blog_editable
+  end
+  
+  def load_blocks
+    super
+    @blocks.delete_if { |b| !b.editable_by?(current_user) }
+  end
+  
+  private
+    
+    # If the current user is not able to edit any blog, just show them a page saying so
+    def show_no_access_if_none_editable
+      if Blog.editable_by(current_user).empty?
+        render :action => "no_access"
+      end
+    end
+    
+    # Ensure the current user can actually edit the blog this blog post is associated with
+    def ensure_blog_editable
+      if @block.blog
+        raise Cms::Errors::AccessDenied unless @block.blog.editable_by?(current_user)
+      end
+    end
+end

data/app/controllers/cms/blogs_controller.rb

@@ -0,0 +1,11 @@
+class Cms::BlogsController < Cms::ContentBlockController
+  check_permissions :administrate, :except => :index
+  
+  def index
+    if current_user.able_to?(:administrate)
+      super
+    else
+      render :action => "admin_only"
+    end
+  end
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,3 @@
+# Methods added to this helper will be available to all templates in the application.
+module ApplicationHelper
+end

data/app/helpers/cms/blog_helper.rb

@@ -0,0 +1,11 @@
+module Cms::BlogHelper
+  # We can't call it 'blog_path' because that would conflict with the actual named route method if there's a blog named "Blog".
+  def _blog_path(blog, route_name, route_params)
+    send("#{blog.name_for_path}_#{route_name}_path", route_params)
+  end
+
+  def _blog_post_path(blog_post)
+    send("#{blog_post.route_name}_path", blog_post.route_params)
+  end
+end
+

data/app/models/blog.rb

@@ -0,0 +1,143 @@
+class Blog < ActiveRecord::Base
+  acts_as_content_block
+  has_many :posts, :class_name => "BlogPost", :conditions => { :published => true }, :order => "published_at desc"
+  
+  has_many :blog_group_memberships
+  has_many :groups, :through => :blog_group_memberships
+  
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  
+  named_scope :editable_by, lambda { |user|
+    if user.able_to?(:administrate)
+      { }
+    else
+      { :include => :groups, :conditions => ["groups.id IN (?)", user.group_ids.join(",")] }
+    end
+  }
+  
+  def self.default_template
+    template_file = ActionController::Base.view_paths.map do |vp| 
+      path = vp.to_s.first == "/" ? vp.to_s : File.join(Rails.root, vp.to_s)
+      File.join(path, "cms/blogs/render.html.erb")
+    end.detect{|f| File.exists? f }
+    template_file ? open(template_file){|f| f.read } : ""
+  end
+  
+  def render
+    @blog = self
+    finder = @blog.posts.published
+
+    if params[:category]
+      @category_type = CategoryType.named("Blog Post").first
+      @category = @category_type.categories.named(params[:category]).first
+      finder = finder.in_category(@category)
+      @page_title = "Posts in category #{params[:category]}"
+    elsif params[:tag]
+      finder = finder.tagged_with(params[:tag])
+      @page_title = "Posts tagged with #{params[:tag]}"
+    elsif params[:year] && params[:month] && params[:day]
+      @date = Date.new(params[:year].to_i, params[:month].to_i, params[:day].to_i)
+      finder = posts.published_between(@date, @date + 1.day)
+      @page_title = "Blog posts from #{@date.to_s(:long)}"
+    elsif params[:year] && params[:month]
+      @date = Date.new(params[:year].to_i, params[:month].to_i)
+      finder = posts.published_between(@date, @date + 1.month)
+      @page_title = "Blog posts from #{Date::MONTHNAMES[@date.month]} #{@date.year}"
+    elsif params[:year]
+      @date = Date.new(params[:year].to_i)
+      finder = posts.published_between(@date, @date + 1.year)
+      @page_title = "Blog posts from #{@date.year}"
+    end
+
+    @blog_posts = finder.all(:limit => 25, :order => "published_at desc") 
+    raise ActiveRecord::RecordNotFound.new("No posts found") if @blog_posts.empty?
+  end
+  
+  def inline_options
+    {:inline => self.template}
+  end
+  
+  def self.default_order
+    "name"
+  end
+  
+  def editable_by?(user)
+    user.able_to?(:administrate) || !(group_ids & user.group_ids).empty?
+  end
+  
+  def potential_authors
+    groups.map(&:users).flatten.uniq
+  end
+  
+
+  #-------------------------------------------------------------------------------------------------
+    
+  def name_for_path
+    name.to_slug.gsub('-', '_')
+  end
+
+protected
+  def after_create
+    section = Section.find_by_name(name) || (
+      section = Section.create!(
+        :name => name,
+        :path => "/#{name_for_path}",
+        :parent_id => 1
+      )
+      section.groups << Group.find_by_code("cms-admin")
+      section.groups << Group.find_by_code("guest")
+      section.groups << Group.find_by_code("content-editor")
+      section.save!
+      section
+    )
+
+    page = Page.find_by_name(name) || Page.create!(
+      :name => name,
+      :path => "/#{name_for_path}",
+      :section => section,
+      :template_file_name => "default.html.erb",
+      :hidden => true
+    )
+    page.create_connector(self, 'main')
+    create_route(page, "#{name}: Posts In Day",      "/#{name_for_path}/:year/:month/:day")
+    create_route(page, "#{name}: Posts In Month",    "/#{name_for_path}/:year/:month")
+    create_route(page, "#{name}: Posts In Year",     "/#{name_for_path}/:year")
+    create_route(page, "#{name}: Posts With Tag",    "/#{name_for_path}/tag/:tag")
+    create_route(page, "#{name}: Posts In Category", "/#{name_for_path}/category/:category")
+
+    page = Page.find_by_name(portlet_name = "#{name}: Post") || Page.create!(
+      :name => portlet_name,
+      :path => "/#{name_for_path}/post",
+      :section => section,
+      :template_file_name => "default.html.erb",
+      :hidden => true)
+    page.publish
+    create_route(  page, portlet_name, "/#{name_for_path}/:year/:month/:day/:slug")
+    create_portlet(page, portlet_name, BlogPostPortlet)
+
+    # FIXME: This takes about 5 seconds to run, which is probably too long.
+    # Solution: Disable PageRoute's after_save :reload_routes and add this to the end here:
+    # ActionController::Routing::Routes.load!
+  end
+
+  def create_route(page, name, pattern)
+    route = page.page_routes.build(:name => name, :pattern => pattern, :code => "")
+    route.add_condition(:method, "get")
+    route.add_requirement(:year,  '\d{4,}') if pattern.include?(":year")
+    route.add_requirement(:month, '\d{2,}') if pattern.include?(":month")
+    route.add_requirement(:day,   '\d{2,}') if pattern.include?(":day")
+    route.save!
+  end
+
+  def create_portlet(page, name, portlet_class)
+    portlet_class.create!(
+      :name => "#{name} Portlet",
+      :blog_id => self.id,
+      :template => portlet_class.default_template,
+      :connect_to_page_id => page.id,
+      :connect_to_container => "main",
+      :publish_on_save => true)
+  end
+
+end

data/app/models/blog_comment.rb

@@ -0,0 +1,28 @@
+class BlogComment < ActiveRecord::Base
+  acts_as_content_block :is_searachable => "body"
+  belongs_to :post, :class_name => "BlogPost", :counter_cache => "comments_count"
+
+  validates_presence_of :post_id, :author, :body
+
+  def self.default_order
+    "blog_comments.created_at desc"
+  end
+
+  def self.default_order_for_search
+    default_order
+  end
+
+  def self.columns_for_index
+    [ {:label => "Comment",    :method => :name,                 :order => "blog_comments.body" },
+      {:label => "Created At", :method => :formatted_created_at, :order => "blog_comments.created_at"} ]
+  end
+
+  def name
+    body ? body[0..50] : ""
+  end
+
+  def formatted_created_at
+    created_at.to_s(:date)
+  end
+
+end

data/app/models/blog_group_membership.rb

@@ -0,0 +1,4 @@
+class BlogGroupMembership < ActiveRecord::Base
+  belongs_to :blog
+  belongs_to :group
+end

data/app/models/blog_post.rb

@@ -0,0 +1,101 @@
+class BlogPost < ActiveRecord::Base
+  acts_as_content_block :taggable => true
+
+  belongs_to_attachment
+  def set_attachment_file_path
+    # The default behavior is use /attachments/file.txt for the attachment path,
+    # assuming file.txt was the name of the file the user uploaded
+    # You should override this with your own strategy for setting the attachment path
+    super
+  end
+
+  def set_attachment_section
+    # The default behavior is to put all attachments in the root section
+    # Override this method if you would like to change that
+    super
+  end
+
+
+  before_save :set_published_at
+
+  belongs_to :blog
+  belongs_to_category
+  belongs_to :author, :class_name => "User"
+  has_many :comments, :class_name => "BlogComment", :foreign_key => "post_id"
+
+  before_validation :set_slug
+  validates_presence_of :name, :slug, :blog_id, :author_id
+
+  named_scope :published_between, lambda { |start, finish|
+    { :conditions => [
+         "blog_posts.published_at >= ? AND blog_posts.published_at < ?",
+         start, finish ] }
+  }
+
+  INCORRECT_PARAMETERS = "Incorrect parameters. This is probably because you are trying to view the " +
+                         "portlet through the CMS interface, and so we have no way of knowing what " +
+                         "post(s) to show"
+
+  delegate :editable_by?, :to => :blog
+
+  def set_published_at
+    if !published_at && publish_on_save
+      self.published_at = Time.now
+    end
+  end
+
+  # This is necessary because, oddly, the publish! method in the Publishing behaviour sends an update
+  # query directly to the database, bypassing callbacks, so published_at does not get set by our
+  # set_published_at callback.
+  def after_publish_with_set_published_at
+    if published_at.nil?
+      self.published_at = Time.now
+      self.save!
+    end
+    after_publish_without_set_published_at if respond_to? :after_publish_without_set_published_at
+  end
+  if instance_methods.map(&:to_s).include? 'after_publish'
+    alias_method_chain :after_publish, :set_published_at
+  else
+    alias_method       :after_publish, :after_publish_with_set_published_at
+  end
+
+  def self.default_order
+    "created_at desc"
+  end
+
+  def self.columns_for_index
+    [ {:label => "Name", :method => :name, :order => "name" },
+      {:label => "Published", :method => :published_label, :order => "published" } ]
+  end
+
+  def published_label
+    published_at ? published_at.to_s(:date) : nil
+  end
+
+  def set_slug
+    self.slug = name.to_slug
+  end
+
+  def path
+    send("#{blog.name_for_path}_post_path", route_params)
+  end
+  def route_name
+    "#{blog.name_for_path}_post"
+  end
+  def route_params
+    {:year => year, :month => month, :day => day, :slug => slug}
+  end
+
+  def year
+    published_at.strftime("%Y") unless published_at.blank?
+  end
+
+  def month
+    published_at.strftime("%m") unless published_at.blank?
+  end
+
+  def day
+    published_at.strftime("%d") unless published_at.blank?
+  end
+end

data/app/portlets/blog_post_portlet.rb

@@ -0,0 +1,38 @@
+class BlogPostPortlet < Portlet
+  render_inline false
+  enable_template_editor false
+
+  def render
+    scope = Blog.find(self.blog_id).posts
+    if params[:blog_post_id]
+      @blog_post = scope.find(params[:blog_post_id])
+    elsif params[:slug]
+      if params[:year]
+        date = Date.new(params[:year].to_i, params[:month].to_i, params[:day].to_i)
+        scope = scope.published_between(date, date + 1.day)
+      end
+      @blog_post = scope.find_by_slug!(params[:slug])
+    else
+      raise BlogPost::INCORRECT_PARAMETERS
+    end
+
+    pmap = flash[instance_name] || params
+    pmap[:blog_comment] ||= {}
+
+    @blog_comment = @blog_post.comments.build pmap[:blog_comment]
+    @blog_comment.errors.add_from_hash flash["#{instance_name}_errors"]
+  end
+
+  def create_comment
+    params[:blog_comment].merge! :ip => request.remote_ip
+    blog_comment = BlogComment.new(params[:blog_comment])
+    if blog_comment.valid? && blog_comment.save
+      url_for_success
+    else
+      store_params_in_flash
+      store_errors_in_flash(blog_comment.errors)
+      url_for_failure
+    end
+  end
+
+end

data/app/views/cms/blog_comments/_form.html.erb

@@ -0,0 +1,5 @@
+<%= f.cms_drop_down :post_id, BlogPost.all(:order => "name").map{|p| [p.name, p.id]} %>
+<%= f.cms_text_field :author %>
+<%= f.cms_text_field :email %>
+<%= f.cms_text_field :url %>
+<%= f.cms_text_area :body %>

data/app/views/cms/blog_comments/render.html.erb

@@ -0,0 +1,2 @@
+<%= link_to h(@content_block.post.name), cms_blog_post_path(@content_block.post) %>
+<p><%=h @content_block.body %></p>

data/app/views/cms/blog_posts/_form.html.erb

@@ -0,0 +1,11 @@
+<%= f.cms_drop_down :blog_id, Blog.editable_by(current_user).map{|b| [b.name, b.id]} %>
+<% unless @block.new_record? %>
+  <%= f.cms_drop_down :author_id, @block.blog.potential_authors.map { |u| ["#{u.full_name} (#{u.login})", u.id] } %>
+<% end %>
+<%= f.cms_drop_down :category_id, categories_for('Blog Post').map{|c| [c.path, c.id]}, :include_blank => true %>
+<%= f.cms_text_field :name, :label => 'Title' %>
+<%= f.cms_tag_list %>
+<%= f.cms_datetime_select :published_at, :label => "Date" %>
+<%= f.cms_text_area :summary, :style => "height: 200px", :instructions => 'This will be displayed on the list page with a Read More link if present' %>
+<%= f.cms_text_editor :body %>
+<%= f.cms_file_field :attachment_file, :label => "Image" %>

data/app/views/cms/blog_posts/no_access.html.erb

@@ -0,0 +1,9 @@
+<% content_for(:html_head) do %>
+<%= stylesheet_link_tag "cms/content_library" %>
+<% end %>
+<% page_title "Content Library / List #{content_type.display_name_plural}" %>
+<% @toolbar_title = "List #{content_type.display_name_plural}" %>
+
+<div class="roundedcorners">
+  <p>Sorry, you don't have the permissions to write blog posts.</p>
+</div>

data/app/views/cms/blog_posts/render.html.erb

@@ -0,0 +1 @@
+<%= render :partial => "partials/blog_post", :object => @content_block %>

data/app/views/cms/blogs/_form.html.erb

@@ -0,0 +1,23 @@
+<%= f.cms_text_field :name %>
+
+<div class="checkbox_group fields" style="float: left; width: 100%">
+  <label>Permissions</label>
+  <%= hidden_field_tag "blog[group_ids][]", "", :id => nil %>
+  <div class="checkboxes">
+    <% for group in Group.cms_access.all(:order => "groups.name") %>
+    <div class="checkbox_fields">
+        <%= check_box_tag "blog[group_ids][]", group.id,
+            @block.groups.include?(group), :class => "cms_group_ids", :id => "cms_group_ids_#{group.id}", :tabindex => next_tabindex %>
+        <label for="cms_group_ids_<%= group.id %>"><%= group.name %></label>
+    </div>
+    <% end %>
+    <div class="instructions">Which &ldquo;CMS&rdquo; groups can edit and publish the blog?</div>
+    <div class="check_uncheck">
+      <%= link_to_check_all 'input.cms_group_ids' %>, 
+      <%= link_to_uncheck_all 'input.cms_group_ids' %>
+    </div>
+  </div>
+</div>
+<br clear="all" />
+
+<%= f.cms_text_area :template, :default_value => Blog.default_template %>

data/app/views/cms/blogs/admin_only.html.erb

@@ -0,0 +1,9 @@
+<% content_for(:html_head) do %>
+<%= stylesheet_link_tag "cms/content_library" %>
+<% end %>
+<% page_title "Content Library / List #{content_type.display_name_plural}" %>
+<% @toolbar_title = "List #{content_type.display_name_plural}" %>
+
+<div class="roundedcorners">
+  <p>Sorry, this section is restricted to administrators.</p>
+</div>

data/app/views/cms/blogs/render.html.erb

@@ -0,0 +1,2 @@
+<% page_title @page_title || @blog.name %>
+<%= render :partial => "partials/blog_post", :collection => @blog_posts %>

data/app/views/partials/_blog_post.html.erb

@@ -0,0 +1,106 @@
+<style>
+  .blog_post {
+    border-bottom: 1px solid #ccc;
+    margin-bottom: 20px;
+  }
+
+  .blog_post h2 {
+    margin-bottom: 0
+  }
+
+  .blog_post h2,
+  .blog_post h2 a {
+    font: normal 30px/28px 'arial black', arial, sans-serif !important;
+    text-decoration: none !important;
+  }
+  .blog_post h2 a:hover {
+    text-decoration: underline !important;
+  }
+
+  .blog_post .image {
+    float: left;
+    border: 1px solid #ccc;
+    margin: 10px;
+    margin-top: 0;
+  }
+  .blog_post .date {
+    color: #666;
+  }
+  .blog_post .read_more {
+    font-weight: bold;
+  }
+
+  .blog_post .comment + .comment {
+    border-top: 1px dashed #ccc;
+  }
+
+  .clear {
+    clear: both;
+  }
+</style>
+
+<%
+  # _counter is defined only if we pass :collection to the partial
+  if defined?(blog_post_counter)
+    showing_individual_post = false
+  else
+    showing_individual_post = true
+    blog_post_counter = 0
+  end
+%>
+
+<div id="blog_post_<%= blog_post.id %>" class="blog_post clear">
+  <% if blog_post.attachment %>
+    <div class="image">
+      <%# image_tag_with_max_size blog_post.attachment.file_path, blog_post.attachment.full_file_location, :width => max_width %>
+      <%= image_tag blog_post.attachment.file_path %>
+    </div>
+  <% end %>
+
+  <h2><%= link_to h(blog_post.name), href = _blog_post_path(blog_post) %></h2>
+  
+  <div class="date"><%= blog_post.published_at.to_s(:long) %></div>
+  
+  <div class="body">
+    <% if showing_individual_post or blog_post.summary.blank? %>
+      <%= blog_post.body %>
+    <% else %>
+      <%= blog_post.summary %>
+      <p class="read_more">
+        <%= link_to 'Read More »', href %>
+      </p>
+    <% end %>
+  </div>
+  
+  <div class="meta">
+    <% unless blog_post.category_id.blank? %>
+      Posted in <%= link_to h(blog_post.category_name), _blog_path(blog_post.blog, 'posts_in_category', :category => blog_post.category_name) %>
+      <strong>|</strong>
+    <% end %>
+
+    <% if blog_post.tags.any? %>
+      Tags:
+      <span class="tags">
+        <%= blog_post.tags.map{|t| link_to(h(t.name), _blog_path(blog_post.blog, 'posts_with_tag', :tag => t.name)) }.join(", ") %>
+      </span>
+      <strong>|</strong>
+    <% end %>
+    
+    <%= link_to h(pluralize(blog_post.comments_count, "Comment")), "#{_blog_post_path(blog_post)}#comments" %>
+  </div>
+  <br class="clear" />
+
+
+  <% comments = blog_post.comments.reject(&:new_record?) %>
+  <% if showing_individual_post and comments.any? -%>
+    <h2>Comments</h2>
+    <% comments.each_with_index do |comment, i| %>
+      <div class="comment <%= 'first' if i == 0 %>">
+        <%= h comment.body %>
+        <p>&mdash;<%= comment.url.present? ? link_to(h(comment.author), comment.url) : h(comment.author) %></p>
+      </div>
+    <% end %>
+  <% end %>
+
+
+</div>