Module: Gluttonberg::Admin

Included in:
ApplicationHelper
Defined in:
app/helpers/gluttonberg/admin.rb,
app/controllers/gluttonberg/admin/help_controller.rb,
app/controllers/gluttonberg/admin/main_controller.rb,
app/controllers/gluttonberg/admin/content/flag_controller.rb,
app/controllers/gluttonberg/admin/content/main_controller.rb,
app/controllers/gluttonberg/admin/content/blogs_controller.rb,
app/controllers/gluttonberg/admin/content/pages_controller.rb,
app/controllers/gluttonberg/admin/settings/main_controller.rb,
app/controllers/gluttonberg/admin/user_sessions_controller.rb,
app/controllers/gluttonberg/admin/settings/users_controller.rb,
app/controllers/gluttonberg/admin/membership/main_controller.rb,
app/controllers/gluttonberg/admin/password_resets_controller.rb,
app/controllers/gluttonberg/admin/content/articles_controller.rb,
app/controllers/gluttonberg/admin/content/comments_controller.rb,
app/controllers/gluttonberg/admin/settings/locales_controller.rb,
app/controllers/gluttonberg/admin/content/galleries_controller.rb,
app/controllers/gluttonberg/admin/membership/groups_controller.rb,
app/controllers/gluttonberg/admin/membership/members_controller.rb,
app/controllers/gluttonberg/admin/asset_library/assets_controller.rb,
app/controllers/gluttonberg/admin/settings/stylesheets_controller.rb,
app/controllers/gluttonberg/admin/settings/global_history_controller.rb,
app/controllers/gluttonberg/admin/asset_library/collections_controller.rb,
app/controllers/gluttonberg/admin/settings/generic_settings_controller.rb,
app/controllers/gluttonberg/admin/content/page_localizations_controller.rb

Overview

Helpers specific to the administration interface. The majority are related to forms, but there are other short cuts for things like navigation.

Defined Under Namespace

Modules: AssetLibrary, Content, Membership, Settings Classes: BaseController, HelpController, MainController, PasswordResetsController, UserSessionsController

Instance Method Summary collapse

Instance Method Details

#admin_form(obj, opts = {}, &blk) ⇒ Object

A form helper which automatically injects the form builder which automatically wraps the fields in divs.



7
8
9
10
 
# File 'app/helpers/gluttonberg/admin.rb', line 7

def admin_form(obj, opts = {}, &blk)
  opts.merge!(:builder => Gluttonberg::Helpers::FormBuilder)
  form_for(obj, opts, &blk)
end

#back_link(name, url) ⇒ Object

Writes out the back control for the sub nav.



143
144
145
 
# File 'app/helpers/gluttonberg/admin.rb', line 143

def back_link(name, url)
  content_tag(:li, link_to(name, url , :title => name), :id => "backLink")
end

#backend_logo(default_logo_image_path, html_opts = {}, thumbnail_type = :backend_logo) ⇒ Object 



295
296
297
298
299
300
301
302
303
304
 
# File 'app/helpers/gluttonberg/admin.rb', line 295

def (default_logo_image_path , html_opts={}, thumbnail_type = :backend_logo)
   = Gluttonberg::Setting.get_setting("backend_logo")
  asset = Asset.find(:first , :conditions => { :id =>  } )
  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

#block(label = nil, opts = {}, &blk) ⇒ Object

If it’s passed a label this method will return a fieldset, otherwise it will just return the contents wrapped in a block.



104
105
106
107
108
109
110
111
112
 
# File 'app/helpers/gluttonberg/admin.rb', line 104

def block(label = nil, opts = {}, &blk)
  if label
    field_set_tag(label) do
      content_tag(:fieldset, opts, &blk)
    end
  else
    content_tag(:fieldset, opts, &blk)
  end
end

#contextual_help ⇒ Object

Checks to see if there is a matching help page for this particular controller/action. If there is it renders a link to the help controller.



75
76
77
78
79
80
81
82
83
84
 
# File 'app/helpers/gluttonberg/admin.rb', line 75

def contextual_help

  if Help.help_available?(:controller => params[:controller], :page => params[:action])
    content_tag(
      :p,
      link_to("Help", admin_help_path(:module_and_controller => params[:controller], :page => params[:action]), :class => "button"),
      :id => "contextualHelp"
    )
  end
end

#current_domain ⇒ Object 



375
376
377
378
 
# File 'app/helpers/gluttonberg/admin.rb', line 375

def current_domain
  domain = "#{request.protocol}#{request.host_with_port}/"
  domain.strip
end

#custom_javascript_include_tag ⇒ Object 



255
256
257
258
259
 
# File 'app/helpers/gluttonberg/admin.rb', line 255

def custom_javascript_include_tag
  if Rails.configuration.custom_js_for_cms == true
    javascript_include_tag "custom"
  end
end

#custom_stylesheet_link_tag ⇒ Object 



249
250
251
252
253
 
# File 'app/helpers/gluttonberg/admin.rb', line 249

def custom_stylesheet_link_tag
  if Rails.configuration.custom_css_for_cms == true
    stylesheet_link_tag "custom"
  end
end

#date_format(date_time) ⇒ Object 



287
288
289
290
291
292
293
 
# File 'app/helpers/gluttonberg/admin.rb', line 287

def date_format(date_time)
  if date_time < 1.week.ago
    date_time.strftime("%d/%m/%Y")
  else
    time_ago_in_words(date_time)
  end
end

#form_controls(return_url, opts = {}) ⇒ Object

Controls for standard forms. Writes out a save button and a cancel link



115
116
117
118
 
# File 'app/helpers/gluttonberg/admin.rb', line 115

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

#gb_editable_field(object, property, options = {}) ⇒ Object

Creates an editable span for the given property of the given object.

Options

:method

Specify the HTTP method to use: 'PUT' or 'POST'.

:name

The name attribute to be used when the form is posted.

:update_url

The URL to submit the form to. Defaults to url_for(object).



329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
 
# File 'app/helpers/gluttonberg/admin.rb', line 329

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/spinner.gif')}'
          };
          $.extend(args, #{args.to_json});
          $(".editable[data-id='#{object.id}'][data-name='#{name}']").editable("#{update_url}", args);
        });
      })( jQuery );
    </script>
  }.html_safe
end

#gb_error_messages_for(model_object) ⇒ Object 



159
160
161
162
163
164
165
166
167
168
169
 
# File 'app/helpers/gluttonberg/admin.rb', line 159

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

#get_localized_value(name) ⇒ Object 



67
68
69
70
 
# File 'app/helpers/gluttonberg/admin.rb', line 67

def get_localized_value(name)
  @localized_model ||= current_form_context.instance_variable_get(:@obj)
  @localized_model.current_localization.send(name)
end

#honeypot_field_tag ⇒ Object 



281
282
283
284
285
 
# File 'app/helpers/gluttonberg/admin.rb', line 281

def honeypot_field_tag
  html = label_tag(Rails.configuration.honeypot_field_name , 'Please leave this field empty:' )
  html << text_field_tag( Rails.configuration.honeypot_field_name )
  content_tag :div , html , :class => Rails.configuration.honeypot_field_name , :style => "display:none"
end

#localization_field ⇒ Object

Returns a hidden field which stores the localization param in the form.



63
64
65
 
# File 'app/helpers/gluttonberg/admin.rb', line 63

def localization_field
  hidden_field(:name => "localization", :value => params[:localization])
end

#localization_picker(url) ⇒ Object

Returns a form for selecting the localized version of a record you want to edit. TODO DO we need that



15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
# File 'app/helpers/gluttonberg/admin.rb', line 15

def localization_picker(url)
  # Collect the locale/dialect pairs
  locales = ::Gluttonberg::Locale.all(:fields => [:id, :name])
  localizations = []
  locales.each do |locale|
      localizations << ["#{locale.id}", "#{locale.name}"]
  end
  # Output the form for picking the locale
  form(:action => url, :method => :get, :id => "select-localization") do
    output = ""
    output << select(:name => :localization, :collection => localizations, :label => "Select localization", :selected => params[:localization])
    output << button("Edit", :class => "buttonGrey")
  end
end

#localized_field_opts(name, set_value = true) ⇒ Object

Returns a hash of common options to be used in the localized versions of fields.



52
53
54
55
56
57
58
59
60
 
# File 'app/helpers/gluttonberg/admin.rb', line 52

def localized_field_opts(name, set_value = true)
  prefix = current_form_context.instance_variable_get(:@name)
  opts = {
    :name   => "#{prefix}[localized_attributes][#{name}]",
    :id     => "#{prefix}_localized_#{name}"
  }
  opts[:value] = get_localized_value(name) if set_value
  opts
end

#localized_text_area(name, opts = {}) ⇒ Object

Returns a text area with the name, id and values for the localized version of the specified attribute.



46
47
48
 
# File 'app/helpers/gluttonberg/admin.rb', line 46

def localized_text_area(name, opts = {})
  text_area(get_localized_value(name), localized_field_opts(name, false).merge!(opts))
end

#localized_text_field(name, opts = {}) ⇒ Object

Returns a text field with the name, id and values for the localized version of the specified attribute.



39
40
41
42
 
# File 'app/helpers/gluttonberg/admin.rb', line 39

def localized_text_field(name, opts = {})
  final_opts = localized_field_opts(name)
  text_field(final_opts.merge!(opts))
end

#main_nav_entry(text, mod, url = nil, opts = {}) ⇒ Object

Takes text and url and checks to see if the path specified matches the current url. This is so we can add a highlight.



149
150
151
152
153
154
155
156
157
 
# File 'app/helpers/gluttonberg/admin.rb', line 149

def main_nav_entry(text, mod, url = nil, opts = {})
  if url
    li_opts = {:id => "#{mod}Nav"}
    if( ( request.env["REQUEST_PATH"] && (request.env["REQUEST_PATH"].match(%r{/#{mod}}) || request.env["REQUEST_PATH"] == url) )  || (request.env["REQUEST_PATH"] && request.env["REQUEST_PATH"].include?("content") && request.env["REQUEST_PATH"] == url ) )
      li_opts[:class] = "current"
    end
    content_tag("li", link_to(text, url, opts), li_opts)
  end
end

#nav_link(*args) ⇒ Object

Writes out a link styled like a button. To be used in the sub nav only



136
137
138
139
140
 
# File 'app/helpers/gluttonberg/admin.rb', line 136

def nav_link(*args)
  class_names = "button"
  class_names = "#{class_names} #{args[2][:class]}" if args.length >= 3
  content_tag(:li, link_to(args[0] , args[1] , :title => args[0]), :class => class_names)
end

#page_localization_picker(page_localizations) ⇒ Object

Returns a form for selecting the localized version of a record you want to edit.



32
33
34
 
# File 'app/helpers/gluttonberg/admin.rb', line 32

def page_localization_picker(page_localizations)

end

#page_table_rows(pages, output = "", inset = 0, row = 0) ⇒ Object

Writes out a row for each page and then for each page’s children, iterating down through the heirarchy.



178
179
180
181
182
183
184
185
 
# File 'app/helpers/gluttonberg/admin.rb', line 178

def page_table_rows(pages, output = "", inset = 0 , row = 0)
  pages.each do |page|
    row += 1
    output << render( :partial => "gluttonberg/admin/content/pages/row", :locals => { :page => page, :inset => inset , :row => row })
    page_table_rows(page.children, output, inset + 1 , row)
  end
  output.html_safe
end

#publisable_dropdown(form, object) ⇒ Object 



188
189
190
191
192
193
 
# File 'app/helpers/gluttonberg/admin.rb', line 188

def publisable_dropdown(form ,object)
  val = object.state
  val = "ready" if val.blank? || val == "not_ready"
  @@workflow_states = [  [ 'Draft' , 'ready' ] , ['Published' , "published" ] , [ "Archived" , 'archived' ]  ]
  form.select( :state, options_for_select(@@workflow_states , val)   )
end

#publish_message(object, versions) ⇒ Object

shows publish message if object’s currect version is published



196
197
198
199
200
201
202
203
204
205
206
 
# File 'app/helpers/gluttonberg/admin.rb', line 196

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

#publishable_form_controls(return_url, object_name, is_published) ⇒ Object

Controls for publishable forms. Writes out a draft , publish/unpublish button and a cancel link



121
122
123
124
125
126
127
 
# File 'app/helpers/gluttonberg/admin.rb', line 121

def publishable_form_controls(return_url , object_name , is_published )
  content = hidden_field(:published , :value => false)
  content += "#{link_to("<strong>Cancel</strong>", return_url)}"
  content += " or #{submit_tag("draft")}"
  content += " or #{submit_tag("publish" , :onclick => "publish('#{object_name}_published')" )}"
  content_tag(:p, content, :class => "controls")
end

#render_flash_messages ⇒ Object 



306
307
308
309
310
311
312
313
314
315
316
 
# File 'app/helpers/gluttonberg/admin.rb', line 306

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

#slug_donotmodify_val ⇒ Object 



371
372
373
 
# File 'app/helpers/gluttonberg/admin.rb', line 371

def slug_donotmodify_val
  action_name == "edit"  || action_name == "update"
end

#sortable_column(column, title = nil) ⇒ Object 



363
364
365
366
367
368
369
 
# File 'app/helpers/gluttonberg/admin.rb', line 363

def sortable_column(column, title = nil)
  title ||= column.titleize
  css_class = column == sort_column ? "current #{sort_direction}" : nil
  direction = column == sort_column && sort_direction == "asc" ? "desc" : "asc"
  new_params = params.merge(:sort => column, :direction => direction)
  link_to title, new_params, {:class => css_class}
end

#sub_nav(&blk) ⇒ Object

Writes out a nicely styled subnav with an entry for each of the specified links.



131
132
133
 
# File 'app/helpers/gluttonberg/admin.rb', line 131

def sub_nav(&blk)
  content_tag(:ul, :id => "subnav", :class => "nav nav-pills", &blk)
end

#tab(label, url) ⇒ Object

For adding a tab to the tab bar. It will automatically mark the current tab by examining the request path.



94
95
96
97
98
99
100
 
# File 'app/helpers/gluttonberg/admin.rb', line 94

def tab(label, url)
  if request.env["REQUEST_PATH"] && request.env["REQUEST_PATH"].match(%r{^#{url}})
    content_tag(:li, link_to(label, url), :class => "current")
  else
    content_tag(:li, link_to(label, url))
  end
end

#tab_bar(&blk) ⇒ Object

TODO Do we need these? Generates a styled tab bar



88
89
90
 
# File 'app/helpers/gluttonberg/admin.rb', line 88

def tab_bar(&blk)
  content_tag(:ul, {:id => "tabBar"}, &blk)
end

#tags_string(tag_type) ⇒ Object 



267
268
269
270
271
272
273
274
275
276
277
278
 
# File 'app/helpers/gluttonberg/admin.rb', line 267

def tags_string(tag_type)
  @themes = ActsAsTaggableOn::Tag.find_by_sql(%{select DISTINCT tags.id , tags.name
    from tags inner join taggings on tags.id = taggings.tag_id
    where context = '#{tag_type}'
  })
  output = ""
  @themes.each do |theme|
    output << "," unless output.blank?
    output << theme.name
  end
  output
end

#version_listing(versions, selected_version_num) ⇒ Object 



208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
 
# File 'app/helpers/gluttonberg/admin.rb', line 208

def version_listing(versions , selected_version_num)
  unless versions.blank?
    output = "<div class='historycontrols'>"
    selected = versions.last.version
    selected_version = versions.last
    collection = []
    versions.each do |version|
      link = version.version
      snippet = "Version #{version.version} - #{version.updated_at.to_s(:long)}  " unless version.updated_at.blank?
      if version.version.to_i == selected_version_num.to_i
        selected = link
        selected_version = version
      end
      collection << [snippet , link]
    end

    # Output the form for picking the version
    versions_html = "<ul class='dropdown-menu'>"
    collection.each do |c|
      versions_html << content_tag(:li , link_to(c[0] , "?version=#{c[1]}") , :class => "#{c[1].to_s == selected.to_s ? 'active' : '' }" )
    end
    versions_html << "</ul>"

    current_version = '<a class="btn dropdown-toggle" data-toggle="dropdown" href="#">'
    current_version += "Editing Version #{selected_version.version} "
    current_version += '<span class="caret"></span>'
    current_version += '</a>'

    combined_versions = current_version
    combined_versions += versions_html

    output << content_tag(:div , combined_versions.html_safe, :class => "btn-group" )

    output += "</div>"
    output += "<div class='clear'></div>"
    output += "<br />"
    output += "<br />"
    output.html_safe
  end
end

#website_title ⇒ Object 



171
172
173
174
 
# File 'app/helpers/gluttonberg/admin.rb', line 171

def website_title
  title = Gluttonberg::Setting.get_setting("title")
  (title.blank?)? "Gluttonberg" : title.html_safe
end

#wysiwyg_js_css_link_tag ⇒ Object 



261
262
263
264
265
 
# File 'app/helpers/gluttonberg/admin.rb', line 261

def wysiwyg_js_css_link_tag
  if Gluttonberg::Setting.get_setting("enable_WYSIWYG") == "Yes"
    javascript_include_tag("/assets/tiny_mce/jquery.tinymce.js")
  end
end