coalla-cms 0.5.2.4 → 0.6.0.9

data/lib/coalla/builders/form_builder.rb

@@ -0,0 +1,291 @@
+#encoding: utf-8
+require 'coalla/builders/text_formatter'
+
+module Coalla
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    include ActionView::Helpers::FormTagHelper
+
+    COLS_CLASS = 'col-md-8'
+
+    def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def collection_check_boxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def collection_radio_buttons(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def collection_select(method, collection, value_method, text_method, options = {}, html_options = {})
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def date_select(method, options = {}, html_options = {})
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def datetime_select(method, options = {}, html_options = {})
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def fields_for(record_name, record_object = nil, fields_options = {}, &block)
+      return unless policy.field_enabled?(record_name)
+      super
+    end
+
+    def file_field(method, options = {})
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def grouped_collection_select(method, collection, group_method, group_label_method, option_key_method, option_value_method, options = {}, html_options = {})
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def radio_button(method, tag_value, options = {})
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def select(method, choices = nil, options = {}, html_options = {}, &block)
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def time_select(method, options = {}, html_options = {})
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    def time_zone_select(method, priority_zones = nil, options = {}, html_options = {})
+      return unless policy.field_enabled?(method)
+      super
+    end
+
+    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 = {})
+      return unless policy.field_enabled?(method)
+      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 = {})
+      return unless policy.field_enabled?(method)
+      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 = {})
+      return unless policy.field_enabled?(association_name)
+      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 = {}, checked_value = '1', unchecked_value = '0')
+      row method, content_tag(:div, check_box(method, options, checked_value, unchecked_value), 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
+
+    # 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, record_object = nil, options = {}, &block)
+      return unless policy.field_enabled?(association)
+
+      @template.render('admin/common/nested_fields_for',
+                       f: self,
+                       section_name: options[:title] || @object.class.human_attribute_name(association),
+                       collection: association,
+                       record_object: record_object,
+                       block: block,
+                       options: {include_id: false, destroy: true, add: true, sort: false}.merge(options))
+    end
+
+    def image_upload(method, options = {})
+      return unless policy.field_enabled?(method)
+
+      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)
+      return unless policy.field_enabled?(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]}.merge!(options[:data] || {})
+    end
+
+    def row(method, controls, options = {})
+      return unless policy.field_enabled?(method)
+
+      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
+
+    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
+
+    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 ||= TextFormatter.new(@object)
+    end
+
+    def policy
+      @policy ||= @template.try(:policy) || Coalla.policy.new(@template)
+    end
+  end
+end

data/lib/coalla/builders/link_renderer.rb

@@ -0,0 +1,43 @@
+require 'will_paginate/view_helpers/action_view'
+
+module Coalla
+  class LinkRenderer < 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
+end

data/lib/coalla/builders/policy.rb

@@ -0,0 +1,30 @@
+module Coalla
+  class DefaultPolicy
+    def initialize(context)
+      @context = context
+    end
+
+    def action_enabled?(action, options = {})
+      return true
+    end
+
+    def field_enabled?(field, options = {})
+      return true
+    end
+
+    def section_enabled?(section, options = {})
+      return true
+    end
+
+    def sanitize_params(params, options = {})
+      return params
+    end
+
+    protected
+
+    attr_reader :context
+  end
+
+  mattr_accessor :policy
+  @@policy = DefaultPolicy
+end

data/lib/coalla/builders/table_builder.rb

@@ -0,0 +1,99 @@
+require 'coalla/builders/column_definition'
+require 'coalla/builders/actions_column_definition'
+require 'coalla/builders/table_formatter'
+
+module Coalla
+  class TableBuilder
+    def initialize(context, model_class, options = {})
+      @context, @model_class = context, model_class
+      @options = options
+      @columns = []
+      @table_formatter = TableFormatter.for(@model_class)
+    end
+
+    def content(collection, &block)
+      @collection = collection
+      block.call(self) if block_given?
+      create_content
+    end
+
+    # Метод добавляет столбец к таблице
+    def column(method, options = {})
+      helper = @table_formatter[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.sort = sort_value(method, options.fetch(:sort, false))
+      cd.edit = edit_options(method, options.fetch(:edit, false))
+      cd.value_extractor = ->(item) { helper.format_value(item, options[:format]) }
+      cd.align = options[:align] || helper.respond_to?(:align) && 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_name = value.is_a?(Proc) ? options[:action_name] : value
+      return unless policy.action_enabled?(action_name, options)
+      @action_definition ||= ActionsColumnDefinition.new
+      @action_definition.action(value, options)
+      if @columns.exclude?(@action_definition)
+        @columns << @action_definition
+      end
+    end
+
+    def sort_value(method, sort_option)
+      return sort_option.to_s if sort_option.is_a?(String) || sort_option.is_a?(Symbol)
+      method.to_s if sort_option
+    end
+
+    def edit_options(method, options)
+      return unless options
+      result_options = {column: method}
+      if options.is_a?(Hash)
+        result_options.merge!(options)
+      else
+        result_options
+      end
+      return false unless policy.field_enabled?(result_options[:column])
+      result_options
+    end
+
+    def create_content
+      @context.render(partial: '/admin/common/table_template', locals: {definitions: @columns, items: @collection, row_class: @row_class})
+    end
+
+    def policy
+      @policy ||= @context.try(:policy) || Coalla.policy.new(@context)
+    end
+  end
+end

data/lib/coalla/builders/table_formatter.rb

@@ -0,0 +1,133 @@
+module Coalla
+  class TableFormatter
+    # TODO (vl): move formatters to separate files and lambdas
+
+    class SimpleFormatter
+      def format_value(item, format)
+        return '' unless item
+        return format.call(item) if format.is_a?(Proc)
+        customize(item)
+      end
+
+      def customize(item)
+        item
+      end
+    end
+
+    class BooleanFormatter < SimpleFormatter
+      def customize(item)
+        item ? '<i class="glyphicon glyphicon-check"></i>'.html_safe : ''
+      end
+
+      def align
+        :center
+      end
+    end
+
+    class DateFormatter < SimpleFormatter
+      def initialize(default_format = '%d.%m.%Y')
+        @default_format = default_format
+      end
+
+      def customize(item)
+        item = item.localtime if item.respond_to?(:localtime)
+        Russian::strftime(item, @default_format)
+      end
+    end
+
+    class EnumerizeFormatter < SimpleFormatter
+      def customize(item)
+        item.try(:text)
+      end
+    end
+
+    class SelfFormatter
+      def format_value(item, format)
+        raise 'Format should be lambda' unless format.is_a?(Proc)
+        format.call(item)
+      end
+    end
+
+    class ReflectionFormatter
+      def initialize(method)
+        @method = method
+      end
+
+      def format_value(item, format)
+        target = item.send(@method)
+        raise 'Format should be lambda' unless format.is_a?(Proc)
+        format.call(target)
+      end
+    end
+
+    class MethodFormatter
+      FORMATS = {
+          boolean: BooleanFormatter.new,
+          date: DateFormatter.new,
+          datetime: DateFormatter.new('%d.%m.%Y %H:%M'),
+          enumerize: EnumerizeFormatter.new
+      }
+
+      FORMATS.default = SimpleFormatter.new
+
+      def initialize(method, type)
+        @method = method
+        @formatter = FORMATS[type]
+      end
+
+      def format_value(item, format)
+        @formatter.format_value(item.send(@method), format)
+      end
+
+      def align
+        @align || @formatter.respond_to?(:align) && @formatter.align || :left
+      end
+
+      def align=(value)
+        @align = value
+      end
+
+      def respond_to?(method)
+        return (@align.present? || @formatter.respond_to?(method)) if method == :align
+        super
+      end
+    end
+
+    def initialize(model_class)
+      @model_class = model_class
+      @columns = model_class.columns.index_by(&:name).with_indifferent_access
+      @reflections = model_class.reflections.dup.with_indifferent_access
+      @helpers = {}
+    end
+
+    def self.for(model_class)
+      new(model_class)
+    end
+
+    def [](method)
+      return @helpers[method] if @helpers[method]
+      @helpers[method] = load_helper(method)
+      @helpers[method]
+    end
+
+    private
+
+    def load_helper(method)
+      return SelfFormatter.new if method == :self
+
+      reflection = @reflections[method]
+      return ReflectionFormatter.new(method) if reflection && reflection.macro == :belongs_to
+
+      # TODO (vl): refactor this
+      if @model_class.respond_to?(:enumerized_attributes) && @model_class.enumerized_attributes[method]
+        type = :enumerize
+      else
+        type = @columns[method] && @columns[method].type || :default
+      end
+
+      helper = MethodFormatter.new(method, type)
+      helper.align = :right if [:integer, :float, :decimal].include?(type.to_sym)
+      helper
+    end
+  end
+end

data/lib/coalla/builders/text_formatter.rb

@@ -0,0 +1,22 @@
+module Coalla
+  class TextFormatter
+    def initialize(object)
+      @object = object
+      # TODO (vl): refactor this
+      @columns = @object.class.columns.index_by(&:name).with_indifferent_access
+    end
+
+    def format(method)
+      method_value = @object.send(method)
+      return unless method_value
+
+      method_type = @columns[method].try(: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
+    end
+  end
+end

data/lib/coalla/cms/engine.rb

@@ -4,10 +4,11 @@ module Coalla
       require 'active_support/i18n'
       I18n.load_path += Dir[File.expand_path('../../../config/locales/*.yml', __FILE__)]
 
-      initializer :init_slider do
+      initializer :init_orm do
         ActiveSupport.on_load :active_record do
+          require 'coalla/orm/sortable_association'
           require 'coalla/orm/page_slider'
-          require 'coalla/orm/relation'
+          require 'coalla/orm/multi_field'
           require 'coalla/orm/sanitized'
         end
       end

data/lib/coalla/cms/version.rb

@@ -1,5 +1,5 @@
 module Coalla
   module Cms
-    VERSION = '0.5.2.4'
+    VERSION = '0.6.0.9'
   end
-end
+end

data/lib/coalla/ext/mapper.rb

@@ -9,6 +9,13 @@ module ActionDispatch::Routing
       end
     end
 
+    def editable_columns
+      member do
+        get :edit_column
+        put :update_column
+      end
+    end
+
   end
 
 end

data/lib/coalla/orm/{relation.rb → multi_field.rb}

@@ -1,12 +1,11 @@
 module Coalla
-
-  module Relation
-
+  module MultiField
     def multi_field(relation_name, options = {})
       through_collection_name = options[:through_collection_name] || "#{self.model_name.singular}_#{relation_name}".to_sym
       reflection = self.reflections[through_collection_name] || self.reflections[through_collection_name.to_s]
       through_class = reflection.klass
-      self_foreign_key = reflection.foreign_key
+
+      self_foreign_key_method = options.fetch(:self_foreign_key_method, reflection.foreign_key.gsub('_id', ''))
 
       reflection = self.reflections[relation_name] || self.reflections[relation_name.to_s]
       association_model_name = reflection.source_reflection_name.to_sym
@@ -17,7 +16,9 @@ module Coalla
 
       define_method "#{tokens_attribute_name}=" do |ids|
         new_through_collection = ids.split(',').each_with_index.map do |id, position|
-          through_class.new(self_foreign_key => self.id, association_foreign_key => id, position: position)
+          item = through_class.find_or_initialize_by(self_foreign_key_method => self, association_foreign_key => id)
+          item.position = position
+          item
         end
         self.send("#{through_collection_name}=", new_through_collection)
       end
@@ -27,9 +28,7 @@ module Coalla
       end
 
     end
-
   end
-
 end
 
-ActiveRecord::Base.extend Coalla::Relation
+ActiveRecord::Base.extend(Coalla::MultiField)