gluttonberg-core 2.6.4 → 3.0.0

data/app/models/gluttonberg/setting.rb

@@ -1,18 +1,39 @@
 module Gluttonberg
  class Setting  < ActiveRecord::Base
-   self.table_name = "gb_settings"
-   after_save  :update_settings_in_config
+    self.table_name = "gb_settings"
 
-   before_destroy :destroy_cache
-   attr_accessible :name, :value, :values_list, :help, :category, :row , :delete_able , :enabled
-    def self.generate_or_update_settings(settings={})
+    after_save :update_settings_in_config
+
+    before_destroy :destroy_cache
+
+    attr_accessible :name, :value, :values_list, :help, :category
+    attr_accessible :row, :delete_able, :enabled, :site
+
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
+
+    def self.generate_or_update_settings(settings, site=nil)
       settings.each do |key , val |
-        obj = self.find(:first , :conditions => {:name => key })
-        if obj.blank?
-          obj = self.new(:name=> key , :value => val[0] , :row => val[1] , :delete_able => false , :help => val[2] , :values_list => val[3])
+        obj = self.where(:name => key).first
+        if obj.blank? || obj.site != site
+          obj = self.new({
+            :name=> key,
+            :value => val[0],
+            :row => val[1],
+            :delete_able => false,
+            :help => val[2],
+            :values_list => val[3],
+            :site => site
+          })
           obj.save!
         else
-          obj.update_attributes(:name=> key  , :row => val[1] , :delete_able => false , :help => val[2])
+          obj.update_attributes({
+            :name=> key,
+            :row => val[1],
+            :delete_able => false,
+            :help => val[2],
+            :site => site
+          })
         end
       end
     end
@@ -21,21 +42,21 @@ module Gluttonberg
       name.titlecase
     end
 
+    # Generate common settings for gluttonberg
+    # If its not multisite case then it only creates one set of settings
+    # In case of multisite it creates one set of global settings 
+    # and xx times for websited based settings
     def self.generate_common_settings
-      settings = {
-        :title => [ "" , 0, "Website Title"],
-        :keywords => ["" , 1, "Please separate keywords with a comma."],
-        :description => ["" ,2 , "The Description will appear in search engine's result list."],
-        :fb_icon => ["" , 3 , "Facebook Icon for the website"],
-        :google_analytics => ["", 4, "Google Analytics ID"],
-        :comment_notification => ["No" , 5 , "Enable comment notification" , "Yes;No" ],
+      cms_settings = {
         :number_of_revisions => ["10" , 6 , "Number of revisions to maintain for versioned contents."],
         :library_number_of_recent_assets => ["15" , 7 , "Number of recent assets in asset library."],
         :number_of_per_page_items => ["20" , 8 , "Number of per page items for any paginated content."],
         :enable_WYSIWYG => ["Yes" , 9 , "Enable WYSIWYG on textareas" , "Yes;No" ],
         :backend_logo => ["" , 10 , "Logo for backend" ] ,
-        :restrict_site_access => ["" , 11 , "If this setting is provided then user needs to enter password to access public site."]  ,
-        :from_email => ["" , 12 , "This email address is used for 'from' email address for all emails sent through system."],
+        :auto_save_time => ["30" , 22 , "If editing is in progress then gluttonberg will auto save the form in XX seconds" ]
+      }
+
+      settings = {
         :video_assets => ["" , 13 , "FFMPEG settings" , "Enable;Disable"],
         :s3_key_id => ["" , 14 , "S3 Key ID"],
         :s3_access_key => ["" , 15 , "S3 Access Key"],
@@ -47,7 +68,32 @@ module Gluttonberg
         :comment_number_of_emails_allowed => ["2" , 21 , "How many email addresses should a comment include to be marked as spam?" ],
         :comment_number_of_urls_allowed => ["2" , 21 , "How many URLs should a comment include to be marked as spam?" ]
       }
+
+      sitewise_settings = {
+        :title => [ "" , 0, "Website Title"],
+        :keywords => ["" , 1, "Please separate keywords with a comma."],
+        :description => ["" ,2 , "The Description will appear in search engine's result list."],
+        :fb_icon => ["" , 3 , "Facebook Icon for the website"],
+        :google_analytics => ["", 4, "Google Analytics ID"],
+        :from_email => ["" , 12 , "This email address is used for 'from' email address for all emails sent through system."],
+        :restrict_site_access => ["" , 11 , "If this setting is provided then user needs to enter password to access public site."],
+        :comment_notification => ["No" , 5 , "Enable comment notification" , "Yes;No" ]
+      }
+
+      self.generate_or_update_settings(cms_settings)
       self.generate_or_update_settings(settings)
+      if Rails.configuration.multisite == false
+        self.generate_or_update_settings(sitewise_settings)
+      else
+        Rails.configuration.multisite.each do |key, val|
+          self.generate_or_update_settings(sitewise_settings, key)
+        end
+      end
+
+      version = Version.new
+      version.version_number = VERSION
+      version.save
+
     end
 
     def self.has_deletable_settings?
@@ -64,17 +110,20 @@ module Gluttonberg
       end
     end
 
-    def self.get_setting(key)
+    def self.get_setting(key, site='')
       if Gluttonberg::Setting.table_exists?
+        cache_key = (site.blank? ? "setting_#{key}" : "setting_#{key}_#{site}")
         data  = nil
         begin
-          data = Rails.cache.read("setting_#{key}")
+          data = Rails.cache.read(cache_key)
         rescue
         end
         if data.blank?
-          setting = Setting.find(:first , :conditions => { :name => key })
+          setting = Setting.where(:name => key)
+          setting = setting.where(:site => site) unless site.blank?
+          setting = setting.first
           data = ( (!setting.blank? && !setting.value.blank?) ? setting.value : "" )
-           Rails.cache.write("setting_#{key}" , (data.blank? ? "~" : data))
+           Rails.cache.write(cache_key , (data.blank? ? "~" : data))
            data
         elsif data == "~" # empty setting
           ""
@@ -87,24 +136,25 @@ module Gluttonberg
     def self.update_settings(settings={})
       settings.each do |key , val |
         obj = self.where(:name=> key).first
-        obj.value = val
-        obj.save!
+        unless obj.blank?
+          obj.value = val
+          obj.save!
+        end
       end
     end
 
     def update_settings_in_config
       begin
-        setting = self
-        Rails.cache.write("setting_#{setting.name}" , setting.value)
+        cache_key = (self.site.blank? ? "setting_#{self.name}" : "setting_#{self.name}_#{self.site}")
+        Rails.cache.write(cache_key , self.value)
       rescue => e
         Rails.logger.info e
       end
     end
 
     def destroy_cache
-      Rails.cache.write("setting_#{self.name}" , "")
+      cache_key = (self.site.blank? ? "setting_#{self.name}" : "setting_#{self.name}_#{self.site}")
+      Rails.cache.write(cache_key , "")
     end
-
-
   end
 end

data/app/models/gluttonberg/sitemap.rb

@@ -1,4 +1,5 @@
 module Gluttonberg
+  # Wrapper class for sitemap generator gem
   class Sitemap
     @@sitemap = nil
     @@links = {}

data/app/models/gluttonberg/stylesheet.rb

@@ -1,9 +1,15 @@
 module Gluttonberg
- class Stylesheet  < ActiveRecord::Base
-   self.table_name = "gb_stylesheets"
-   include Content::SlugManagement
-   is_versioned :non_versioned_columns => ['position']
-   is_drag_tree :flat => true , :order => "position"
-   attr_accessible :name, :slug, :css_prefix, :css_postfix, :value
+  # This class is used for create CMS based stylesheets.
+  class Stylesheet  < ActiveRecord::Base
+    self.table_name = "gb_stylesheets"
+
+    include Content::SlugManagement
+
+    # Included mixins which are registered by host app for extending functionality
+    MixinManager.load_mixins(self)
+
+    is_versioned :non_versioned_columns => ['position']
+    is_drag_tree :flat => true , :order => "position"
+    attr_accessible :name, :slug, :css_prefix, :css_postfix, :value, :position
   end
 end

data/app/models/gluttonberg/textarea_content.rb

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

data/app/models/gluttonberg/version.rb

@@ -0,0 +1,9 @@
+module Gluttonberg
+  class Version < ActiveRecord::Base
+
+    self.table_name = "gb_versions"
+
+    attr_accessible :version_number
+
+  end
+end

data/app/models/user.rb

@@ -1,23 +1,32 @@
 class User < ActiveRecord::Base
-  attr_accessible :first_name , :last_name , :email , :password , :password_confirmation , :bio , :image_id
-
   self.table_name = "gb_users"
+
   belongs_to :images , :foreign_key => "image_id" , :class_name => "Gluttonberg::Asset"
+  has_many :collapsed_pages, :class_name => "Gluttonberg::CollapsedPage", :dependent => :destroy
+  has_many :authorizations, :class_name => "Gluttonberg::Authorization", :dependent => :destroy
 
-  validates_presence_of :first_name , :email , :role
-  validates_format_of :password, :with => /^(?=.*\d)(?=.*[a-zA-Z])(?!.*[^\w\S\s]).{6,}$/ , :if => :require_password?, :message => "must be a minimum of 6 characters in length, contain at least 1 letter and at least 1 number"
+  attr_accessible :first_name , :last_name , :email
+  attr_accessible :password , :password_confirmation
+  attr_accessible :bio , :image_id
 
+  attr_accessible :authorizations, :authorizations_attributes
+  accepts_nested_attributes_for :authorizations, :allow_destroy => false
+
+  validates_presence_of :first_name , :email , :role
+  validates_format_of :password, :with => Rails.configuration.password_pattern , :if => :require_password?, :message => Rails.configuration.password_validation_message
 
   clean_html [:bio]
 
   acts_as_authentic do |c|
     c.login_field = "email"
+    c.crypto_provider = Authlogic::CryptoProviders::Sha512
   end
 
+  # Included mixins which are registered by host app for extending functionality
+  Gluttonberg::MixinManager.load_mixins(self)
+
   def full_name
-    self.first_name = "" if self.first_name.blank?
-    self.last_name = "" if self.last_name.blank?
-    self.first_name + " " + self.last_name
+    "#{self.first_name} #{self.last_name}".strip
   end
 
   def deliver_password_reset_instructions!
@@ -25,6 +34,10 @@ class User < ActiveRecord::Base
     Notifier.password_reset_instructions(self.id).deliver
   end
 
+  def ability
+    @ability ||= Ability.new(self)
+  end
+
   def super_admin?
     self.role == "super_admin"
   end
@@ -33,27 +46,138 @@ class User < ActiveRecord::Base
     self.role == "admin"
   end
 
+  def editor?
+    self.role == "editor"
+  end
+
+  def contributor?
+    self.role == "contributor"
+  end
+
   def self.user_roles
-    @roles ||= (["super_admin" , "admin" , "contributor"] << (Rails.configuration.user_roles) ).flatten
+    @roles ||= (["super_admin" , "admin", 'editor' , "contributor"] << (Rails.configuration.user_roles) ).flatten
   end
 
   def user_valid_roles(user)
     if user.id == self.id
       []
     else
-      roles = (["super_admin" , "admin" , "contributor"] << (Rails.configuration.user_roles) ).flatten
+      roles = (["super_admin" , "admin", 'editor' , "contributor"] << (Rails.configuration.user_roles) ).flatten
       roles.delete("super_admin") unless self.super_admin?
-      roles.delete("contributor") if !self.super_admin? && !self.admin?
-      roles
+      if !self.super_admin? && !self.admin?
+        [self.role]
+      else
+        roles
+      end
     end
   end
 
   def have_backend_access?
-    ["super_admin" , "admin" , "contributor"].include?(self.role)
+    true
   end
 
   def self.all_super_admin_and_admins
     self.where(:role => ["super_admin" , "admin"]).all
   end
 
-end
+  def self.all_super_admin_and_admins_editors
+    self.where(:role => ["super_admin" , "admin", 'editor']).all
+  end
+
+  # Search users based on current user role
+  def self.search_users(query, current_user, get_order)
+    users = User.order(get_order)
+    unless query.blank?
+      users = users.where("first_name LIKE :query OR last_name LIKE :query OR email LIKE :query OR bio LIKE :query ", :query => "%#{query}%")
+    end
+    if current_user.super_admin?
+    elsif current_user.admin?
+      users = users.where("role != ?" , "super_admin")
+    else
+      users = users.where("id = ?" , current_user.id)
+    end
+    users
+  end
+
+  # Find user based on current user role
+  def self.find_user(id, current_user)
+    user = User.where(:id => id)
+    if current_user.super_admin?
+    elsif current_user.admin?
+      user = user.where("role != ?" , "super_admin")
+    else
+      user = user.where(:id => current_user.id)
+    end
+    user.first
+  end
+
+  # core logic for authorization system
+  def authorized?(object)
+    auth = nil
+    status = case object.class.name.to_s
+    when "Gluttonberg::Page"
+      _authorize_page?(object)
+    when "Gluttonberg::Blog::Weblog"
+      _authorize_blog?(object)
+    when "String"
+      _authorize_class_name?(object)
+    else
+      _authorize_class?(object)
+    end
+    status
+  end
+
+  def _authorize_page?(object)
+    auth = self.authorizations.where(:authorizable_type => object.class.name).first
+    unless auth.blank?
+      auth.authorizable_id == object.id || object.grand_child_of?(auth.authorizable)
+    else
+      false
+    end
+  end
+
+  def _authorize_blog?(object)
+    auth = self.authorizations.where(:authorizable_type => object.class.name, :authorizable_id => object.id).first
+    unless auth.blank?
+      auth.allow == true
+    else
+      false
+    end
+  end
+
+  def _authorize_class_name?(object)
+    auth = self.authorizations.where(:authorizable_type => object).first
+    unless auth.blank?
+      auth.allow == true
+    else
+      false
+    end
+  end
+
+  def _authorize_class?(object)
+    auth = self.authorizations.where(:authorizable_type => object.class.name).first
+    unless auth.blank?
+      auth.allow == true
+    else
+      true
+    end
+  end
+
+  def can_view_page(object)
+    if self.contributor?
+      if object.class.name == "Gluttonberg::Page"
+        auth = self.authorizations.where(:authorizable_type => object.class.name).first
+        unless auth.blank? || auth.authorizable.blank?
+          object.id == auth.authorizable.id || object.grand_child_of?(auth.authorizable) || object.grand_parent_of?(auth.authorizable)
+        else
+          false
+        end
+      else
+        false
+      end
+    else
+      true
+    end
+  end
+
+end

data/app/observers/gluttonberg/locale_observer.rb

@@ -1,45 +1,56 @@
 module Gluttonberg
+  # Locale Observer makes sures that if new locale is created then 
+  # create localization for existing pages 
+  # It also adjusts some variables on locale update
+
   class LocaleObserver < ActiveRecord::Observer
     observe Locale
     
+    # create localization for existing pages 
     def after_create(locale)   
-      pages = Page.all
-      
-      pages.each do |page|
+      Page.all.each do |page|
         #create localizations for all pages for new locale
-        new_localizations = []
-        new_localizations << page.localizations.create(
-          :name     => page.name,
-          :locale_id   => locale.id
-        )
+        new_localizations = create_page_localization(page, locale)
         
         # create content localizations
         unless page.description.sections.empty?
           Rails.logger.info("Generating stubbed content for all pages using new localizations")
           page.description.sections.each do |name, section|
             # Create the content
-              association = page.send(section[:type].to_s.pluralize)
-              content = association.find(:first , :conditions => {:section_name => name})
-              # Create each localization
-               if content && content.class.localized?
-                   new_localizations.each do |localization|
-                     content.localizations.create(:parent => content, :page_localization => localization)
-                   end
-              end
+            create_page_content(page, new_localizations, name, section)
           end
         end
-        
       end
-      
-    end
-
-      
+    end      
     
     def after_update(locale)
       existing_localization_ids = []
       remove_list = []
       new_localizations = []
-    end  
+    end 
+
+    private
+      # create localization for a page
+      def create_page_localization(page, locale)
+        new_localizations = []
+        new_localizations << page.localizations.create(
+          :name     => page.name,
+          :locale_id   => locale.id
+        )
+        new_localizations
+      end 
+
+      # create content localization for page localization 
+      def create_page_content(page, new_localizations, name, section)
+        association = page.send(section[:type].to_s.pluralize)
+        content = association.where(:section_name => name).first
+        # Create each localization
+        if content && content.class.localized?
+          new_localizations.each do |localization|
+            content.localizations.create(:parent => content, :page_localization => localization)
+          end
+        end
+      end
         
   end
 end