gluttonberg-core 2.6.4 → 3.0.0

data/app/helpers/gluttonberg/public/meta_tags.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Public
+    module MetaTags
+      # Keywords meta tag with CMS settings of keywords
+      def keywords_meta_tag
+        _meta_tag("keywords", "keywords")
+      end
+
+      # Description meta tag with CMS settings of description
+      def description_meta_tag
+        _meta_tag("description", "description")
+      end
+
+      private
+        def _meta_tag(setting_name, tag_name)
+          value = Gluttonberg::Setting.get_setting(setting_name, current_site_config_name)
+          unless value.blank?
+            tag("meta",{:content =>  value, :name => tag_name } ) 
+          else
+            nil
+          end
+        end
+    end
+  end
+end

data/app/helpers/gluttonberg/public/nav_tree.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Public
+    module NavTree
+
+      # A simple helper which loops through a heirarchy of pages and produces a
+      # set of nested lists with links to each page.
+      def navigation_tree(pages, opts = {})
+        opts[:max_depth] ||= 10
+        content = ""
+        home = Gluttonberg::Page.home_page if pages.nil?
+        pages = home.children.published if home
+        pages = Gluttonberg::Page.where(:parent_id => nil, :state => "published").order("position ASC") if pages.nil?
+        pages = pages.to_a
+        pages.insert(0, Gluttonberg::Page.home_page) if opts[:include_home] == true
+
+        # if opts[:path]
+        #   content_ul = Rails.cache.read("nav-#{opts[:path]}")
+        #   return content_ul if content_ul
+        # end
+
+        pages.each do |page|
+          page_depth = 1
+          page.load_localization(@locale)
+          li_opts = {:class => page.localizations[0] && page.localizations[0].slug ? "#{page.localizations[0].slug}-nav" : "#{page.slug}-nav"}
+          unless Gluttonberg::Page.home_page == page
+            li_opts[:class] += " active" if page == @page || children_active?(page)
+          end
+          li_content = build_page(page, opts)
+          unless Gluttonberg::Page.home_page == page
+            li_content << find_children(page, page_depth, opts) if opts[:max_depth] >= page_depth && page.number_of_children > 0
+          end
+          content << content_tag(:li, li_content.html_safe, li_opts).html_safe
+        end
+
+        content_ul = content_tag(:ul, content.html_safe, opts).html_safe
+
+        # Rails.cache.write("nav-#{opts[:path]}", content_ul, :expires_in => 5.minutes) if opts[:path]
+
+        return content_ul
+      end
+
+      def find_children(parent, page_depth, opts)
+        content = ""
+        parent.children.published.each do |page|
+          child_depth = page_depth + 1
+          page.load_localization(@locale)
+          li_opts = {:class => page.localizations[0] && page.localizations[0].slug ? "#{page.localizations[0].slug}-nav" : "#{page.slug}-nav"}
+          li_opts[:class] += " active" if page == @page  || children_active?(page)
+          li_content = build_page(page, opts)
+          li_content << find_children(page, child_depth, opts) if opts[:max_depth] >= child_depth
+          content << content_tag(:li, li_content.html_safe, li_opts).html_safe
+        end
+        return content_tag(:ul, content.html_safe, opts).html_safe if !content.blank?
+      end
+
+      # build each page and returns an li
+      def build_page(page, opts)
+        span = content_tag(:span, page.nav_label).html_safe
+        if page.home?
+          return content_tag(:a, span, :href => "/").html_safe
+        else
+          if page.description && page.description.top_level_page?
+            return content_tag(:a, span, :href=>"javascript:;", :class => "menu_disabled").html_safe
+          else
+            return content_tag(:a, span, :href => page_url(page , opts), :target => "#{page.redirect_required? && URI(page.redirect_url).absolute? ? '_blank' : ''}").html_safe
+          end
+        end
+      end
+
+      def children_active?(parent)
+        active = false
+        active = true if parent == @page
+        parent.children.each do |page|
+          active = true if children_active?(page) == true
+          active = true if page == @page
+        end
+        return active
+      end
+
+      # finds the correct url for a page.
+      def page_url(path_or_page , opts = {})
+        if path_or_page.redirect_required?
+          path_or_page.redirect_url
+        elsif path_or_page.rewrite_required?
+          "#{path_or_page.description.rewrite_route}"
+        else
+          if Gluttonberg.localized? && !opts[:slug].blank?
+            "/#{opts[:slug]}/#{path_or_page.path}"
+          else
+            "#{path_or_page.public_path}"
+          end
+        end
+      end
+
+    end
+  end
+end

data/app/helpers/gluttonberg/public/page_info.rb

@@ -0,0 +1,168 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Public
+    module PageInfo
+
+      # This returns page title (just text only). 
+      # It checks for page/article/custom model for (:seo_title, :title, :name, :title_or_name?) methods
+      # it concats it with website title (if exists)
+      def page_title
+        title_setting = Gluttonberg::Setting.get_setting("title", current_site_config_name)
+        page_title = _prepare_page_title
+
+        if page_title.blank?
+          title_setting
+        elsif title_setting.blank?
+          page_title
+        else
+          "#{page_title} | #{title_setting}"
+        end
+      end
+
+      # This returns page title (just text only). 
+      # It checks for page/article/custom model for (:seo_title, :title, :name, :title_or_name?) methods
+      # It only returns page related information
+      def og_title
+        og_title = _prepare_page_title
+        return og_title if !og_title.blank?
+        return nil
+      end
+
+      # It only returns website title from backend settings
+      def og_site_name
+        og_site_name = Gluttonberg::Setting.get_setting("title", current_site_config_name)
+        return og_site_name if !og_site_name.blank?
+        return nil
+      end
+
+      # This returns absolute path to OG image. 
+      # It checks for page/article/custom model for fb_icon_id method
+      # otherwise it checks for website fb_icon_id from settings
+      def og_image
+        object = find_current_object_for_meta_tags
+        fb_icon_id = Gluttonberg::Setting.get_setting("fb_icon", current_site_config_name)
+
+        if !object.blank? && object.respond_to?(:fb_icon_id) && !object.fb_icon_id.blank?
+          fb_icon_id = object.fb_icon_id
+        end
+
+        asset = unless fb_icon_id.blank?
+          Asset.where(:id => fb_icon_id).first
+        end
+
+        if asset
+          return "http://#{request.host_with_port}#{asset.url}"
+        else
+          return nil
+        end
+      end
+
+      alias_method :page_fb_icon_path, :og_image
+
+      # This returns page description if it exits (just text only). 
+      # It checks for page/article/custom model for seo_description method
+      # otherwise it returns website description from settings
+      def page_description
+        object = find_current_object_for_meta_tags
+        description_settings = Gluttonberg::Setting.get_setting("description", current_site_config_name)
+        page_description = if !object.blank? && object.respond_to?(:seo_description)
+          object.seo_description
+        end
+
+        if !page_description.blank?
+          page_description
+        else !description_settings.blank?
+          description_settings
+        end
+      end
+
+      # This returns page keywords if it exits (just text only). 
+      # It checks for page/article/custom model for seo_keywords method
+      # otherwise it returns website keywords from settings
+      def page_keywords
+        object = find_current_object_for_meta_tags
+        keywords_settings = Gluttonberg::Setting.get_setting("keywords", current_site_config_name)
+        page_keywords = if !object.blank? && object.respond_to?(:seo_keywords)
+          object.seo_keywords
+        end
+
+        if !page_keywords.blank?
+          page_keywords
+        elsif !keywords_settings.blank?
+          keywords_settings
+        end
+      end
+
+      # returns current page slug and 'page' class if it is page 
+      # returns current post slug and 'post' class if it is blog post 
+      # otherwise class name and object slug
+      def page_fb_icon_path
+        path = nil
+        object = find_current_object_for_meta_tags
+        fb_icon_id = Gluttonberg::Setting.get_setting("fb_icon", current_site_config_name)
+
+        if !object.blank? && object.respond_to?(:fb_icon_id) && !object.fb_icon_id.blank?
+          fb_icon_id = object.fb_icon_id
+        end
+
+        asset = unless fb_icon_id.blank?
+          Asset.where(:id => fb_icon_id).first
+        end
+
+        path = asset_file_url(asset) unless asset.blank?
+        path
+      end
+
+      def body_class(page=nil)
+        page = @page if page.blank?
+        if !page.blank?
+         "page #{page.current_localization.slug.blank? ? page.slug : page.current_localization.slug} #{page.home? ? 'home' : ''}"
+        else
+          object = find_current_object_for_meta_tags
+          unless object.blank?
+            class_name = (Gluttonberg.constants.include?(:Blog) && object.kind_of?(Gluttonberg::Blog::ArticleLocalization) ? 'post' : object.class.name.demodulize.downcase)
+            "#{class_name} #{object.slug}"
+          end
+        end
+      end
+
+      def og_type
+        if !@page.blank? && @page.home == true
+          'website'
+        elsif !@blog.blank? && @article.blank?
+          'blog'
+        else
+          'article'
+        end
+      end
+
+      private
+
+        def find_current_object_for_meta_tags
+          if !@page.blank?
+            @page.current_localization
+          elsif !@article.blank?
+            @article.current_localization
+          elsif !@blog.blank?
+            @blog
+          elsif !@custom_model_object.blank?
+            @custom_model_object
+          end
+        end
+
+        def _prepare_page_title
+          object = find_current_object_for_meta_tags
+          page_title = nil
+          page_title = unless object.blank?
+            [:seo_title, :title, :name, :title_or_name?].each do |method|
+              if object.respond_to?(method) && !object.send(method).blank?
+                return object.send(method)
+              end
+            end
+            nil
+          end
+        end
+    end
+  end
+end

data/app/mailer/gluttonberg/base_notifier.rb

@@ -0,0 +1,25 @@
+module Gluttonberg
+  class BaseNotifier < ActionMailer::Base
+  	default_url_options[:host] = Rails.configuration.host_name 
+    protected
+      def setup_email
+        site_title = Gluttonberg::Setting.get_setting("title")
+        setup_from
+
+        @subject     = site_title.blank? ? "" : "[#{site_title}] "
+        @sent_on     = Time.now
+        @content_type = "text/html"
+      end
+
+      def setup_from
+        site_title = Gluttonberg::Setting.get_setting("title")
+        from_email = Gluttonberg::Setting.get_setting("from_email")
+
+        @from = ""
+        unless from_email.blank?
+          @from  = site_title.blank? ? from_email : "#{site_title} <#{from_email}>"
+        end
+        self.class.default :from => @from
+      end
+  end
+end

data/app/mailer/member_notifier.rb

@@ -1,22 +1,20 @@
-class MemberNotifier < ActionMailer::Base
-  
-  default :from => "#{Gluttonberg::Setting.get_setting("title")} <#{Gluttonberg::Setting.get_setting("from_email")}>"
-  default_url_options[:host] = Rails.configuration.host_name 
-  
+class MemberNotifier < Gluttonberg::BaseNotifier
+    
   def password_reset_instructions(member_id ,  current_localization_slug = "")
     member = Gluttonberg::Member.find(member_id)
     setup_email
     @subject += "Password Reset Instructions"
     @recipients = member.email  
     @edit_password_reset_url = edit_member_password_reset_url( current_localization_slug,  member.perishable_token)
+    mail(:to => member.email, :subject => @subject)
   end
   
   def confirmation_instructions(member_id ,  current_localization_slug = "")
     member = Gluttonberg::Member.find(member_id)
     setup_email
     @subject += "Confirmation Instructions"
-    @recipients = member.email  
     @member_confirmation_url = member_confirmation_url(:locale => current_localization_slug , :key => member.confirmation_key)
+    mail(:to => member.email, :subject => @subject)
   end
   
   # welcome email will be sent to member when admin user will create member. 
@@ -25,27 +23,17 @@ class MemberNotifier < ActionMailer::Base
   def welcome(member_id, current_localization_slug = "")
     @member = Gluttonberg::Member.find(member_id)
     setup_email
-    @subject += "Confirmation Instructions"
-    @recipients = @member.email  
+    @subject += "Your account is registered"
     @password = Gluttonberg::Member.generateRandomString
     password_hash = {  
-        :password => @password ,
-        :password_confirmation => @password
+      :password => @password ,
+      :password_confirmation => @password
     }
     @member.welcome_email_sent = true
     @member.assign_attributes(password_hash)
     @member.save
     @login_url = member_login_url
+    mail(:to => @member.email, :subject => @subject)
   end
   
-  
-  protected
-  
-    def setup_email
-      @from        = "#{Gluttonberg::Setting.get_setting("title")} <#{Gluttonberg::Setting.get_setting("from_email")}>"
-      @subject     = "[#{Gluttonberg::Setting.get_setting("title")}] "
-      @sent_on     = Time.now
-      @content_type = "text/html"
-    end
-    
 end

data/app/mailer/notifier.rb

@@ -1,45 +1,20 @@
-class Notifier < ActionMailer::Base
-  
-  default :from => "#{Gluttonberg::Setting.get_setting("title")} <#{Gluttonberg::Setting.get_setting("from_email")}>"
-  default_url_options[:host] = Rails.configuration.host_name 
-  
+class Notifier < Gluttonberg::BaseNotifier
   def password_reset_instructions(user_id)
     user = User.find(user_id)
     setup_email
     @subject += "Password Reset Instructions"
-    @recipients = user.email  
-    @body[:edit_password_reset_url] = edit_admin_password_reset_url(user.perishable_token)
+    @edit_password_reset_url = edit_admin_password_reset_url(user.perishable_token)
+    mail(:to => user.email, :subject => @subject)
   end
-  
-  def comment_notification(subscriber , article , comment)
-    @subscriber = subscriber
-    @article = article
-    @comment = comment
-    @website_title = Gluttonberg::Setting.get_setting("title")
-    @article_url = blog_article_url(article.blog.slug, article.slug)
-    @unsubscribe_url = unsubscribe_article_comments_url(@subscriber.reference_hash)
-    
-    mail(:to => @subscriber.author_email, :subject => "Re: [#{@website_title}] #{@article.title}")
-  end
-  
-  def comment_notification_for_admin(admin , article , comment)
-    @admin = admin
-    @article = article
-    @blog = @article.blog
-    @comment = comment
-    @website_title = Gluttonberg::Setting.get_setting("title")
-    @article_url = blog_article_url(:blog_id => article.blog.slug, :id => article.slug)
-    
-    mail(:to => @admin.email, :subject => "Re: [#{@website_title}] #{@article.title}")
-  end
-  
-  protected
-  
-    def setup_email
-      @from        = "#{Gluttonberg::Setting.get_setting("title")} <#{Gluttonberg::Setting.get_setting("from_email")}>"
-      @subject     = "[#{Gluttonberg::Setting.get_setting("title")}] "
-      @sent_on     = Time.now
-      @content_type = "text/html"
-    end
-    
+
+  def version_declined(current_user, version, url, title)
+    user = version.user if version && version.user
+    @current_user = current_user
+    @version = version
+    @title = title.blank? ? 'Page/Post' : title
+    setup_email
+    @subject += "Website Publishing"
+    @url = url
+    mail(:to => user.email, :subject => @subject) unless user.blank?
+  end    
 end

data/app/models/ability.rb

@@ -1,46 +1,60 @@
+# Default abilities of CMS users. 
+# This class needs to be overrided in host app if customization required
 class Ability
   include CanCan::Ability
-  
-  # commented code is left for example for hostapps. In hostapp developer can override this class for custom authorization requirements
   def initialize(user)
-    
     user ||= User.new # guest user (not logged in)
+    can :manage, :all
+    can :manage_object, :all
+    can :manage_model, :all
     if user.super_admin?
-      can :manage, :all
     elsif user.admin?
-      can :manage, :all
-      restricted_features_for_admin
+      restricted_features_for_admin(user)
+    elsif user.editor?
+      restricted_features_for_editors(user)
     else
-      can :manage, :all
-      restricted_features_for_admin
-      
-      cannot :manage , User
-      cannot :manage , Gluttonberg::Setting
-      cannot :destroy , Gluttonberg::Asset
-      
-      #page roles
-      #cannot :manage , Gluttonberg::Page
-      cannot :change_home , Gluttonberg::Page
-      cannot :destroy , Gluttonberg::Page
-      cannot :publish , Gluttonberg::Page
-      cannot :reorder , Gluttonberg::Page
-      
-      #cannot :manage , Gluttonberg::Blog
-      cannot :publish , Gluttonberg::Blog
-      cannot :destroy , Gluttonberg::Blog
-      
-      #cannot :manage , Gluttonberg::Article
-      #cannot :publish , Gluttonberg::Article
-      #cannot :destroy , Gluttonberg::Article
-      
-      #cannot :manage , Gluttonberg::Comment
-      #cannot :moderate , Gluttonberg::Comment
+      restricted_features_for_contributors(user)
     end
-    
   end
   
-  def restricted_features_for_admin
-    cannot :manage , Gluttonberg::Locale
-    cannot :create_or_destroy , Gluttonberg::Setting
+  def restricted_features_for_admin(user)
+    cannot :manage, Gluttonberg::Locale
+    cannot :create_or_destroy, Gluttonberg::Setting
+  end
+
+  def restricted_features_for_editors(user)
+    restricted_features_for_admin(user)
+    cannot :manage, User
+    cannot :manage, Gluttonberg::Member
+    cannot :manage, Gluttonberg::Setting
+  end
+
+  def restricted_features_for_contributors(user)
+    restricted_features_for_editors(user)
+    cannot :publish, :all
+    cannot :destroy, :all do |object|
+      if object.respond_to?(:user_id)
+        (object.respond_to?(:state) && ["published", "archived"].include?(object.state)) || object.user_id != user.id
+      else
+        true
+      end 
+    end
+
+    cannot :edit, Gluttonberg::Asset do |object|
+      object.user_id != user.id
+    end
+    cannot :moderate, :all
+    cannot :reorder, :all
+
+    # cannot manage unauthorized objects
+    cannot :manage_object, :all do |object|
+      !user.authorized?(object)
+    end
+
+    # cannot manage unauthorized custom models (make sure pass custom model name (only for manage_model) as string.)
+    cannot :manage_model, :all do |object|
+      !user.authorized?(object)
+    end
+
   end
 end