gluttonberg-core 2.6.4 → 3.0.0

data/app/helpers/gluttonberg/admin/assets.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module Assets
+      # Generates a link which launches the asset browser
+      #
+      # @param field_name [String or Symbol]
+      # @param opts [Hash]
+      #        :id (optional) This is the id to use for the generated hidden field to store the selected assets id. If its not provided then this helper will auto generate
+      #        :asset_id (nil allowed) The id of the currently selected asset.
+      #        :filter (optional) If valid filter is provided then it only brings assets of belonging to select filter type. (image,audio video). Now comma seperated list of filters is also allowed.
+      #        :button_class (optional) Css class for asset selector link/button
+      #        :data_url  (optional) If this url is provided then it will auto save selection
+      #
+      # For Finding image assets
+      #   asset_browser_tag( field_name ,  opts = { :id => "" , :asset_id => "" ,  :filter => "" ,  :id => "html_id", :data_url => "", :button_class =>  "" } )
+
+      def asset_browser_tag( field_name , opts = {} )
+        _asset_browser_tag( field_name , opts  )
+      end
+
+      def _asset_browser_tag( field_name , opts = {} )
+        asset_id = opts[:asset_id]
+        opts[:filter] = opts[:filter] || "all"
+        asset = if asset_id.blank?
+          nil
+        else
+          Gluttonberg::Asset.where(:id => asset_id).first
+        end
+
+        opts[:id] = "#{field_name}_#{asset_id}" if opts[:id].blank?
+        render :partial => "/gluttonberg/admin/asset_library/shared/asset_browser", :locals => {
+          :opts => opts,
+          :asset => asset,
+          :field_name => field_name
+        }
+      end
+
+      # Generates a link which clears asset browser input
+      #
+      # @param field_name [String or Symbol]
+      # @param opts [Hash]
+      #        :id (optional) This is the id to use for the generated hidden field to store the selected assets id. If its not provided then this helper will auto generate
+      #        :asset_id (nil allowed) The id of the currently selected asset.
+      #        :button_class (optional) Css class for asset selector link/button
+      #        :data_url  (optional) If this url is provided then it will auto save selection
+      #
+      # For clearing image asset
+      #   clear_asset_tag( field_name ,  opts = { :id => "", :asset_id => "", :id => "html_id", :data_url => "", :button_class =>  "" } )
+      def clear_asset_tag( field_id , opts = {} )
+        asset_id = opts[:asset_id]
+        if opts[:id].blank?
+          rel = field_id.to_s + "_" + id.to_s
+          opts[:id] = rel
+        end
+        html_id = opts[:id]
+        link_to("Remove", "Javascript:;" , {
+          :class => "btn btn-danger button remove #{opts[:button_class]}",
+          :data_url => opts[:data_url]
+        })
+      end
+
+      def asset_panel(assets, name_or_id , type )
+        render :partial => "/gluttonberg/admin/shared/asset_panel" , :locals => {:assets => assets , :name_or_id => name_or_id , :type => type} , :formats => [:html]
+      end
+
+      # Button to select Backend logo on settings page
+      def backend_logo(default_logo_image_path , html_opts={}, thumbnail_type = :backend_logo)
+        backend_logo = Gluttonberg::Setting.get_setting("backend_logo")
+        if !backend_logo.blank? && backend_logo.to_i > 0
+          asset = Asset.where(:id => backend_logo).first
+          unless asset.blank?
+            path = thumbnail_type.blank? ? asset.url : asset.url_for(thumbnail_type)
+            content_tag(:img , "" , html_opts.merge( :alt => asset.name , :src => path ) )
+          else
+            image_tag(default_logo_image_path)
+          end
+        end
+      end
+
+    end
+  end #Assets
+end

data/app/helpers/gluttonberg/admin/form.rb

@@ -0,0 +1,159 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module Form
+      # Use this helper on public submissions forms to avoid robotic submissions
+      def honeypot_field_tag
+        html = label_tag(Rails.configuration.honeypot_field_name , Rails.configuration.honeypot_field_name.humanize )
+        html << text_field_tag( Rails.configuration.honeypot_field_name )
+        content_tag :div , html , :class => Rails.configuration.honeypot_field_name , :style => "display:none"
+      end
+
+      # Controls for standard forms. Writes out a save button with gluttonberg default styling
+      def form_controls(return_url , opts={})
+        content = "#{submit_tag("Save" , :id => opts[:submit_id], :class => "btn btn-success").html_safe} #{link_to("Cancel".html_safe, return_url, :class => "btn")}"
+        content_tag(:p, content.html_safe, :class => "controls")
+      end
+
+      # shows publish message if object's currect version is published
+      def publish_message(object , versions)
+        content = msg = ""
+        if versions.length > 1
+          msg = content_tag(:a,  "Click here to see other versions" , :onclick => "$('#select-version').toggle();" , :href => "javascript:;"  , :title => "Click here to see other versions").html_safe
+          msg = content_tag(:span , msg , :class => "view-versions").html_safe
+        end
+        content = content_tag(:div , "Updated on #{object.updated_at.to_s(:long)}    #{msg}".html_safe , :class => "unpublish_message") unless object.updated_at.blank?
+        content.html_safe
+      end
+
+      # Form controls for contributor. It renders "Save draft", "Submit for approval" buttons.
+      def contributor_form_controls(published, opts={})
+        html = submit_tag("Save draft" , :id => "#{published ? 'revision_btn' : 'draft_btn'}", :class => "btn publishing_btn").html_safe
+        html += " ".html_safe +  submit_tag("Submit for approval" , :id => "approval_btn", :class => "btn btn-success publishing_btn").html_safe
+        content_tag(:p, html.html_safe, :class => "controls")
+      end
+
+      # Form controls for admin when object is on draft status. It renders "Save draft", "Publish" buttons.
+      def admin_form_controls_for_draft_objects(opts={})
+        html = submit_tag("Save draft" , :id => "draft_btn", :class => "btn publishing_btn").html_safe
+        html += " ".html_safe +  submit_tag("Publish" , :id => "publish_btn", :class => "btn btn-success publishing_btn").html_safe
+        content_tag(:p, html.html_safe, :class => "controls")
+      end
+
+      # Form controls for admin when object is already published. It rendres "Save revision", "Update", "Unpublish" buttons.
+      def admin_form_controls_for_published_objects(revisions=true, opts={})
+        html =  ""
+        html += submit_tag("Save revision" , :id => "revision_btn", :class => "btn publishing_btn").html_safe if revisions == true
+        html += " ".html_safe +  submit_tag("Update" , :id => "update_btn", :class => "btn btn-success publishing_btn").html_safe
+        html += " ".html_safe +  submit_tag("Unpublish" , :id => "unpublish_btn", :class => "btn btn-danger publishing_btn").html_safe
+        content_tag(:p, html.html_safe, :class => "controls")
+      end
+
+      # Form controls for admin when they are viewing submitted revision of an object. It renders "Approve", "Decline" buttons.
+      def admin_form_controls_for_approving_or_decling_objects(version, opts={})
+        html = submit_tag("Approve" , :id => "publish_btn", :class => "btn btn-success publishing_btn").html_safe
+        html += " ".html_safe +  link_to("Decline", admin_decline_content_path(version.class.name.gsub("::Version",""), version.id) , :id => "decline_btn", :class => "btn btn-danger ").html_safe
+        content_tag(:p, html.html_safe, :class => "controls")
+      end
+
+      # new form controls based on new logic of authorization and publishing workflow
+      # It renders some hidden fields which manage publishing status.
+      # It also renders form controls based on current_user role, and status of object.
+      def submit_and_publish_controls(form, object, can_publish, schedule_field=true, revisions=true, opts={})
+        version_status = ''
+        begin
+          version_status = !object.respond_to?(:loaded_version) || object.loaded_version.blank? ? '' : object.loaded_version.version_status
+        rescue
+        end
+        html = content_tag("legend", "Publish").html_safe
+        if object.published?
+          html += content_tag(:p, "<span class='date'>Published on #{object.published_at.strftime("%d/%m/%Y")}</span>".html_safe)
+        else
+          html += form.publishing_schedule(schedule_field)
+        end
+        html += form.hidden_field(:state, :class => "_publish_state") 
+        html += form.hidden_field(:_publish_status, :class => "_publish_status") 
+        html += if can_publish
+          if version_status == 'submitted_for_approval'
+            admin_form_controls_for_approving_or_decling_objects(object.loaded_version, opts)
+          elsif object.published?
+            admin_form_controls_for_published_objects(revisions, opts)
+          else
+            admin_form_controls_for_draft_objects(opts)
+          end
+        else
+          contributor_form_controls(object.published?, opts)
+        end
+        html.html_safe
+      end
+
+      # It renders a dropdown with the list of all revisions of given object
+      def version_listing(versions , selected_version_num)
+        unless versions.blank?
+          versions = versions.order("version DESC")
+          selected = versions.last.version
+          selected_version = versions.first
+          versions.each do |version|
+            if version.version.to_i == selected_version_num.to_i
+              selected = version.version
+              selected_version = version
+            end
+          end
+          render :partial => "/gluttonberg/admin/shared/version_listing", :locals => {
+            :versions => versions,
+            :selected_version_num => selected_version_num,
+            :selected => selected,
+            :selected_version => selected_version
+          }
+        end
+      end #version_listing
+
+
+      # Creates an editable span for the given property of the given object.
+      #
+      # === Options
+      #
+      # [:method]
+      #   Specify the HTTP method to use: <tt>'PUT'</tt> or <tt>'POST'</tt>.
+      # [:name]
+      #   The <tt>name</tt> attribute to be used when the form is posted.
+      # [:update_url]
+      #   The URL to submit the form to.  Defaults to <tt>url_for(object)</tt>.
+      def gb_editable_field(object, property, options={})
+
+        name = "#{object.class.to_s.underscore}[#{property}]"
+        value = object.send property
+        update_url = options.delete(:update_url) || url_for(object)
+        args = {:method => 'PUT', :name => name}.merge(options)
+        %{
+          <span class="editable" data-id="#{object.id}" data-name="#{name}">#{value}</span>
+          <script type="text/javascript">
+            (function( $ ){
+              $(function(){
+                var args = {data: function(value, settings) {
+                  // Unescape HTML
+                  var retval = value
+                    .replace(/&amp;/gi, '&')
+                    .replace(/&gt;/gi, '>')
+                    .replace(/&lt;/gi, '<')
+                    .replace(/&quot;/gi, "\\\"");
+                  return retval;
+                },
+                   type      : 'text',
+                   height : '20px',
+                   cancel    : 'Cancel',
+                   submit    : 'OK',
+                   indicator : '#{image_tag('/assets/gb_spinner.gif')}'
+                };
+                $.extend(args, #{args.to_json});
+                $(".editable[data-id='#{object.id}'][data-name='#{name}']").editable("#{update_url}", args);
+              });
+            })( jQuery );
+          </script>
+        }.html_safe
+      end
+
+    end #Form
+  end
+end

data/app/helpers/gluttonberg/admin/messages.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+module Gluttonberg
+  module Admin
+    module Messages
+      # Renders model errors if there is any in Gluttonberg's default style
+      def gb_error_messages_for(model_object)
+        if model_object.errors.any?
+            lis = ""
+            model_object.errors.full_messages.each do |msg|
+              lis << content_tag(:li , msg)
+            end
+          ul = content_tag(:ul , lis.html_safe).html_safe
+          heading = content_tag(:h4 , "Sorry there was an error" , :class => "alert-heading" )
+          content_tag(:div , (heading.html_safe + ul.html_safe) , :class => "model-error alert alert-block alert-error")
+        end
+      end
+
+      # Renders flash messages (notice, warning and error) if there is any in Gluttonberg's default style
+      def render_flash_messages
+        html = ""
+        ["notice", "warning", "error"].each do |type|
+          unless flash[type.intern].nil?
+            html << content_tag("div", flash[type.intern].to_s.html_safe,
+              :id => "alert alert-#{type}", :class => "flash").html_safe
+          end
+        end
+        content_tag("div", html.html_safe, :id => "flash").html_safe
+      end
+    end
+  end
+end

data/app/helpers/gluttonberg/admin/versioning.rb

@@ -0,0 +1,196 @@
+module Gluttonberg
+  module Admin
+    module Versioning
+      # it renders a warning box with message and buttons for restoring/cancel  (warning about un saved version)
+      # if there is any auto save version exists.
+      def auto_save_version(object)
+        auto_save = AutoSave.where(:auto_save_able_id => object.id, :auto_save_able_type => object.class.name).first
+        if !auto_save.blank? && auto_save.updated_at > object.updated_at
+          render :partial => "/gluttonberg/admin/shared/auto_save_version" , :locals => {:object => object} , :formats => [:html]
+        end
+      end
+
+      # It renders warning for if user is viewing older revision of and object
+      def previous_version_warning(versions , selected_version_num)
+        if !versions.blank? && !selected_version_num.blank?
+          versions = versions.sort{|x,y| y.version <=> x.version}
+          if selected_version_num.to_i < versions.first.version
+            render :partial => "/gluttonberg/admin/shared/previous_version_warning" , :locals => {:selected_version_num => selected_version_num} , :formats => [:html]
+          end
+        end
+      end
+
+      # Enable auto save on a form
+      def auto_save(object)
+        "#{auto_save_js_tag(object)} \n #{auto_save_version(object)}".html_safe
+      end
+
+      def auto_save_js_tag(object)
+        delay = Gluttonberg::Setting.get_setting('auto_save_time')
+        unless delay.blank?
+          javascript_tag do
+            %{
+              $(document).ready(function(){
+                AutoSave.save("/admin/autosave/#{object.class.name}/#{object.id}", #{delay});
+              });
+            }.html_safe
+          end
+        end
+      end
+
+      # It shows 3 kind of warnings depending on case
+      # Reviewing Version xx: Submitted for approval
+      # Version xx: Waiting for approval
+      # Version xx: Unpublished revision 
+      def version_alerts(versions , selected_version_num, can_publish)
+        unless versions.blank?
+          versions = versions.order("version DESC")
+          your_revisions = []
+          submitted_for_approval = []
+          published_version = nil
+          viewing_waiting_for_approval = nil
+          versions.each do |version|
+            published_version = version if version.version_status == "published"
+            if (published_version.blank? || published_version.version < version.version)
+              if version.version != selected_version_num.to_i
+                submitted_for_approval << version if version.version_status == "submitted_for_approval"
+                your_revisions << version if version.version_status == "revision" && version.version_user_id == current_user.id
+              else
+                viewing_waiting_for_approval = version if version.version_status == "submitted_for_approval"
+              end
+            end
+          end
+          render :partial => "/gluttonberg/admin/shared/version_alerts", :locals => {
+            :submitted_for_approval => submitted_for_approval,
+            :your_revisions => your_revisions,
+            :can_publish => can_publish,
+            :viewing_waiting_for_approval => viewing_waiting_for_approval
+          }
+        end
+      end #version_alerts
+
+      def version_dashboard_notifications_data
+        submitted_content = []
+
+        _page_version_dashboard_notifications_data(submitted_content)
+        _blog_version_dashboard_notifications_data(submitted_content)
+        _custom_models_version_dashboard_notifications_data(submitted_content)
+
+        submitted_content.uniq! unless submitted_content.blank?
+        submitted_content = submitted_content.sort{|x,y| y[2].created_at <=>  x[2].created_at }
+      end
+
+      # this renders recently submitted contents(max 5 items). Its used on dashboard
+      def version_dashboard_notifications
+        if current_user.ability.can?(:publish, :any)
+          submitted_content = version_dashboard_notifications_data
+
+          more = (submitted_content.length > 5)
+          submitted_content = submitted_content[0..4] if more
+          render :partial => "/gluttonberg/admin/shared/version_dashboard_notifications", :locals => {
+            :submitted_content => submitted_content,
+            :more => more
+          }
+        end
+      end #version_alerts
+
+      private
+
+        def _page_version_dashboard_notifications_data(submitted_content)
+          Gluttonberg::Content::actual_content_classes.each do |klass|
+            uniq_key = klass.columns.map(&:name).include?('page_localization_id') ? :page_localization_id : :page_id
+            klass::Version.where(:version_status => ['submitted_for_approval']).select(uniq_key).uniq.all.each do |submitted_version|
+              object_id = (submitted_version.respond_to?(:page_localization_id) ? submitted_version.page_localization_id : submitted_version.page_id)
+              object = Gluttonberg::PageLocalization.where(:id => object_id).first
+              unless object.blank?
+                versions = object.versions
+                unless versions.blank?
+                  versions = _find_sorted_submitted_or_published_versions(versions)
+                  
+                  published_version = nil
+                  versions.each do |version|
+                    published_version = version if version.version_status == "published"
+                    if (published_version.blank? || published_version.version < version.version) 
+                      if version.version_status == "submitted_for_approval"
+                        path = edit_admin_page_page_localization_path( :page_id => object.page_id, :id => object.id) + "?version=#{version.version}"
+                        submitted_content << [object.name, path, version] 
+                        break
+                      end
+                    end
+                  end # versions loop
+                end
+              end
+            end
+          end # pages
+        end
+
+        def _blog_version_dashboard_notifications_data(submitted_content)
+          if Gluttonberg.constants.include?(:Blog) && Gluttonberg::Blog::Article
+            Gluttonberg::Blog::ArticleLocalization::Version.where(:version_status => ['submitted_for_approval']).includes(:article_localization).all.each do |submitted_version|
+              object = submitted_version.article_localization
+              versions = object.versions
+              unless versions.blank?
+                versions = _find_sorted_submitted_or_published_versions(versions)
+                published_version = nil
+                versions.each do |version|
+                  published_version = version if version.version_status == "published"
+                  if (published_version.blank? || published_version.version < version.version) 
+                    if version.version_status == "submitted_for_approval"
+                      path = edit_admin_blog_article_path( :blog_id => object.article.blog_id, :localization_id => object.id, :id => object.article.id, :version => version.version)
+                      submitted_content << [object.title, path, version] 
+                      break
+                    end
+                  end
+                end 
+              end
+            end
+          end # articles
+        end
+
+        def _custom_models_version_dashboard_notifications_data(submitted_content)
+          Gluttonberg::Components.nav_entries.each do |entry|
+            unless entry[4].blank?
+              _custom_model_version_dashboard_notifications_data(entry, submitted_content)
+            end
+          end # custom models
+        end
+
+        def _custom_model_version_dashboard_notifications_data(entry, submitted_content)
+          is_localized =  entry[4].constantize.respond_to?(:localized?) && entry[4].constantize.localized?
+          model_name = is_localized ? "#{entry[4]}Localization" : entry[4]
+          if model_name.constantize.versioned?
+            association = model_name.demodulize.underscore
+            query = model_name.constantize::Version.where(:version_status => ['submitted_for_approval']).includes(association)
+            query.all.each do |submitted_version|
+              _prepare_message_for_a_submission_of_custom_model(entry, is_localized, model_name, association, submitted_version, submitted_content)
+            end
+          end #versioned
+        end
+
+        def _prepare_message_for_a_submission_of_custom_model(entry, is_localized, model_name, association, submitted_version, submitted_content)
+          object = submitted_version.send(association)
+          versions = object.versions
+          unless versions.blank?
+            versions = _find_sorted_submitted_or_published_versions(versions)
+            published_version = nil
+            versions.each do |version|
+              published_version = version if version.version_status == "published"
+              if (published_version.blank? || published_version.version < version.version) 
+                if version.version_status == "submitted_for_approval"
+                  path = "#{url_for(entry[2])}/#{object.id}/edit" + "?version=#{version.version}#{is_localized ? "&locale_id=#{object.locale_id}" : ''}"
+                  submitted_content << [object.title_or_name?, path, version] 
+                  break
+                end
+              end
+            end 
+          end
+        end
+
+        def _find_sorted_submitted_or_published_versions(versions)
+          versions = versions.sort{|x, y| y.version <=> x.version}
+          versions = versions.find_all{|v| v.version_status == "published" ||  v.version_status == "submitted_for_approval"}
+        end
+
+    end #versioning
+  end
+end