locomotivecms 3.0.0.pre.alpha

data/app/helpers/locomotive/content_assets_helper.rb

@@ -0,0 +1,31 @@
+module Locomotive
+  module ContentAssetsHelper
+
+    def image_resize_form(content_asset)
+      Locomotive::ImageResizeForm.new(
+        width:  content_asset.width,
+        height: content_asset.height
+      )
+    end
+
+    def asset_with_thumbnail?(asset)
+      %w(image pdf).include?(asset.content_type)
+    end
+
+    def asset_filename(asset)
+      truncate(asset.source_filename, length: 28)
+    end
+
+    def asset_text(asset)
+      extname = truncate(asset.extname, length: 3)
+      value = asset.content_type.to_s == 'other' ? extname : asset.content_type
+      value.blank? ? '?' : value
+    end
+
+  end
+
+  class ImageResizeForm
+    include ActiveModel::Model
+    attr_accessor :width, :height
+  end
+end

data/app/helpers/locomotive/content_entries_helper.rb

@@ -0,0 +1,71 @@
+module Locomotive
+  module ContentEntriesHelper
+
+    # Display the name of the account (+ avatar) who created or updated the content entry
+    # as well as the date when it happened.
+    #
+    # @param [ Object ] entry The content entry instance
+    #
+    # @return [ String ] The html output
+    #
+    def content_entry_stamp(entry)
+      distance = time_ago_in_words(entry.updated_at)
+
+      if account = entry.updated_by || entry.created_by
+        profile = account_avatar_and_name(account, '40x40#')
+        key     = entry.updated_by ? :updated_by : :created_by
+        t(key, scope: 'locomotive.content_entries.index', distance: distance, who: profile)
+      else
+        t('locomotive.content_entries.index.updated_at', distance: distance)
+      end
+    end
+
+    # Display the label related to a field of a content entry.
+    # If the field is not localized, we just display the label.
+    # If the field is localized, then we display a nice flag icon
+    # to let the end-user know about it.
+    #
+    # @param [ Object ] entry The content entry
+    # @param [ Object ] field The custom field
+    #
+    # @return [ String ] The label with or without the icon
+    #
+    def label_for_custom_field(entry, field)
+      if field.localized?
+        translated_css = entry.translated_field?(field) ? '' : 'untranslated'
+
+        icon  = content_tag(:i, '', class: 'icon-flag')
+        tag   = content_tag(:span, icon, class: "localized-icon #{translated_css}")
+        "#{tag}#{field.label}"
+      else
+        field.label
+      end
+    end
+
+    # List the labels and url of "groups" used to group the entries
+    # of a content type. 2 sources:
+    # - from a select field
+    # - from a belongs_to field
+    #
+    # @param [ Object ] content_type The content type
+    #
+    # @return [ Array ] The list of labels and urls (Hash)
+    #
+    def each_content_entry_group(content_type, &block)
+      field   = content_type.group_by_field
+      groups  = content_type.list_of_groups || []
+
+      groups.each do |group|
+        block.call({
+          name: group[:name],
+          url:  content_entries_path(current_site, content_type.slug, {
+            group:  group[:name],
+            where:  %({"#{field.name}_id": "#{group[:_id]}"}),
+            q:      params[:q]
+          })
+        })
+      end
+    end
+
+  end
+end

data/app/helpers/locomotive/content_types_helper.rb

@@ -0,0 +1,46 @@
+module Locomotive
+  module ContentTypesHelper
+
+    # Renders the label of a content type entry. If no raw_item_template filled in the content type,
+    # it just calls the _label method of the entry (based on the label_field_id). Otherwise, it
+    # parses and renders the liquid template.
+    #
+    # @param [ ContentType ] content_type The content type for better performance
+    # @param [ ContentEntry] entry The entry we want to display the label
+    #
+    # @return [ String ] The label of the content type entry
+    #
+    def entry_label(content_type, entry)
+      if content_type.raw_item_template.blank?
+        entry._label # default one
+      else
+        assigns = { 'site' => current_site, 'entry' => entry }
+
+        registers = {
+          controller:     self,
+          site:           current_site,
+          current_locomotive_account:  current_locomotive_account,
+          asset_host:     Locomotive::Liquid::AssetHost.new(request, current_site, Locomotive.config.asset_host)
+        }
+
+        preserve(content_type.item_template.render(::Liquid::Context.new({}, assigns, registers)))
+      end
+    end
+
+    # List the fields which could be used to filter the content entries
+    # in the back-office.
+    # Not all the types are included. Only: string, text, integer, float, email
+    #
+    # @param [ ContentType ] content_type The content type owning the fields
+    #
+    # @return [ Array ] Used as it by the select_tag method
+    #
+    def options_for_filter_fields(content_type)
+      allowed_types = %w(string text integer float email)
+      fields = content_type.entries_custom_fields.where(:type.in => allowed_types)
+
+      fields.map { |field| [field.label, field._id] }
+    end
+
+  end
+end

data/app/helpers/locomotive/custom_fields_helper.rb

@@ -0,0 +1,190 @@
+module Locomotive
+  module CustomFieldsHelper
+
+    # Render all the form inputs based on the fields of a content type.
+    #
+    # @param [ Object ] content_type The content type the fields belong to
+    # @param [ Object ] form The SimpleForm form instance
+    #
+    # @return [ String ] The form inputs
+    #
+    def render_custom_fields(content_type, form)
+      html = content_type.ordered_entries_custom_fields.map do |field|
+        render_custom_field(field, form)
+      end
+
+      html.join("\n").html_safe
+    end
+
+    # Render the form input based on the type of the field.
+    #
+    # @param [ Object ] field The field part of the content type
+    # @param [ Object ] form The SimpleForm form instance
+    #
+    # @return [ String ] The form input
+    #
+    def render_custom_field(field, form)
+      highlighted     = field._id == field._parent.label_field_id
+      default_options = default_custom_field_options(field, form, highlighted)
+      field_options   = custom_field_options(field, form)
+
+      return '' if field_options.nil?
+
+      options = default_options.merge(field_options)
+
+      form.input options.delete(:name), options
+    end
+
+    def custom_field_options(field, form)
+      method = "#{field.type}_custom_field_options"
+
+      begin
+        send(method, field, form.object)
+      rescue NoMethodError
+        nil
+      end
+    end
+
+    def default_custom_field_options(field, form, highlighted)
+      {
+        name:   field.name,
+        label:  label_for_custom_field(form.object, field),
+        hint:   field.hint,
+        wrapper_html: {
+          class: "#{'highlighted' if highlighted}"
+        }
+      }
+    end
+
+    def belongs_to_custom_field_options(field, entry)
+      slug      = field.class_name_to_content_type.slug
+      target_id = entry.send(:"#{field.name}_id")
+
+      {
+        as:       :document_picker,
+        edit:     {
+          label:  custom_field_t(:edit, field.type),
+          url:    target_id ? edit_content_entry_path(current_site, slug, target_id, _location: false) : nil
+        },
+        picker:   custom_field_picker_options(field, slug)
+      }
+    end
+
+    def boolean_custom_field_options(field, entry)
+      { as: :toggle }
+    end
+
+    def date_custom_field_options(field, entry)
+      _date_custom_field_options(field, 'calendar', 'date', date_moment_format)
+    end
+
+    def date_time_custom_field_options(field, entry)
+      _date_custom_field_options(field, 'clock-o', 'date-time', datetime_moment_format)
+    end
+
+    def _date_custom_field_options(field, icon, css, format)
+      {
+        name:         :"formatted_#{field.name}",
+        append:       icon_tag("fa-#{icon}"),
+        wrapper_html: { class: css },
+        input_html:   {
+          data:       { format: format },
+          maxlength:  10
+        }
+      }
+    end
+
+    def email_custom_field_options(field, entry)
+      { as: :email }
+    end
+
+    def file_custom_field_options(field, entry)
+      { as: :file }
+    end
+
+    def float_custom_field_options(field, entry)
+      { as: :float, step: 0.1 }
+    end
+
+    def has_many_custom_field_options(field, entry)
+      return nil if entry.new_record? || !field.ui_enabled?
+
+      slug = field.class_name_to_content_type.slug
+
+      {
+        as:           :array,
+        template:     {
+          path:   'locomotive/content_entries/entry',
+          locals: { field: field, slug: slug }
+        },
+        wrapper_html: { class: 'has_many' },
+        new_item: {
+          label:  custom_field_t(:new_label, field.type),
+          url:    new_content_entry_path(current_site, slug, {
+            "content_entry[#{field.inverse_of}_id]" => entry._id,
+            _location: false
+          })
+        }
+      }
+    end
+
+    def integer_custom_field_options(field, entry)
+      { as: :integer }
+    end
+
+    def many_to_many_custom_field_options(field, entry)
+      slug = field.class_name_to_content_type.slug
+
+      {
+        as:           :array,
+        collection:   entry.send(field.name).filtered,
+        template:     {
+          path:   'locomotive/content_entries/entry',
+          locals: { field: field, slug: slug }
+        },
+        template_url: show_in_form_content_entries_path(current_site, slug, parent_slug: entry.content_type.slug, field_id: field._id),
+        picker:       custom_field_picker_options(field, slug)
+      }
+    end
+
+    def select_custom_field_options(field, entry)
+      {
+        name:         "#{field.name}_id",
+        as:           :editable_select,
+        collection:   field.ordered_select_options.map { |option| [option.name, option.id] },
+        manage_collection:    {
+          label:  custom_field_t(:edit, field.type),
+          url:    edit_custom_fields_select_options_path(current_site, entry.content_type.slug, field.name)
+        }
+      }
+    end
+
+    def string_custom_field_options(field, entry)
+      { as: :string }
+    end
+
+    def tags_custom_field_options(field, entry)
+      { wrapper_html: { class: 'tags' } }
+    end
+
+    def text_custom_field_options(field, entry)
+      { as: field.text_formatting ? :rte : :text }
+    end
+
+    def custom_field_picker_options(field, slug)
+      {
+        label_method: :_label,
+        list_url:     content_entries_path(current_site, slug, format: :json),
+        placeholder:  custom_field_t(:placeholder, field.type, name: field.label.downcase),
+        searching:    custom_field_t(:searching, field.type),
+        no_matches:   custom_field_t(:no_matches, field.type),
+        too_short:    custom_field_t(:too_short, field.type)
+      }
+    end
+
+    def custom_field_t(name, type, interpolation = {})
+      t(name, { scope: ['locomotive.custom_fields.types', type] }.merge(interpolation))
+    end
+
+  end
+end

data/app/helpers/locomotive/installation_helper.rb

@@ -0,0 +1,9 @@
+module Locomotive
+  module InstallationHelper
+
+    def next_installation_step_link(step = 1, label = nil)
+      link_to(label || t('admin.installation.common.next'), installation_step_path(step), class: 'btn btn-block btn-danger')
+    end
+
+  end
+end

data/app/helpers/locomotive/memberships_helper.rb

@@ -0,0 +1,19 @@
+module Locomotive
+  module MembershipsHelper
+
+    def options_for_membership_roles(membership)
+      current_role = membership.role
+
+      [].tap do |options|
+        Locomotive::Membership::ROLES.each do |role|
+          membership.role = role
+          if policy(membership).change_role?
+            options << [t("locomotive.memberships.roles.#{role}"), role.to_s]
+          end
+        end
+        membership.role = current_role
+      end
+    end
+
+  end
+end

data/app/helpers/locomotive/my_account_helper.rb

@@ -0,0 +1,17 @@
+module Locomotive
+  module MyAccountHelper
+
+    def options_for_locale
+      Locomotive.config.locales.map do |locale|
+        flag_url = path_to_image "locomotive/icons/flags/#{locale}.png"
+
+        [
+          I18n.t("locomotive.locales.#{locale}"),
+          locale,
+          { :"data-flag" => flag_url }
+        ]
+      end
+    end
+
+  end
+end

data/app/helpers/locomotive/pages_helper.rb

@@ -0,0 +1,61 @@
+module Locomotive
+  module PagesHelper
+
+    def parent_pages_options
+      [].tap do |list|
+        build_page_tree.each do |(page, children)|
+          next if page.not_found?
+
+          add_children_to_options(page, children, list)
+        end
+      end
+    end
+
+    def add_children_to_options(page, children, list)
+      return list if page.parent_ids.include?(@page.id) || page == @page
+
+      offset = '- ' * (page.depth || 0) * 2
+
+      list << ["#{offset}#{page.title}", page.id]
+
+      if children
+        children.each { |(_page, _children)| add_children_to_options(_page, _children, list) }
+      end
+
+      list
+    end
+
+    # def display_page_layouts?
+    #   ((@page.persisted? && @page.allow_layout?) || !@page.persisted?) &&
+    #   !current_site.pages.layouts.empty?
+    # end
+
+    # def options_for_page_layouts
+    #   layouts = current_site.pages.layouts.map do |_layout|
+    #     [_layout.title, _layout._id]
+    #   end
+    #   [[t('.no_layout'), nil]] + layouts
+    # end
+
+    # def options_for_page_response_type
+    #   [
+    #     ['HTML', 'text/html'],
+    #     ['RSS', 'application/rss+xml'],
+    #     ['XML', 'text/xml'],
+    #     ['JSON', 'application/json']
+    #   ]
+    # end
+
+    # def options_for_page_redirect_type
+    #   [
+    #     [t('.redirect_type.permanent'), 301],
+    #     [t('.redirect_type.temporary'), 302]
+    #   ]
+    # end
+
+    # def page_response_type_to_string(page)
+    #   options_for_page_response_type.detect { |t| t.last == page.response_type }.try(:first) || '&mdash;'
+    # end
+
+  end
+end