coalla-cms 0.5.1.8

data/app/helpers/admin_helper.rb

@@ -0,0 +1,29 @@
+module AdminHelper
+
+  def admin_paginate(collection, options={})
+    will_paginate collection, {renderer: BootstrapLinkRenderer, inner_window: 2}.merge(options)
+  end
+
+  def render_slides(form, title, collection_name, options = {})
+    slider_class = options.delete(:slider_class_name) || SliderImage
+    multiple = options.has_key?(:multiple) ? options.delete(:multiple) : true
+    edit_allowed = options.has_key?(:edit_allowed) ? options.delete(:edit_allowed) : true
+    render 'admin/common/slides', form: form, title: title, slides: collection_name, slider_class: slider_class, multiple: multiple, edit_allowed: edit_allowed
+  end
+
+  def generate_slider_template(form_builder, options = {})
+    escape_javascript(generate_slider_html(form_builder, options))
+  end
+
+  def generate_slider_html(form_builder, options = {})
+    options[:object] ||= options[:class].new
+    options[:form_builder_local] ||= :lb
+    options[:locals] ||= {}
+
+    collection_name = options[:collection]
+    form_builder.fields_for(collection_name, options[:object], child_index: 'NEW_RECORD') do |f|
+      render(partial: options[:partial], locals: options[:locals].merge({options[:form_builder_local] => f}))
+    end
+  end
+
+end

data/app/helpers/common_helper.rb

@@ -0,0 +1,22 @@
+require 'standalone_typograf'
+
+module CommonHelper
+
+  def copyright(start_year)
+    current_year = Date.today.year
+    if current_year > start_year
+      "#{start_year} - #{current_year}".html_safe
+    else
+      "#{current_year}"
+    end
+  end
+
+  def hide_style(style)
+    'display: none;' + style
+  end
+
+  def ty(text)
+    ::StandaloneTypograf::Typograf.new(text, mode: :html).prepare.html_safe
+  end
+
+end

data/app/helpers/lookup_helper.rb

@@ -0,0 +1,72 @@
+module LookupHelper
+
+  def lookup(code, default = nil, &block)
+    _lookup(code, 'string', default, &block)
+  end
+
+  def integer_lookup(code, default = nil, &block)
+    _lookup(code, 'integer', default, &block).to_i
+  end
+
+  def float_lookup(code, default = nil, &block)
+    _lookup(code, 'float', default, &block).to_f
+  end
+
+  def boolean_lookup(code, default = nil, &block)
+    _lookup(code, 'boolean', default, &block) == '1'
+  end
+
+  def enum_lookup_value(code, default = nil, &block)
+    _lookup(code, 'enum', default, &block).to_sym
+  end
+
+  def file_lookup(code)
+    Lookup.find_by(code: code, type_code: 'file')
+  end
+
+  def enum_lookup_text(code)
+    value = enum_lookup_value(code)
+    return if value.blank?
+    l = Lookup.where(code: code, type_code: 'enum').first
+    l.value_options[value]
+  end
+
+  def memo_lookup(code, default = nil, &block)
+    sf(unsafe_memo_lookup(code, default, &block))
+  end
+
+  def unsafe_memo_lookup(code, default = nil, &block)
+    _lookup(code, 'memo', default, &block)
+  end
+
+  def wysiwyg_lookup(code, default = nil, &block)
+    raw(_lookup(code, 'wysiwyg', default, &block))
+  end
+
+  def lookup_name(code)
+    t("lookups.#{code}")
+  end
+
+  def sf(text)
+    h(text).gsub("\n", "<br/>").html_safe
+  end
+
+  private
+
+  def _lookup(code, type, default, &block)
+    l = Lookup.where(code: code, type_code: type).first
+    return l.value if l
+
+    value = if block.present?
+              capture(self, &block)
+            else
+              default
+            end
+    value = value.strip if value
+
+    l = Lookup.create!(code: code, value: value, type_code: type)
+
+    l.reload.value
+  end
+
+end

data/app/helpers/nested_fields_helper.rb

@@ -0,0 +1,12 @@
+module NestedFieldsHelper
+
+  def link_to_add_fields(name, builder, association)
+    new_object = builder.object.send(association).klass.new
+    id = new_object.object_id
+    fields = builder.fields_for(association, new_object, child_index: id) do |builder|
+      render 'admin/common/nested_fields_for_element',  builder: builder, partial: "#{association.to_s.singularize}_fields"
+    end
+    link_to(name, '#', class: 'add_fields btn btn-success', data: {id: id, fields: fields.gsub("\n", '')})
+  end
+
+end

data/app/helpers/static_text_formatter.rb

@@ -0,0 +1,25 @@
+class StaticTextFormatter
+
+  def initialize(object)
+    @object = object
+    @columns = @object.class.columns.index_by(&:name).with_indifferent_access
+  end
+
+  def format(method)
+    method_value = @object.send(method)
+    if method_value
+      if @columns[method]
+        method_type = @columns[method].type
+        if method_type == :datetime
+          method_value = method_value.localtime if method_value.respond_to?(:localtime)
+          Russian.strftime(method_value, '%d.%m.%Y %H:%M')
+        else
+          method_value
+        end
+      else
+        method_value
+      end
+    end
+  end
+
+end

data/app/helpers/twitter_builder_helper.rb

@@ -0,0 +1,253 @@
+#encoding: utf-8
+module TwitterBuilderHelper
+
+  ALIGN_CLASSES = {left: 't-left', center: 't-center', right: 't-right'}
+
+  class ColumnDefinition
+    attr_accessor :title, :cols, :col_class, :value_extractor, :align
+
+    def value(item, context = self)
+      self.value_extractor.call(item)
+    end
+
+  end
+
+  class ActionsColumnDefinition < ColumnDefinition
+
+    def initialize
+      self.title = I18n.t('admin.common.actions')
+      @actions = []
+    end
+
+    def cols
+      @cols || @actions.size % 2 + @actions.size / 2
+    end
+
+    def col_class
+      "col-xs-#{cols}"
+    end
+
+    def cols=(value)
+      @cols = value
+    end
+
+    def value(item, context = self)
+      @actions.collect do |action|
+        options = action.second
+        if options[:if]
+          context.instance_exec(item, &action.first) if options[:if].call(item)
+        else
+          context.instance_exec(item, &action.first)
+        end
+      end.compact.join(' ').html_safe
+    end
+
+    def action(method, options = {})
+      @actions << case method
+                    when :edit
+                      [->(item) { edit_link(send("edit_admin_#{item.class.name.underscore.sub('/', '_')}_path", item)) }, options]
+                    when :delete
+                      [->(item) { delete_link([:admin, item]) }, options]
+                    when Proc
+                      [method, options]
+                    else
+                      raise "unsupported method: #{method.inspect}"
+                  end
+    end
+
+  end
+
+  class TableBuilder
+
+    def initialize(parent, model_class)
+      @parent, @model_class = parent, model_class
+      @columns = []
+      @actions_column = ActionsColumnDefinition.new
+      @action_column_on_left = false
+      @table_helpers = TableHelpers.for(@model_class, @parent)
+    end
+
+    def content collection, &block
+      @collection = collection
+      block.call(self) if block_given?
+      create_content
+    end
+
+    # Метод добавляет столбец к таблице
+    def column(method, options = {})
+      helper = @table_helpers[method]
+      cd = ColumnDefinition.new
+      cd.title = options[:title] || I18n.t("activerecord.attributes.#{@model_class.model_name.singular}.#{method}")
+      cd.cols = options[:cols]
+      cd.col_class = options[:class]
+      cd.value_extractor = ->(item) { helper.format_value(item, options[:format]) }
+      cd.align = options[:align] || helper.respond_to?(:align) && "t-#{helper.align}"
+      @columns << cd
+    end
+
+    # Метод позволяет передать блок, который должен вычислять класс для строки. В этот блок передается объект,
+    # по которому данная строка рендерится. Таким образом, можно управлять, например, цветом строки в зависимости
+    # от состояния объекта (статусы заказов и прочее).
+    def row_class lmb
+      @row_class = lmb
+    end
+
+    # Метод добавляет кнопку в столбец действий
+    def action(value, options = {})
+      add_action(value, options)
+    end
+
+    # Метод добавляет кнопку редактирования сущности в столбец действий
+    def edit(options = {})
+      add_action(:edit, options)
+    end
+
+    # Метод добавляет кнопку удаления сущности в столбец действий
+    def delete(options = {})
+      add_action(:delete, options)
+    end
+
+    # Метод добавляет кнопки добавления и удаления сущностей в столбец действий
+    def edit_and_delete(options = {})
+      self.edit(options)
+      self.delete(options)
+    end
+
+    private
+
+    def add_action(value, options)
+      @action_column_on_left = true if @columns.empty?
+      @actions_column.action(value, options)
+    end
+
+    def all_columns
+      @action_column_on_left ? [@actions_column] + @columns : @columns + [@actions_column]
+    end
+
+    def create_content
+      @parent.render(partial: '/admin/common/table_template', locals: {definitions: all_columns, items: @collection, row_class: @row_class})
+    end
+  end
+
+  def twitter_form_for(name, *args, &block)
+    options = args.extract_options!
+    form_for(name, *(args << options.deep_merge(builder: TwitterFormBuilder, html: {class: 'form-horizontal'})), &block)
+  end
+
+  def field_set title = nil, &block
+    content = capture(self, &block)
+    content = content_tag(:legend, title) + content if title
+    content_tag :fieldset, content
+  end
+
+  def actions &block
+    content = capture(self, &block)
+    content_tag :div, content, class: 'well'
+  end
+
+  def standard_actions(form)
+    fixed_actions { form.save + form.apply + form.cancel }
+  end
+
+  def fixed_actions &block
+    panel_tag = actions(&block)
+    content_tag :div, panel_tag, class: 'action-bar'
+  end
+
+  def flash_warning_messages
+    r = if flash[:admin_warning]
+          "<div class='row'>
+            <div class='col-md-8 col-md-offset-2'>
+              <div class='alert alert-danger'>
+                <button data-dismiss='alert' class='close' type='button'>&times;</button>
+                <p>#{h(flash[:admin_warning])}</p>
+              </div>
+            </div>
+          </div>"
+        end
+    r && r.html_safe
+  end
+
+  def flash_alert_messages
+    r = if flash[:alert]
+          "<div class='row'>
+            <div class='col-md-8 col-md-offset-2'>
+              <div class='alert alert-danger'>
+                <button data-dismiss='alert' class='close' type='button'>&times;</button>
+                <p>#{h(flash[:alert])}</p>
+              </div>
+            </div>
+          </div>"
+        end
+    r && r.html_safe
+  end
+
+  def flash_success_messages
+    r = if flash[:admin_success]
+          "<div class='row'>
+            <div class='col-md-8 col-md-offset-2'>
+              <div class='alert alert-success'>
+                <button data-dismiss='alert' class='close' type='button'>&times;</button>
+                <p>#{h(flash[:admin_success])}</p>
+              </div>
+            </div>
+          </div>"
+        end
+    r && r.html_safe
+  end
+
+  def flash_messages
+    [flash_warning_messages, flash_success_messages].compact.join.html_safe
+  end
+
+  def create_link path
+    content = "<i class='glyphicon glyphicon-plus'></i>&nbsp;&nbsp;#{I18n.t('admin.common.new')}".html_safe
+    link_to content, path, class: 'btn btn-success'
+  end
+
+  def sort_link path
+    content = "<i class='glyphicon glyphicon-random'></i>&nbsp;&nbsp;#{I18n.t('admin.common.sort')}".html_safe
+    link_to content, path, class: 'btn btn-primary'
+  end
+
+  def edit_link path
+    content = "<i class='glyphicon glyphicon-pencil'></i>".html_safe
+    link_to content, path, class: 'btn btn-default btn-xs', title: I18n.t('admin.common.edit')
+  end
+
+  def delete_link path
+    content = "<i class='glyphicon glyphicon-trash'></i>".html_safe
+    link_to content, path, data: {confirm: I18n.t('admin.common.sure')}, method: :delete, class: 'btn btn-danger btn-xs', title: I18n.t('admin.common.delete')
+  end
+
+  def cancel_action path, name = I18n.t('admin.common.cancel')
+    link_to name, path, class: 'btn btn-default'
+  end
+
+  def back_action name = I18n.t('admin.common.return'), path = back_uri
+    link_to name, path, class: 'btn btn-default'
+  end
+
+  def table_for a_class
+    TableBuilder.new(self, a_class)
+  end
+
+  def th_class(column)
+    klass = []
+    klass << "col-xs-#{column.cols}" if column.cols
+    klass << ALIGN_CLASSES[column.align] if column.align
+    klass.join(' ')
+  end
+
+  def tr_class(row_class, item)
+    row_class && row_class.call(item)
+  end
+
+  def td_class(column)
+    klass = []
+    klass << column.col_class
+    klass << ALIGN_CLASSES[column.align] if column.align
+    klass.join(' ')
+  end
+
+end

data/app/helpers/twitter_form_builder.rb

@@ -0,0 +1,202 @@
+#encoding: utf-8
+class TwitterFormBuilder < ActionView::Helpers::FormBuilder
+  include ActionView::Helpers::FormTagHelper
+
+  COLS_CLASS = 'col-md-8'
+
+  def errors
+    return nil unless @object.errors.any?
+
+    messages = @object.errors.full_messages.collect do |msg|
+      "<p>#{ERB::Util.h(msg)}</p>".html_safe
+    end
+
+    content_tag(:div,
+                content_tag(:div,
+                            content_tag(:div,
+                                        content_tag(:button, '&times;'.html_safe, class: 'close', type: 'button', :'data-dismiss' => 'alert') + messages.join('').html_safe,
+                                        class: 'alert alert-danger'),
+                            class: 'col-md-8 col-md-offset-2'),
+                class: 'row')
+  end
+
+  def static_text(method, options = {})
+    row method, content_tag(:p, static_text_formatter.format(method), class: 'form-control-static'), options
+  end
+
+  # Displays multi-line static text in form
+  def static_memo_text(method, options = {})
+    row method, simple_format(@object.send(method), class: 'form-control-static'), options
+  end
+
+  def string method, options = {}
+    row method, text_field(method, with_default_options(options)), options
+  end
+
+  def combobox method, choices, options = {}, html_options = {}
+    row method, select(method, choices, options, with_default_options(html_options)), div_class: options.delete(:div_class) || 'col-md-6'
+  end
+
+  def enum(method, options = {}, html_options = {})
+    combobox method, object.class.send(method.to_s.pluralize).collect { |s| [s[0].humanize, s[0]] }, options, html_options
+  end
+
+  def enumerize(method, options = {}, html_options = {})
+    combobox method, object.class.send(method).values.collect { |s| [s.text, s] }, options, html_options
+  end
+
+  def list_all_combobox(association_name, options = {}, html_options = {})
+    collection_class = object.class.reflect_on_association(association_name).klass
+    combobox("#{association_name}_id", collection_class.all.sort_by(&:name).map { |element| [element.name, element.id] }, {include_blank: true}.merge(options), html_options)
+  end
+
+  def textarea method, options = {}
+    row method, text_area(method, with_default_options(options)), options
+  end
+
+  def checkbox method, options = {}
+    row method, content_tag(:div, check_box(method, options), class: 'checkbox'), options
+  end
+
+  def wysiwyg method, options = {}
+    textarea method, with_default_options(merge_classes(options, 'wymeditor'))
+  end
+
+  def ckeditor(method, options = {})
+    row method, cktext_area(method, with_default_options(options))
+  end
+
+  def password method, options = {}
+    row method, password_field(method, with_default_options(options)), options
+  end
+
+  def date method, options = {}
+    string(method, merge_options({data: {'calendar-date' => true}, div_class: 'col-md-2'}, options))
+  end
+
+  def datetime(method, options = {})
+    value = object.try(method).try(:strftime, '%Y-%m-%d %H:%M')
+    string(method, merge_options({data: {'calendar-datetime' => true}, div_class: 'col-md-3', value: value}, options))
+  end
+
+  def time(method, options = {})
+    value = object.try(method).try(:strftime, '%H:%M')
+    string(method, merge_options({data: {'calendar-time' => true}, div_class: 'col-md-2', value: value}, options))
+  end
+
+  def save text = I18n.t('admin.common.save')
+    submit text, name: :save, class: 'btn btn-success wymupdate'
+  end
+
+  def apply text = I18n.t('admin.common.apply')
+    submit text, name: :apply, class: 'btn btn-default wymupdate'
+  end
+
+  def cancel
+    @template.back_action
+  end
+
+  # Editing has_many collection
+  # parameters: association - name of has_many association
+  # association should be defined as accepts_nested_attributes with allow_destroy = true in model
+  # You should create partial with name #{association)_fields
+  def nested_fields_for(association)
+    @template.render 'admin/common/nested_fields_for', f: self, section_name: @object.class.human_attribute_name(association), collection: association
+  end
+
+  def image_upload method, options = {}
+    version = options[:version]
+
+    uri = if version.present?
+            @object.send("#{method}_url", version)
+          else
+            @object.send("#{method}_url")
+          end
+
+    if options[:size]
+      url = uri || 'placeholder'
+    else
+      url = uri
+    end
+
+    upload_uri = options[:upload_path]
+    unless upload_uri
+      upload_uri = @template.admin_upload_image_path(image_class: @object.class.name.underscore, field: method)
+    end
+    @template.render partial: '/admin/common/image_upload_template', locals: {
+        f: self, url: url, size: options[:size],
+        version: version || '',
+        title: options[:title] || '',
+        text: options[:text],
+        field: method, upload_uri: upload_uri,
+        container: options[:parent_id] || upload_container_id(method),
+        options: options.delete(:options) || {},
+        image_style: options.delete(:image_style) || ''
+    }
+  end
+
+  def file_upload method
+    @template.render partial: '/admin/common/file_upload_template', locals: {
+        f: self,
+        field: method
+    }
+  end
+
+  def multi_field(relation_name, options = {})
+    reflection = self.object.class.reflections[relation_name] || self.object.class.reflections[relation_name.to_s]
+    options = {search_field_name: :name,
+               show_all_on_focus: false,
+               use_cache: true,
+               relation_model_name: reflection.klass.model_name.singular}.merge!(options)
+    options[:source] ||= @template.admin_autocomplete_path(options[:relation_model_name], options[:search_field_name])
+    string "#{relation_name}_tokens", title: self.object.class.human_attribute_name(relation_name),
+           data: {
+               multi_field: true,
+               source: options[:source],
+               pre: self.object.send("#{relation_name}_json", options[:search_field_name]),
+               show_all_on_focus: options[:show_all_on_focus],
+               use_cache: options[:use_cache],
+               object_url_name: options[:object_url_name]}
+  end
+
+  def row(method, controls, options = {})
+    label_class = options[:label_class] || 'control-label col-md-4 col-lg-2'
+    label_tag = label(method, options[:title], class: label_class) unless options[:hide_label]
+    options[:div_class] ||= COLS_CLASS
+    div_tag = content_tag :div, controls.html_safe, class: options[:div_class]
+    content_tag :div, "#{label_tag}#{div_tag}".html_safe, class: 'form-group'
+  end
+
+  private
+
+  def upload_container_id(method)
+    fake_method = "#{method}_upload"
+    ActionView::Helpers::Tags::Base.new(@object_name, fake_method, @template).send(:tag_id)
+  end
+
+  def with_default_options(options)
+    merge_classes(options, 'form-control')
+    options
+  end
+
+  def merge_classes(options, *clazz)
+    classes = [options[:class]].compact
+    classes.push(*clazz)
+    options[:class] = classes.uniq.join(' ')
+    options
+  end
+
+  def merge_options(default_options, options)
+    return default_options if options.blank?
+    new_options = default_options.merge(options)
+    if default_options.has_key?(:data) && options.has_key?(:data)
+      new_options[:data] = default_options[:data].merge(options[:data])
+    end
+    new_options
+  end
+
+  def static_text_formatter
+    @static_text_formatter ||= StaticTextFormatter.new(@object)
+  end
+
+end