gluttonberg-core 2.6.4 → 3.0.0

data/app/models/gluttonberg/html_content.rb

@@ -1,10 +1,14 @@
 module Gluttonberg
+  # Page content for html content (wisiwyg). All content/localization related functionality 
+  # is provided Content::Block mixin 
+  # Stores user input in :text column all other information is just meta information
   class HtmlContent  < ActiveRecord::Base
     include Content::Block
     self.table_name = "gb_html_contents"
+    attr_accessible :text
 
     is_localized do
+      attr_accessible :text
     end
-
   end
 end

data/app/models/gluttonberg/image_content.rb

@@ -1,10 +1,14 @@
 module Gluttonberg
+  # Page content for Image content (asset id). All content related functionality 
+  # is provided Content::Block mixin 
+  # Stores user input in :asset_id column all other information is just meta information
   class ImageContent  < ActiveRecord::Base
     include Content::Block
     self.table_name = "gb_image_contents"
-    belongs_to :asset
+    belongs_to :asset, :class_name => "Gluttonberg::Asset"
     attr_accessible :asset_id, :section_name
     is_versioned
+    delegate :current_user_id, :to => :page
 
   end
 end

data/app/models/gluttonberg/locale.rb

@@ -1,19 +1,26 @@
 module Gluttonberg
   class Locale  < ActiveRecord::Base
-    include Content::SlugManagement
     self.table_name = "gb_locales"
 
-    has_many    :page_localizations,  :class_name => "Gluttonberg::PageLocalization" , :dependent => :destroy
+    include Content::SlugManagement
+    
+    has_many :page_localizations,  :class_name => "Gluttonberg::PageLocalization" , :dependent => :destroy
 
     validates_presence_of :name , :slug
     validates_uniqueness_of :slug , :name
+
     attr_accessible :name, :slug, :slug_type, :default
+    after_save :clear_cache
 
-    SLUG_TYPES = ["prefix"]
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
 
-    def  self.first_default(opts={})
-      opts[:default] = true
-      find(:first , :conditions => opts )
+    # Currently gluttonberg only supports prefix. 
+    # TODO Subdomain based localization can be supported later
+    SLUG_TYPES = ["prefix"] 
+
+    def self.first_default(opts={})
+      @@first_default ||= self.where(opts.merge(:default => true)).first
     end
 
     def self.prefix_slug_type
@@ -25,13 +32,25 @@ module Gluttonberg
     end
 
     def self.find_by_locale(locale_slug)
-      find(:first , :conditions => { :slug => locale_slug } )
+      where(:slug => locale_slug).first
     end
 
+    # English (en) is the default locale
     def self.generate_default_locale
-      if Gluttonberg::Locale.find(:first , :conditions => {:slug => "en-au"}).blank?
-        locale = Gluttonberg::Locale.create( :slug => "en-au" , :name => "Australia English" , :default => true , :slug_type => Gluttonberg::Locale.prefix_slug_type )
+      if Gluttonberg::Locale.where(:slug => "en").count == 0
+        locale = Gluttonberg::Locale.create({
+          :slug => "en",
+          :name => "English",
+          :default => true,
+          :slug_type => Gluttonberg::Locale.prefix_slug_type
+        })
       end
     end
+
+    private
+      # Caching is used to avoid database query everywhere when locale is used
+      def clear_cache
+        @@first_default = nil
+      end
   end
 end

data/app/models/gluttonberg/member.rb

@@ -2,35 +2,43 @@ module Gluttonberg
   class Member < ActiveRecord::Base
     self.table_name = "gb_members"
 
-    attr_accessible :first_name , :last_name , :email , :password , :password_confirmation , :bio , :image , :image_delete , :term_and_conditions, :group_ids
+    attr_accessible :first_name , :last_name , :email , :password
+    attr_accessible :password_confirmation , :bio , :image , :image_delete , :term_and_conditions, :group_ids, :groups
+    attr_accessible :return_url
 
     has_and_belongs_to_many :groups, :class_name => "Group" , :join_table => "gb_groups_members"
     has_attached_file :image, :styles => { :profile => ["600x600"], :thumb => ["142x95#"] , :thumb_for_backend => ["100x75#"]}
 
-    validates_format_of :password, :with => /^(?=.*\d)(?=.*[a-zA-Z])(?!.*[^\w\S\s]).{6,}$/ , :if => :require_password?, :message => "must be a minimum of 6 characters in length, contain at least 1 letter and at least 1 number"
+    # Validate content type
+    validates_attachment_content_type :image, :content_type => /\Aimage/
+    # Validate filename
+    validates_attachment_file_name :image, :matches => [/png\Z/, /jpe?g\Z/]
 
+    validates_format_of :password, :with => Rails.configuration.password_pattern , :if => :require_password?, :message => Rails.configuration.password_validation_message
     validates_presence_of :first_name , :email
+    validates :first_name, :last_name, :email, :length => { :maximum => 255 }
+
+    before_validation :verify_confirmation_status
+
     attr_accessor :return_url , :term_and_conditions
     attr_accessor :image_delete
 
-    member_mixins = Rails.configuration.member_mixins
-    unless member_mixins.blank?
-      member_mixins.each do |mixin|
-        include mixin
-      end
-    end
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
+
+    include Membership::Import
+    include Membership::Export
 
     clean_html [:bio]
 
     acts_as_authentic do |c|
       c.session_class = MemberSession
       c.login_field = "email"
+      c.crypto_provider = Authlogic::CryptoProviders::Sha512
     end
 
     def full_name
-      self.first_name = "" if self.first_name.blank?
-      self.last_name = "" if self.last_name.blank?
-      self.first_name + " " + self.last_name
+      "#{self.first_name} #{self.last_name}".strip
     end
 
     def deliver_password_reset_instructions!(current_localization_slug = "")
@@ -51,11 +59,7 @@ module Gluttonberg
     end
 
     def self.enable_members
-      if Rails.configuration.enable_members == true || Rails.configuration.enable_members.kind_of?(Hash)
-        true
-      else
-        false
-      end
+      Rails.configuration.enable_members == true || Rails.configuration.enable_members.kind_of?(Hash)
     end
 
     def self.does_email_verification_required
@@ -73,15 +77,23 @@ module Gluttonberg
     end
 
     def self.generateRandomString(length=10)
-      chars = ("A".."Z").to_a + ("0".."9").to_a
-      numbers = ("0".."9").to_a
-      similar_chars = %w{ i I 1 0 O o 5 S s }
-      chars.delete_if {|x| similar_chars.include? x}
-      numbers.delete_if {|x| similar_chars.include? x}
-      newpass = ""
-      1.upto(length-1) { |i| newpass << chars[rand(chars.size-1)] }
-      1.upto(1) { |i| newpass << numbers[rand(numbers.size-1)] }
-      newpass
+      RandomStringGenerator.generate(length)
+    end
+
+    def self.generate_password_hash
+      password = self.generateRandomString
+      password_hash = {
+          :password => password ,
+          :password_confirmation => password
+      }
+    end
+
+    def assign_groups(group_ids)
+      if !group_ids.blank? && group_ids.kind_of?(String)
+        self.group_ids = [group_ids]
+      else
+        self.group_ids = group_ids
+      end
     end
 
     def does_member_have_access_to_the_page?( page)
@@ -96,182 +108,21 @@ module Gluttonberg
       end
     end
 
-    ###############################
-    # takes complete path to csv file.
-    # and returns successfull_users , failed_users and updated_users arrays that contains user objects
-    # if user exist with given email then update its information
-    # otherwise create a new user for it
-    # returns [successfull_users , failed_users , updated_users , ]
-    # if csv format is incorrect then it will return a string "CSV file format is invalid"
-    def self.importCSV(file_path , invite , group_ids )
-      begin
-        if RUBY_VERSION >= "1.9"
-          require 'csv'
-          csv_table = CSV.read(file_path)
-        else
-          csv_table = FasterCSV.read(file_path)
-        end
-      rescue => e
-        return "Please provide a valid CSV file with correct column names."
-      end
-      first_name_column_num =   self.find_column_position(csv_table , Rails.configuration.member_csv_metadata[:first_name] )
-      last_name_column_num =   self.find_column_position(csv_table ,  Rails.configuration.member_csv_metadata[:last_name]  )
-      email_column_num =   self.find_column_position(csv_table , Rails.configuration.member_csv_metadata[:email] )
-      groups_column_num =   self.find_column_position(csv_table , Rails.configuration.member_csv_metadata[:groups] )
-      other_columns = {}
-
-      Rails.configuration.member_csv_metadata.each do |key , val|
-        if ![:first_name, :last_name , :email, :groups].include?(key)
-          other_columns[key] = self.find_column_position(csv_table , val )
-        end
-      end
-
-      successfull_users = []
-      failed_users = []
-      updated_users = []
-
-
-      if first_name_column_num && last_name_column_num  && email_column_num
-        csv_table.each_with_index do |row , index |
-            if index > 0 # ignore first row because its meta data row
-              #user information hash
-              user_info = {
-                :first_name => row[first_name_column_num] ,
-                :last_name => row[last_name_column_num] ,
-                :email => row[email_column_num],
-                :group_ids => []
-              }
-              other_columns.each do |key , val|
-                if !val.blank? && val >= 0
-                  if row[val].blank? || !user_info[key].kind_of?(String)
-                    user_info[key] = row[val]
-                  else
-                    user_info[key] = row[val].force_encoding("UTF-8")
-                  end
-                end
-              end
-
-              #attach user to an industry if its valid
-              unless groups_column_num.blank? || row[groups_column_num].blank?
-                group_names = row[groups_column_num].split(";")
-                temp_group_ids = []
-                group_names.each do |group_name|
-                  group = Group.find(:first,:conditions=>{:name => group_name.strip})
-                  temp_group_ids << group.id unless group.blank?
-                end
-                user_info[:group_ids] = temp_group_ids
-              end
-
-              unless group_ids.blank?
-                if user_info[:group_ids].blank?
-                  user_info[:group_ids] = group_ids
-                else
-                  user_info[:group_ids] << group_ids
-                end
-              end
-
-              user = self.find(:first , :conditions => { :email => row[email_column_num] } )
-              if user.blank?
-                # generate random password
-                temp_password = self.generateRandomString
-                password_hash = {
-                  :password => temp_password ,
-                  :password_confirmation => temp_password
-                }
-
-                # make user object
-                user = self.new(user_info.merge(password_hash))
-
-                #if its valid then save it send an email and also add it to successfull_users array
-                if user.valid?
-                  user.save
-                  if invite == "1"
-                    # we will regenerate password and send it member
-                    MemberNotifier.delay.welcome(user)
-                  end
-                  successfull_users << user
-                else # if failed then add it to failed list
-                  failed_users << user
-                end
-              else
-                if  !self.contains_user?(user , successfull_users) and !self.contains_user?(user , updated_users)
-                    if user.update_attributes(user_info)
-                      updated_users << user
-                    else
-                      failed_users << user
-                    end
-                end
-              end
-            end # if csv row index > 0
-
-        end #loop
-      else
-        return "Please provide a valid CSV file with correct column names"
-      end #if
-      [successfull_users , failed_users , updated_users ]
+    def generate_confirmation_key
+      self.confirmation_key = Digest::SHA1.hexdigest(Time.now.to_s + rand(12341234).to_s)[1..24]
     end
 
-    def self.contains_user?(user , list)
-      list.each do |record|
-        return true if record.id == user.id || record.email == user.email
-      end
-      false
-    end
+    private
 
-    # csv_table is two dimentional array
-    # col_name is a string.
-    # if structure is proper and column name found it returns column index from 0 to n-1
-    # otherwise nil
-    def self.find_column_position(csv_table  , col_name)
-      if csv_table.instance_of?(Array) && csv_table.count > 0 && csv_table.first.count > 0
-        csv_table.first.each_with_index do |table_col , index|
-          return index if table_col.to_s.upcase == col_name.to_s.upcase
-        end
-        nil
-      else
-        nil
-      end
-    end
-
-    #############################
-    #export to a csv
-    def self.exportCSV
-      all_records = self.all
-      csv_class = nil
-      if RUBY_VERSION >= "1.9"
-        require 'csv'
-        csv_class = CSV
-      else
-        csv_class = FasterCSV
-      end
-      other_columns = {}
-      csv_string = csv_class.generate do |csv|
-          header_row = ["DATABASE ID",Rails.configuration.member_csv_metadata[:first_name],Rails.configuration.member_csv_metadata[:last_name], Rails.configuration.member_csv_metadata[:email], Rails.configuration.member_csv_metadata[:groups]]
-
-          index = 0
-          Rails.configuration.member_csv_metadata.each do |key , val|
-            if ![:first_name, :last_name , :email , :groups].include?(key)
-              other_columns[key] = index + 5
-              header_row << val
-              index += 1
-            end
-          end
-          csv << header_row
-
-          all_records.each do |record|
-            data_row = [record.id, record.first_name, record.last_name , record.email , record.groups_name("; ")]
-            other_columns.each do |key , val|
-              if !val.blank? && val >= 0
-                data_row[val] = record.send(key)
-              end
-            end
-            csv << data_row
+      def verify_confirmation_status
+        if self.profile_confirmed != true
+          if self.class.does_email_verification_required
+            self.generate_confirmation_key
+          else
+            self.profile_confirmed = true
           end
+        end
       end
 
-      csv_string
-    end
-
-
   end
-end
+end

data/app/models/gluttonberg/page.rb

@@ -1,204 +1,99 @@
 # encoding: utf-8
-# Do not remove above encoding line utf-8, its required for ruby 1.9.2. We are using some special chars in this file.
+# Do not remove above encoding line utf-8, its required for ruby 1.9.2. 
+# We are using some special chars in this file.
 
 module Gluttonberg
+  # One of the most important model of Gluttonberg.
+  # It stores basic meta data about page and have associations with its related models
+
   class Page < ActiveRecord::Base
-    include Content::Publishable
-    include Content::SlugManagement
+    include Content::PageComponents
+    
+    # this is used by slug management for the purpose of uniqueness within tree
+    self.slug_scope = :parent_id
+
+    self.table_name = "gb_pages"
+
+    # User who has created this page
     belongs_to :user
-    has_many :localizations, :class_name => "Gluttonberg::PageLocalization"   , :dependent => :destroy
+
+    # Page Lolcalizations
+    has_many :localizations, :class_name => "Gluttonberg::PageLocalization", :dependent => :destroy
+    
+    # Groups (membership) This is used to restrict pages to particular group members
     has_and_belongs_to_many :groups, :class_name => "Group" , :join_table => "gb_groups_pages"
 
     attr_protected :user_id , :state , :published_at
-    attr_accessible :parent_id, :name, :navigation_label, :slug, :description_name, :hide_in_nav, :group_ids, :home
+    attr_accessible :parent_id, :parent, :position, :name
+    attr_accessible :navigation_label, :slug, :description_name
+    attr_accessible :hide_in_nav, :group_ids, :home
 
-    # Generate the associations for the block/content classes
-    Content::Block.classes.each do |klass|
-      has_many klass.association_name, :class_name => klass.name, :dependent => :destroy
-    end
+    # Store information regarding collapsed/expanded pages on pages tree
+    has_many :collapsed_pages, :class_name => "Gluttonberg::CollapsedPage", :dependent => :destroy
 
     validates_presence_of :name , :description_name
 
-    self.table_name = "gb_pages"
-
-    after_save   :check_for_home_update
+    is_drag_tree :scope => :parent_id, :flat => false , :order => "position", :counter_cache => :children_count
 
-    is_drag_tree :scope => :parent_id, :flat => false , :order => "position"
-
-    attr_accessor :current_localization, :locale_id, :paths_need_recaching
+    attr_accessor :current_localization, :locale_id, :paths_need_recaching, :current_user_id
+    delegate :version, :loaded_version,  :to => :current_localization
 
+    # Returns content for a page section
+    #
+    # @param section_name [String or Symbol]
+    # @param opts [Hash] Its a optional parameter. 
+      # :locale
+      # :url_for for image contents. Pass image size symbol.
+    # @return [String] Html safe text content or image path depending on content type
     def easy_contents(section_name, opts = {})
       begin
+        prepared_content = nil
         section_name = section_name.to_sym
-        load_localization
-        content = localized_contents.pluck {|c| c.section[:name] == section_name}
-        if content.class.name == "Gluttonberg::ImageContent"
-          if opts[:url_for].blank?
-            content.asset.url
-          else
-            content.asset.url_for(opts[:url_for].to_sym)
-          end
-        elsif content.class.name == "Gluttonberg::HtmlContent"
-          content.current_localization.text.html_safe
-        elsif content.class.name == "Gluttonberg::PlainTextContent"
-          content.current_localization.text
-        else
-          nil
-        end
+        load_localization(opts[:locale]) if current_localization.blank?
+        content = current_localization.contents.pluck {|c| (c.respond_to?(:parent) && c.parent.section[:name] ==  section_name ) || (c.respond_to?(:section) && c.section[:name] ==  section_name ) }
+        prepared_content = _prepare_content(content, opts)
       rescue
-        nil
-      end
-    end
-
-    # A custom finder used to find a page + locale combination which most
-    # closely matches the path specified. It will also optionally limit it's
-    # search to the specified locale, otherwise it will fall back to the
-    # default.
-    def self.find_by_path(path, locale = nil , domain_name=nil)
-      path = path.match(/^\/(\S+)/)
-      if( !locale.blank? && !path.blank?)
-        path = path[1]
-        page = joins(:localizations).where("locale_id = ? AND gb_page_localizations.path LIKE ? ", locale.id, path).first
-        unless page.blank?
-          page.current_localization = page.localizations.where("locale_id = ? AND path LIKE ? ", locale.id, path).first
-        end
-        page
-      elsif path.blank? #looking for home
-        locale = Gluttonberg::Locale.first_default if locale.blank?
-        if !Rails.configuration.multisite.blank?
-          page_desc = PageDescription.all.find{|key , val|  val.home_for_domain?(domain_name) }
-          page_desc = page_desc.last unless page_desc.blank?
-          unless page_desc.blank?
-            pages = joins(:localizations).where("locale_id = ? AND description_name = ?", locale.id, page_desc.name)
-          end
-        end
-
-        if pages.blank?
-          pages = joins(:localizations).where("locale_id = ? AND home = ?", locale.id, true)
-        end
-
-        page = pages.first unless pages.blank?
-        unless page.blank?
-          page.current_localization = page.localizations.where("locale_id = ? ", locale.id).first
-        end
-        page
-      else # default locale
-         path = path[1]
-         locale = Gluttonberg::Locale.first_default
-         page = joins(:localizations).where("locale_id = ? AND gb_page_localizations.path LIKE ? ", locale.id, path).first
-         unless page.blank?
-           page.current_localization = page.localizations.where("locale_id = ? AND path LIKE ? ", locale.id, path).first
-         end
-         page
       end
+      prepared_content
     end
 
-    # A custom finder used to find a page + locale combination which most
-    # closely matches the path specified. It will also optionally limit it's
-    # search to the specified locale, otherwise it will fall back to the
-    # default.
-    def self.find_by_previous_path(path, locale = nil , domain_name=nil)
-      path = path.match(/^\/(\S+)/)
-      if( !locale.blank? && !path.blank?)
-        path = path[1]
-        page = joins(:localizations).where("locale_id = ? AND gb_page_localizations.previous_path LIKE ? ", locale.id, path).first
-        unless page.blank?
-          page.current_localization = page.localizations.where("locale_id = ? AND previous_path LIKE ? ", locale.id, path).first
-        end
-        page
-      elsif(!path.blank?) # default locale
-         path = path[1]
-         locale = Gluttonberg::Locale.first_default
-         page = joins(:localizations).where("locale_id = ? AND gb_page_localizations.previous_path LIKE ? ", locale.id, path).first
-         unless page.blank?
-           page.current_localization = page.localizations.where("locale_id = ? AND previous_path LIKE ? ", locale.id, path).first
-         end
-         page
+    # Returns current localization of page if its not loaded yet then loads default localization
+    #
+    # @return [PageLocalization]
+    def current_localization
+      if @current_localization.blank?
+        load_localization
       end
+      @current_localization
     end
 
-    def redirect_required?
-      self.description.redirect?
-    end
-    def redirect_url
-      self.description.redirect_url(self,{})
-    end
-
-    # Indicates if the page is used as a mount point for a public-facing
-    # controller, e.g. a blog, message board etc.
-    def rewrite_required?
-      self.description.rewrite_required?
-    end
-
-    # Takes a path and rewrites it to point at an alternate route. The idea
-    # being that this path points to a controller.
-    def generate_rewrite_path(path)
-      path.gsub(current_localization.path, self.description.rewrite_route)
-    end
-
-    # Returns the PageDescription associated with this page.
-    def description
-      @description = PageDescription[self.description_name.to_sym] if self.description_name
-      @description
-    end
-
-    # Returns the name of the view template specified for this page —
-    # determined via the associated PageDescription
-    def view
-      self.description if @description.blank?
-      @description[:view] if @description
-    end
-
-    # Returns the name of the layout template specified for this page —
-    # determined via the associated PageDescription
-    def layout
-      self.description if @description.blank?
-      @description[:layout] if @description
-    end
-
-    # Returns the localized navigation label, or falls back to the page for a
-    # the default.
+    # Returns the localized navigation label, or falls back to the localized page name
     def nav_label
-      if current_localization.blank?
-        if navigation_label.blank?
-          name
-        else
-          navigation_label
-        end
+      if current_localization.navigation_label.blank?
+        current_localization.name
       else
-        if current_localization.navigation_label.blank?
-          current_localization.name
-        else
-          current_localization.navigation_label
-        end
+        current_localization.navigation_label
       end
     end
 
     # Returns the localized title for the page or a default
     def title
-      (current_localization.blank? || current_localization.name.blank?) ? self.name : current_localization.name
+      current_localization.name
     end
 
-    # Delegates to the current_localization
+    # Delegates to the current_localization path
     def path
-      unless current_localization.blank?
-        current_localization.path
-      else
-        localizations.first.path
-      end
+      current_localization.path
     end
 
+    # returns public path of current localization
     def public_path
-      unless current_localization.blank?
-        current_localization.public_path
-      else
-        localizations.first.public_path
-      end
+      current_localization.public_path
     end
 
-
+    # this method returns true if page path needs to be recalculated.
     def paths_need_recaching?
-      @paths_need_recaching
+      self.paths_need_recaching
     end
 
     # Just palms off the request for the contents to the current localization
@@ -221,147 +116,42 @@ module Gluttonberg
       end
     end
 
-    def home=(state)
-      write_attribute(:home, state)
-      @home_updated = state
-    end
-
-    def self.home_page
-      Page.find( :first ,  :conditions => [ "home = ? " , true ] )
-    end
-
-    def self.home_page_name
-      home_temp = self.home_page
-      if home_temp.blank?
-        "Not Selected"
-      else
-        home_temp.name
-      end
-    end
-
-    # if page type is not redirection.
-    # then create default view files for all localzations of the page.
-    # file will be created in host appliation/app/views/pages/template_name.locale-slug.html.haml
-    def create_default_template_file
-      unless self.description.redirection_required?
-        self.localizations.each do |page_localization|
-          file_path = File.join(Rails.root, "app", "views" , "pages" , "#{self.view}.#{page_localization.locale.slug}.html.haml"  )
-          unless File.exists?(file_path)
-            file = File.new(file_path, "w")
-
-            page_localization.contents.each do |content|
-              file.puts("= @page.easy_contents(:#{content.section_name})")
-            end
-            file.close
-          end
-        end
-      end
+    # Load the default localization and set it as current_localization
+    def load_default_localizations
+      Gluttonberg::Locale.first_default.id
+      self.current_localization = Gluttonberg::PageLocalization.where(:page_id => id , :locale_id => Gluttonberg::Locale.first_default.id).first
     end
 
+    # Repair Page tree by optimizing 'position' column
     def self.repair_pages_structure
-      pages = Page.all
-
-      pages.each do |page|
-
-        if page.description.blank?
-          puts "Page description '#{page.description_name}' for '#{page.name}' page  does not exist in page descriptions file. #{page.id}"
-        elsif !page.description.sections.blank?
-          puts("Generating stubbed content for new page #{page.id}")
-
-          [PlainTextContent , HtmlContent , ImageContent].each do |klass|
-            list = klass.find(:all , :conditions => { :page_id => page.id})
-            list.each do |item|
-              found = page.description.contains_section?(item.section_name , item.class.to_s.demodulize.underscore)
-              puts found
-              if(!found)
-                  item.destroy
-              end
-            end
-          end
-
-
-          page.description.sections.each do |name, section|
-            # Create the content
-                association = page.send(section[:type].to_s.pluralize)
-                content = association.find(:first , :conditions => {:section_name => name})
-                if content.blank?
-                  content = association.create(:section_name => name)
-                end
-                # Create each localization
-                 if content.class.localized?
-                     page.localizations.all.each do |localization|
-                       if content.localizations.find(:first , :conditions => { "#{section[:type]}_id" => content.id, :page_localization_id => localization.id }).blank?
-                         content.localizations.create(:parent => content, :page_localization => localization)
-                       end
-                     end
-                end
-          end
-        end
-      end # pages loop end
-      puts "completed"
+      PageRepairer.repair_pages_structure
     end
 
+    # if page does not belongs to group (membership) then its a public page
     def is_public?
       groups.blank?
     end
 
-    def load_default_localizations
-      self.current_localization = Gluttonberg::PageLocalization.find(:first , :conditions => { :page_id => id , :locale_id => Gluttonberg::Locale.first_default.id } )
-    end
-
-    def published?
-      if publishing_status == "Published"
-        return true
-      else
-        return false
-      end
-    end
-
+    # Duplicate current page and draft it.
     def duplicate
-      ActiveRecord::Base.transaction do
-        duplicated_page = self.dup
-        duplicated_page.state = "draft"
-        duplicated_page.created_at = Time.now
-        duplicated_page.published_at = nil
-        duplicated_page.position = nil
-
-        if duplicated_page.save
-          self.localizations.each do |localization|
-            dup_loc = duplicated_page.localizations.where(:locale_id => localization.locale_id).first
-            dup_loc_contents = dup_loc.contents
-            unless dup_loc.blank?
-              localization.contents.each do |content|
-                 if content.respond_to?(:parent) && content.parent.localized
-                    dup_content = dup_loc_contents.find{|c| c.respond_to?(:page_localization_id) &&  c.page_localization_id == dup_loc.id && c.parent.section_name ==  content.parent.section_name}
-                    dup_content.update_attributes(:text => content.text)
-                    dup_content = nil
-                 else
-                    dup_content = dup_loc_contents.find{|c| c.respond_to?(:page_id) && c.page_id == duplicated_page.id && c.section_name ==  content.section_name}
-                    dup_content.update_attributes(:asset_id => content.asset_id)
-                    dup_content = nil
-                 end
-              end
-
-            end
-          end
+      PageDuplicate.duplicate(self)
+    end
 
-          duplicated_page
-        else
-          nil
-        end
-      end
+    # check if current page is collapsed for current user?
+    def collapsed?(current_user)
+      !self.collapsed_pages.find_all{|page| page.user_id == current_user.id}.blank?
     end
 
     private
-
-
-
-      # Checks to see if this page has been set as the homepage. If it has, we
-      # then go and
-      def check_for_home_update
-        if @home_updated && @home_updated == true
-          previous_home = Page.find( :first ,  :conditions => [ "home = ? AND id <> ? " , true ,self.id ] )
-          previous_home.update_attributes(:home => false) if previous_home
+      # Prepare content based on its on content type
+      def _prepare_content(content, opts)
+        case content.class.name
+          when "Gluttonberg::ImageContent"
+            content.asset.url_for opts[:url_for] unless content.asset.blank?
+          when "Gluttonberg::HtmlContentLocalization", "Gluttonberg::TextareaContentLocalization"
+            content.text.html_safe
+          when "Gluttonberg::PlainTextContentLocalization", "Gluttonberg::SelectContent"
+            content.text
         end
       end