goldencobra 1.4.0 → 1.4.27

data/app/models/goldencobra/article_author.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+
+# == Schema Information
+#
+# Table name: goldencobra_article_authors
+#
+#  id         :integer          not null, primary key
+#  article_id :integer
+#  author_id  :integer
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
+
+module Goldencobra
+  class ArticleAuthor < ActiveRecord::Base
+    belongs_to :article
+    belongs_to :author
+  end
+end

data/app/models/goldencobra/article_image.rb

@@ -17,5 +17,7 @@ module Goldencobra
     belongs_to :article
     belongs_to :image, :class_name => Goldencobra::Upload, :foreign_key => "image_id"
 
+    accepts_nested_attributes_for :image, :allow_destroy => true
+
   end
 end

data/app/models/goldencobra/articletype.rb

@@ -6,46 +6,48 @@ module Goldencobra
     has_many :articles, :class_name => Goldencobra::Article, :foreign_key => :article_type, :primary_key => :name
     validates_uniqueness_of :name
 
-    has_many :fieldgroups, :class_name => Goldencobra::ArticletypeGroup
+    has_many :fieldgroups, :class_name => Goldencobra::ArticletypeGroup, :dependent => :destroy
     accepts_nested_attributes_for :fieldgroups, :allow_destroy => true
 
     ArticleFieldOptions = {
-    	:title => %{<% f.input :title, :label => "Titel", :hint => "Der Titel/die Überschrift des Artikels/der Seite, hier können Leerzeichen und Sonderzeichen verwendet werden" %>},
-        :subtitle => %{<% f.input :subtitle, :label => "Untertitel" %>},
-        :content => %{<% f.input :content, :label => "Haupt-Textfeld", :input_html => { :class => "tinymce" } %>},
-        :teaser => %{<% f.input :teaser, :hint => "Dieser Text beschreibt den Artikel auf Übersichtsseiten kurz, außerdem wird er für die Beschreibung bei Google & Facebook genutzt", :input_html => { :rows => 5 } %>},
-        :summary => %{<% f.input :summary, :label => "Zusammenfassung", hint: "Dient einer zusammenfassenden Einleitung in den Haupttext und wird hervorgehoben dargestellt", :input_html => { :rows => 5 } %>},
-        :tag_list => %{<% f.input :tag_list, :label => "Liste von internen Tags", :hint => "Tags sind komma-getrennte Werte, mit denen sich ein Artikel intern gruppiern l&auml;sst", :wrapper_html => { class: 'expert' } %>},
-        :frontend_tag_list => %{<% f.input :frontend_tag_list, label: "Filterkriterium", hint: "Hier eingetragene Begriffe werden auf &Uuml;bersichtsseiten als Filteroptionen angeboten.", :wrapper_html => { class: 'expert' } %>},
-        :active => %{<% f.input :active, :label => "Aktiv?", :hint => "Soll dieser Artikel im System aktiv und online sichtbar sein?", :wrapper_html => { class: 'expert' } %>},
-        :active_since => %{<% f.input :active_since, :label => "Online seit", :hint => "Wenn der Artikel online ist, seit wann ist er online? Bsp: 02.10.2011 15:35", as: :string, :input_html => { class: "", :size => "20" }, :wrapper_html => { class: 'expert' } %>},
-        :context_info => %{<% f.input :context_info, :label => "Weiterer Inhalt", :input_html => { :class => "tinymce" }, :hint => "Dieser Text ist f&uuml;r eine Sidebar gedacht" %>},
+        :global_sorting_id => %{<% f.input :global_sorting_id, :hint => I18n.t("goldencobra.article_field_hints.global_sorting_id") %>},
+        :title => %{<% f.input :title, :hint => I18n.t("goldencobra.article_field_hints.title") %>},
+        :subtitle => %{<% f.input :subtitle %>},
+        :content => %{<% f.input :content, :input_html => { :class => "tinymce" } %>},
+        :teaser => %{<% f.input :teaser, :hint => I18n.t("goldencobra.article_field_hints.teaser"), :input_html => { :rows => 5 } %>},
+        :summary => %{<% f.input :summary, :hint => I18n.t("goldencobra.article_field_hints.summary"), :input_html => { :rows => 5 } %>},
+        :tag_list => %{<% f.input :tag_list, :hint => I18n.t("goldencobra.article_field_hints.tag_list"), :wrapper_html => { class: '' } %>},
+        :frontend_tag_list => %{<% f.input :frontend_tag_list, hint: I18n.t("goldencobra.article_field_hints.frontend_tag_list"), :wrapper_html => { class: '' } %>},
+        :active => %{<% f.input :active, :hint => I18n.t("goldencobra.article_field_hints.active"), :wrapper_html => { class: '' } %>},
+        :active_since => %{<% f.input :active_since, :hint => I18n.t("goldencobra.article_field_hints.active_since"), as: :string, :input_html => { class: "", :size => "20" }, :wrapper_html => { class: 'expert' } %>},
+        :context_info => %{<% f.input :context_info, :input_html => { :class => "tinymce" }, :hint => I18n.t("goldencobra.article_field_hints.context_info") %>},
         :metatags => %{<% f.has_many :metatags do |m|
-          m.input :name, :label => "Art", :as => :select, :collection => Goldencobra::Article::MetatagNames, :input_html => { :class => 'metatag_names'}, :hint => "Hier k&ouml;nnen Sie die verschiedenen Metatags definieren, sowie alle Einstellungen f&uuml;r den OpenGraph vonehmen"
-          m.input :value, :label => "Wert", :input_html => { :class => 'metatag_values'}
-          m.input :_destroy, :label => "entfernen/zurücksetzen", :hint => "hiermit werden die Werte entfernt bzw. auf ihren Ursprung zurückgesetzt", :as => :boolean
+          m.input :name, :as => :select, :collection => Goldencobra::Article::MetatagNames, :input_html => { :class => 'metatag_names'}, :hint => I18n.t("goldencobra.article_field_hints.metatags_name")
+          m.input :value, :input_html => { :class => 'metatag_values'}
+          m.input :_destroy, :label => "entfernen/zurücksetzen", :hint => I18n.t("goldencobra.article_field_hints.metatags_destroy"), :as => :boolean
         end %>},
-        :breadcrumb => %{<% f.input :breadcrumb, :label => "Breadcrumb-Titel", :hint => "Kurzer Titel f&uuml;r die Breadcrumb-Navigation" %>},
-        :url_name => %{<% f.input :url_name, :label => "Website-Adresse des Artikels", :hint => "Nicht mehr als 64 Zeichen, sollte keine Umlaute, Sonderzeichen oder Leerzeichen enthalten. Wenn die Seite unter 'http://meine-seite.de/mein-artikel' erreichbar sein soll, tragen Sie hier 'mein-artikel' ein.", required: false %>},
-        :parent_id => %{<% f.input :parent_id, :label => "Übergeordneter Artikel", :hint => "Auswahl des Artikels, der in der Seitenstruktur _oberhalb_ liegen soll. Beispiel: http://www.meine-seite.de/der-oberartikel/mein-artikel", :as => :select, :collection => Goldencobra::Article.all.map{|c| [c.parent_path, c.id]}.sort{|a,b| a[0] <=> b[0]}, :include_blank => true, :input_html => { :class => 'chzn-select-deselect', :style => 'width: 70%;', 'data-placeholder' => 'Elternelement auswählen' } %>},
-        :canonical_url => %{<% f.input :canonical_url, :label => "Canonical URL", :hint => "Falls auf dieser Seite Inhalte erscheinen, die vorher schon auf einer anderen Seite erschienen sind, sollte hier die URL der Quellseite eingetragen werden, um von Google nicht f&uuml;r doppelten Inhalt abgestraft zu werden" %>},
-        :enable_social_sharing => %{<% f.input :enable_social_sharing, :label => "'Social Sharing'-Aktionen anzeigen", :hint => "Sollen Besucher Aktionen angezeigt bekommen, um diesen Artikel in den sozialen Netzwerken zu verbreiten?" %>},
-        :robots_no_index => %{<% f.input :robots_no_index, :label => "Artikel nicht durch Suchmaschinen finden lassen", :hint => "Um bei Google nicht in Konkurrenz zu anderen wichtigen Einzelseiten der eigenen Webseite zu treten, kann hier Google mitgeteilt werden, diese Seite nicht zu indizieren" %>},
-        :cacheable => %{<% f.input :cacheable, :label => "Artikel cachebar", :as => :boolean, :hint => "Dieser Artikel darf im Cache liegen" %>},
-        :commentable => %{<% f.input :commentable, :label => "Artikel kommentierbar", :as => :boolean, :hint => "Kommentarfunktion für diesen Artikel aktivieren?" %>},
-        :dynamic_redirection => %{<% f.input :dynamic_redirection, :label => "Automatische Weiterleitung", :as => :select, :collection => Goldencobra::Article::DynamicRedirectOptions.map{|a| [a[1], a[0]]}, :include_blank => false %>},
-        :external_url_redirect => %{<% f.input :external_url_redirect, :label => "Weiterleitung zu externer URL" %>},
-        :redirect_link_title => %{<% f.input :redirect_link_title, :label => "Name des externen Links" %>},
-        :redirection_target_in_new_window => %{<% f.input :redirection_target_in_new_window, :label => "Weiterleitung in neuem Fenster öffnen?" %>},
-        :author => %{<% f.input :author, :label => "Autor", :hint => "Wer ist der Verfasser dieses Artikels?" %>},
+        :breadcrumb => %{<% f.input :breadcrumb, :hint => I18n.t("goldencobra.article_field_hints.breadcrumb") %>},
+        :url_name => %{<% f.input :url_name, :hint => I18n.t("goldencobra.article_field_hints.url_name"), required: false %>},
+        :parent_id => %{<% f.input :parent_id, :hint => I18n.t("goldencobra.article_field_hints.parent_id"), :as => :select, :collection => Goldencobra::Article.where("id = ?", f.object.parent_id).select([:id,:title, :ancestry]).map{|c| [c.parent_path, c.id]}.sort{|a,b| a[0] <=> b[0]}, :include_blank => true, :input_html => { :class => 'chzn-select-deselect get_goldencobra_articles_per_remote', :style => 'width: 70%;', 'data-placeholder' => 'Elternelement auswählen' } %>},
+        :canonical_url => %{<% f.input :canonical_url, :hint => I18n.t("goldencobra.article_field_hints.canonical_url") %>},
+        :enable_social_sharing => %{<% f.input :enable_social_sharing, :hint => I18n.t("goldencobra.article_field_hints.enable_social_sharing") %>},
+        :robots_no_index => %{<% f.input :robots_no_index, :hint => I18n.t("goldencobra.article_field_hints.robots_no_index") %>},
+        :cacheable => %{<% f.input :cacheable, :as => :boolean, :hint => I18n.t("goldencobra.article_field_hints.cacheable") %>},
+        :commentable => %{<% f.input :commentable, :as => :boolean, :hint => I18n.t("goldencobra.article_field_hints.commentable") %>},
+        :dynamic_redirection => %{<% f.input :dynamic_redirection, :as => :select, :collection => Goldencobra::Article::DynamicRedirectOptions.map{|a| [a[1], a[0]]}, :include_blank => false %>},
+        :external_url_redirect => %{<% f.input :external_url_redirect %>},
+        :redirect_link_title => %{<% f.input :redirect_link_title %>},
+        :redirection_target_in_new_window => %{<% f.input :redirection_target_in_new_window %>},
+        :author => %{<% f.input :authors, :as => :select, :collection => Goldencobra::Author.order("lastname ASC").map{ |a| [a.lastname.to_s + ", " + a.firstname.to_s, a.id] }, :input_html => { :class => "chzn-select", :style => "width: 70%;", "data-placeholder" => I18n.t("goldencobra.article_field_placeholder.author") }, :hint => I18n.t("goldencobra.article_field_hints.author") %>},
         :permissions => %{<% f.has_many :permissions do |p|
+          p.input :domain, :include_blank => "Alle"
           p.input :role, :include_blank => "Alle"
           p.input :action, :as => :select, :collection => Goldencobra::Permission::PossibleActions, :include_blank => false
           p.input :_destroy, :as => :boolean
         end %>},
         :article_images => %{<% f.has_many :article_images do |ai|
           ai.input :image, :as => :select, :collection => Goldencobra::Upload.order("updated_at DESC").map{|c| [c.complete_list_name, c.id]}, :input_html => { :class => 'article_image_file chzn-select', :style => 'width: 70%;', 'data-placeholder' => 'Medium auswählen' }, :label => "Medium wählen"
-          ai.input :position, :as => :select, :collection => Goldencobra::Setting.for_key("goldencobra.article.image_positions").split(",").map(&:strip), :include_blank => false
+          ai.input :position, :as => :select, :collection => Goldencobra::Setting.for_key("goldencobra.article.image_positions").to_s.split(",").map(&:strip), :include_blank => false
           ai.input :_destroy, :as => :boolean
         end %>}
     }

data/app/models/goldencobra/author.rb

@@ -2,11 +2,13 @@
 
 module Goldencobra
 	class Author < ActiveRecord::Base
-		has_many :article
-		web_url :goolgeplus
+		has_many  :article_authors
+    has_many  :articles, :through => :article_authors
+    
+		web_url :googleplus
 
 		def title
-			[self.try(:firstname),self.try(:lastname)].join(" ")
+			[self.try(:firstname), self.try(:lastname)].join(" ")
 		end
 	end
 end

data/app/models/goldencobra/domain.rb

@@ -3,6 +3,8 @@
 module Goldencobra
   class Domain < ActiveRecord::Base
 
+    has_many :permissions, :class_name => Goldencobra::Permission
+
     validates_presence_of :client
     validates_format_of :client, :with => /^[\w]+$/
     validates_presence_of :title

data/app/models/goldencobra/import.rb

@@ -82,7 +82,7 @@ module Goldencobra
     def run!
       self.result = []
       count = 0
-      all_data_attribute_assignments = remove_emty_assignments
+      all_data_attribute_assignments = remove_empty_assignments
       master_data_attribute_assignments = all_data_attribute_assignments[self.target_model]
       import_data_attribute_assignments = all_data_attribute_assignments["Goldencobra::ImportMetadata"]
       #all_data_attribute_assignments.delete("Goldencobra::ImportMetadata")
@@ -247,7 +247,7 @@ module Goldencobra
       end
     end
 
-    def remove_emty_assignments
+    def remove_empty_assignments
       self.assignment.each do |key, values|
         self.assignment[key].delete_if{|k,v| v['data_function'] == "Default" && v['csv'].blank?} if self.assignment[key].present? && self.assignment[key].class == Array
         if self.assignment[key].blank?

data/app/models/goldencobra/link_checker.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module Goldencobra
+  class LinkChecker
+    def initialize(article)
+      @article = article
+    end
+
+    #get all links of a page and make a check for response status and time
+    def set_link_checker
+      links_to_check = []
+      status_for_links = {}
+      doc = Nokogiri::HTML(open(@article.absolute_public_url))
+      #find all links and stylesheets
+      doc.css('a,link').each do |link|
+        if add_link_to_checklist(link, "href").present?
+          links_to_check << {"link" => add_link_to_checklist(link, "href"), "pos" => link.path}
+        end
+      end
+      #find all images and javascripts
+      doc.css('img,script').each do |link|
+        if add_link_to_checklist(link,"src").present?
+          links_to_check << {"link" => add_link_to_checklist(link,"src"), "pos" => link.path}
+        end
+      end
+      links_to_check = links_to_check.compact.delete_if{|a| a.blank?}
+      links_to_check.each_with_index do |linkpos|
+        status_for_links[linkpos["link"]] = {"position" => linkpos["pos"]}
+        begin
+          start = Time.now
+          response = open(linkpos["link"])
+          status_for_links[linkpos["link"]]["response_code"] = response.status[0]
+          status_for_links[linkpos["link"]]["response_time"] = Time.now - start
+        rescue Exception  => e
+          status_for_links[linkpos["link"]]["response_code"] = "404"
+          status_for_links[linkpos["link"]]["response_error"] = e.to_s
+        end
+      end
+      @article.link_checker = status_for_links
+    end
+
+
+    private
+    #helper method for finding links in html document
+    def add_link_to_checklist(link, src_type)
+      begin
+        if link.blank? || link[src_type].blank?
+          return nil
+        elsif link[src_type][0 .. 6] == "http://" || link[src_type][0 .. 6] == "https:/"
+          return "#{link[src_type]}"
+        elsif link[src_type] && link[src_type][0 .. 1] == "//"
+          return "http:/#{link[src_type][/.(.*)/m,1]}"
+        elsif link[src_type] && link[src_type][0] == "/"
+          return "#{Goldencobra::Setting.absolute_base_url}/#{link[src_type][/.(.*)/m,1]}"
+        elsif link[src_type] && !link[src_type].include?("mailto:")
+          return "#{@article.absolute_public_url}/#{link[src_type]}"
+        end
+      rescue
+        return nil
+      end
+    end
+
+  end
+end

data/app/models/goldencobra/menue.rb

@@ -61,7 +61,7 @@ module Goldencobra
 
     def is_active?(request)
       @is_active_result ||= {}
-      @is_active_result[request.path.squeeze("/").split("?")[0]] ||= request.path.squeeze("/").split("?")[0] == self.target.gsub("\"",'')
+      @is_active_result[request.path.squeeze("/").chomp("/").split("?")[0]] ||= request.path.squeeze("/").chomp("/").split("?")[0] == self.target.gsub("\"",'')
     end
 
     def has_active_child?(request, subtree_menues)
@@ -74,7 +74,9 @@ module Goldencobra
     end
 
     def mapped_to_article?
-      @mapped_to_article_result ||= Goldencobra::Article.select([:url_name, :startpage, :ancestry, :id]).map{|a| a.public_url}.uniq.include?(self.target)
+      #TODO Anfrage dauert zu lange bei 2000 Artikeln
+      #@mapped_to_article_result ||= Goldencobra::Article.select([:url_name, :startpage, :ancestry, :id]).map{|a| a.public_url}.uniq.include?(self.target)
+      false
     end
 
   end

data/app/models/goldencobra/permission.rb

@@ -9,6 +9,7 @@
 #  subject_class :string(255)
 #  subject_id    :string(255)
 #  role_id       :integer
+#  domain_id     :integer
 #  created_at    :datetime         not null
 #  updated_at    :datetime         not null
 #  sorter_id     :integer          default(0)
@@ -16,8 +17,9 @@
 
 module Goldencobra
   class Permission < ActiveRecord::Base
-    attr_accessible :role_id, :action, :subject_class, :subject_id, :sorter_id
+    attr_accessible :role_id, :action, :subject_class, :subject_id, :sorter_id, :operator_id, :domain_id
     belongs_to :role
+    belongs_to :domain
     PossibleSubjectClasses = [":all"] + ActiveRecord::Base.descendants.map(&:name)
     PossibleActions = ["read", "not_read", "manage", "not_manage", "update", "not_update", "destroy", "not_destroy"]
 

data/app/models/goldencobra/redirector.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+
+module Goldencobra
+  class Redirector < ActiveRecord::Base
+    attr_accessible :active, :redirection_code, :source_url, :target_url, :ignore_url_params, :include_subdirs, :import_csv_data
+
+    attr_accessor :import_csv_data
+
+    validates_presence_of :source_url, :if => proc { |obj| obj.import_csv_data.blank? }
+    validates_presence_of :target_url, :if => proc { |obj| obj.active == true && obj.import_csv_data.blank? }
+
+    validates_uniqueness_of :source_url
+
+    web_url :source_url, :target_url
+
+    scope :active, where(:active => true)
+
+    validate :check_csv_data
+    after_create :create_multiples_from_csv_data
+
+    # Creates multiple new Redirections based on 'import_csv_data'
+    # and deletes this single, new, invalid record afterwards  
+    # 
+    # @return [Goldencobra::Redirector] 
+    def create_multiples_from_csv_data
+      if import_csv_data.present?
+          data = CSV.parse(import_csv_data, { :col_sep => "," })
+          Goldencobra::Redirector.transaction do
+            data.each do |row|
+              Goldencobra::Redirector.create(source_url: row[0].strip, target_url: row[1].strip, redirection_code: redirection_code, active: active, ignore_url_params: ignore_url_params )
+            end
+          end
+          self.destroy
+      end
+    end
+
+    # Validator wenn es csv Daten zum importierne gibt
+    # 
+    # @return [Boolean]
+    def check_csv_data
+      if import_csv_data.present?
+        begin
+          all_source_urls = Goldencobra::Redirector.where(:active => true).pluck(:source_url)
+          data = CSV.parse(import_csv_data, { :col_sep => "," })
+          source_urls_from_data = data.map{|a| a[0].strip}
+          if source_urls_from_data.length != source_urls_from_data.uniq.length
+            errors.add(:import_csv_data, "Die CSV Daten enthalten mehrere Zeilen mit gleichen Source URLs<br>" )
+          end
+          data.each_with_index do |row, index|
+            if row.length != 2
+              errors.add(:import_csv_data, "Format der CSV Datei hat nicht 2 Spalten in Zeile #{index + 1}<br>" )
+            end
+            if all_source_urls.include?(row[0].strip)
+              errors.add(:import_csv_data, "Source URL in Zeile #{index + 1} existiert bereits<br>" )
+            end
+          end
+        rescue 
+          errors.add(:import_csv_data, "Die CSV Daten sind leider ungültig")
+        end
+      end
+    end
+    
+    # 
+    # Returns a target url where to redirect of a given url
+    # @param request_original_url [String] SourceURl of Request
+    # 
+    # @return [Array] target url to rewrite to | status code for redirection
+    def self.get_by_request(request_original_url)
+      begin
+        uri = URI.parse(request_original_url)
+      rescue
+        uri = nil
+      end
+      if uri.present?
+        uri_params = Rack::Utils.parse_nested_query(uri.query.to_s)
+        request_path = "#{uri.scheme}://#{uri.host}#{uri.path}%"
+        redirects = Goldencobra::Redirector.active.where("source_url LIKE ?", request_path)
+        if redirects.any?
+          #if multiple redirectors found, select the first
+          redirect = redirects.first
+          redirecter_source_uri = URI.parse(redirect.source_url)
+          if redirecter_source_uri.path == uri.path
+            #Wenn die url parameter egal sind
+            if redirect.ignore_url_params
+              return [redirect.rewrite_target_url(uri.query), redirect.redirection_code]
+            else
+              #wenn die urlparameter nicht egal sind und identisch sind
+              source_params = Rack::Utils.parse_nested_query(redirecter_source_uri.query.to_s)
+              if !source_params.map{|k,v| uri_params[k] == v}.include?(false)
+                return [redirect.rewrite_target_url(uri.query), redirect.redirection_code]
+              else
+                return nil
+              end
+            end
+          end
+        else
+          return nil
+        end
+      else
+        return nil
+      end
+    end
+
+
+    # Helper Method for rewriting urls
+    # @param uri_params [String] foo=bar&test=12
+    # 
+    # @return [String] TargetURl of given Redirector merged with source params
+    def rewrite_target_url(uri_params)
+      Goldencobra::Redirector.add_param_to_url(self.target_url, uri_params)
+    end
+
+    # Add a url-params tu an url
+    # @param url [string] "http://www.test.de" || "http://www.test.de?test=a"
+    # @param uri_params [string] "foo=bar"
+    # 
+    # @return [string] "http://www.test.de?test=a&foo=bar"
+    def self.add_param_to_url(url, uri_params)
+      target_uri = URI.parse(url)
+      target_params = Rack::Utils.parse_nested_query(target_uri.query.to_s)
+      request_params = Rack::Utils.parse_nested_query(uri_params)
+      merged_params = target_params.merge(request_params)
+      if merged_params.present?
+        return "#{target_uri.scheme}://#{target_uri.host}#{target_uri.path}?#{merged_params.to_param}"
+      else
+        return "#{target_uri.scheme}://#{target_uri.host}#{target_uri.path}"
+      end
+    end
+
+  end
+end

data/app/models/goldencobra/setting.rb

@@ -15,6 +15,10 @@
 
 module Goldencobra
   class Setting < ActiveRecord::Base
+
+    # TODO cache invalidate über touch /temp/settings_updated.txt
+
+
     @@key_value = {}
     attr_accessible :title, :value, :ancestry, :parent_id, :data_type
     SettingsDataTypes = ["string","date","datetime","boolean","array"]
@@ -50,14 +54,19 @@ module Goldencobra
       end
     end
 
-
+    # Goldencobra::Setting.for_key("test.foo.bar")
     def self.for_key(name, cacheable=true)
-      if cacheable
+      @@mtime_setting ||= {}
+      mtime = get_cache_modification_time(name)
+
+      if cacheable && @@mtime_setting[name].present? && @@mtime_setting[name] >= mtime
         @@key_value ||= {}
         @@key_value[name] ||= for_key_helper(name)
       else
+        @@mtime_setting[name] = mtime
         for_key_helper(name)
       end
+
     end
 
     def self.for_key_helper(name)
@@ -114,6 +123,10 @@ module Goldencobra
       self.ancestors.map(&:title).join(".")
     end
 
+    def path_name
+      self.path.map(&:title).join(".")
+    end
+
 
     private
     def self.generate_default_setting(key, yml_data, parent_id=nil)
@@ -162,7 +175,20 @@ module Goldencobra
     end
 
     def update_cache
-      @@key_value = nil
+      @@key_value ||= {}
+      @@key_value[self.path_name] = nil
+      FileUtils.mkdir_p("tmp/settings")
+      FileUtils.touch("tmp/settings/updated_#{self.path_name}.txt")
+    end
+
+    def self.get_cache_modification_time(name)
+      if File.exists?("tmp/settings/updated_#{name}.txt")
+        File.mtime("tmp/settings/updated_#{name}.txt")
+      else
+        FileUtils.mkdir_p("tmp/settings")
+        FileUtils.touch("tmp/settings/updated_#{name}.txt")
+        return Time.now
+      end
     end
 
   end