coalla-cms 0.4.2.0

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 = 'Действия'
+      @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;Добавить".html_safe
+    link_to content, path, class: 'btn btn-success'
+  end
+
+  def sort_link path
+    content = "<i class='glyphicon glyphicon-random'></i>&nbsp;&nbsp;Сортировать".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: 'Редактировать'
+  end
+
+  def delete_link path
+    content = "<i class='glyphicon glyphicon-trash'></i>".html_safe
+    link_to content, path, data: {confirm: 'Вы уверены?'}, method: :delete, class: 'btn btn-danger btn-xs', title: 'Удалить'
+  end
+
+  def cancel_action path, name = 'Отменить'
+    link_to name, path, class: 'btn btn-default'
+  end
+
+  def back_action name = 'Вернуться', 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,196 @@
+#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 save text = 'Сохранить'
+    submit text, name: :save, class: 'btn btn-success wymupdate'
+  end
+
+  def apply text = 'Применить'
+    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 = {})
+    options = {search_field_name: :name,
+               show_all_on_focus: false,
+               use_cache: true,
+               relation_model_name: self.object.class.reflections[relation_name].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

data/app/models/file_upload.rb

@@ -0,0 +1,19 @@
+class FileUpload < ActiveRecord::Base
+
+  mount_uploader :file, FileUploader
+
+  before_save :update_file_attributes
+
+  validates_presence_of :file, unless: :file_cache
+
+  private
+
+  def update_file_attributes
+    if file.present? && file_changed?
+      self.content_type = file.file.content_type
+      self.file_size = file.file.size
+      self.file_name = file.file.filename if self.respond_to? :file_name=
+    end
+  end
+
+end

data/app/models/lookup.rb

@@ -0,0 +1,6 @@
+class Lookup < ActiveRecord::Base
+
+  validates_presence_of :code
+  validates_uniqueness_of :code
+
+end

data/app/uploaders/file_uploader.rb

@@ -0,0 +1,10 @@
+class FileUploader < CarrierWave::Uploader::Base
+
+  storage :file
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+
+end

data/app/uploaders/generic_image_uploader.rb

@@ -0,0 +1,74 @@
+#encoding: utf-8
+require 'carrierwave/processing/mime_types'
+require 'shellwords'
+
+# TODO Добавить настройку watermark_image, position
+
+class GenericImageUploader < CarrierWave::Uploader::Base
+  include CarrierWave::RMagick
+  include CarrierWave::MimeTypes
+
+  before :cache, :capture_size_before_cache
+
+  storage :file
+
+  process :set_content_type
+  process :set_image_properties
+
+  def watermark
+    return if !model || !model.respond_to?(getter(:watermarked?)) || !model.send(getter(:watermarked?))
+
+    manipulate! do |img|
+      logo = Magick::Image.read(Rails.root.join("app/assets/images/watermark.png")).first
+      img.composite(logo, Magick::SouthEastGravity, 0, 0, Magick::OverCompositeOp)
+    end
+  end
+
+  def store_dir
+    "uploads/#{model.class.to_s.underscore}/#{mounted_as}/#{model.id}"
+  end
+
+  #def default_url
+  #  "/assets/fallback/" + [version_name, "default.png"].compact.join('_')
+  #end
+
+  def capture_size_before_cache(new_file)
+    return unless model
+    return unless new_file.path
+    if model.respond_to?(setter(:width)) && model.respond_to?(setter(:height))
+      w, h = `identify -format "%wx %h" #{new_file.path.shellescape}`.split(/x/).map { |dim| dim.to_i }
+      model.send(setter(:width), w)
+      model.send(setter(:height), h)
+    end
+  end
+
+  def set_image_properties
+    return if !model || !file
+
+    model.send(setter(:file_name), file.filename) if model.respond_to?(setter(:file_name))
+    model.send(setter(:size), file.size) if model.respond_to?(setter(:size))
+    model.send(setter(:content_type), file.content_type) if model.respond_to?(setter(:content_type))
+  end
+
+  private
+
+  def setter(name)
+    opt = model.class.uploader_options[mounted_as] || {}
+    if opt[:prefixed]
+      "#{mounted_as}_#{name}="
+    else
+      "#{name}="
+    end
+  end
+
+
+  def getter(name)
+    opt = model.class.uploader_options[mounted_as] || {}
+    if opt[:prefixed]
+      "#{mounted_as}_#{name}"
+    else
+      "#{name}"
+    end
+  end
+
+end

data/app/utils/admin_structure.rb

@@ -0,0 +1,67 @@
+#encoding: utf-8
+class AdminStructure
+
+  include Rails.application.routes.url_helpers
+
+  Section = Struct.new(:name, :path, :icon, :description, :counter, :show_menu_counter, :creation_path) do
+
+    def show_menu_counter?
+      show_menu_counter.present?
+    end
+
+  end
+
+  Separator = Struct.new(:title)
+
+  CONFIG_FILE_NAME = 'structure.rb'
+
+  attr_accessor :sections
+
+  def initialize
+    @sections = []
+    load_sections_from_config
+  end
+
+  def menu_items
+    dashboard_item = Section.new('Сводка', admin_dashboard_path, 'glyphicon glyphicon-align-left')
+    [dashboard_item] + @sections
+  end
+
+  def sections
+    @sections.find_all { |section| section.is_a?(Section) }
+  end
+
+  private
+
+  def load_sections_from_config
+    config_path = Rails.root.join('config', CONFIG_FILE_NAME).to_s
+    if File.exist?(config_path)
+      instance_eval(File.read(config_path), config_path)
+    end
+  end
+
+  # Options:
+  # creation_path - false or path string
+  def section(section_reference, options = {})
+    path = options.delete(:path)
+    icon = options.delete(:icon)
+    description = options.delete(:description)
+    counter = options.delete(:counter)
+    show_menu_counter = options.delete(:show_menu_counter)
+    creation_path = options.delete(:creation_path)
+    if section_reference.is_a?(Class)
+      section_name = section_reference.model_name.human
+      path = send("admin_#{section_reference.model_name.route_key}_path") unless path
+      counter = ->() { section_reference.count } unless counter
+      creation_path = send("new_admin_#{section_reference.model_name.singular}_path") if creation_path.nil?
+    else
+      section_name = section_reference
+    end
+    @sections << Section.new(section_name, path, icon, description, counter, show_menu_counter, creation_path)
+  end
+
+  def separator(title)
+    @sections << Separator.new(title)
+  end
+
+end

data/app/utils/bootstrap_link_renderer.rb

@@ -0,0 +1,40 @@
+class BootstrapLinkRenderer < WillPaginate::ActionView::LinkRenderer
+
+  protected
+
+  def html_container(html)
+    tag(:div, tag(:ul, html, class: 'pagination'), class: 't-center')
+  end
+
+  def page_number(page)
+    if page == current_page
+      tag(:li, tag(:a, page), class: 'active')
+    else
+      tag(:li, link(page, page, rel: rel_value(page)))
+    end
+  end
+
+  def gap
+    text = @template.will_paginate_translate(:page_gap) { '&hellip;' }
+    tag(:li, tag(:a, text), class: 'disabled')
+  end
+
+  def previous_page
+    num = @collection.current_page > 1 && @collection.current_page - 1
+    previous_or_next_page(num, @options[:previous_label])
+  end
+
+  def next_page
+    num = @collection.current_page < @collection.total_pages && @collection.current_page + 1
+    previous_or_next_page(num, @options[:next_label])
+  end
+
+  def previous_or_next_page(page, text)
+    if page
+      tag(:li, link(text, page))
+    else
+      tag(:li, tag(:a, text), class: 'disabled')
+    end
+  end
+
+end