zen 0.1a

data/lib/zen/packages/sections/lib/sections/controller/sections.rb

@@ -0,0 +1,205 @@
+module Sections
+  module Controllers
+    ##
+    # Sections can be seen as mini applications inside your website.
+    # Examples of sections can be a blog, pages, a products listing, etc.
+    # Before being able to properly add section entries you need to assign
+    # the following data to a section:
+    #
+    # * a category group
+    # * a custom field group
+    #
+    # @author  Yorick Peterse
+    # @since   0.1
+    #
+    class Sections < Zen::Controllers::AdminController
+      map '/admin'
+      
+      trait :extension_identifier => 'com.zen.sections'
+      
+      include ::Sections::Models
+      
+      before_all do
+        csrf_protection :save, :delete do
+          respond(@zen_general_lang.errors[:csrf], 401)
+        end
+      end
+      
+      ##
+      # Constructor method, called upon initialization. It's used to set the
+      # URL to which forms send their data and load the language pack.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      #
+      def initialize
+        super
+        
+        @form_save_url   = '/admin/save'
+        @form_delete_url = '/admin/delete'
+        @sections_lang   = Zen::Language.load 'sections'
+        
+        # Set the page title
+        if !action.method.nil?
+          method = action.method.to_sym
+        
+          if @sections_lang.titles.key? method 
+            @page_title = @sections_lang.titles[method]
+          end
+        end
+      end
+    
+      ##
+      # Show an overview of all existing sections. Using this overview a user
+      # can manage an existing section, delete it or create a new one.
+      # 
+      # @author Yorick Peterse
+      # @since  0.1
+      #
+      def index
+        if !user_authorized?([:read])
+          respond(@zen_general_lang.errors[:not_authorized], 403)
+        end
+        
+        set_breadcrumbs @sections_lang.titles[:index]
+        
+        @sections = Section.all
+      end
+      
+      ##
+      # Show a form that lets the user edit an existing section.
+      #
+      # @author Yorick Peterse
+      # @param  [Integer] id The ID of the section to retrieve so that we can edit it.
+      # @since  0.1
+      #
+      def edit id
+        if !user_authorized?([:read, :update])
+          respond(@zen_general_lang.errors[:not_authorized], 403)
+        end
+        
+        set_breadcrumbs anchor_to(@sections_lang.titles[:index], "admin"), @page_title
+        
+        @custom_field_group_pk_hash = CustomFields::Models::CustomFieldGroup.pk_hash(:name)
+        @category_group_pk_hash     = Categories::Models::CategoryGroup.pk_hash(:name)
+        @section                    = Section[id]
+      end
+      
+      ##
+      # Show a form that lets the user create a new section.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      #
+      def new
+        if !user_authorized?([:create, :read])
+          respond(@zen_general_lang.errors[:not_authorized], 403)
+        end
+        
+        set_breadcrumbs anchor_to(@sections_lang.titles[:index], "admin"), @page_title
+        
+        @custom_field_group_pk_hash = CustomFields::Models::CustomFieldGroup.pk_hash(:name)
+        @category_group_pk_hash     = Categories::Models::CategoryGroup.pk_hash(:name)
+        @section                    = Section.new
+      end
+      
+      ##
+      # Method used for processing the form data and redirecting the user back to
+      # the proper URL. Based on the value of a hidden field named "id" we'll determine
+      # if the data will be used to create a new section or to update an existing one.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      #
+      def save
+        if !user_authorized?([:create, :update])
+          respond(@zen_general_lang.errors[:not_authorized], 403)
+        end
+        
+        post = request.params.dup
+       
+        post.each do |key, value|
+          post.delete(key) if value.empty?
+        end
+
+        if post["id"] and !post["id"].empty?
+          @section      = Section[post["id"]]
+          save_action   = :save
+        else
+          @section      = Section.new
+          save_action   = :new
+        end
+        
+        flash_success = @sections_lang.success[save_action]
+        flash_error   = @sections_lang.errors[save_action]
+        
+        # The primary keys have to be integers otherwise Sequel will soil it's pants
+        if !post["custom_field_group_pks"].nil?
+          post["custom_field_group_pks"].map! { |value| value.to_i }
+        else
+          post["custom_field_group_pks"] = []
+        end
+        
+        if !post["category_group_pks"].nil?
+          post["category_group_pks"].map! { |value| value.to_i }
+        else
+          post["category_group_pks"] = [] 
+        end
+        
+        begin
+          @section.update(post)
+          
+          if save_action == :new
+            @section.custom_field_group_pks = post['custom_field_group_pks']
+            @section.category_group_pks     = post['category_group_pks']
+          end
+          
+          notification(:success, @sections_lang.titles[:index], flash_success)
+        rescue
+          notification(:error, @sections_lang.titles[:index], flash_error)
+          
+          flash[:form_errors] = @section.errors
+        end
+        
+        if @section.id
+          redirect "/admin/edit/#{@section.id}"
+        else
+          redirect_referrer
+        end
+      end
+      
+      ##
+      # Delete an existing section. Poor section, what did he do wrong?
+      # In order to delete a section you'll need to send a POST request that contains
+      # a field named "section_ids[]". This field should contain the primary values of
+      # each section that has to be deleted.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      #
+      def delete
+        if !user_authorized?([:delete])
+          respond(@zen_general_lang.errors[:not_authorized], 403)
+        end
+        
+        if !request.params["section_ids"] or request.params["section_ids"].empty?
+          notification(:error, @sections_lang.titles[:index], @sections_lang.errors[:no_delete])
+          redirect_referrer
+        end
+        
+        request.params["section_ids"].each do |id|
+          @section = Section[id]
+          
+          begin
+            @section.delete
+            notification(:success, @sections_lang.titles[:index], @sections_lang.success[:delete] % id)
+          rescue
+            notification(:error, @sections_lang.titles[:index], @sections_lang.errors[:delete] % id)
+          end
+        end
+        
+        redirect_referrer
+      end
+    end 
+  end
+end

data/lib/zen/packages/sections/lib/sections/language/en/section_entries.rb

@@ -0,0 +1,58 @@
+Zen::Language.translation 'section_entries' do |item|
+  # Page titles
+  item.titles = {
+    :index  => 'Entries',
+    :edit   => 'Edit Entry',
+    :new    => 'Add Entry'
+  }
+  
+  # Labels
+  item.labels = {
+    :id         => '#',
+    :title      => 'Title',
+    :slug       => 'Slug',
+    :status     => 'Status',
+    :created    => 'Created at',
+    :updated    => 'Updated at',
+    :author     => 'Author'
+  }
+  
+  # Special items such as sub hashes and such
+  item.special = {
+    :status_hash => {"draft" => "Draft", "published" => "Published"},
+  }
+  
+  # Tabs
+  item.tabs = {
+    :basic      => 'Basic',
+    :categories => 'Categories'
+  }
+
+  # General messages
+  item.messages = {
+    :no_entries    => 'No section entries have been created yet.',
+    :no_categories => 'No categories have been assigned to the current section.'
+  }
+  
+  # Error specific messages
+  item.errors = {
+    :new        => "Failed to create a new entry.",
+    :save       => "Failed to save the entry.",
+    :delete     => "Failed to delete the entry with ID #%s",
+    :no_delete  => "You haven't specified any entries to delete."
+  }
+  
+  # Success messages
+  item.success = {
+    :new    => "The new entry has been created.",
+    :save   => "The entry has been modified.",
+    :delete => "The entry with ID #%s has been deleted."
+  }
+  
+  # Buttons
+  item.buttons = {
+    :new_entry      => 'New entry',
+    :delete_entries => 'Delete selected entries',
+    :save_entry     => 'Save entry'
+  }
+end

data/lib/zen/packages/sections/lib/sections/language/en/sections.rb

@@ -0,0 +1,63 @@
+Zen::Language.translation 'sections' do |item|
+  # Page titles
+  item.titles = {
+    :index  => 'Sections',
+    :edit   => 'Edit Section',
+    :new    => 'Add Section'
+  }
+  
+  # Labels
+  item.labels = {
+    :id                       => '#',
+    :name                     => 'Name',
+    :slug                     => 'Slug',
+    :description              => 'Description',
+    :comment_allow            => 'Allow comments',
+    :comment_require_account  => 'Comments require an account',
+    :comment_moderate         => 'Moderate comments',
+    :comment_format           => 'Comment format',
+    :custom_field_groups      => 'Custom field groups',
+    :category_groups          => 'Category groups',
+    :manage_entries           => 'Manage entries'
+  }
+  
+  # Special items such as sub hashes and such
+  item.special = {
+    :boolean_hash => {"Yes" => true, "No" => false},
+    :format_hash  => {"plain" => "Plain", "html" => "HTML", "textile" => "Textile", "markdown" => "Markdown"}
+  }
+  
+  # Tabs
+  item.tabs = {
+    :general            => 'General',
+    :comment_settings   => 'Comment Settings',
+    :group_assignments  => 'Group Assignments'
+  }
+
+  # General messages
+  item.messages = {
+    :no_sections    => 'It seems you haven\'t created any sections yet.'
+  }
+  
+  # Error specific messages
+  item.errors = {
+    :new        => "Failed to create a new section.",
+    :save       => "Failed to save the section.",
+    :delete     => "Failed to delete the section with ID #%s",
+    :no_delete  => "You haven't specified any sections to delete."
+  }
+  
+  # Success messages
+  item.success = {
+    :new    => "The new section has been created.",
+    :save   => "The section has been modified.",
+    :delete => "The section with ID #%s has been deleted."
+  }
+  
+  # Buttons
+  item.buttons = {
+    :new_section     => 'New section',
+    :delete_sections => 'Delete selected sections',
+    :save_section    => 'Save section'
+  }
+end

data/lib/zen/packages/sections/lib/sections/liquid/section_entries.rb

@@ -0,0 +1,209 @@
+module Sections
+  module Liquid
+    ##
+    # The SectionEntries tag can be used to retrieve all section entries
+    # for the given section. A basic example of this looks like the following:
+    #
+    # bc. {% section_entries section="blog" %}
+    # Do something in here
+    # {% endsection_entries %}
+    #
+    # When using this tag you can specify the following optionally arguments:
+    #
+    # * section: the slug of the section for which to retrieve all entries
+    # * limit: the amount of entries to retrieve
+    # * offset: the offset from which to start selecting entries
+    # * section_entry: the slug of the section entry to select
+    # * order: the sort order type
+    # * order_by: the name of the column to sort on
+    #
+    # These arguments can be specified as following:
+    #
+    # bc. {% section_entries section="blog" limit="10" offset="20" %}
+    # Do something in here
+    # {% endsection_entries %}
+    #
+    # Inside this block you can output the values of your custom fields by
+    # calling the variable tag containing the name of the custom field. For example,
+    # if you have a field called "body" you can output it for each entry as following:
+    #
+    # bc. {% section_entries section="blog" limit="10" offset="20" %}
+    # {{body}}
+    # {% endsection_entries %}
+    #
+    # The following variables are available by default:
+    #
+    # * id: the ID of the section entry
+    # * title: the entry title
+    # * slug: the entry slug
+    # * status: the status of the entry
+    # * created_at
+    # * updated_at
+    # * section_id: the ID of the section to which this entry belongs
+    #
+    # @example
+    #
+    #  {% section_entries section="blog" limit="10" offset="20" %}
+    #  <article>
+    #    <header>
+    #      <h1>{{title}}</h1>
+    #    </header>
+    #
+    #    {{body}}
+    #  </article>
+    #  {% endsection_entries %}
+    #
+    # @author Yorick Peterse
+    # @since  0.1
+    #
+    class SectionEntries < ::Liquid::Block
+      include ::Ramaze::Helper::CGI
+      include ::Zen::Liquid::General
+      
+      ##
+      # Creates a new instance of the block and passes the tag name,
+      # all additional arguments and the HTML to the constructor method.
+      #
+      # @author Yorick Peterse
+      # @since  0.1
+      # @param  [String] tag_name The name of the tag that was called.
+      # @param  [String] arguments All additional arguments passed as a string.
+      # @param  [String] html The HTML inside the block.
+      #
+      def initialize tag_name, arguments, html
+        super
+        
+        @arguments = {
+          'limit'   => nil,
+          'offset'  => nil,
+          'section' => Zen::Controllers::FrontendController.session[:settings][:default_section],
+          'order'   => 'desc',
+          'order_by'=> 'id'
+        }.merge(parse_key_values(arguments))
+        
+        @args_parsed = false
+      end
+      
+      ##
+      # Processes that arguments, retrieves all data and renders the tag block.
+      # When outputting data inside the tag block you can always use the following
+      # variables:
+      #
+      # * total_rows: the amount of rows retrieved
+      # * index: the current index
+      #
+      # Depending on whether you have any entries or not you can use the following
+      # values as well:
+      #
+      # * comments: array containing all comments for each entry
+      # * categories: array of all categories for each entry
+      # * user: data about the author of each entry
+      #
+      # On top of that you can of course also use your own custom values. Each value
+      # can be accessed by it's slug.
+      # 
+      # @author Yorick Peterse
+      # @since  0.1
+      #
+      def render context
+        # Check if any of the given arguments in @arguments exist in our context.
+        if @args_parsed == false
+          @arguments.each do |k, v|
+            v = v.to_s
+            
+            if context.has_key?(v)
+              @arguments[k] = h(context[v])
+            end
+          end
+        end
+        
+        @args_parsed = true
+        result       = []
+        entries      = []
+        filter_hash  = {:status => 'published'}
+        
+        if @arguments.key?('section_entry')
+          if @arguments['section_entry'].empty?
+            raise ArgumentError, "You need to specify a section entry to retrieve"
+          end
+          
+          filter_hash[:slug] = @arguments['section_entry']
+        
+        else
+          if @arguments['section'].empty?
+            raise ArgumentError, "You need to specify a section for which to retrieve all entries"
+          end
+          
+          section = ::Sections::Models::Section[:slug => @arguments['section']]
+          
+          return result if section.nil?
+          filter_hash[:section_id] = section.id
+        end
+        
+        entries = ::Sections::Models::SectionEntry
+          .eager(:custom_field_values, :categories, :comments, :section, :user)
+          .filter(filter_hash)
+          .order(@arguments['order_by'].to_sym.send(@arguments['order']))
+          .limit(@arguments['limit'], @arguments['offset'])
+        
+        context['total_rows'] = entries.count
+        
+        entries.each_with_index do |entry, index|
+          entry.values.each do |k, v|
+            context[k.to_s] = v
+          end
+          
+          context['index']      = index
+          context['categories'] = []
+          context['comments']   = []
+          context['user']       = {}
+          
+          # Retrieve all categories
+          entry.categories.each do |c|
+            values = {}
+            
+            c.values.each { |k, v| values[k.to_s] = v }
+            context['categories'].push(values)
+          end
+          
+          # Get the user for the current entry
+          if !entry.user.nil?
+            entry.user.values.each { |k, v| context['user'][k.to_s] = v }
+          end
+          
+          # Retrieve all comments
+          entry.comments.each do |c|
+            values = {}
+            
+            c.values.each { |k, v| values[k.to_s] = v }
+            
+            # Pull the Email, name and website fields from the user table in case the comment
+            # was posted by somebody who was logged in to the backend.
+            ['email', 'name', 'website'].each do |m|
+              if values[m].nil? or values[m].empty?
+                values[m] = c.user.send(m)
+              end
+            end
+            
+            values['comment'] = markup_to_html(values['comment'], entry.section.comment_format)
+            context['comments'].push(values)
+          end
+          
+          # Get all our custom fields
+          entry.custom_field_values.each do |field_value|
+            field = field_value.custom_field
+            name  = field.slug
+            value = markup_to_html(field_value.value, field.format.to_sym)
+            
+            context[name.to_s] = value
+          end
+          
+          result << render_all(@nodelist, context)
+        end
+        
+        result << render_all(@nodelist, context) if result.empty?
+        return result
+      end
+    end
+  end
+end