gluttonberg-core 2.6.4 → 3.0.0

data/lib/gluttonberg/content/page_duplicate.rb

@@ -0,0 +1,68 @@
+module Gluttonberg
+  class PageDuplicate
+    def self.duplicate(page)
+      ActiveRecord::Base.transaction do
+        duplicated_page = _duplicate_page_object(page)
+        if duplicated_page.save
+          _duplicate_page_localizations(page, duplicated_page)
+          duplicated_page
+        else
+          nil
+        end
+      end #transaction end
+    end
+
+    private
+      #duplicate page helper
+        def self._duplicate_page_object(page)
+          duplicated_page = page.dup
+          duplicated_page.state = "draft"
+          duplicated_page.created_at = Time.now
+          duplicated_page.published_at = nil
+          duplicated_page.position = nil
+          duplicated_page
+        end
+
+        def self._duplicate_page_localizations(page, duplicated_page)
+          page.localizations.each do |localization|
+            dup_loc = duplicated_page.localizations.where(:locale_id => localization.locale_id).first
+            unless dup_loc.blank?
+              _duplicate_localization_contents(duplicated_page, localization, dup_loc)
+            end
+          end
+        end
+
+        def self._duplicate_localization_contents(duplicated_page, localization, dup_loc)
+          dup_loc_contents = dup_loc.contents
+          localization.contents.each do |content|
+            if content.respond_to?(:parent) && content.parent.localized
+              _duplicate_localized_content(duplicated_page, dup_loc, dup_loc_contents, content)
+            else
+              _duplicate_non_localized_content(duplicated_page, dup_loc, dup_loc_contents, content)
+            end
+          end
+        end
+
+        def self._duplicate_localized_content(duplicated_page, dup_loc, dup_loc_contents, content)
+          dup_content = dup_loc_contents.find do |c|
+            c.respond_to?(:page_localization_id) &&
+            c.page_localization_id == dup_loc.id &&
+            c.parent.section_name ==  content.parent.section_name
+          end
+          dup_content.update_attributes(:text => content.text)
+        end
+
+        def self._duplicate_non_localized_content(duplicated_page, dup_loc, dup_loc_contents, content)
+          dup_content = dup_loc_contents.find do |c|
+            c.respond_to?(:page_id) &&
+            c.page_id == duplicated_page.id &&
+            c.section_name ==  content.section_name
+          end
+          if dup_content.respond_to? :asset_id
+            dup_content.update_attributes(:asset_id => content.asset_id)
+          elsif dup_content.respond_to? :text
+            dup_content.update_attributes(:text => content.text)
+          end
+        end
+  end
+end

data/lib/gluttonberg/content/page_finder.rb

@@ -0,0 +1,63 @@
+module Gluttonberg
+  module Content
+    module PageFinder
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # 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 find_by_path(path, locale = nil , domain_name=nil)
+          path = clean_path(path)
+          locale = Gluttonberg::Locale.first_default if locale.blank?
+          page = nil
+          if( !locale.blank? && !path.blank?)
+            page = joins(:localizations).where("locale_id = ? AND ( gb_page_localizations.path LIKE ? OR path LIKE ? ) ", locale.id, path, path).first
+            page.load_localization(locale) unless page.blank?
+          elsif path.blank? #looking for home
+            page = self.find_home(locale, domain_name)
+          end
+          page
+        end
+
+        # find home page
+        # if multisite then pass domain_name to find right home page
+        def find_home(locale, domain_name=nil)
+          unless Rails.configuration.multisite.blank?
+            page_desc = PageDescription.find_home_page_description_for_domain?(domain_name)
+            page = joins(:localizations).where("locale_id = ? AND description_name = ?", locale.id, page_desc.name).first unless page_desc.blank?
+          end
+          page = joins(:localizations).where("locale_id = ? AND home = ?", locale.id, true).first if page.blank?
+          page.load_localization(locale) unless page.blank?
+          page
+        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 find_by_previous_path(path, locale = nil , domain_name=nil)
+          path = clean_path(path)
+          locale = Gluttonberg::Locale.first_default if locale.blank?
+          unless path.blank?
+            joins(:localizations).where("locale_id = ? AND ( gb_page_localizations.previous_path LIKE ?  OR previous_path LIKE ? ) ", locale.id, path, path).first
+          end
+        end
+
+        private
+          def clean_path(path)
+            path = "" if path.blank?
+            path = path.match(/^\/(\S+)/)
+            unless path.blank?
+              path = path[1]
+              path = path[0..-2] if !(path.blank? || path == "/") && path.last == "/"
+            end
+            path
+          end
+
+      end #ClassMethods
+
+    end #PageFinder
+  end
+end

data/lib/gluttonberg/content/page_localization_slug.rb

@@ -0,0 +1,89 @@
+module Gluttonberg
+  module Content
+    module PageLocalizationSlug
+      extend ActiveSupport::Concern
+
+
+      # Write an explicit setter for the slug so we can check it’s not a blank
+      # value. This stops it being overwritten with an empty string.
+      def slug=(new_slug)
+        unless new_slug.blank?
+          write_attribute(:slug, new_slug.to_s.sluglize)
+          page_temp_slug = self.page.slug
+          self.page.slug = self.slug
+          write_attribute(:slug, self.page.slug)
+          unless self.locale.default
+            self.page.slug = page_temp_slug
+          end
+        end
+      end #slug=
+
+      def paths_need_recaching?
+        self.paths_need_recaching
+      end
+
+      def public_path
+        if Gluttonberg.localized?
+          "/#{self.locale.slug}/#{self.path}"
+        else
+          "/#{self.path}"
+        end
+      end
+
+
+      # Forces the localization to regenerate it's full path. It will firstly
+      # look to see if there is a parent page that it need to derive the path
+      # prefix from. Otherwise it will just use the slug, with a fall-back
+      # to it's page's default.
+      def regenerate_path
+        self.current_path = self.path
+        page.reload #forcing that do not take cached page object
+        slug = nil if slug.blank?
+        new_path = prepare_new_path
+
+        self.previous_path = self.current_path
+        write_attribute(:path, new_path)
+      end
+
+      # Regenerates and saves the path to this localization.
+      def regenerate_path!
+        regenerate_path
+        save
+      end
+
+      def path_without_self_slug
+        if page.parent_id && !page.parent.blank? && page.parent.home != true
+          localization = page.parent.localizations.where(:locale_id  => locale_id).first
+          "#{localization.path}/"
+        else
+          ""
+        end
+      end
+
+      def find_potential_duplicates(_path)
+        potential_duplicates = self.class.where([ "path = ? AND page_id != ?", _path, page.id]).all
+        potential_duplicates = potential_duplicates.find_all{|l| l.page.parent_id == self.page.parent_id}
+      end
+
+      private
+        def prepare_new_path
+          if page.parent_id && !page.parent.blank? && page.parent.home != true
+            localization = page.parent.localizations.where(:locale_id  => locale_id).first
+            new_path = "#{localization.path}/#{self.slug || page.slug}"
+          else
+            new_path = "#{self.slug || page.slug}"
+          end
+          check_duplication_in(new_path)
+        end
+
+        def check_duplication_in(new_path)
+          # check duplication: add id at the end if its duplicated
+          potential_duplicates = find_potential_duplicates(new_path)
+          Content::SlugManagement::ClassMethods.check_for_duplication(new_path, self, potential_duplicates)
+        end
+
+
+
+    end
+  end
+end

data/lib/gluttonberg/content/page_repairer.rb

@@ -0,0 +1,117 @@
+module Gluttonberg
+  class PageRepairer
+    def self.repair_pages_structure
+      pages = Page.all
+
+      pages.each do |page|
+        self.repair_page_structure(page)
+      end # pages loop end
+      puts "completed"
+    end #repair_pages_structure
+
+    def self.repair_page_structure(page)
+      if page.description.blank?
+        puts "Page description '#{page.description_name}' for '#{page.name}' (#{page.id}) page  does not exist in page descriptions file. "
+      elsif !page.description.sections.blank?
+        puts "Updating page structure for #{page.name} (#{page.id}) page"
+        self.clean_page_sections(page)
+        self.create_missing_sections(page)
+        puts "\n"
+      end
+    end
+
+    # remove page sections from database which does not exist anymore in page description
+    def self.clean_page_sections(page)
+      [PlainTextContent , HtmlContent , ImageContent].each do |klass|
+        list = klass.where(:page_id => page.id).all
+        list.each do |item|
+          self.clean_page_section(page, item, klass)
+        end
+      end
+    end
+
+    def self.clean_page_section(page, content, klass)
+      found = page.description.contains_section?(content.section_name , content.class.to_s.demodulize.underscore)
+      unless found
+        puts "#{content.section_name} (#{klass.name}) section from #{page.name} page"
+        content.destroy
+      end
+    end
+
+    # create missing page sections for page
+    def self.create_missing_sections(page)
+      page.description.sections.each do |section_name, section_info|
+        content = self.create_missing_section(page, section_name, section_info)
+        self.create_missing_section_localizations(page, section_name, section_info, content)
+      end
+    end
+
+    def self.create_missing_section(page, section_name, section_info)
+      # Create the content
+      association = page.send(section_info[:type].to_s.pluralize)
+      content = association.where(:section_name => section_name).first
+      if content.blank?
+        puts "Create #{section_name} section for #{page.name} page"
+        content = association.create(:section_name => section_name)
+      end
+      content
+    end
+
+    def self.change_page_description(page, old_description_name, new_description_name, page_attributes)
+      if(old_description_name != new_description_name)
+        old_description = PageDescription[old_description_name.to_sym]
+        new_description = PageDescription[new_description_name.to_sym]
+        if old_description && new_description
+          PageRepairer.update_page_sections(page, old_description, new_description)
+        elsif new_description #old one does not exist anymore
+        end
+        page.update_attributes(page_attributes)
+        PageRepairer.create_missing_sections(page)
+        page.create_default_template_file
+      end
+    end
+
+    def self.update_page_sections(page, old_description, new_description)
+      used_sections = []
+      new_description.sections.each do |section_name,  section_info|
+        matched_type_section = old_description.sections.find_all{|old_section_name, old_section_info| !used_sections.include?(old_section_name) &&  old_section_name == section_name && old_section_info[:type] == section_info[:type] }.first
+        association = page.send(section_info[:type].to_s.pluralize)
+        unless matched_type_section.blank?
+          content = association.where(:section_name => matched_type_section.first.to_s).first
+          used_sections << matched_type_section.first.to_s
+          unless content.blank?
+            content.update_attributes(:section_name => section_name)
+          end
+        else
+        end
+      end #sections loop
+    end
+
+    def self.create_missing_section_localizations(page, section_name, section_info, content)
+      # Create each localization
+      if content.class.localized?
+        page.localizations.all.each do |localization|
+          self.create_missing_section_localization(page, section_name, section_info, content, localization)
+        end
+      end
+    end
+
+    def self.create_missing_section_localization(page, section_name, section_info, content, localization)
+      content_localization_count = content.localizations.where({
+        "#{section_info[:type]}_id" => content.id,
+        :page_localization_id => localization.id
+      }).count
+      # missing localization. create it
+      if content_localization_count == 0
+        puts "Create #{localization.locale.name} localizations for #{content.section_name}"
+        content.localizations.create({
+          :parent => content,
+          :page_localization => localization
+        })
+      end
+    end
+
+
+
+  end #PageRepairer
+end

data/lib/gluttonberg/content/publishable.rb

@@ -4,86 +4,92 @@ module Gluttonberg
     # model. This includes finders for retrieving published records and 
     # instance methods for quickly changing the state.
     module Publishable
+      extend ActiveSupport::Concern
       # Add the class and instance methods, declare the property we store the
       # published state in.
-      def self.included(klass)
-        klass.class_eval do
-          extend ClassMethods
-          include InstanceMethods
-          scope :published, lambda { where("state = 'published'  AND  published_at <= ?", Time.zone.now) }
-          scope :archived, :conditions => { :state => "archived" }
-          scope :draft, :conditions => { :state => "draft" }
-          scope :non_published, :conditions => "state != 'published'"
-          before_validation :clean_published_date 
-        end
+      included do
+        scope :published, lambda { where("state = 'published'  AND  published_at <= ?", Time.zone.now) }
+        scope :archived, lambda { where(:state => "archived") }
+        scope :draft, lambda { where( :state => "draft") }
+        scope :non_published, lambda { where("state != 'published'") }
+        before_validation :set_status 
+        before_validation :clean_published_date 
+        attr_accessor :_publish_status
+        attr_accessible :_publish_status
       end
 
-      module ClassMethods
-        
-         
-        # Returns all matching records that are published for a particular user. May be called 
-        # with additional conditions.
-        def all_unpublished_for_user( user , options = {})
-          if options[:conditions].blank?
-             options[:conditions] = { :state => "published" }
-          else   
-            options[:conditions][:state] = "published"
-          end
-          
-          all(options)
-        end
-        
+      # Change the publish state to true and save the record.
+      def publish!
+        self.publish
+        self.save
+      end
+      
+      # Change the publish state to false and save the record.
+      def unpublish!
+        self.unpublish
+        self.save
       end
 
-      module InstanceMethods
-        # Change the publish state to true and save the record.
-        def publish!
-          update_attributes(:state=>"published")
-        end
-        
-        # Change the publish state to false and save the record.
-        def unpublish!
-          update_attributes(:state=>"draft")
-        end
+      # Change the publish state to draft but not save the record
+      def publish
+        self.state= "published"
+        self.published_at = Time.now
+      end
 
-        # Change the publish state to draft but not save the record
-        def unpublish
-          assign_attributes(:state=>"draft")
-        end
-        
-        # Change the publish state to true and save the record.
-        def archive!
-          update_attributes(:state=>"archived")
-        end
-        
-        # Check to see if this record has been published.
-        def published?
-          self.state == "published" && published_at <= Time.zone.now
-        end
-        
-        # Check to see if this record has been published.
-        def archived?
-          self.state == "archived"
-        end
-        
-        def draft?
-          self.state == "draft" || self.state == "ready" || self.state == "not_ready"
-        end
-        
-        def publishing_status
-          if draft?
-            "Draft"
-          else  
-            self.state.capitalize unless self.state.blank?
-          end  
+      # Change the publish state to draft but not save the record
+      def unpublish
+        self.state= "draft"
+      end
+      
+      # Change the publish state to true but not save the record.
+      def archive
+        self.state = "archived"
+      end
+
+      # Change the publish state to true and save the record.
+      def archive!
+        self.archive
+        self.save
+      end
+      
+      # Check to see if this record has been published.
+      def published?
+        self.state == "published" && published_at <= Time.zone.now
+      end
+      
+      # Check to see if this record has been published.
+      def archived?
+        self.state == "archived"
+      end
+      
+      def draft?
+        self.state == "draft" || self.state == "ready" || self.state == "not_ready"
+      end
+      
+      def publishing_status
+        temp_status = if draft?
+          "Draft"
+        else  
+          self.state.capitalize unless self.state.blank?
         end
-        
-        def clean_published_date
-          if self.state != "published"
-            self.published_at = nil
-          end  
+        # TODO support for 'submitted for approval'
+        temp_status.html_safe 
+      end
+      
+      def set_status
+        if ["draft", "ready", "not_ready"].include?(self.state) || self.state.blank?
+          self.state = "draft"
+        elsif ["published", "archived"].include?(self.state) 
+          self.state = self.state
+        else
+          #self.state = "draft"
         end
-        
+      end
+
+      def clean_published_date
+        if self.state != "published"
+          self.published_at = nil
+        end  
       end
     end # Publishable
   end # Content