basepack 0.0.2

data/lib/basepack/forms/fields/has_many_association.rb

@@ -0,0 +1,50 @@
+module Basepack
+  module Forms
+    module Fields
+      class HasManyAssociation < Fields::Base
+        attr_default :partial, [:nested_form] do
+          File.join('forms', 'edit', nested_form ? 'form_nested_many' : 'form_filtering_multiselect')
+        end
+
+        attr_default :orderable do
+          false
+        end
+
+        attr_default :inline_add do
+          true
+        end
+
+        attr_default :method_name, [:nested_form] do
+          nested_form ? "#{name}_attributes".to_sym : "#{name.singularize}_ids".to_sym  # name_ids
+        end
+
+        def build_resource
+          # TODO - raise exception for `through' assoc: form.resource_class.reflect_on_association(name).nested?
+          value.build
+        end
+
+        def parse_input(params)
+          if params[method_name].is_a? String
+            params[method_name] = params[method_name].split ','
+          else
+            @delegate.parse_input(params) if @delegate
+          end
+        end
+
+        # returns true only for for N-N associations
+        def bulk_editable?
+          #N-N association are only with:
+          # has_many through: <join_table>, where join_table has foreign_keys for both associations
+
+          reflection = abstract_model.model.reflect_on_association(name)
+          (
+            (ActiveRecord::Reflection::ThroughReflection === reflection) and
+            (reflection.through_reflection.macro == :has_many) and
+            (reflection.source_reflection.macro == :belongs_to)
+          )
+
+        end
+      end
+    end
+  end
+end

data/lib/basepack/forms/fields/has_one_association.rb

@@ -0,0 +1,19 @@
+module Basepack
+  module Forms
+    module Fields
+      class HasOneAssociation < Fields::SingleAssociation
+        attr_default :editable, [:nested_form] do
+          (nested_form || form.resource.respond_to?("#{name}_id=")) && super
+        end
+
+        attr_default :method_name, [:nested_form] do
+          nested_form ? "#{name}_attributes".to_sym  : "#{name}_id".to_sym
+        end
+
+        def selected_id
+          value.try :id
+        end
+      end
+    end
+  end
+end

data/lib/basepack/forms/fields/single_association.rb

@@ -0,0 +1,32 @@
+module Basepack
+  module Forms
+    module Fields
+      class SingleAssociation < Fields::Base
+        attr_default :formatted_value do
+          value.try? :to_label
+        end
+
+        attr_default :partial, [:nested_form] do
+          File.join('forms', 'edit', nested_form ? 'form_nested_one' : 'form_filtering_select')
+        end
+
+        attr_default :inline_add do
+          true
+        end
+
+        attr_default :inline_edit do
+          true
+        end
+
+        attr_default :multiple do
+          false
+        end
+
+        def build_resource
+          value || form.resource.send("build_#{name}")
+        end
+      end
+
+    end
+  end
+end

data/lib/basepack/forms/groups/base.rb

@@ -0,0 +1,71 @@
+module Basepack
+  module Forms
+    module Groups
+      class Base
+        include Basepack::Delegation
+
+        delegate_attrs :name, :label, :help
+
+        attr_reader :form, :delegate
+        attr_accessor :field_names
+
+        def initialize(form, delegate_or_attributes = nil)
+          @form = form
+          @field_names = []
+          update_attributes(delegate_or_attributes)
+        end
+
+        def update_attributes(delegate_or_attributes)
+          if delegate_or_attributes.is_a? Hash
+            delegate_or_attributes.each do |a, v|
+              send("#{a}=", v)
+            end
+          else
+            @delegate = delegate_or_attributes
+          end
+        end
+
+        def field(name, delegate_or_attributes = nil, &block)
+          field = @form.field(name, delegate_or_attributes, &block)
+          @field_names << name if field and !@field_names.include?(name)
+          field
+        end
+
+        def content_for_field(field_name, &block)
+          field(field_name) do |f|
+            f.content(&block)
+          end
+        end
+
+        def fields
+          @field_names.map {|f| @form.field(f)}.compact
+        end
+
+        def visible_fields
+          @field_names.map {|f| @form.visible_field(f)}.compact
+        end
+
+        def remove
+          @form.groups.delete self
+        end
+
+        def values
+          result = {}
+          visible_fields.each {|f| result[f.name] = f.value}
+          result
+        end
+
+        def values_without_blank
+          result = {}
+          visible_fields.each do |f|
+            val = f.value.presence
+            result[f.name] = val unless val.nil?
+          end
+          result
+        end
+
+      end
+    end
+  end
+end
+

data/lib/basepack/forms/groups/diff.rb

@@ -0,0 +1,18 @@
+module Basepack
+  module Forms
+    module Groups
+      class Diff < Groups::Base
+        def visible_fields2
+          field_names.map {|f| form.visible_field2(f)}.compact
+        end
+
+        def changes
+          fields2_hash = form.form2.fields_hash
+          visible_fields.map {|f| [f, fields2_hash[f.name]]}.reject do |f1, f2|
+            (form.compare(f1.name) || form.compare("*")).call(f1, f2)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/basepack/forms/import.rb

@@ -0,0 +1,147 @@
+module Basepack
+  module Forms
+    class Import < Forms::Base
+      attr_reader   :edit_form
+      attr_reader   :show_form
+      attr_reader   :list_form
+      attr_reader   :builder
+      attr_reader   :action_name
+      attr_accessor :builder_default_options
+
+      def initialize(factory, chain, options = {})
+        super(factory, chain, options)
+
+        @action_name = options[:action_name] || :import
+
+        @builder_default_options = {
+          as:       :import,
+          html:     { multipart: true, class: 'form-horizontal denser' },
+          defaults: { input_html: { class: 'span6'} }
+        }
+
+        if options[:show_form]
+          @show_form = options[:show_form]
+        end
+
+        if options[:edit_form]
+          @edit_form = options[:edit_form]
+          @edit_form.builder_default_options[:as] = :import
+          @edit_form.content_for_form do |form, opt = {}, &block|
+            form.render_form!(opt) do
+              view.safe_concat form.render_fields
+              view.safe_concat(view.content_tag(:div, class: "pull-right") do
+                form.view.render("forms/buttons/submit_create")
+              end)
+            end
+          end
+        end
+
+        if options[:list_form]
+          @list_form = options[:list_form]
+          @list_form.content_for_row do |form, &block|
+            view.content_tag(:tr, class: @show_form.resource.id == form.resource.id ? "success" : nil, &block)
+          end
+          @list_form.content_for_actions do |form|
+            result = ''.html_safe
+            result << form.render_action("Zobrazit", path(import_id: form.resource.id), "icon-eye-open",
+                                         class: @show_form.resource.id == form.resource.id ? 'btn btn-mini disabled' : 'btn btn-mini',
+                                        )
+            result << form.render_action("Smazat", path(delete_id: form.resource.id), "icon-trash",
+                                         class: 'btn btn-mini btn-danger',
+                                         method: :delete,
+                                         data: { confirm: I18n.t('admin.form.confirmation') })
+            result
+          end
+        end
+      end
+
+      def path(params = {})
+        view.polymorphic_path([@action_name, association_chain, resource_class].flatten, params)
+      end
+
+      def with_builder(builder, &block)
+        @builder = builder
+        begin
+          yield(self)
+        ensure
+          @builder = nil
+        end
+      end
+
+      def view=(view)
+        super
+        if @edit_form
+          @edit_form.view = view
+          @edit_form.path = path
+        end
+        @show_form.view = view if @show_form
+        @list_form.view = view if @list_form
+      end
+
+      def default_partial
+        'forms/import'
+      end
+
+      def field_nested_name(field)
+        field.form.nested_in ? "#{field_nested_name(field.form.nested_in)}[#{field.method_name}]" : field.method_name
+      end
+
+      def fields_for_import_as_select_options
+        @normal = [["Žádný", '']]
+        @association = []
+
+        visible_fields.each do |field|
+          if !field.association?
+            @normal << [field.label.to_s, field.method_name.to_s]
+          elsif nform = field.nform
+            # nested form
+            next if field.multiple? or !field.nested_form
+            nform.visible_fields.each do |f|
+              @association << [f.nested_label, field_nested_name(f)]
+            end
+          end
+        end
+
+        @normal + @association
+      end
+
+      def configuration_params(&block)
+        if block
+          @configuration_params = block
+        else
+          if @configuration_params
+            @configuration_params.(self, @show_form.resource)
+          elsif @show_form.resource.respond_to? :configuration_params
+            @show_form.resource.configuration_params
+          else
+            nil
+          end
+        end
+      end
+
+      render :configuration do
+        params = configuration_params
+        view.render(*params) if params
+      end
+
+      render :form do |options = nil, &block|
+        options = (options || {}).dup.reverse_merge!(@builder_default_options)
+        options[:url] ||= path
+
+        view.simple_form_for(@show_form.chain, options) do |simple_form|
+          with_builder(simple_form) do
+            view.safe_concat render_setup_form
+            view.safe_concat(view.capture(self, &block)) if block
+          end
+        end
+      end
+
+      render :setup_form do
+        view.form_setup_simple_form(builder) + view.hidden_field_tag(:import_id, @show_form.resource.id)
+      end
+
+    end
+  end
+end
+
+

data/lib/basepack/forms/list.rb

@@ -0,0 +1,74 @@
+module Basepack
+  module Forms
+    class List < Forms::Base
+      attr_reader :query_form
+
+      def initialize(factory, chain, options = {})
+        super(factory, chain, options)
+        @query_form = options[:query_form]
+      end
+
+      def view=(view)
+        super
+        @query_form.view = view if @query_form
+      end
+
+      def default_partial
+        'forms/list'
+      end
+
+      def collection
+        @query_form ? @query_form.collection : []
+      end
+
+      def collection_each(&block)
+        collection.each_with_index do |res, i|
+          with_resource(res, res, i, &block)
+        end
+      end
+
+      render :sort_link do |field|
+        view.form_sort_link(@query_form.resource_filter, field, @query_form.params)
+      end
+
+      render :row do |&block|
+        view.content_tag(:tr, &block)
+      end
+
+      render :action do |name, url, icon=nil, html_options={}|
+        view.link_to (icon ? "<i class='#{icon}'></i> ".html_safe + name : name), url, html_options.reverse_merge(class: "btn btn-mini")
+      end
+
+      render :show_action do
+        if view.can? :show, resource
+          render_action(self.translate(resource, :show), [association_chain, resource].flatten, "icon-eye-open")
+        end
+      end
+
+      render :edit_action do
+        if view.can? :edit, resource
+          render_action(self.translate(resource, :edit), [:edit, association_chain, resource].flatten, "icon-pencil",
+              class: 'btn btn-info btn-mini')
+
+        end
+      end
+
+      render :destroy_action do
+        if view.can? :destroy, resource
+          render_action(self.translate(resource, :delete), [association_chain, resource].flatten, "icon-trash",
+                class: 'btn btn-mini btn-danger',
+                method: :delete,
+                data: { confirm: I18n.t('admin.form.confirmation') })
+        end
+      end
+
+      render :actions do
+        result = ''.html_safe
+        result << render_show_action
+        result << render_edit_action
+        result << render_destroy_action
+        result
+      end
+    end
+  end
+end

data/lib/basepack/forms/query.rb

@@ -0,0 +1,211 @@
+module Basepack
+  module Forms
+    class Query < Forms::Base
+      attr_reader   :query
+      attr_reader   :edit_ql
+      attr_reader   :params # parameters required to build similar form
+      attr_accessor :ql
+      attr_accessor :date_format
+      attr_reader   :auth_object
+      attr_reader   :filterql_options
+
+      def initialize(factory, chain, options = {})
+        super(factory, chain, options)
+
+        @scope = options[:scope]
+        @auth_object = options[:auth_object]
+        @filterql_options = options[:filterql_options]
+        @collection_includes = options[:collection_includes]
+
+        if params = options[:params]
+          @params = params.slice(:query, :ql, :f, :page, :per).reject {|k, v| v.empty?}
+          @query = params[:query]
+
+          if has_errors?
+            @ql = params[:ql]
+          elsif params[:edit_ql]
+            @edit_ql = params[:edit_ql]
+          end
+        end
+      end
+
+      def collection
+        @collection || begin
+          query_from_params
+          @collection
+        end
+      end
+
+      def collection_without_pagination
+        collection.offset(nil).limit(nil)
+      end
+
+      def resource_filter
+        @resource_filter || begin
+          query_from_params
+          @resource_filter
+        end
+      end
+
+      def has_errors?
+        resource_filter.errors[:base].present?
+      end
+
+      def nested_filterable_field(name)
+        filterable_field(name) || begin
+          n = name.to_s.split('_')
+          (n.size - 1).downto(1) do |count|
+            if f = filterable_field(n[0, count].join('_').to_sym)
+              return f.nform.nested_filterable_field(n[count..-1].join('_').to_sym)
+            end
+          end
+          nil
+        end
+      end
+
+      def field_nested_name(field)
+        field.form.nested_in ? "#{field_nested_name(field.form.nested_in)}_#{field.name}" : field.name
+      end
+
+      def filterable_field(name)
+        f = field(name)
+        f.try(:filterable?) ? f : nil
+      end
+
+      def filterable_fields
+        fields.select {|f| f.filterable? }
+      end
+
+      def present?
+        @query or @ql or filtered_fields.present?
+      end
+
+      def setup
+        {
+          options: {
+            regional: { datePicker: { dateFormat: date_format }.reverse_merge!(Basepack::Forms::Edit.data_picker_options) },
+            predicates: FilterQL.predicates,
+            enum_options: enum_options,
+          },
+          initial: initial_data,
+        }
+      end
+
+      def filtered_fields
+        @filtered_fields || begin
+          if nested_in
+            @filtered_fields = []
+          else
+            @filtered_fields = resource_filter.c.map do |condition|
+              if condition.valid? and condition.attributes.size == 1
+                if field = nested_filterable_field(condition.attributes.first.name.to_sym)
+                  [field, condition.predicate_name, Query.localize_value(field, condition.predicate_name, condition.value)]
+                end
+              end
+            end.concat(Array.wrap(resource_filter.custom_filters).map do |name, predicate_name, values|
+              if field = nested_filterable_field(name.to_sym)
+                [field, predicate_name, values]
+              end
+            end).compact
+          end
+        end
+      end
+
+      def filtered_fields_find(nested_field_name, condition = nil)
+        filtered_fields.find do |f|
+          (field_nested_name(f[0]) == nested_field_name) and 
+          (condition ? (f[1] == condition) : true)
+        end
+      end
+
+      def initial_data
+        if @edit_ql
+          init = []
+        else
+          init = filtered_fields.map do |field, predicate_name, values|
+            {
+              label:     field.nested_label,
+              name:      field_nested_name(field),
+              type:      field.type,
+              value:     values,
+              predicate: predicate_name,
+              template:  field.render.to_s,
+            }
+          end
+        end
+
+        if @ql or @edit_ql
+          init << {
+            label:     'Dotaz',
+            name:      'ql',
+            type:      'ql',
+            value:     @ql || conditions_to_ql,
+            predicate: 'eq',
+            template:  '',
+          }
+        end
+
+        init
+      end
+
+      def conditions_to_ql
+        FilterQL.conditions_to_ql(filtered_fields.map do |field, predicate_name, value|
+          [field_nested_name(field), predicate_name, value]
+        end)
+      end
+
+      def enum_options
+        Hash[filterable_fields.map do |f|
+          if options = f.enum_options
+            [ f.name, options ]
+          end
+        end.compact]
+      end
+
+      def date_format
+        @date_format ||
+          I18n.t("admin.misc.filter_date_format", :default => I18n.t("admin.misc.filter_date_format", :locale => :en))
+      end
+
+      def default_partial
+        'forms/query'
+      end
+
+      def render_field!(field)
+        # TODO view.render field.partial
+      end
+
+      def path
+        view.polymorphic_path([:query, association_chain, resource_class].flatten)
+      end
+
+      def self.localize_value(field, predicate_name, value)
+        return value if value.is_a? Array
+        return "" if FilterQL.predicates[predicate_name][:type] == :boolean
+
+        case field.type
+        when :date, :datetime
+          I18n.l(value.to_date)
+        when :time
+          I18n.l(value.to_time, :format => "%H:%M")
+        else
+          value
+        end
+      end
+
+      private
+
+      def query_from_params
+        @resource_filter, @collection = Basepack::Utils.query_from_params(
+          @scope,
+          @params,
+          {
+            auth_object: @auth_object,
+            filterql_options: @filterql_options,
+          }
+        )
+        @collection = @collection.includes(@collection_includes) if @collection_includes
+      end
+    end
+  end
+end

data/lib/basepack/forms/show.rb

@@ -0,0 +1,18 @@
+module Basepack
+  module Forms
+    class Show < Forms::Base
+      def default_partial
+        'forms/show'
+      end
+
+      def render_field!(field)
+        if field.partial_show.present?
+          view.render field.partial_show, form: self, field: field
+        else
+          view.form_field_show(field)
+        end
+      end
+    end
+  end
+end
+