ab_admin 0.3.6 → 0.4.0

data/lib/ab_admin/views/form_builder.rb

@@ -11,35 +11,38 @@ module AbAdmin
       map_type :color, to: ::AbAdmin::Views::Inputs::ColorInput
       map_type :ckeditor, to: ::AbAdmin::Views::Inputs::CkeditorInput
       map_type :editor, to: ::AbAdmin::Views::Inputs::EditorInput
-      map_type :date, :time, :datetime, to: ::AbAdmin::Views::Inputs::DateTimeInput
+      map_type :date_picker, :time_picker, :datetime_picker, to: ::AbAdmin::Views::Inputs::DateTimePickerInput
       map_type :token, to: ::AbAdmin::Views::Inputs::TokenInput
+      map_type :capture_block, to: ::AbAdmin::Views::Inputs::CaptureBlockInput
+      map_type :uploader, to: ::AbAdmin::Views::Inputs::UploaderInput
 
       def input(attribute_name, options = {}, &block)
-        if options[:fancy] || (!options.key?(:fancy) && ((!options.key?(:as) && options[:collection]) || options[:as] == :select))
+        options[:collection] = options[:collection].call if options[:collection].is_a?(Proc)
+        
+        is_select = options[:as].nil? || options[:as] == :select
+        is_large_collection = options[:collection] && options[:collection].to_a.length > 30
+        if options[:fancy] || (is_select && is_large_collection)
           options[:input_html] ||= {}
           options[:input_html][:class] = "#{options[:input_html][:class]} fancy_select"
         end
 
+        if options[:append]
+          return super(attribute_name, options.merge(wrapper: 'append')) do
+            input_field(attribute_name, options.merge(options[:input_html] || {})) + %(<span class="add-on #{options[:append_class]}">#{options[:append]}</span>).html_safe
+          end
+        end
+
         case options[:as]
-          when :uploader
-            title = options[:title] || I18n.t("admin.#{attribute_name}", default: object.class.han(attribute_name))
-            return template.input_set(title) { attach_file_field(attribute_name, options) }
           when :map
             title = options[:title] || I18n.t("admin.#{attribute_name}", default: object.class.han(attribute_name))
             prefix = options[:prefix] || object.class.model_name.singular
             data_fields = [:lat, :lon, :zoom].map { |attr| hidden_field(attr) }.join.html_safe
             return template.input_set(title) { data_fields + geo_input(prefix, options[:js_options]) }
           when :token
-            options[:label] ||= object.class.han(attribute_name.to_s.sub(/^token_|_id$/, ''))
+            options[:label] = object.class.han(attribute_name.to_s.sub(/^token_|_id$/, '')) unless options.key?(:label)
           when :association, :tree_select
             unless options[:reflection]
-              if options[:as] == :tree_select
-                options[:collection] ||= begin
-                  reflection = object.class.reflect_on_association(attribute_name)
-                  records = reflection.klass.all(reflection.options.slice(:conditions, :order))
-                  reflection.klass.nested_opts_with_parent(records, object)
-                end
-              end
+              options[:collection] ||= fetch_nested_options(attribute_name) if options[:as] == :tree_select
               return association(attribute_name, options.merge(as: :select))
             end
           when :checkbox_tree
@@ -52,9 +55,13 @@ module AbAdmin
         super(attribute_name, options, &block)
       end
 
+      def render_dsl_node(node, options={})
+        input node.name, node.options.merge(options), &node.block
+      end
+
       def link_to_add_assoc(assoc, options={})
         model = @object.class.reflect_on_association(assoc).klass
-        title = [@template.icon('plus', true), I18n.t('admin.add'), model.model_name.human].join(' ').html_safe
+        title = [@template.icon('plus', true), I18n.t('admin.add'), options[:title] || model.model_name.human].join(' ').html_safe
         link_to_add title, assoc, class: "btn btn-primary #{options[:class]}"
       end
 
@@ -93,84 +100,15 @@ module AbAdmin
         HTML
       end
 
-      def attach_file_field(attribute_name, options = {})
-        value = options.delete(:value) if options.key?(:value)
-        value ||= object.fileupload_asset(attribute_name)
-        asset_klass = object.reflections[attribute_name].try(:klass)
-
-        element_guid = object.fileupload_guid
-        element_id = template.dom_id(object, [attribute_name, element_guid].join('_'))
-        max_size = options[:file_max_size] || asset_klass.try(:max_size)
-        script_options = (options.delete(:script) || {}).stringify_keys
-
-        params = {
-            method: attribute_name,
-            assetable_id: object.new_record? ? nil : object.id,
-            assetable_type: object.class.name,
-            guid: element_guid
-        }.merge(script_options.delete(:params) || {})
-
-        script_options['action'] ||= '/sunrise/fileupload?' + Rack::Utils.build_query(params)
-        if !script_options['allowedExtensions'] && asset_klass
-          script_options['allowedExtensions'] = asset_klass.ext_list
-        end
-        if options[:template_id]
-          script_options['template_id'] = options[:template_id]
-        end
-        if options[:file]
-          script_options['allowedExtensions'] ||= %w(pdf doc docx xls xlsx ppt pptx zip rar csv jpg jpeg gif png)
-          script_options['template_id'] = '#fileupload_ftmpl'
-          options[:asset_template] = 'file'
-        elsif options[:video]
-          script_options['allowedExtensions'] ||= %w(mp4 flv)
-          script_options['template_id'] = '#fileupload_vtmpl'
-          options[:asset_template] = 'video'
-        end
-        script_options['allowedExtensions'] ||= %w(jpg jpeg png gif)
-        script_options['multiple'] ||= object.fileupload_multiple?(attribute_name)
-        script_options['element'] ||= element_id
-        script_options['sizeLimit'] = max_size.megabytes.to_i
-
-        locals = {
-            element_id: element_id,
-            error: error(attribute_name),
-            file_title: (options[:file_title] || script_options['allowedExtensions'].join(', ')),
-            file_max_size: max_size,
-            assets: [value].flatten.delete_if { |v| v.nil? || v.new_record? },
-            button_title: options[:button_title] || I18n.t("admin.fileupload.button#{'s' if script_options['multiple']}"),
-            asset_template: (options[:asset_template] || 'asset'),
-            container_data: {
-                klass: params[:assetable_type],
-                asset: asset_klass.to_s,
-                assoc: params[:method],
-                multiple: script_options['multiple'],
-                crop: options[:crop]
-            }
-        }
-
-        locals[:css_class] = ['fileupload', "#{locals[:asset_template]}_render_template"]
-        locals[:css_class] << "#{options[:file] ? 'file' : 'image'}_asset_type"
-        locals[:css_class] << (script_options['multiple'] ? 'many_assets' : 'one_asset')
-        locals[:css_class] << 'error' if locals[:error]
-
-
-        js_opts = [locals[:element_id], template.sort_admin_assets_path(klass: asset_klass), script_options['multiple']].map(&:inspect).join(', ')
-        locals[:js] = <<-JAVASCRIPT
-          var upl = new qq.FileUploaderInput(#{script_options.to_json});
-          upl._setupDragDrop();
-          new AdminAssets(#{js_opts});
-        JAVASCRIPT
-
-        if options[:description]
-          opts = [attribute_name, object.class.name, object.id, object.fileupload_guid].map { |i| i.to_s.inspect }.join(', ')
-          template.concat javascript_tag("$(function(){new AssetDescription(#{opts})})")
-        end
+      protected
 
-        template.render(partial: "admin/fileupload/#{options[:container] || 'container'}", locals: locals)
+      def fetch_nested_options(attribute_name)
+        reflection = object.class.reflect_on_association(attribute_name)
+        records = reflection.klass
+        records = records.instance_exec(&reflection.scope) if reflection.scope
+        reflection.klass.nested_opts_with_parent(records.all, object)
       end
 
-      protected
-
       def object_plural
         object_name.to_s.pluralize
       end

data/lib/ab_admin/views/helpers.rb

@@ -1,11 +1,8 @@
+# -*- encoding : utf-8 -*-
 module AbAdmin
   module Views
     module Helpers
 
-      def pjax?
-        request.headers['X-PJAX']
-      end
-
       def admin?
         user_signed_in? && current_user.admin?
       end
@@ -38,17 +35,6 @@ module AbAdmin
         I18n.locale == I18n.default_locale ? '' : "/#{I18n.locale}"
       end
 
-      def external_link(raw_link, options={}, &block)
-        return unless raw_link.present?
-        options.reverse_merge!(title: raw_link, target: '_blank', rel: 'nofollow')
-        link = raw_link =~ /^http[s]?:\/\// ? raw_link : "http://#{raw_link}"
-        if block_given?
-          link_to link, options, &block
-        else
-          link_to options[:title], link, options
-        end
-      end
-
       def skype_link(skype, options={})
         return '' if skype.blank?
         link_to skype, "skype:#{skype.strip}?chat", options
@@ -63,19 +49,6 @@ module AbAdmin
         image_tag image, options
       end
 
-      def render_title
-        @page_title || I18n.t('page.title')
-      end
-
-      def render_keywords
-        @page_keywords || I18n.t('page.keywords')
-      end
-
-      def render_description
-        @page_description || I18n.t('page.description')
-      end
-
-      # swf_object
       def swf_object(swf, id, width, height, flash_version, options = {})
         options.symbolize_keys!
 

data/lib/ab_admin/views/inputs/capture_block_input.rb

@@ -0,0 +1,16 @@
+module AbAdmin
+  module Views
+    module Inputs
+      class CaptureBlockInput < ::SimpleForm::Inputs::Base
+        def initialize(*args, &block)
+          super
+          @block = block
+        end
+
+        def input
+          template.capture(@builder, &@block)
+        end
+      end
+    end
+  end
+end

data/lib/ab_admin/views/inputs/date_time_picker_input.rb

@@ -0,0 +1,45 @@
+module AbAdmin
+  module Views
+    module Inputs
+      class DateTimePickerInput < ::SimpleForm::Inputs::Base
+
+        def input
+          input_html_options[:value] ||= formated_value
+          input_html_classes << input_type
+          @builder.text_field(attribute_name, input_html_options)
+        end
+
+        private
+
+        def formated_value
+          object.send(attribute_name).try(:strftime, value_format)
+        end
+
+        def value_format
+          case input_type
+            when :date_picker
+              '%d.%m.%Y'
+            when :datetime_picker
+              '%d.%m.%Y %H:%M'
+            when :time_picker
+              '%H:%M'
+          end
+        end
+
+        def has_required?
+          false
+        end
+
+        def label_target
+          case input_type
+            when :date, :datetime
+              "#{attribute_name}_1i"
+            when :time
+              "#{attribute_name}_4i"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/ab_admin/views/inputs/token_input.rb

@@ -5,7 +5,8 @@ module AbAdmin
 
         def input
           attr = options.delete(:assoc) || attribute_name.to_s.sub(/^token_|_id$/, '')
-          input_html_options.reverse_deep_merge!(object.token_data(attr.to_sym, options.extract!(:geo_order, :c)))
+          token_data = object.token_data(attr.to_sym, options.extract!(:geo_order, :c, :sortable))
+          input_html_options.reverse_deep_merge!(token_data)
           super
         end
 

data/lib/ab_admin/views/inputs/uploader_input.rb

@@ -0,0 +1,101 @@
+module AbAdmin
+  module Views
+    module Inputs
+      class UploaderInput < ::SimpleForm::Inputs::Base
+        disable :label
+
+        def initialize(*args, &block)
+          super
+          @assoc = object.class.reflect_on_association(attribute_name)
+          defaults = {
+              file_type: 'image',
+              container_id: "#{attribute_name}_#{object.fileupload_guid}",
+              multiple: @assoc.collection?,
+              extensions: @assoc.klass.ext_list,
+              max_size: @assoc.klass.try(:max_size),
+              error: @builder.error(attribute_name)
+          }
+          @options.reverse_merge!(defaults)
+          @options[:sortable] = @options[:multiple] unless @options.has_key?(:sortable)
+          @options[:asset_template] ||= @options[:file_type]
+          @options[:container_class] = container_class
+        end
+
+        def input
+          title = options[:title] || object.class.han(attribute_name)
+          template.capture do
+            if @options[:unwrapped]
+              render_input
+            else
+              template.input_set(title) { render_input }
+            end
+          end
+        end
+
+        def render_input
+          locals = {
+              options: @options,
+              js_options: js_options,
+              assets: uploader_values,
+              asset_template: "#{theme_path}/#{@options[:asset_template]}"
+          }
+          template.render(partial: "#{theme_path}/container", locals: locals)
+        end
+
+        def container_class
+          classes = Array(@options[:container_class])
+          classes << (@options[:multiple] ? 'fileupload-multiple' : 'fileupload-single')
+          classes << "fileupload-klass-#{@assoc.klass.name}"
+          classes << "fileupload-record-#{object.fileupload_guid}"
+          classes << "fileupload-theme-#{@options[:theme]}" if @options[:theme]
+          classes << "fileupload-file_type-#{@options[:file_type]}"
+          classes << "fileupload-asset_template-#{@options[:asset_template]}"
+          classes << 'fileupload-sortable' if @options[:sortable]
+          classes << 'error' if @options[:error]
+          classes
+        end
+
+        def theme_path
+          [@options[:views_path] || 'admin/fileupload', @options[:theme]].compact.join('/')
+        end
+
+        def uploader_values
+          if options.key?(:value)
+            values = options.delete(:value)
+          else
+            values = object.fileupload_asset(attribute_name)
+          end
+          Array(values).delete_if { |v| v.nil? || v.new_record? }
+        end
+
+        def js_options
+          {
+            container_id: @options[:container_id],
+            file_type: @options[:file_type],
+            asset_template: @options[:asset_template],
+            multiple: @options[:multiple],
+            sort_url: template.sort_admin_assets_path(klass: @assoc.klass.name),
+            extensions: @options[:extensions],
+            klass: @assoc.klass.name,
+            sortable: @options[:sortable],
+            edit_meta: @options[:edit_meta],
+            crop: @options[:crop],
+            fileupload: {
+              url: AbAdmin.fileupload_url,
+              maxNumberOfFiles: @options[:max_files],
+              maxFileSize: @options[:max_size].try(:megabytes),
+              minFileSize: @options[:min_size].try(:megabytes),
+              formData: {
+                assetable_type: object.class.name,
+                assetable_id: object.id,
+                method: attribute_name,
+                guid: object.fileupload_guid
+              }
+            }
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/ab_admin/views/manager_helpers.rb

@@ -2,6 +2,8 @@ module AbAdmin
   module Views
     module ManagerHelpers
 
+      INDEX_VIEW_ICONS = {table: 'list', tree: 'move', grid: 'th'}
+
       def table_builder
         manager.table ||= ::AbAdmin::Config::Table.default_for_model(resource_class)
       end
@@ -14,6 +16,10 @@ module AbAdmin
         manager.form ||= ::AbAdmin::Config::Form.default_for_model(resource_class, skip: [:id, :created_at, :updated_at, :lft, :rgt, :depth])
       end
 
+      def modal_form_builder
+        manager.modal_form ||= ::AbAdmin::Config::ModalForm.default_for_model(resource_class, skip: [:id, :created_at, :updated_at, :lft, :rgt, :depth])
+      end
+
       def show_builder
         manager.show ||= ::AbAdmin::Config::Show.default_for_model(resource_class)
       end
@@ -27,6 +33,12 @@ module AbAdmin
           admin_member_action_path(model_name: resource_collection_name, id: record.id, custom_action: custom_action.name)
         end
       end
+
+      def index_view_link(index_view)
+        options = {class: "btn #{('active' if current_index_view == index_view)}", title: t("admin.index_view.#{index_view}")}
+        url = url_for(index_view: index_view)
+        link_to icon(INDEX_VIEW_ICONS[index_view.to_sym]), url, options
+      end
     end
   end
 end

data/lib/ab_admin/views/search_form_builder.rb

@@ -6,15 +6,15 @@ module AbAdmin
                :options_for_select, :options_from_collection_for_select, :hidden_field_tag, to: :@template
 
       def input(attr, options={})
-        filed_type = filed_type(attr, options)
-        content_tag :div, class: "clearfix #{filed_type}" do
-          send("#{filed_type}_field", attr, options)
+        field_type = field_type(attr, options)
+        content_tag :div, class: "clearfix #{field_type} #{options[:wrapper_class]}" do
+          send("#{field_type}_field", attr, options)
         end
       end
 
       def select_field(attr, options={})
         label(attr, options[:label]) + content_tag(:div, class: 'controls') do
-          param = "#{options[:value_attr] || attr}_eq"
+          param = options[:param] || "#{options[:value_attr] || attr}_eq"
 
           if options[:collection].is_a?(Proc)
             collection = options[:collection].call
@@ -26,16 +26,25 @@ module AbAdmin
             collection.map!{|r| [AbAdmin.display_name(r), r.id] }
           end
 
-          options[:html_options] ||= {}
-          if options[:fancy] || !options.has_key?(:fancy)
-            options[:html_options][:class] = [options[:html_options][:class], 'fancy_select'].join(' ')
+          options[:input_html] ||= {}
+          if options[:fancy] || collection.length > 30
+            options[:input_html][:class] = [options[:input_html][:class], 'fancy_select'].join(' ')
           end
 
-          html_options = options[:html_options].merge(include_blank: true, id: "q_#{attr}")
+          html_options = options[:input_html].merge(include_blank: true, id: "q_#{attr}")
           select_tag("q[#{param}]", options_for_select(collection, params[:q][param]), html_options)
         end
       end
 
+      def ac_select_field(attr, options={})
+        klass = options[:klass]
+        options[:param] ||= "#{options[:value_attr] || attr}_eq"
+        pre_select = params.val(:q, options[:param]) ? klass.where(id: params[:q][options[:param]]).map(&:for_input_token) : []
+        options[:input_html] ||= {}
+        options[:input_html].deep_merge! class: 'fancy_select', data: {class: klass.name, pre: pre_select.to_json}
+        string_field attr, options
+      end
+
       def date_field(attr, options={})
         label(attr, options[:label]) + content_tag(:div, class: 'controls') do
           gt_param, lt_param = "#{attr}_gteq", "#{attr}_lteq"
@@ -46,7 +55,7 @@ module AbAdmin
 
       def string_field(attr, options={})
         label(attr, options[:label]) + content_tag(:div, class: 'controls') do
-          param = "#{options[:value_attr] || attr}_cont"
+          param = options[:param] || "#{options[:value_attr] || attr}_cont"
           options[:input_html] ||= {}
           options[:input_html][:id] = "q_#{attr}"
           text_field_tag("q[#{param}]", params[:q][param], options[:input_html])
@@ -69,7 +78,7 @@ module AbAdmin
 
       def boolean_field(attr, options={})
         content_tag(:div, class: 'pull-left') do
-          param = "#{attr}_eq"
+          param = options[:param] || "#{attr}_eq"
           content_tag(:label, class: 'checkbox inline') do
             check_box_tag("q[#{param}]", 1, params[:q][param].to_i == 1, class: 'inline', id: "q_#{attr}") + I18n.t('simple_form.yes')
           end +
@@ -79,8 +88,21 @@ module AbAdmin
         end + label(attr, options[:label], class: 'right-label')
       end
 
+      def presence_field(attr, options={})
+        content_tag(:div, class: 'pull-left') do
+          content_tag(:label, class: 'checkbox inline') do
+            param = "#{attr}_present"
+            check_box_tag("q[#{param}]", 1, params[:q][param].to_i == 1, class: 'inline', id: "q_#{attr}") + I18n.t('simple_form.yes')
+          end +
+          content_tag(:label, class: 'checkbox inline') do
+            param = "#{attr}_null"
+            check_box_tag("q[#{param}]", 1, params[:q][param].to_i == 1, class: 'inline') + I18n.t('simple_form.no')
+          end
+        end + label(attr, options[:label], class: 'right-label')
+      end
+
       def hidden_field(attr, options={})
-        hidden_field_tag("q[#{attr}_eq]", options.delete(:value), options)
+        hidden_field_tag("q[#{attr}_eq]", options[:value], options)
       end
 
       def label(attr, text=nil, options={})
@@ -88,14 +110,15 @@ module AbAdmin
         super(attr, text, options)
       end
 
-      def filed_type(attr, options={})
-        return options.delete(:as).to_sym if options[:as]
+      def field_type(attr, options={})
+        return options[:as].to_sym if options[:as]
         return :string if attr =~ /^translations_/
 
         input_type = @object.klass.columns_hash[attr.to_s].try(:type)
 
         if input_type
           return :select if options[:collection]
+          return :string if input_type == :text
         elsif @object.klass.translates? && @object.klass.translated?(attr)
           options[:value_attr] = "translations_#{attr}"
           return :string