caboose-cms 0.3.129 → 0.4.1

data/app/controllers/caboose/edit_controller.rb

@@ -0,0 +1,33 @@
+
+module Caboose
+  class EditController < ApplicationController
+    
+    helper :application    
+
+    # GET /edit/.*
+    def index
+      return unless user_is_allowed('pages', 'add')
+      
+      # Find the page with an exact URI match 
+      @page = Page.page_with_uri(request.fullpath.gsub('/edit'), false)
+
+      @user = logged_in_user            
+      if !user.is_allowed(@page, 'view')        
+        if user.id == User::LOGGED_OUT_USER_ID	
+          redirect_to "/modal/login?return_url=" + URI.encode(request.fullpath)		  		
+          return
+        else
+          @page.title = 'Access Denied'          
+        end
+      end
+            
+      @editmode = !params['edit'].nil? && user.is_allowed('pages', 'edit') ? true : false
+      @crumb_trail = Caboose::Page.crumb_trail(@page)
+      @subnav = Caboose::Page.subnav(@page, session['use_redirect_urls'], @user)
+
+      #@subnav.links = @tasks.collect {|href, task| {'href' => href, 'text' => task, 'is_current' => uri == href}}
+      render :file ':layout => 'caboose/admin'
+    end
+		
+  end
+end

data/app/controllers/caboose/pages_controller.rb

@@ -131,8 +131,9 @@ module Caboose
     def admin_edit_content
       return unless user_is_allowed('pages', 'edit')      
       @page = Page.find(params[:id])
-      @block_types = Caboose::PageBlockType.reorder(:name).all
-      render :layout => 'caboose/admin'
+      #@block_types = Caboose::BlockType.reorder(:name).all
+      #render :layout => 'caboose/admin'
+      @editing = true
     end
     
     # GET /admin/pages/:id/block-order
@@ -148,7 +149,7 @@ module Caboose
       block_ids = params[:block_ids]
       i = 0
       block_ids.each do |block_id|
-        b = PageBlock.find(block_id)
+        b = Block.find(block_id)
         b.sort_order = i
         b.save
         i = i + 1

data/app/controllers/caboose/posts_controller.rb

@@ -59,7 +59,7 @@ module Caboose
   
     # POST /admin/posts/:id
     def admin_update
-      Caboose.log(params)
+      #Caboose.log(params)
       return if !user_is_allowed('posts', 'edit')
       
       resp = Caboose::StdClass.new({'attributes' => {}})

data/app/models/caboose/block.rb

@@ -0,0 +1,222 @@
+
+class Caboose::Block < ActiveRecord::Base
+  self.table_name = "blocks"
+  
+  belongs_to :page
+  belongs_to :block_type
+  belongs_to :parent, :foreign_key => 'parent_id', :class_name => 'Caboose::Block'   
+  has_many :children, :foreign_key => 'parent_id', :class_name => 'Caboose::Block', :dependent => :delete_all, :order => 'sort_order'
+  has_attached_file :file, :path => '/uploads/:id.:extension'
+  do_not_validate_attachment_file_type :file
+  has_attached_file :image, 
+    :path => 'uploads/:id_:style.:extension', 
+    :styles => {
+      :tiny  => '160x120>',
+      :thumb => '400x300>',
+      :large => '640x480>'
+    }
+  do_not_validate_attachment_file_type :image
+  
+  attr_accessible :id, 
+    :page_id, 
+    :parent_id,
+    :block_type_id,
+    :sort_order,
+    :name,
+    :value        
+    
+  after_initialize do |b|
+    # Do whatever we need to do to set the value to be correct for the field type we have.
+    # Most field types are fine with the raw value in the database
+    if b.block_type.nil?
+      bt = Caboose::BlockType.where(:field_type => 'text').first
+      b.block_type_id = bt.id
+    end
+    if b.block_type.field_type.nil?
+      b.block_type.field_type = 'text'
+      b.save
+    end
+    case b.block_type.field_type
+      when 'checkbox' then b.value = (b.value == 1 || b.value == '1' || b.value == true ? true : false)
+    end
+  end
+  
+  before_save :caste_value
+  def caste_value  
+    case self.block_type.field_type
+      when 'checkbox'
+        if self.value.nil? then self.value = false
+        else self.value = (self.value == 1 || self.value == '1' || self.value == true ? 1 : 0)
+        end
+    end
+  end
+  
+  def child_value(name)
+    b = child(name)
+    return nil if b.nil?
+    return b.image if b.block_type.field_type == 'image'
+    return b.file  if b.block_type.field_type == 'file'
+    return b.value        
+  end
+  
+  def child(name)
+    Caboose::Block.where("parent_id = ? and name = ?", self.id, name).first
+  end
+  
+  def create_children(block_type_override = nil)
+    bt = block_type_override ? block_type_override : block_type
+    bt.children.each do |bt2|
+      bt_id = bt2.id      
+      #if bt2.parent_id
+      #  new_bt_id = Caboose::BlockType.where(:name => bt2.field_type).first.id 
+      #end      
+      if self.child(bt2.name).nil?
+        b = Caboose::Block.create(
+          :page_id => self.page_id,
+          :parent_id => self.id, 
+          :block_type_id => bt_id,
+          :name => bt2.name,
+          :value => bt2.default
+        )
+        b.create_children(bt2)
+      end
+    end
+  end
+                                            
+  def render(block, options)    
+    Caboose.log("block.render\nself.id = #{self.id}\nblock = #{block}\noptions.class = #{options.class}\noptions = #{options}")
+    
+    if block && block.is_a?(String)
+      Caboose.log("Block #{block} is a string, finding block object... self.id = #{self.id}")
+      b = self.child(block)        
+      if b.nil?
+        self.create_children
+        b = self.child(block)
+        if b.nil?        
+          Caboose.log("No block exists with name \"#{block}\".")
+          return false
+        end
+      end
+      block = b
+    end        
+    str = ""
+
+    defaults = {
+      :modal      => false,
+      :empty_text => "",
+      :editing    => false,
+      :css        => nil,
+      :js         => nil,
+      :block      => block
+    }
+    options2 = nil
+    #Caboose.log(options.class)
+    if options.is_a?(Hash)
+      options2 = defaults.merge(options)      
+    #elsif options.is_a?(ActionView::Base)
+    #  options2 = {        
+    #    :modal      => options.modal,
+    #    :empty_text => options.empty_text,
+    #    :editing    => options.editing,
+    #    :css        => options.css,
+    #    :js         => options.js        
+    #  }
+    else
+      options2 = {        
+        :modal      => options.modal,
+        :empty_text => options.empty_text,
+        :editing    => options.editing,
+        :css        => options.css,
+        :js         => options.js        
+      }        
+    end
+    options2[:block] = block
+          
+    #options2.modal      = false if options2.modal.nil? 
+    #options2.empty_text = ""    if options2.empty_text.nil? 
+    #options2.editing    = false if options2.editing.nil?
+    #options[:css => nil, 
+    #options[:js => nil 
+    #}.merge(options)
+    #options2.block = block
+       
+    if block.block_type.use_render_function && block.block_type.render_function
+      #Caboose.log("Rendering from function")      
+      str = block.render_from_function(options2)
+    else
+      view = ActionView::Base.new(ActionController::Base.view_paths)
+      begin
+        #Caboose.log("Rendering caboose/blocks/#{block.name}")
+        str = view.render(:partial => "caboose/blocks/#{block.name}", :locals => options2)
+      rescue
+        #Caboose.log("Error rendering caboose/blocks/#{block.name}")
+        begin          
+          #Caboose.log("Rendering caboose/blocks/#{block.block_type.name}")
+          str = view.render(:partial => "caboose/blocks/#{block.block_type.name}", :locals => options2)
+        rescue                    
+          #Caboose.log("Error rendering caboose/blocks/#{block.block_type.name}")
+          #Caboose.log("Rendering caboose/blocks/#{block.block_type.field_type}")
+          str = view.render(:partial => "caboose/blocks/#{block.block_type.field_type}", :locals => options2)
+        end
+      end        
+    end     
+    #return str if block.parent_id.nil?    
+    #return str if options[:editing].nil? || options[:editing] == false
+    #return "<div id='block_#{block.id}' class='block'>#{str}</div>"
+    return str
+  end
+
+  def render_from_function(options)
+    self.create_children    
+    #locals = OpenStruct.new(:block => self, :empty_text => empty_text, :editing => editing)
+    locals = OpenStruct.new(options)
+    erb = ERB.new(block_type.render_function)
+    return erb.result(locals.instance_eval { binding })
+  end
+  
+  def child_block_link        
+    return "<div class='new_block' id='new_block_#{self.id}'>New Block</div>"    
+  end    
+  
+  def js_hash
+    kids = self.children.collect { |b| b.js_hash }
+    bt = self.block_type
+    return {
+      'id'             => self.id,           
+      'page_id'        => self.page_id,      
+      'parent_id'      => self.parent_id,    
+      'block_type_id'  => self.block_type_id,    
+      'sort_order'     => self.sort_order,
+      'name'           => self.name,
+      'value'          => self.value,
+      'children'       => kids,      
+      'block_type'     => {      
+        'id'                              => bt.id,                            
+        'parent_id'                       => bt.parent_id,                     
+        'name'                            => bt.name,
+        'description'                     => bt.description,
+        'render_function'                 => bt.render_function,
+        'use_render_function'             => bt.use_render_function,
+        'use_render_function_for_layout'  => bt.use_render_function_for_layout,
+        'allow_child_blocks'              => bt.allow_child_blocks,
+        'field_type'                      => bt.field_type,
+        'default'                         => bt.default,
+        'width'                           => bt.width,
+        'height'                          => bt.height,
+        'fixed_placeholder'               => bt.fixed_placeholder,
+        'options'                         => bt.options,
+        'options_function'                => bt.options_function,
+        'options_url'                     => bt.options_url
+      },
+      'file' => {
+        'url' => self.file.url
+      },
+      'image' => {
+        'tiny_url'  => self.image.url(:tiny),
+        'thumb_url' => self.image.url(:thumb),
+        'large_url' => self.image.url(:large),
+      }
+    }
+  end
+
+end

data/app/models/caboose/block_type.rb

@@ -0,0 +1,28 @@
+
+class Caboose::BlockType < ActiveRecord::Base
+  self.table_name = "block_types"
+
+  belongs_to :parent, :foreign_key => 'parent_id', :class_name => 'Caboose::BlockType'
+  has_many :children, :foreign_key => 'parent_id', :class_name => 'Caboose::BlockType', :dependent => :destroy    
+  attr_accessible :id,
+    :parent_id,
+    :name, 
+    :description, 
+    :use_render_function,
+    :use_render_function_for_layout,
+    :allow_child_blocks,
+    :render_function,
+    :field_type, 
+    :default, 
+    :width,
+    :height, 
+    :fixed_placeholder, 
+    :options,
+    :options_function,
+    :options_url
+    
+  def render_options(empty_text = nil)    
+    return eval(self.options_function)    
+  end
+
+end

data/app/models/caboose/core_plugin.rb

@@ -21,12 +21,12 @@ class Caboose::CorePlugin < Caboose::CaboosePlugin
       'children' => []
     }
         
-    item['children'] << { 'id' => 'users'        , 'text' => 'Users'            , 'href' => '/admin/users'            , 'modal' => false } if user.is_allowed('users'          , 'view')
-    item['children'] << { 'id' => 'roles'        , 'text' => 'Roles'            , 'href' => '/admin/roles'            , 'modal' => false } if user.is_allowed('roles'          , 'view')
-    item['children'] << { 'id' => 'permissions'  , 'text' => 'Permissions'      , 'href' => '/admin/permissions'      , 'modal' => false } if user.is_allowed('permissions'    , 'view')
-    item['children'] << { 'id' => 'blocktypes'   , 'text' => 'AB Test Variants' , 'href' => '/admin/ab-variants'      , 'modal' => false } if user.is_allowed('abvariants'     , 'view')
-    item['children'] << { 'id' => 'variables'    , 'text' => 'Variables'        , 'href' => '/admin/settings'         , 'modal' => false } if user.is_allowed('settings'       , 'view')
-    item['children'] << { 'id' => 'blocktypes'   , 'text' => 'Page Block Types' , 'href' => '/admin/page-block-types' , 'modal' => false } if user.is_allowed('pageblocktypes' , 'view')    
+    item['children'] << { 'id' => 'users'        , 'text' => 'Users'            , 'href' => '/admin/users'       , 'modal' => false } if user.is_allowed('users'       , 'view')
+    item['children'] << { 'id' => 'roles'        , 'text' => 'Roles'            , 'href' => '/admin/roles'       , 'modal' => false } if user.is_allowed('roles'       , 'view')
+    item['children'] << { 'id' => 'permissions'  , 'text' => 'Permissions'      , 'href' => '/admin/permissions' , 'modal' => false } if user.is_allowed('permissions' , 'view')
+    item['children'] << { 'id' => 'blocktypes'   , 'text' => 'AB Test Variants' , 'href' => '/admin/ab-variants' , 'modal' => false } if user.is_allowed('abvariants'  , 'view')
+    item['children'] << { 'id' => 'variables'    , 'text' => 'Variables'        , 'href' => '/admin/settings'    , 'modal' => false } if user.is_allowed('settings'    , 'view')
+    item['children'] << { 'id' => 'blocktypes'   , 'text' => 'Page Block Types' , 'href' => '/admin/block-types' , 'modal' => false } if user.is_allowed('blocktypes'  , 'view')    
         
     nav << item if item['children'].count > 0
     

data/app/models/caboose/page.rb

@@ -4,8 +4,8 @@ class Caboose::Page < ActiveRecord::Base
   
   belongs_to :parent, :class_name => "Page"
   has_many :children, :class_name => "Page", :foreign_key => 'parent_id', :order => 'sort_order, title'
-  has_many :page_permissions
-  has_many :page_blocks, :order => 'sort_order'
+  has_many :page_permissions  
+  has_many :blocks, :order => 'sort_order'
   attr_accessible :parent_id, 
     :title, 
     :menu_title, 
@@ -39,8 +39,12 @@ class Caboose::Page < ActiveRecord::Base
     return ""
   end
   
-  def blocks
-    self.page_blocks
+  def block
+    Caboose::Block.where("page_id = ? and parent_id is null", self.id).first
+  end
+  
+  def top_level_blocks
+    Caboose::Block.where("page_id = ? and parent_id is null", self.id).reorder(:sort_order).all
   end
   
   #def content

data/app/models/caboose/schema.rb

@@ -4,18 +4,33 @@ class Caboose::Schema < Caboose::Utilities::Schema
   # Tables (in order) that were renamed in the development of the gem.
   def self.renamed_tables
     {
-      :roles_users       => :role_memberships,
-      :permissions_roles => :role_permissions
+      :roles_users             => :role_memberships,
+      :permissions_roles       => :role_permissions,
+      :page_block_field_values => :fields,
+      :page_block_fields       => :field_types,
+      :page_block_types        => :block_types,
+      :page_blocks             => :blocks
+    }
+  end
+  
+  def self.renamed_columns
+    {
+      #Caboose::Field     => { :page_block_id        => :block_id,
+      #                        :page_block_field_id  => :field_type_id },      
+      #Caboose::FieldType => { :page_block_type_id   => :block_type_id },
+      Caboose::Block     => { :page_block_type_id   => :block_type_id }    
     }
   end
   
   def self.removed_columns
     {
-      Caboose::PageBlock => [:block_type, :value, :name],      
-      Caboose::PageBlockField => [:model_binder_options],
+      Caboose::Block => [:block_type],      
+      #Caboose::FieldType => [:model_binder_options],
       Caboose::AbValue => [:i, :text],
       Caboose::AbOption => [:text],
-      Caboose::User => [:timezone]
+      Caboose::User => [:timezone],
+      #Caboose::Field => [:child_block_id],
+      Caboose::BlockType => [:layout_function]
     }
   end
   
@@ -90,63 +105,79 @@ class Caboose::Schema < Caboose::Utilities::Schema
         [ :alias                 , :string  ],
         [ :uri                   , :string  ],
         [ :redirect_url          , :string  ],
-        [ :hide                  , :boolean , :default => false ],
-        [ :content_format        , :integer , :default => Caboose::Page::CONTENT_FORMAT_HTML ],
+        [ :hide                  , :boolean , { :default => false }],
+        [ :content_format        , :integer , { :default => Caboose::Page::CONTENT_FORMAT_HTML }],
         [ :custom_css            , :text    ],
         [ :custom_js             , :text    ],
         [ :linked_resources      , :text    ],
         [ :layout                , :string  ],
-        [ :sort_order            , :integer , :default => 0                ],
-        [ :custom_sort_children  , :boolean , :default => false            ],
-        [ :seo_title             , :string  , :limit => 70                 ],
-        [ :meta_description      , :string  , :limit => 156                ],
-        [ :meta_robots           , :string  , :default => 'index, follow'  ],
+        [ :sort_order            , :integer , { :default => 0                }],
+        [ :custom_sort_children  , :boolean , { :default => false            }],
+        [ :seo_title             , :string  , { :limit => 70                 }],
+        [ :meta_description      , :string  , { :limit => 156                }],
+        [ :meta_robots           , :string  , { :default => 'index, follow'  }],
         [ :canonical_url         , :string  ],
-        [ :fb_description        , :string  , :limit => 156 ],
-        [ :gp_description        , :string  , :limit => 156 ]
-      ],
-      Caboose::PageBlock => [        
-        [ :page_id               , :integer ],         
-        [ :page_block_type_id    , :integer ],
-        [ :sort_order            , :integer , :default => 0   ],
-        [ :name                  , :string  ],
-        [ :value                 , :text    ]        
+        [ :fb_description        , :string  , { :limit => 156 }],
+        [ :gp_description        , :string  , { :limit => 156 }]
       ],
-      Caboose::PageBlockType => [        
+      Caboose::Block => [        
+        [ :page_id               , :integer ],
+        [ :parent_id             , :integer ],
+        [ :block_type_id         , :integer ],
+        [ :sort_order            , :integer , { :default => 0 }],
         [ :name                  , :string  ],
-        [ :description           , :string  ],
-        [ :use_render_function   , :boolean , :default => false ],
-        [ :render_function       , :text    ] 
-      ],
-      Caboose::PageBlockField => [
-        [ :page_block_type_id   , :integer ],      
-        [ :name                 , :string  ],
-        [ :field_type           , :string  ],
-        [ :nice_name            , :string  ],
-        [ :default              , :text    ],
-        [ :width                , :integer ],
-        [ :height               , :integer ],
-        [ :fixed_placeholder    , :boolean ],
-        [ :options              , :text    ],
-        [ :options_function     , :text    ],
-        [ :options_url          , :string  ]
+        [ :value                 , :text    ],   
+        [ :file                  , :attachment ],
+        [ :image                 , :attachment ]
       ],
-      Caboose::PageBlockFieldValue => [
-        [ :page_block_id        , :integer    ],
-        [ :page_block_field_id  , :integer    ],
-        [ :value                , :text       ],
-        [ :file                 , :attachment ],
-        [ :image                , :attachment ]
+      Caboose::BlockType => [      
+        [ :parent_id                       , :integer ],
+        [ :name                            , :string  ],
+        [ :description                     , :string  ],
+        [ :render_function                 , :text    ],
+        [ :use_render_function             , :boolean , { :default => false }],        
+        [ :use_render_function_for_layout  , :boolean , { :default => false }],
+        [ :allow_child_blocks              , :boolean , { :default => false }],
+        
+        # Used for field values
+        [ :field_type                      , :string  ],        
+        [ :default                         , :text    ],
+        [ :width                           , :integer ],
+        [ :height                          , :integer ],
+        [ :fixed_placeholder               , :boolean ],
+        [ :options                         , :text    ],
+        [ :options_function                , :text    ],
+        [ :options_url                     , :string  ]
       ],      
+      #Caboose::Field => [
+      #  [ :block_id             , :integer    ],
+      #  [ :field_type_id        , :integer    ],        
+      #  [ :value                , :text       ],
+      #  [ :file                 , :attachment ],
+      #  [ :image                , :attachment ]        
+      #],
+      #Caboose::FieldType => [
+      #  [ :block_type_id        , :integer ],      
+      #  [ :name                 , :string  ],
+      #  [ :field_type           , :string  ],
+      #  [ :nice_name            , :string  ],
+      #  [ :default              , :text    ],
+      #  [ :width                , :integer ],
+      #  [ :height               , :integer ],
+      #  [ :fixed_placeholder    , :boolean ],
+      #  [ :options              , :text    ],
+      #  [ :options_function     , :text    ],
+      #  [ :options_url          , :string  ]
+      #],
       Caboose::Post => [  
-        [ :title       , :text       ],  		 	 
-        [ :body        , :text 		   ],  	 
-        [ :hide        , :boolean    ], 	 
-        [ :image_url   , :text 		   ],
-        [ :published   , :boolean    ],
-        [ :created_at  , :datetime   ],
-        [ :updated_at  , :datetime   ],
-        [ :image       , :attachment ]
+        [ :title                , :text       ],  		 	 
+        [ :body                 , :text 		   ],  	 
+        [ :hide                 , :boolean    ], 	 
+        [ :image_url            , :text 		   ],
+        [ :published            , :boolean    ],
+        [ :created_at           , :datetime   ],
+        [ :updated_at           , :datetime   ],
+        [ :image                , :attachment ]
       ],
       Caboose::PostCategory => [
         [ :name , :string ]
@@ -213,15 +244,15 @@ class Caboose::Schema < Caboose::Utilities::Schema
     #  c.remove_column(:pages, :content)
     #end
       
-    if !Caboose::PageBlockType.where(:name => 'heading').exists?
-      bt = Caboose::PageBlockType.create(:name => 'heading', :description => 'Heading')
-      Caboose::PageBlockField.create(:page_block_type_id => bt.id, :name => 'text', :field_type => 'text', :nice_name => 'Text', :default => '', :width => 800, :fixed_placeholder => false)
-      Caboose::PageBlockField.create(:page_block_type_id => bt.id, :name => 'size', :field_type => 'text', :nice_name => 'Size', :default =>  1, :width => 800, :fixed_placeholder => false, :options => "1|2|3|4|5|6")
+    if !Caboose::BlockType.where(:name => 'heading').exists?
+      bt = Caboose::BlockType.create(:name => 'heading', :description => 'Heading')
+      Caboose::FieldType.create(:block_type_id => bt.id, :name => 'text', :field_type => 'text', :nice_name => 'Text', :default => '', :width => 800, :fixed_placeholder => false)
+      Caboose::FieldType.create(:block_type_id => bt.id, :name => 'size', :field_type => 'text', :nice_name => 'Size', :default =>  1, :width => 800, :fixed_placeholder => false, :options => "1|2|3|4|5|6")
     end
     
-    if !Caboose::PageBlockType.where(:name => 'richtext').exists?
-      bt = Caboose::PageBlockType.create(:name => 'richtext', :description => 'Rich Text')
-      Caboose::PageBlockField.create(:page_block_type_id => bt.id, :name => 'text', :field_type => 'richtext', :nice_name => 'Text', :default => '', :width => 800, :height => 400, :fixed_placeholder => false)      
+    if !Caboose::BlockType.where(:name => 'richtext').exists?
+      bt = Caboose::BlockType.create(:name => 'richtext', :description => 'Rich Text')
+      Caboose::FieldType.create(:block_type_id => bt.id, :name => 'text', :field_type => 'richtext', :nice_name => 'Text', :default => '', :width => 800, :height => 400, :fixed_placeholder => false)      
     end
     
     admin_user = nil