goldencobra 1.4.27 → 2.3.3

data/app/helpers/goldencobra/login_helper.rb

@@ -1,13 +1,12 @@
 module Goldencobra
   module LoginHelper
-
     def render_login_widget(usermodel_name)
-      render :partial => "/goldencobra/sessions/login", :locals => {:usermodel => usermodel_name}
+      render partial: "/goldencobra/sessions/login", locals: { usermodel: usermodel_name }
     end
 
     def render_registration_widget(usermodel_name, associated_model=nil)
-      render :partial => "/goldencobra/sessions/register", :locals => {:usermodel => usermodel_name, :associated_model => associated_model}
+      render partial: "/goldencobra/sessions/register",
+             locals: { usermodel: usermodel_name, associated_model: associated_model }
     end
-
   end
-end
+end

data/app/helpers/goldencobra/navigation_helper.rb

@@ -1,9 +1,8 @@
 module Goldencobra
   module NavigationHelper
-
     def breadcrumb(options={})
-      id_name = options[:id] || "breadcrumb"
-      class_name = options[:class] || ""
+      id_name = options["id"] || "breadcrumb"
+      class_name = options["class"] || ""
       if @article
         list = ""
         @article.path.each do |art|
@@ -12,21 +11,22 @@ module Goldencobra
         end
         content_list = content_tag(:ol, raw(list))
         if id_name.present?
-          result = content_tag(:nav, raw(content_list), :id => "#{id_name}", :class => "#{class_name}")
+          result = content_tag(:nav, raw(content_list), id: "#{id_name}", class: "#{class_name}")
         else
-          result = content_tag(:nav, raw(content_list), :class => "#{class_name}")
+          result = content_tag(:nav, raw(content_list), class: "#{class_name}")
         end
         return raw(result)
       end
     end
 
-    # navigation_menu("Hauptmenue", :depth => 1, :class => "top", :id => "menue1", :offset => 1 )
+    # navigation_menu("Hauptmenue", depth: 1, class: "top", id: "menue1", offset: 1 )
     # depth: 0 = unlimited, 1 = self, 2 = self and children 1. grades, 3 = self and up to children 2.grades
     # offset: number of levels to skip, 0 = none
 
-    #<%= navigation_menu("Top-Menu", :current_article => @article, :class => "ul_main_nav", :depth => 1, :offset => 1 %>
+    #<%= navigation_menu("Top-Menu", current_article: @article, class: "ul_main_nav", depth: 1, offset: 1 %>
 
-    #TODO: offset implementieren
+    # TODO: offset implementieren
+    # TODO: refactor method to make it easier to test
     def navigation_menu(menue_id, options={})
       return "id can't be blank" if menue_id.blank?
       depth = options[:depth] || 9999
@@ -38,14 +38,14 @@ module Goldencobra
 
       if menue_id.class == String
         if current_article.present? && current_article.public_url.present?
-          current_menue = Goldencobra::Menue.active.where(:target => current_article.public_url(false)).select{|a| a.path.map(&:title).join("/").include?(menue_id)}.first
+          current_menue = Goldencobra::Menue.active.where(target: current_article.public_url(false)).select{|a| a.path.map(&:title).join("/").include?(menue_id)}.first
           if current_menue
             master_menue = Goldencobra::Menue.find_by_id(current_menue.path_ids[offset])
           else
             return ""
           end
         elsif submenue_of_article.present? && submenue_of_article.public_url.present?
-          master_menue = Goldencobra::Menue.active.where(:target => submenue_of_article.public_url).select{|a| a.path.map(&:title).join("/").include?(menue_id)}.first
+          master_menue = Goldencobra::Menue.active.where(target: submenue_of_article.public_url).select{|a| a.path.map(&:title).join("/").include?(menue_id)}.first
         else
           master_menue = Goldencobra::Menue.active.find_by_pathname(menue_id)
         end
@@ -56,7 +56,7 @@ module Goldencobra
       return "" if master_menue.blank?
 
       current_depth = master_menue.ancestry_depth
-      #Check for Permission
+      # Check for Permission
       begin
         if params.present? && params[:frontend_tags].present? && params[:frontend_tags].class != String && params[:frontend_tags][:format] && params[:frontend_tags][:format] == "email"
           #Wenn format email, dann gibt es keinen realen webseit besucher
@@ -69,42 +69,50 @@ module Goldencobra
         ability = Ability.new()
       end
 
-      if !ability.can?(:read, master_menue)
-        return ""
-      end
+      return "" unless ability.can?(:read, master_menue)
 
-      if master_menue.present?
-        content = ""
-        if current_article.present?
-          subtree_menues = master_menue.subtree.after_depth(current_depth).to_depth(current_depth + depth).active.includes(:permissions).includes(:image)
-        else
-          subtree_menues = master_menue.subtree.after_depth(current_depth + offset).to_depth(current_depth + depth).active.includes(:permissions).includes(:image)
-        end
-        subtree_menues = subtree_menues.to_a.delete_if{|a| !ability.can?(:read, a)}
-
-        current_depth = 1
-        menue_roots(subtree_menues).each do |root|
-          content << navigation_menu_helper(root, options, subtree_menues, current_depth)
-        end
+      content = ""
+      if current_article.present?
+        subtree_menues = master_menue.subtree.after_depth(current_depth)
+                                     .to_depth(current_depth + depth)
+                                     .active.includes(:permissions).includes(:image)
+      else
+        subtree_menues = master_menue.subtree.after_depth(current_depth + offset)
+                                     .to_depth(current_depth + depth)
+                                     .active.includes(:permissions).includes(:image)
+      end
+      subtree_menues = subtree_menues.to_a.delete_if{|a| !ability.can?(:read, a)}
 
-        if id_name.present?
-          result = content_tag(:ul, raw(content),:id => "#{id_name}", :class => "#{class_name} #{depth} navigation #{master_menue.css_class.to_s.gsub(/\W/,' ')}".squeeze(' ').strip)
-        else
-          result = content_tag(:ul, raw(content), :class => "#{class_name} #{depth} navigation #{master_menue.css_class.to_s.gsub(/\W/,' ')}".squeeze(' ').strip)
-        end
+      current_depth = 1
+      menue_roots(subtree_menues).each do |root|
+        content << navigation_menu_helper(root, options, subtree_menues, current_depth)
       end
-      return raw(result)
+
+      klass = [
+        class_name,
+        depth,
+        "navigation",
+        master_menue.css_class.to_s.gsub(/[^\w\-]/, " ")
+      ].join(" ").squeeze(" ").strip
+      result = content_tag(
+        :ul,
+        raw(content),
+        id: id_name.present? ? id_name.to_s : nil,
+        class: klass
+      )
+
+      raw(result)
     end
 
     private
 
     def menue_roots(menue_array)
       min_of_layers = menue_array.map{|a| a.ancestry.to_s.split("/").count }.min
-      return menue_array.select{|a| a.ancestry.to_s.split("/").count == min_of_layers }
+      menue_array.select{|a| a.ancestry.to_s.split("/").count == min_of_layers }
     end
 
     def menue_children(menue_element, menue_array)
-      return menue_array.select{|a| a.ancestry.to_s.split("/").last.to_i == menue_element.id }
+      menue_array.select{|a| a.ancestry.to_s.split("/").last.to_i == menue_element.id }
     end
 
     def navigation_menu_helper(child, options, subtree_menues, current_depth)
@@ -114,17 +122,17 @@ module Goldencobra
         child_target_link = child.target.gsub("\"",'')
       end
       if child.remote
-        link_options = {"data-remote" => "true",:href => child_target_link}
+        link_options = {"data-remote" => "true",href: child_target_link}
       else
-        link_options = {:href => child_target_link}
+        link_options = {href: child_target_link}
       end
       child_link = content_tag(:a, child.title, link_options )
       image_link = child.image.present? ? image_tag(child.image.image(:original)) : ""
-      child_link = child_link + content_tag(:a, image_link, link_options.merge(:class => "navigtion_link_imgage_wrapper")) unless options[:show_image] == false
-      child_link = child_link + content_tag(:a, child.description_title, link_options.merge(:class => "navigtion_link_description_title")) unless options[:show_description_title] == false
+      child_link = child_link + content_tag(:a, image_link, link_options.merge(class: "navigtion_link_imgage_wrapper")) unless options[:show_image] == false
+      child_link = child_link + content_tag(:a, child.description_title, link_options.merge(class: "navigtion_link_description_title")) unless options[:show_description_title] == false
       template = Liquid::Template.parse(child.description)
-      child_link = child_link + content_tag("div", raw(template.render(Goldencobra::Article::LiquidParser)), :class => "navigtion_link_description") unless options[:show_description] == false
-      child_link = child_link + content_tag(:a, child.call_to_action_name, link_options.merge(:class => "navigtion_link_call_to_action_name")) unless options[:show_call_to_action_name] == false
+      child_link = child_link + content_tag("div", raw(template.render(Goldencobra::Article::LiquidParser)), class: "navigtion_link_description") unless options[:show_description] == false
+      child_link = child_link + content_tag(:a, child.call_to_action_name, link_options.merge(class: "navigtion_link_call_to_action_name")) unless options[:show_call_to_action_name] == false
 
       current_depth += 1
       child_elements = menue_children(child, subtree_menues)
@@ -138,7 +146,7 @@ module Goldencobra
           content_level << navigation_menu_helper(subchild, options, subtree_menues, current_depth)
         end
         if content_level.present?
-          child_link = child_link + content_tag(:ul, raw(content_level), :class => "level_#{current_depth} children_#{visible_child_element_count}" )
+          child_link = child_link + content_tag(:ul, raw(content_level), class: "level_#{current_depth} children_#{visible_child_element_count}" )
         end
       end
 
@@ -153,8 +161,8 @@ module Goldencobra
       #   request = path_obj.new(options[:liquid_url_path])
       # end
 
-      return content_tag(:li, raw(child_link), "data-id" => child.id, :class => "#{ visible_child_element_count > 0 ? 'has_children' : '' } #{ (child.has_active_child?(request, subtree_menues) ? 'has_active_child' : '') if request.present? } #{ (child.is_active?(request) ? 'active' : '') if request.present? } #{ child.css_class.gsub(/\W/,' ') }".squeeze(' ').strip)
+      return content_tag(:li, raw(child_link), "data-id" => child.id, class: "#{ visible_child_element_count > 0 ? 'has_children' : '' } #{ (child.has_active_child?(request, subtree_menues) ? 'has_active_child' : '') if request.present? } #{ (child.is_active?(request) ? 'active' : '') if request.present? } #{ child.css_class.gsub(/\W/,' ') }".squeeze(' ').strip)
     end
 
   end
-end
+end

data/app/mailers/goldencobra/confirmation_mailer.rb

@@ -14,7 +14,8 @@ module Goldencobra
 
     def send_support_mail(link)
       @link = link
-      mail to: Goldencobra::Setting.for_key("goldencobra.live-support.email"), :subject => "Live Support Anfrage von: #{Goldencobra::Setting.for_key("goldencobra.url")}"
+      mail to: Goldencobra::Setting.for_key("goldencobra.live-support.email"),
+      subject: "Live Support Anfrage von: #{Goldencobra::Setting.for_key("goldencobra.url")}"
     end
 
   end
@@ -47,4 +48,4 @@ module Goldencobra
       false
     end
   end
-end
+end

data/app/models/ability.rb

@@ -72,4 +72,4 @@ class Ability
   def check_for_domain_restrictions(permission,domain)
     permission.domain.blank? || (domain.present? && permission.domain.present? && permission.domain == domain)
   end
-end
+end

data/app/models/active_admin/views/index_as_seo_table.rb

@@ -0,0 +1,9 @@
+module ActiveAdmin
+  module Views
+    class IndexAsSeoTable < ActiveAdmin::Views::IndexAsTable
+      def self.index_name
+        "SEO"
+      end
+    end
+  end
+end

data/app/models/active_admin/views/index_as_tree.rb

@@ -0,0 +1,118 @@
+module ActiveAdmin
+  module Views
+    class IndexAsTree < ActiveAdmin::Component
+
+      def build(page_presenter, collection)
+        @collection = collection
+        @origin_ids_to_display = @collection.map(&:id)
+        instance_exec &page_presenter.block if page_presenter.block
+
+        # Get Root Elements to display
+        @root_elements = @collection.map(&:root).uniq
+
+        # Get all Element IDs and their parent_ids (path_ids) to display
+        @items_to_display = @collection.map(&:path_ids).flatten.uniq
+
+        # Start With root elements and display all children
+        # which ar in @items_to_display
+        @root_elements.each do |item|
+          ul :class=> "item_tree" do
+            show_subtree_of_item(item)
+          end
+        end
+      end
+
+      def self.index_name
+        "Tree"
+      end
+
+      # Setter method for the configuration of the title
+      def title(method = nil, &block)
+        if block_given? || method
+          @title = block_given? ? block : method
+        end
+        @title
+      end
+
+      # Setter method for the configuration of optional value
+      def value(method = nil, &block)
+        if block_given? || method
+          @value = block_given? ? block : method
+        end
+        @value
+      end
+
+      # Setter method for the configuration of the title
+      #
+      # possible values in array: [:preview, :view, :edit, :new, :destroy]
+      def options(methods = [])
+        @options = methods
+        @options
+      end
+
+      private
+
+      def show_subtree_of_item(item)
+        li do
+          div class: "tree_item" do
+            div class: "tree_item_title" do
+              if @title.present?
+                div do
+                  render_method_on_post_or_call_proc item, @title
+                end
+              end
+              if @value.present?
+                div class: "tree_item_value" do
+                  render_method_on_post_or_call_proc item, @value
+                end
+              end
+            end
+
+            div class: "tree_item_options" do
+              if @options.include?(:preview)
+                div do
+                  link_to(t(:view), item.public_url, class: "member_link edit_link view", title: I18n.t('active_admin.articles.index.article_edit'))
+                end
+              end
+              if @options.include?(:view)
+                div do
+                  link_to(t(:view), resource_path(item), class: "member_link edit_link view", title: I18n.t('active_admin.articles.index.article_edit'))
+                end
+              end
+              if @options.include?(:edit)
+                div do
+                  link_to(t(:edit), edit_resource_path(item), class: "edit", title: I18n.t('active_admin.articles.index.article_preview'))
+                end
+              end
+              if @options.include?(:new)
+                div do
+                  link_to(t(:new_subarticle), new_resource_path(item, parent: item), class: "member_link edit_link new_subarticle", title: I18n.t('active_admin.articles.index.create_subarticle'))
+                end
+              end
+              if @options.include?(:destroy)
+                div do
+                  link_to(t(:delete), resource_path(item), method: :DELETE, "data-confirm" => t("delete_article", scope: [:goldencobra, :flash_notice]), class: "member_link delete_link delete", title: I18n.t('active_admin.articles.index.delete_article'))
+                end
+              end
+            end
+          end
+          ul do
+            item.children.each do |child|
+              next unless @items_to_display.include?(child.id)
+              show_subtree_of_item(child)
+            end
+          end
+        end
+      end
+
+      def render_method_on_post_or_call_proc(post, proc)
+        case proc
+        when String, Symbol
+          post.public_send proc
+        else
+          instance_exec post, &proc
+        end
+      end
+    end
+  end
+end

data/app/models/goldencobra/article.rb

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 # == Schema Information
 #
 # Table name: goldencobra_articles
@@ -46,102 +46,104 @@
 #  author_id                        :integer
 #
 
-
-#For article rendering to string (:render_html) needed
+# For article rendering to string (:render_html) needed
 include Goldencobra::ApplicationHelper
 require "open-uri"
 
 module Goldencobra
   class Article < ActiveRecord::Base
+    include Goldencobra::ArticleConcerns::MetaTag
 
-    extend FriendlyId
-    MetatagNames = ["Title Tag", "Meta Description", "Keywords", "OpenGraph Title", "OpenGraph Description", "OpenGraph Type", "OpenGraph URL", "OpenGraph Image"]
+    # extend FriendlyId
     LiquidParser = {}
     SortOptions = ["Created_at", "Updated_at", "Random", "Alphabetically", "GlobalSortID"]
     DynamicRedirectOptions = [[:false,"deaktiviert"],[:latest,"neuester Untereintrag"], [:oldest, "ältester Untereintrag"]]
-    DisplayIndexTypes = [["Einzelseiten", "show"],["Übersichtsseiten", "index"], ["Alle Seiten", "all"]]
+    DisplayIndexTypes = [["Einzelseiten und Übersichtsseiten", "all"], ["Einzelseiten", "show"],["Übersichtsseiten", "index"]]
+
     attr_accessor   :hint_label, :manual_article_sort, :create_redirection
     ImportDataFunctions = []
 
-    serialize :link_checker#, Hash
-
-    has_many :metatags
-    has_many :images, :through => :article_images, :class_name => Goldencobra::Upload
-    has_many :article_images
+    has_many :link_checks, class_name: Goldencobra::LinkChecker
+    has_many :images, through: :article_images, class_name: Goldencobra::Upload
+    has_many :article_images, dependent: :destroy
     has_many :article_widgets
-    has_many :widgets, :through => :article_widgets
-    has_many :vita_steps, :as => :loggable, :class_name => Goldencobra::Vita
-    has_many :comments, :class_name => Goldencobra::Comment
-    has_many :permissions, :class_name => Goldencobra::Permission, :foreign_key => "subject_id", :conditions => {:subject_class => "Goldencobra::Article"}
-    belongs_to :articletype, :class_name => Goldencobra::Articletype, :foreign_key => "article_type", :primary_key => "name"
-    belongs_to :creator, :class_name => User, :foreign_key => "creator_id"
+    has_many :widgets, through: :article_widgets
+    has_many :vita_steps, as: :loggable, class_name: Goldencobra::Vita
+    has_many :urls, class_name: Goldencobra::ArticleUrl, dependent: :destroy
+
+    has_many :permissions, -> { where subject_class: "Goldencobra::Article" }, class_name: Goldencobra::Permission, foreign_key: "subject_id"
+    belongs_to :articletype, class_name: Goldencobra::Articletype, foreign_key: "article_type", primary_key: "name"
+    belongs_to :creator, class_name: User, foreign_key: "creator_id"
 
     has_many :article_authors
-    has_many :authors, :through => :article_authors
+    has_many :authors, through: :article_authors
 
-    accepts_nested_attributes_for :metatags, :allow_destroy => true, :reject_if => proc { |attributes| attributes['value'].blank? }
-    accepts_nested_attributes_for :article_images, :allow_destroy => true
-    accepts_nested_attributes_for :images, :allow_destroy => true
-    accepts_nested_attributes_for :permissions, :allow_destroy => true
+    accepts_nested_attributes_for :article_images, allow_destroy: true
+    accepts_nested_attributes_for :images, allow_destroy: true
+    accepts_nested_attributes_for :permissions, allow_destroy: true
+    accepts_nested_attributes_for :article_widgets, allow_destroy: true
 
     acts_as_taggable_on :tags, :frontend_tags #https://github.com/mbleigh/acts-as-taggable-on
-    has_ancestry    :orphan_strategy => :restrict
-    friendly_id     :for_friendly_name, use: [:slugged] #, :history
+    has_ancestry orphan_strategy: :restrict, cache_depth: true
+
+    enum state: { void: 0, draft: 1, in_review: 2, waiting: 3, published: 4, discarded: 5 }
     web_url         :external_url_redirect
     has_paper_trail
     liquid_methods :title, :created_at, :updated_at, :subtitle, :context_info, :id, :frontend_tags
 
-    validates_presence_of :title, :article_type
-    validates_format_of :url_name, :with => /\A[\w\-]+\Z/, allow_blank: true
-    validates_presence_of :breadcrumb, :on => :create
-    validates_length_of :breadcrumb, :within => 1..70, :on => :create
+    validates_presence_of :article_type
+    validates_format_of :url_name, with: /\A[\w\-]+\Z/, allow_blank: true
+    validates_presence_of :breadcrumb, on: :create
+    validates_length_of :breadcrumb, within: 1..70, on: :create
 
     attr_protected :startpage
 
     before_update :set_redirection_step_1
+    before_create :set_title_from_breadcrumb
     after_create :set_active_since
     after_create :notification_event_create
     after_create :cleanup_redirections
+    after_create :set_index_article_id
     before_save :parse_image_gallery_tags
     before_save :set_url_name_if_blank
+    before_save :uniqify_url_name
     before_save :set_standard_application_template
-    after_save :set_default_meta_opengraph_values
+    before_save :set_descendants_status
     after_save :verify_existence_of_opengraph_image
     after_update :notification_event_update
     after_update :update_parent_article_etag
     after_save :set_url_path
     before_destroy :update_parent_article_etag
     after_update :set_redirection_step_2
-
-    scope :robots_index, where(:robots_no_index => false)
-    scope :robots_no_index, where(:robots_no_index => true)
-    #scope :active nun als Klassenmethode unten definiert
-    scope :inactive, where(:active => false)
-    scope :startpage, where(:startpage => true)
-    scope :articletype, lambda{ |name| where(:article_type => name)}
+    after_commit :update_article_urls
+
+    scope :robots_index, -> { where(robots_no_index: false) }
+    scope :robots_no_index, -> { where(robots_no_index: true) }
+    scope :active, -> { where("active = 1 AND active_since < '#{Time.now.strftime('%Y-%m-%d %H:%M:%S ')}'") }
+    scope :inactive, -> { where(active: false) }
+    scope :startpage, -> { where(startpage: true) }
+    scope :articletype, lambda{ |name| where(article_type: name)}
     scope :latest, lambda{ |counter| order("created_at DESC").limit(counter)}
-    scope :parent_ids_in_eq, lambda { |art_id| subtree_of(art_id) }
-    scope :parent_ids_in, lambda { |art_id| subtree_of(art_id) }
+
+    # Vermutlich ein Active Admin Bug:
+    # url /admin/articles?q[parent_ids_in]=1 wird mit nil an den Scope
+    # übergeben. daher hier der HotFix
+    scope :parent_ids_in_eq, -> (art_id = 1) { subtree_of(art_id) }
+    scope :parent_ids_in, -> (art_id = 1) { subtree_of(art_id) }
+
     scope :modified_since, lambda{ |date| where("updated_at > ?", Date.parse(date))}
-    scope :for_sitemap, includes(:images).where('dynamic_redirection = "false" AND ( external_url_redirect IS NULL OR external_url_redirect = "") AND active = 1 AND robots_no_index =  0')
-    scope :frontend_tag_name_contains, lambda{|tag_name| tagged_with(tag_name.split(","), :on => :frontend_tags)}
-    scope :tag_name_contains, lambda{|tag_name| tagged_with(tag_name.split(","), :on => :tags)}
-    if ActiveRecord::Base.connection.table_exists?("goldencobra_metatags")
-      scope :no_title_tag, where("goldencobra_articles.id NOT IN (?)", Goldencobra::Metatag.where(:name => "Title Tag").where("value IS NOT NULL AND value <> ''").pluck(:article_id).uniq)
-      scope :no_meta_description, where("goldencobra_articles.id NOT IN (?)", Goldencobra::Metatag.where(:name => "Meta Description").where("value IS NOT NULL AND value <> ''").pluck(:article_id).uniq)
-    end
+    scope :for_sitemap, -> { includes(:images).where('dynamic_redirection = "false" AND ( external_url_redirect IS NULL OR external_url_redirect = "") AND active = 1 AND robots_no_index =  0') }
+    scope :frontend_tag_name_contains, lambda{|tag_name| tagged_with(tag_name.split(","), on: :frontend_tags)}
+    scope :tag_name_contains, lambda{|tag_name| tagged_with(tag_name.split(","), on: :tags)}
+    scope :no_title_tag, -> { where("metatag_title_tag IS NULL OR metatag_title_tag = ''") }
+    scope :no_meta_description, -> { where("metatag_meta_description IS NULL OR metatag_meta_description = ''") }
     scope :fulltext_contains, lambda{ |name| where("content LIKE '%#{name}%' OR teaser LIKE '%#{name}%' OR url_name LIKE '%#{name}%' OR subtitle LIKE '%#{name}%' OR summary LIKE '%#{name}%' OR context_info LIKE '%#{name}%' OR breadcrumb LIKE '%#{name}%'")}
 
-    search_methods :frontend_tag_name_contains
-    search_methods :tag_name_contains
-    search_methods :parent_ids_in
-    search_methods :parent_ids_in_eq
-    search_methods :fulltext_contains
 
     if ActiveRecord::Base.connection.table_exists?("goldencobra_settings")
       if Goldencobra::Setting.for_key("goldencobra.use_solr") == "true"
         searchable do
-          text :title, :boost => 5
+          text :title, boost: 5
           text :summary
           text :content
           text :subtitle
@@ -161,44 +163,67 @@ module Goldencobra
     # **************************
     # **************************
 
+    def active?
+      self.active && self.active_since < Time.now.utc
+    end
+
+    def link_checker
+      old_result = {}
+      self.link_checks.each do |lc|
+        old_result[lc.target_link] = { "response_code"  => lc.response_code,
+                                       "response_time"  => lc.response_time,
+                                       "response_error" => lc.response_error,
+                                       "position"       => lc.position }
+      end
+      return old_result
+    end
+
+    def has_children
+      self.has_children?
+    end
+
+    def restricted
+      Goldencobra::Permission.restricted?(self)
+    end
 
     #Das ist der Titel, der verwendet wird, wenn daraus ein Menüpunkt erstellt werden soll.
-    #der menue.title hat folgende vorgaben: validates_format_of :title, :with => /^[\w\d\?\.\'\!\s&üÜöÖäÄß\-\:\,\"]+$/
+    #der menue.title hat folgende vorgaben: validates_format_of :title, with: /^[\w\d\?\.\'\!\s&üÜöÖäÄß\-\:\,\"]+$/
     def parsed_title
       self.title.to_s.gsub("/", " ")
     end
 
-
-    #@article.image_standard @article.image_logo @article.image_logo_medium
+    # @article.image_standard @article.image_logo @article.image_logo_medium
     def self.init_image_methods
       if ActiveRecord::Base.connection.table_exists?("goldencobra_settings")
         Goldencobra::Setting.for_key("goldencobra.article.image_positions").to_s.split(",").map(&:strip).each do |image_type|
           define_method "image_#{image_type.underscore}" do
-            self.image(image_type,"original")
+            image(image_type, "original")
           end
           define_method "image_alt_#{image_type.underscore}" do
-            self.article_images.where(position: image_type).first.image.alt_text || self.article_images.where(position: image_type).first.image.image_file_name
+            selected_images = article_images.where(position: image_type)
+            return "" if selected_images.none? || selected_images.first.image.blank?
+            selected_images.first.image.alt_text || selected_images.first.image.image_file_name
           end
-          Goldencobra::Upload.attachment_definitions[:image][:styles].keys.each do |style_name|
-            define_method "image_#{image_type.underscore}_#{style_name.to_s}" do
-              self.image(image_type,style_name)
+          if ActiveRecord::Base.connection.table_exists?("goldencobra_uploads") && Goldencobra::Upload.respond_to?(:attachment_definitions)
+            Goldencobra::Upload.attachment_definitions[:image][:styles].keys.each do |style_name|
+              define_method "image_#{image_type.underscore}_#{style_name}" do
+                image(image_type, style_name)
+              end
             end
           end
         end
       end
     end
-
     Goldencobra::Article.init_image_methods
-    def image(position="standard", size="original")
-      any_images = self.article_images.where(position: position)
-      if any_images.any? && any_images.first.image && any_images.first.image.image
-        return any_images.first.image.image.url(size.to_sym)
+    def image(position = "standard", size = "original")
+      selected_images = self.article_images.where(position: position)
+      if selected_images.any? && selected_images.first.image && selected_images.first.image.image
+        return selected_images.first.image.image.url(size.to_sym)
       else
         return ""
       end
     end
 
-
     def respond_to_all?(method_name)
       begin
         return eval("self.#{method_name}.present?")
@@ -207,23 +232,25 @@ module Goldencobra
       end
     end
 
-    # Gets the related object by article_type
+    # gets the related object by article_type
     def get_related_object
-      if self.article_type.present? && self.article_type_form_file.present? && self.respond_to?(self.article_type_form_file.underscore.parameterize.downcase)
+      if self.article_type.present? && self.article_type_form_file.present? &&
+          self.respond_to?(self.article_type_form_file.underscore.parameterize.downcase)
+
         return self.send(self.article_type_form_file.underscore.parameterize.downcase)
       else
         return nil
       end
     end
 
-    #dynamic methods for article.event or article.consultant .... depending on related object type
+    # dynamic method for an object to make the article respond to it like article.object
     def method_missing(meth, *args, &block)
       if meth.to_s.split(".").first == self.get_related_object.class.name.downcase
-          if meth.to_s.split(".").count == 1
-            self.get_related_object
-          else
-            self.get_related_object.send(meth.to_s.split(".").last)
-          end
+        if meth.to_s.split(".").count == 1
+          self.get_related_object
+        else
+          self.get_related_object.send(meth.to_s.split(".").last)
+        end
       else
         super
       end
@@ -281,14 +308,14 @@ module Goldencobra
     end
 
 
-    # Gibt Consultant | Subsidiary | etc. zurück je nach Seitentyp
+    # returns article type name without index/show
     def article_type_form_file
       if self.article_type.present?
         self.article_type.split(" ")[0..-2].join("")
       end
     end
 
-    # Gibt Index oder Show zurück, je nach Seitentyp
+    # returns index/show without article type name
     def kind_of_article_type
       self.article_type.present? ? self.article_type.split(" ").last : ""
     end
@@ -350,9 +377,7 @@ module Goldencobra
     end
 
     def metatag(name)
-      return "" if !MetatagNames.include?(name)
-      metatag = self.metatags.find_by_name(name)
-      metatag.value if metatag
+      warn "Deprecated method metatag(name). Will be removed in GC 2.1"
     end
 
 
@@ -371,7 +396,7 @@ module Goldencobra
     end
 
     def linked_menues
-      Goldencobra::Menue.where(:target => self.public_url)
+      Goldencobra::Menue.where(target: self.public_url)
     end
 
     def complete_json
@@ -389,14 +414,26 @@ module Goldencobra
     # **************************
 
 
-    #scope for index articles, display show articles, index articless or both articles of an current type
+    # scope for index articles, display show-articles, index-articles or both articletypes
     def self.articletype_for_index(current_article)
-      if current_article.display_index_types == "show"
-        articletype("#{current_article.article_type_form_file} Show")
-      elsif current_article.display_index_types == "index"
-        articletype("#{current_article.article_type_form_file} Index")
+      # Wenn alle Artikeltypen angezeigt werden sollen
+      if current_article.display_index_articletypes == "all"
+        if current_article.display_index_types == "show"
+          where("article_type LIKE '% Show' ")
+        elsif current_article.display_index_types == "index"
+          where("article_type LIKE '% Index' ")
+        else
+          where("article_type LIKE '% Show' OR article_type LIKE '% Index' ")
+        end
       else
-        where("article_type = '#{current_article.article_type_form_file} Show' OR article_type = '#{current_article.article_type_form_file} Index'")
+        # Wenn NUR Artikel von EINEM bestimmten Artkeltypen angezeigt werden sollen
+        if current_article.display_index_types == "show"
+          articletype("#{current_article.display_index_articletypes} Show")
+        elsif current_article.display_index_types == "index"
+          articletype("#{current_article.display_index_articletypes} Index")
+        else
+          where("article_type = '#{current_article.display_index_articletypes} Show' OR article_type = '#{current_article.display_index_articletypes} Index'")
+        end
       end
     end
 
@@ -409,8 +446,8 @@ module Goldencobra
       if localparams.present? && localparams[:params].present?
         av.params.merge!(localparams[:params])
       end
-      av.assign({:article => self})
-      html_to_render = av.render(template: "/goldencobra/articles/show.html.erb", :layout => "layouts/#{layoutfile}", :locals => localparams, :content_type => "text/html" )
+      av.assign({article: self})
+      html_to_render = av.render(template: "/goldencobra/articles/show.html.erb", layout: "layouts/#{layoutfile}", locals: localparams, content_type: "text/html" )
       return html_to_render
     end
 
@@ -428,65 +465,102 @@ module Goldencobra
 
 
     def index_articles(current_operator=nil, user_frontend_tags=nil)
+      return Goldencobra::Article.none unless display_index_articles
+
       if self.article_for_index_id.blank?
-        #Index aller Artikel anzeigen
+        # Index aller Artikel anzeigen
         @list_of_articles = Goldencobra::Article.active.articletype_for_index(self)
       else
-        #Index aller Artikel anzeigen, die Kinder sind von einem Bestimmten artikel
-        parent_article = Goldencobra::Article.find_by_id(self.article_for_index_id)
-        if parent_article
+        # Index aller Artikel anzeigen, die Kinder sind von einem Bestimmten artikel
+        parent_article = Goldencobra::Article.where(id: self.article_for_index_id).select(:id, :ancestry).first
+        if parent_article.present?
           @list_of_articles = parent_article.descendants.active.articletype_for_index(self)
+          # Wenn nicht alle Ebenen unterhalb des gewählten Baumes angezeigt werden sollen
+          unless self.index_of_articles_descendents_depth == "all"
+            current_depth = parent_article.depth
+            @list_of_articles = @list_of_articles.to_depth(current_depth + self.index_of_articles_descendents_depth.to_i)
+          end
         else
           @list_of_articles = Goldencobra::Article.active.articletype_for_index(self)
         end
       end
-      #include related models
-      @list_of_articles = @list_of_articles.includes("#{self.article_type_form_file.underscore.parameterize.downcase}") if self.respond_to?(self.article_type_form_file.underscore.parameterize.downcase)
-      #get articles with tag
+
+      # include related models
+      if self.respond_to?(self.article_type_form_file.underscore.parameterize.downcase)
+        @list_of_articles = @list_of_articles.includes("#{self.article_type_form_file.underscore.parameterize.downcase}")
+      end
+
+      # get articles with tag
       if self.index_of_articles_tagged_with.present?
-        @list_of_articles = @list_of_articles.tagged_with(self.index_of_articles_tagged_with.split(",").map{|t| t.strip}, on: :tags, any: true)
+        @list_of_articles = @list_of_articles.tagged_with(self.index_of_articles_tagged_with.split(",").map(&:strip),
+                                                          on: :tags,
+                                                          any: true)
       end
-      #get articles without tag
+
+      # get articles without tag
       if self.not_tagged_with.present?
-        @list_of_articles = @list_of_articles.tagged_with(self.not_tagged_with.split(",").map{|t| t.strip}, :exclude => true, on: :tags)
+        @list_of_articles = @list_of_articles.tagged_with(self.not_tagged_with.split(",").map(&:strip),
+                                                          exclude: true,
+                                                          on: :tags)
       end
-      #get_articles_by_frontend_tags
+
+      # get_articles_by_frontend_tags
       if user_frontend_tags.present?
         @list_of_articles = @list_of_articles.tagged_with(user_frontend_tags, on: :frontend_tags, any: true)
       end
-      #filter with permissions
-      @list_of_articles = filter_with_permissions(@list_of_articles,current_operator)
 
-      #sort list of articles
-      if self.sort_order.present?
-        if self.sort_order == "Random"
+      # filter with permissions
+      @list_of_articles = filter_with_permissions(@list_of_articles, current_operator)
+
+      # sort list of articles
+      if sort_order.present?
+        if sort_order == "Random"
           @list_of_articles = @list_of_articles.flatten.shuffle
-        elsif self.sort_order == "Alphabetically"
-          @list_of_articles = @list_of_articles.flatten.sort_by{ |article| article.title }
-        elsif self.sort_order == "GlobalSortID"
-          @list_of_articles = @list_of_articles.flatten.sort_by{ |article| article.try(:global_sorting_id) }
-        elsif self.respond_to?(self.sort_order.downcase)
-          sort_order = self.sort_order.downcase
-          @list_of_articles = @list_of_articles.flatten.sort_by{ |article| article.respond_to?(sort_order) ? article.send(sort_order) : article }
-        elsif self.sort_order.include?(".")
-          sort_order = self.sort_order.downcase.split(".")
-          @unsortable = @list_of_articles.flatten.select{|a| !a.respond_to_all?(self.sort_order) }
-          @list_of_articles = @list_of_articles.flatten.delete_if{|a| !a.respond_to_all?(self.sort_order) }
-          @list_of_articles = @list_of_articles.sort_by{|a| eval("a.#{self.sort_order}") }
+        elsif sort_order == "Alphabetically"
+          @list_of_articles = @list_of_articles.flatten.sort_by do |article|
+            [article.title.downcase, article.title]
+          end
+        elsif sort_order == "GlobalSortID"
+          @list_of_articles = @list_of_articles.flatten.sort_by do |article|
+            article.try(:global_sorting_id).to_i
+          end
+        elsif respond_to?(sort_order.downcase)
+          sorter = sort_order.downcase.to_sym
+          @list_of_articles = @list_of_articles.flatten.sort_by do |article|
+            article.respond_to?(sorter) ? article.send(sorter) : article
+          end
+        elsif sort_order.include?(".")
+          sorter = sort_order.downcase
+          @unsortable = @list_of_articles.flatten.select { |a| !a.respond_to_all?(sorter) }
+          @list_of_articles = @list_of_articles.flatten.delete_if { |a| !a.respond_to_all?(sorter) }
+          @list_of_articles = @list_of_articles.sort_by { |a| eval("a.#{sorter}") }
           if @unsortable.count > 0
             @list_of_articles = @unsortable + @list_of_articles
             @list_of_articles = @list_of_articles.flatten
           end
         end
-        if self.reverse_sort
+        if reverse_sort
           @list_of_articles = @list_of_articles.reverse
         end
       end
-      if self.sorter_limit && self.sorter_limit > 0
-        @list_of_articles = @list_of_articles[0..self.sorter_limit-1]
+      if sorter_limit && sorter_limit > 0
+        @list_of_articles = @list_of_articles[0..sorter_limit - 1]
       end
 
-      return @list_of_articles
+      @list_of_articles
+    end
+
+    def self.articles_for_index_selecetion
+      cache_key ||= [
+        "indexarticlesselect",
+        Goldencobra::Article.all.pluck(:id, :ancestry, :url_name)
+      ]
+
+      Rails.cache.fetch(cache_key) do
+        Goldencobra::Article.select([:id, :ancestry, :url_name]).map do
+          |a| [a.parent_path, a.id]
+        end.sort
+      end
     end
 
     # **************************
@@ -495,8 +569,30 @@ module Goldencobra
     # **************************
     # **************************
 
+    # creates and updates external url table
+    #
+    # only update URLs if there were any changes on the url
+    #
+    # @return [boolean] Goldencobra::AricleUrl.setup() response
+    def update_article_urls
+      if previous_changes["startpage"] || previous_changes["url_path"] ||
+         previous_changes["url_name"] || previous_changes["ancestry"] ||
+         urls.blank?
+        Goldencobra::ArticleUrl.setup(id)
+      end
+    end
+
+    def set_title_from_breadcrumb
+      if self.title.blank? && self.breadcrumb.present?
+        self.title = self.breadcrumb
+      end
+
+      true
+    end
+
+
     def cleanup_redirections
-      Goldencobra::Redirector.where(:source_url => self.absolute_public_url).destroy_all
+      Goldencobra::Redirector.where(source_url: self.absolute_public_url).destroy_all
     end
 
     #bevor ein Artikle gespeichert wird , wird ein redirector unvollständig erstellt
@@ -510,7 +606,10 @@ module Goldencobra
         else
           old_url = "#{self.absolute_base_url}#{Goldencobra::Domain.current.try(:url_prefix)}#{self.url_path}"
         end
-        r = Goldencobra::Redirector.find_or_create_by_source_url(old_url)
+        r = Goldencobra::Redirector.find_by_source_url(old_url)
+        if r.blank?
+          r = Goldencobra::Redirector.create(source_url: old_url)
+        end
         r.active = false
         r.save
         self.create_redirection = r.id
@@ -520,13 +619,13 @@ module Goldencobra
     def set_redirection_step_2
       if self.create_redirection.present? && self.create_redirection.to_i > 0
         #Suche Redirector nur mit source und vervollständige ihn
-        Goldencobra::Redirector.where(:source_url => self.absolute_public_url).destroy_all
+        Goldencobra::Redirector.where(source_url: self.absolute_public_url).destroy_all
         r = Goldencobra::Redirector.find_by_id(self.create_redirection)
         if r.present?
           r.target_url = self.absolute_public_url
           r.active = true
           r.save
-          custom_children = Goldencobra::Article.find_all_by_ancestry("#{self.ancestry}/#{self.id}")
+          custom_children = Goldencobra::Article.where(ancestry: "#{self.ancestry}/#{self.id}")
           if custom_children.any?
             if custom_children.count < 30
               # wenn es nur wenige Kinderartikel gibt, dann gleich direkt machen
@@ -552,10 +651,10 @@ module Goldencobra
       "/#{self.path.select([:ancestry, :url_name, :startpage, :id]).map{|a| a.url_name if !a.startpage}.compact.join("/")}"
     end
 
-    #Nachdem ein Artikel gelöscht oder aktualsisiert wurde soll sein Elternelement aktualisiert werden, damit ein rss feed oder ähnliches mitbekommt wenn ein kindeintrag gelöscht oder bearbeitet wurde
+    # Nachdem ein Artikel gelöscht oder aktualsisiert wurde soll sein Elternelement aktualisiert werden, damit ein rss feed oder ähnliches mitbekommt wenn ein kindeintrag gelöscht oder bearbeitet wurde
     def update_parent_article_etag
       if self.parent.present?
-        self.parent.update_attributes(:updated_at => Time.now)
+        self.parent.update_attributes(updated_at: Time.now)
       end
     end
 
@@ -569,76 +668,48 @@ module Goldencobra
       end
     end
 
-    def set_default_meta_opengraph_values
-      # Diese Zeile schein Überflüssig geworden zu sein, da nun der teaser, description oder title als defaultwerte genommen werden
-      #meta_description = Goldencobra::Setting.for_key('goldencobra.page.default_meta_description_tag')
-
-      if self.teaser.present?
-        meta_description = remove_html_tags(self.teaser.truncate(200))
-      else
-        meta_description = self.content.present? ? remove_html_tags(self.content).truncate(200) : self.title
-      end
-
-      if Goldencobra::Metatag.where(article_id: self.id, name: 'Meta Description').none?
-        Goldencobra::Metatag.create(name: 'Meta Description',
-                                    article_id: self.id,
-                                    value: meta_description)
-      end
-
-      if Goldencobra::Metatag.where(article_id: self.id, name: 'Title Tag').none?
-        Goldencobra::Metatag.create(name: 'Title Tag',
-                                    article_id: self.id,
-                                    #value: self.breadcrumb.present? ? self.breadcrumb : self.title)
-                                    value: self.title)
-      end
-
-      if Goldencobra::Metatag.where(article_id: self.id, name: 'OpenGraph Description').none?
-        Goldencobra::Metatag.create(name: 'OpenGraph Description',
-                                    article_id: self.id,
-                                    value: meta_description)
-      end
-
-      if Goldencobra::Metatag.where(article_id: self.id, name: 'OpenGraph Title').none?
-        Goldencobra::Metatag.create(name: 'OpenGraph Title',
-                                    article_id: self.id,
-                                    value: self.title)
-      end
-
-      if Goldencobra::Metatag.where(article_id: self.id, name: 'OpenGraph URL').none?
-        Goldencobra::Metatag.create(name: 'OpenGraph URL',
-                                    article_id: self.id,
-                                    value: self.absolute_public_url)
-      end
-    end
-
     # helper um links zu entfernen in text
     def remove_html_tags(text)
       text.gsub(/<[^<]+?>/, "")
     end
 
     def verify_existence_of_opengraph_image
-      if Goldencobra::Metatag.where(article_id: self.id, name: "OpenGraph Image").none?
-        if self.article_images.any? && self.article_images.first.present? && self.article_images.first.image.present? && self.article_images.first.image.image.present?
+      if self.metatag_open_graph_image.blank?
+        if self.article_images.any? && self.article_images.first.present? &&
+           self.article_images.first.image.present? &&
+           self.article_images.first.image.image.present?
           og_img_val = "#{self.absolute_base_url}#{self.article_images.first.image.image.url}"
         else
           og_img_val = Goldencobra::Setting.for_key("goldencobra.facebook.opengraph_default_image")
         end
-        Goldencobra::Metatag.create(name: "OpenGraph Image", article_id: self.id, value: og_img_val)
+        self.metatag_open_graph_image = og_img_val
       end
     end
 
     def notification_event_create
-      ActiveSupport::Notifications.instrument("goldencobra.article.created", :article_id => self.id)
+      ActiveSupport::Notifications.instrument("goldencobra.article.created", article_id: id)
     end
 
     def notification_event_update
-      ActiveSupport::Notifications.instrument("goldencobra.article.updated", :article_id => self.id)
+      ActiveSupport::Notifications.instrument("goldencobra.article.updated", article_id: id)
     end
 
     def set_url_name_if_blank
       if self.url_name.blank?
-        #self.url_name = self.breadcrumb
-        self.url_name = self.friendly_id.split("--")[0]
+        self.url_name = self.breadcrumb.urlize(downcase: true, convert_spaces: true).gsub("_", "-")
+      end
+    end
+
+    # append counter, if url_name is already used in siblings
+    #
+    # news => news--2
+    #
+    # @return [String] url_name
+    def uniqify_url_name
+      similar_names = self.siblings.pluck(:url_name).select{|c| c.split("--")[0] == self.url_name }
+      if similar_names.count > 1
+        last_used_number = similar_names.map{|v| v.split("--")[1].to_i}.compact.max
+        self.url_name = [self.url_name, last_used_number + 1].join("--")
       end
     end
 
@@ -654,8 +725,17 @@ module Goldencobra
       end
     end
 
+    def set_index_article_id
+      return unless self.kind_of_article_type == "Index"
+      return if self.article_for_index_id.present?
 
-
+      # Save without callbacks
+      if Rails::VERSION::MAJOR == 3
+        self.update_column(:article_for_index_id, self.id)
+      elsif Rails::VERSION::MAJOR > 3
+        self.update_columns(article_for_index_id: self.id)
+      end
+    end
 
     # **************************
     # **************************
@@ -663,24 +743,21 @@ module Goldencobra
     # **************************
     # **************************
 
-
     def self.search_by_url(url)
       article = nil
-      articles = Goldencobra::Article.where(:url_name => url.split("/").last.to_s.split(".").first)
+      articles = Goldencobra::Article.where(url_name: url.split("/").last.to_s.split(".").first)
       article_path = "/#{url.split('.').first}"
       if articles.count > 0
-        article = articles.select{|a| a.public_url(false) == article_path}.first
+        article = articles.select { |a| a.public_url(false) == article_path }.first
       end
       return article
     end
 
-
     def parent_path
-      self.path.map(&:title).join(" / ")
+      self.path.map(&:url_name).join("/")
     end
 
-
-    def public_url(with_prefix=true)
+    def public_url(with_prefix = true)
       if self.startpage
         if with_prefix
           return "#{Goldencobra::Domain.current.try(:url_prefix)}/"
@@ -689,83 +766,55 @@ module Goldencobra
         end
       else
 
-        #url_path in der Datenbank als string speichern und beim update von ancestry neu berechnen... ansosnten den urlpafh aus dem string holen statt jedesmal über alle eltern iterierne
-        if self.url_path.blank? || self.url_path_changed? || self.url_name_changed? || self.ancestry_changed?
+        #url_path in der Datenbank als string speichern und beim update von ancestry neu berechnen... ansonsten den urlpath aus dem string holen statt jedesmal über alle eltern zu iterieren
+        if self.url_path.blank? || self.url_path_changed? || self.url_name_changed? || self.ancestry_changed? || self.ancestors.map{ |a| a.url_path_changed? }
           a_url = self.get_url_from_path
         else
           a_url = self.url_path
         end
 
-        if with_prefix
-          return "#{Goldencobra::Domain.current.try(:url_prefix)}#{a_url}"
-        else
-          return a_url
-        end
+        return "#{Goldencobra::Domain.current.try(:url_prefix)}#{a_url}" if with_prefix
+
+        a_url
       end
     end
 
-
     def absolute_base_url
-      if Goldencobra::Setting.for_key("goldencobra.use_ssl") == "true"
-        "https://#{Goldencobra::Setting.for_key('goldencobra.url')}"
-      else
-        "http://#{Goldencobra::Setting.for_key('goldencobra.url')}"
-      end
+      Goldencobra::Url.to_s
     end
 
 
     def absolute_public_url
-      if Goldencobra::Setting.for_key("goldencobra.use_ssl") == "true"
-        "https://#{Goldencobra::Setting.for_key('goldencobra.url')}#{self.public_url}"
-      else
-        "http://#{Goldencobra::Setting.for_key('goldencobra.url')}#{self.public_url}"
-      end
-    end
-
-
-    def for_friendly_name
-      if self.url_name.present?
-        self.url_name
-      elsif self.breadcrumb.present?
-        self.breadcrumb
-      else
-        self.title
-      end
+      "#{absolute_base_url}#{public_url}"
     end
 
-
     # **************************
     # **************************
     # Class Methods
     # **************************
     # **************************
 
-    def self.active
-      Goldencobra::Article.where("active = 1 AND active_since < '#{Time.now.strftime('%Y-%m-%d %H:%M:%S ')}'")
-    end
-
-    def active?
-      self.active && self.active_since < Time.now.utc
+    def self.state_attributes_for_select
+      states.map do |s, _|
+        [I18n.t("activerecord.attributes.#{model_name.i18n_key}.states.#{s}"), s]
+      end
     end
 
-
-
-    def self.load_liquid_methods(options={})
-
+    def self.load_liquid_methods(options = {})
+      Goldencobra::Article::LiquidParser["location"] = options.fetch(:location, nil)
+      Goldencobra::Article::LiquidParser["current_article"] = options.fetch(:article, nil)
+      Goldencobra::Article::LiquidParser["url_params"] = options.fetch(:params, nil)
     end
 
     def self.recent(count)
-      Goldencobra::Article.where('title IS NOT NULL').order('created_at DESC').limit(count)
+      Goldencobra::Article.where("title IS NOT NULL").order("created_at DESC").limit(count)
     end
 
     def self.recreate_cache
-      if RUBY_VERSION.include?("1.9.")
-        ArticlesCacheWorker.perform_async()
+      if RUBY_VERSION.to_f >= 1.9
+        ArticlesCacheWorker.perform_async
       else
-        Goldencobra::Article.active.each do |article|
-          article.updated_at = Time.now
-          article.without_versioning :save
-        end
+        Goldencobra::Article.active.each(&:touch)
       end
     end
 
@@ -773,12 +822,12 @@ module Goldencobra
       results = []
       path_to_articletypes = File.join(::Rails.root, "app", "views", "articletypes")
       if Dir.exist?(path_to_articletypes)
-        Dir.foreach(path_to_articletypes) do |name| #.map{|a| File.basename(a, ".html.erb")}.delete_if{|a| a =~ /^_edit/ }.delete_if{|a| a[0] == "_"}
+        Dir.foreach(path_to_articletypes) do |name|
           file_name_path = File.join(path_to_articletypes,name)
           if File.directory?(file_name_path)
             Dir.foreach(file_name_path) do |sub_name|
-                file_name = "#{name.titleize.gsub(' ','')}#{sub_name.titleize}" if File.exist?(File.join(file_name_path,sub_name)) && (sub_name =~ /^_(?!edit).*/) == 0
-                results << file_name.split(".").first if file_name.present?
+              file_name = [name.titleize.gsub(' ',''), sub_name.gsub('_','').titleize].join(" ") if File.exist?(File.join(file_name_path,sub_name)) && (sub_name =~ /^_(?!edit).*/) == 0
+              results << file_name.split(".").first if file_name.present?
             end
           end
         end
@@ -790,7 +839,7 @@ module Goldencobra
       results = []
       path_to_articletypes = File.join(::Rails.root, "app", "views", "articletypes")
       if Dir.exist?(path_to_articletypes)
-        Dir.foreach(path_to_articletypes) do |name| #.map{|a| File.basename(a, ".html.erb")}.delete_if{|a| a =~ /^_edit/ }
+        Dir.foreach(path_to_articletypes) do |name|
           results << name.capitalize unless name.include?(".")
         end
       end
@@ -798,25 +847,58 @@ module Goldencobra
     end
 
     def self.templates_for_select
-      Dir.glob(File.join(::Rails.root, "app", "views", "layouts", "*.html.erb")).map{|a| File.basename(a, ".html.erb")}.delete_if{|a| a =~ /^_/ }
+      Dir.glob(File.join(::Rails.root, "app", "views", "layouts", "*.html.erb"))
+         .map { |a| File.basename(a, ".html.erb") }
+         .delete_if { |a| a =~ /^_/ }
     end
 
     def self.simple_search(q)
-      self.active.search(:title_or_subtitle_or_url_name_or_content_or_summary_or_teaser_contains => q).relation.map {
-          |article|
+      active.search(title_or_subtitle_or_url_name_or_content_or_summary_or_teaser_contains: q).relation.map do |article|
         {
-            :id => article.id,
-            :absolute_public_url => article.absolute_public_url,
-            :title => article ? article.title : '',
-            :teaser => article ? article.teaser : '',
-            :article_type => article.article_type,
-            :updated_at => article.updated_at,
-            :parent_title => article.parent ? article.parent.title ? article.parent.title : '' : '',
-            :ancestry => article.ancestry ? article.ancestry : ''
+          id: article.id,
+          absolute_public_url: article.absolute_public_url,
+          title: article ? article.title : '',
+          teaser: article ? article.teaser : '',
+          article_type: article.article_type,
+          updated_at: article.updated_at,
+          parent_title: article.parent ? article.parent.title ? article.parent.title : '' : '',
+          ancestry: article.ancestry ? article.ancestry : ''
         }
-      }
+      end
     end
 
+    # **************************
+    # **************************
+    # Private Methods
+    # **************************
+    # **************************
+
+    private
+
+    # Allow Scopes and Methods to search for in ransack (n.a. metasearch)
+    # @param auth_object = nil [self] "if auth_object.try(:admin?)"
+    #
+    # @return [Array] Array of Symbols representing scopes and class methods
+    def self.ransackable_scopes(auth_object = nil)
+      [
+        :parent_ids_in,
+        :frontend_tag_name_contains, :frontend_tag_name_equals, :frontend_tag_name_starts_with, :frontend_tag_name_ends_with,
+        :tag_name_contains, :tag_name_equals, :tag_name_starts_with, :tag_name_ends_with,
+        :fulltext_contains, :fulltext_equals, :fulltext_starts_with, :fulltext_ends_with,
+        :state_eq
+      ]
+    end
+
+    def set_descendants_status
+      if !self.new_record? && self.active_changed? && self.descendants.any?
+        # Save without callbacks
+        if Rails::VERSION::MAJOR == 3
+          self.descendants.map{ |d| d.update_column(:active, self.active) }
+        elsif Rails::VERSION::MAJOR > 3
+          self.descendants.map{ |d| d.update_columns(active: self.active) }
+        end
+      end
+    end
   end
 end
 
@@ -842,4 +924,3 @@ end
 #subtree          Scopes the model on descendants and itself
 #subtree_ids      Returns a list of all ids in the record's subtree
 #depth            Return the depth of the node, root nodes are at depth 0
-