netzke-basepack-zh 0.7.6

data/lib/netzke/basepack/grid_panel/columns.rb

@@ -0,0 +1,394 @@
+module Netzke
+  module Basepack
+    class GridPanel < Netzke::Base
+      module Columns
+        extend ActiveSupport::Concern
+        extend ActiveSupport::Memoizable
+
+        # module ClassMethods
+        #   # Columns to be displayed by the FieldConfigurator, "meta-columns". Each corresponds to a configuration
+        #   # option for each column in the grid.
+        #   def meta_columns
+        #     [
+        #       # Whether the column will be present in the grid, also in :hidden or :meta state. The value for this column will
+        #       # always be sent to/from the JS grid to the server
+        #       {:name => "included",      :attr_type => :boolean, :width => 40, :header => "Incl", :default_value => true},
+        #
+        #       # The name of the column. May be any accessible method or attribute of the data_class.
+        #       {:name => "name",          :attr_type => :string, :width => 200},
+        #
+        #       # The header for the column.
+        #       {:name => "label",         :attr_type => :string, :width => 200, :header => "Header"},
+        #
+        #       # The default value of this column. Is used when a new row in the grid gets created.
+        #       {:name => "default_value", :attr_type => :string, :width => 200},
+        #
+        #       # Options for drop-downs
+        #       {:name => "combobox_options",       :attr_type => :string, :editor => :textarea, :width => 200},
+        #
+        #       # Whether the column is editable in the grid.
+        #       {:name => "read_only",     :attr_type => :boolean, :header => "R/O", :tooltip => "Read-only"},
+        #
+        #       # Whether the column will be in the hidden state (hide/show columns from the column menu, if it's enabled).
+        #       {:name => "hidden",        :attr_type => :boolean},
+        #
+        #       # Whether the column should have "grid filters" enabled
+        #       # (see here: http://www.extjs.com/deploy/dev/examples/grid-filtering/grid-filter-local.html)
+        #       {:name => "with_filters",  :attr_type => :boolean, :default_value => true, :header => "Filters"},
+        #
+        #       #
+        #       # Below some rarely used parameters, hidden by default (you can always un-hide them from the column menu).
+        #       #
+        #
+        #       # The column's width
+        #       {:name => "width",         :attr_type => :integer, :hidden => true},
+        #
+        #       # Whether the column should be hideable
+        #       {:name => "hideable",      :attr_type => :boolean, :default_value => true, :hidden => true},
+        #
+        #       # Whether the column should be sortable (why change it? normally it's hardcoded)
+        #       {:name => "sortable",      :attr_type => :boolean, :default_value => true, :hidden => true},
+        #     ]
+        #   end
+        #
+        # end
+
+        # Normalized columns for the grid, e.g.:
+        # [{:name => :id, :hidden => true, ...}, {:name => :name, :editable => false, ...}, ...]
+        # Possible options:
+        # * +with_excluded+ - when set to true, also excluded columns will be returned (handy for dynamic column configuration)
+        # * +with_meta+ - when set to true, the meta column will be included as the last column
+        def columns(options = {})
+          [].tap do |cols|
+            if loaded_columns = load_columns
+              filter_out_excluded_columns(loaded_columns) unless options[:with_excluded]
+              cols.concat(reverse_merge_equally_named_columns(loaded_columns, initial_columns(options[:with_excluded])))
+            else
+              cols.concat(initial_columns(options[:with_excluded]))
+            end
+
+            append_meta_column(cols) if options[:with_meta]
+          end
+        end
+
+        memoize :columns
+
+        def append_meta_column(cols)
+          cols << {}.tap do |c|
+            c.merge!(
+              :name => "_meta",
+              :meta => true,
+              :getter => lambda do |r|
+                meta_data(r)
+              end
+            )
+            c[:default_value] = meta_default_data if meta_default_data.present?
+          end
+        end
+
+        # default_value for the meta column; used when a new record is being created in the grid
+        def meta_default_data
+          get_default_association_values.present? ? { :association_values => get_default_association_values.literalize_keys } : {}
+        end
+
+        # Override it when you need extra meta data to be passed through the meta column
+        def meta_data(r)
+          { :association_values => get_association_values(r).literalize_keys }
+        end
+
+        # Columns as a hash, for easier access to a specific column
+        def columns_hash
+          @columns_hash ||= columns.inject({}){|r,c| r.merge(c[:name].to_sym => c)}
+        end
+
+        # Columns that we fall back to when neither persistent columns, nor configured columns are present.
+        # If there's a model-level field configuration, it's being used.
+        # Otherwise the defaults straight from the ActiveRecord model ("netzke_attributes").
+        # Override this method if you want to provide a fix set of columns in your subclass.
+        def default_columns
+          @default_columns ||= load_model_level_attrs || data_class.netzke_attributes
+        end
+
+        # Columns that were overridden with :override_columns config option.
+        def overridden_default_columns
+          if config[:override_columns].present?
+            result = []
+            default_columns.each do |col|
+              result << col.merge(config[:override_columns][col[:name].to_sym] || {})
+            end
+            result
+          else
+            default_columns
+          end
+        end
+
+        # Columns that represent a smart merge of default_columns and columns passed during the configuration.
+        def initial_columns(with_excluded = false)
+          # Normalize here, as from the config we can get symbols (names) instead of hashes
+          columns_from_config = config[:columns] && normalize_attrs(config[:columns])
+
+          if columns_from_config
+            # automatically add a column that reflects the primary key (unless specified in the config)
+            columns_from_config.insert(0, {:name => data_class.primary_key.to_s}) unless columns_from_config.any?{ |c| c[:name] == data_class.primary_key }
+
+            # reverse-merge each column hash from config with each column hash from exposed_attributes
+            # (columns from config have higher priority)
+            for c in columns_from_config
+              corresponding_default_column = overridden_default_columns.find{ |k| k[:name] == c[:name] }
+              c.reverse_merge!(corresponding_default_column) if corresponding_default_column
+            end
+            columns_for_create = columns_from_config
+          else
+            # we didn't have columns configured in component's config, so, use the columns from the data class
+            columns_for_create = overridden_default_columns
+          end
+
+          filter_out_excluded_columns(columns_for_create) unless with_excluded
+
+          # Make the column config complete with the defaults.
+          # Note: dup is needed to avoid modifying original hashes.
+          columns_for_create.map { |c| c.dup.tap { |c| augment_column_config c } }
+        end
+
+        memoize :initial_columns
+
+        private
+
+          # Based on initial column config, e.g.:
+          #
+          #   {:name=>"author__name", :attr_type=>:string}
+          #
+          # augment it with additional configuration params, e.g.:
+          #
+          #   {:name=>"author__name", :attr_type=>:string, :editor=>{:xtype=>:netzkeremotecombo}, :assoc=>true, :virtual=>true, :header=>"Author  name", :editable=>true, :sortable=>false, :filterable=>false}
+          #
+          # It may be handy to override it.
+          def augment_column_config(c)
+            # note: the order of these calls is important, as consequent calls may depend on the result of previous ones
+            set_default_xtype(c)
+            set_default_virtual(c)
+            set_default_text(c)
+            set_default_editable(c)
+            set_default_editor(c)
+            set_default_width(c)
+            set_default_hidden(c)
+            set_default_sortable(c)
+            set_default_filterable(c)
+            c[:assoc] = association_attr?(c)
+          end
+
+          def set_default_xtype(c)
+            return if c[:renderer] || c[:editor] # if user set those manually, we don't mess with column xtype
+            c[:xtype] ||= attr_type_to_xtype_map[c[:attr_type]]
+          end
+
+          def set_default_text(c)
+            c[:text] ||= c[:label] || data_class.human_attribute_name(c[:name])
+          end
+
+          def set_default_editor(c)
+            # if shouldn't be editable, don't set any default editor; also, specifying xtype takes care of the editor
+            return if c[:read_only] || c[:editable] == false
+
+            if association_attr?(c)
+              set_default_association_editor(c)
+            else
+              c[:editor] ||= editor_for_attr_type(c[:attr_type])
+            end
+
+          end
+
+          def set_default_width(c)
+            c[:width] ||= 50 if c[:attr_type] == :boolean
+            c[:width] ||= 150 if c[:attr_type] == :datetime
+          end
+
+          def set_default_hidden(c)
+            c[:hidden] = true if primary_key_attr?(c) && c[:hidden].nil?
+          end
+
+          def set_default_editable(c)
+            if c[:editable].nil?
+              c[:editable] = is_editable_column?(c)
+            end
+          end
+
+          def set_default_sortable(c)
+            # this *has* to be set to false if we don't want the column to be sortable (it's sortable by default in Ext)
+            c[:sortable] = !(c[:virtual] && !c[:sorting_scope]) if c[:sortable].nil?
+          end
+
+          def set_default_filterable(c)
+            c[:filterable] = !c[:virtual] if c[:filterable].nil?
+          end
+
+
+          # Detects an association column and sets up the proper editor.
+          def set_default_association_editor(c)
+            assoc, assoc_method =  c[:name].split('__')
+            return unless assoc
+
+            assoc_method_type = data_adapter.get_assoc_property_type assoc, assoc_method
+
+            # if association column is boolean, display a checkbox (or alike), otherwise - a combobox (or alike)
+            if c[:nested_attribute]
+              c[:editor] ||= editor_for_attr_type(assoc_method_type)
+            else
+              c[:editor] ||= assoc_method_type == :boolean ? editor_for_attr_type(:boolean) : editor_for_association
+            end
+          end
+
+          # If the column should be editable
+          def is_editable_column?(c)
+            not_editable_if = primary_key_attr?(c)
+            not_editable_if ||= c[:virtual] && !association_attr?(c[:name])
+            not_editable_if ||= c[:read_only]
+
+            editable_if = data_class.column_names.include?(c[:name])
+            editable_if ||= data_class.instance_methods.map(&:to_s).include?("#{c[:name]}=")
+            editable_if ||= association_attr?(c[:name])
+
+            editable_if && !not_editable_if
+          end
+
+          def initial_columns_order
+            columns.map do |c|
+              {
+                :name => c[:name],
+                :width => c[:width],
+                :hidden => c[:hidden]
+              }
+            end
+          end
+
+          def columns_order
+            if config[:persistence]
+              update_state(:columns_order, initial_columns_order) if columns_have_changed?
+              state[:columns_order] || initial_columns_order
+            else
+              initial_columns_order
+            end
+          end
+
+          def columns_have_changed?
+            init_column_names = initial_columns_order.map{ |c| c[:name].to_s }.sort
+            stored_column_names = (state[:columns_order] || initial_columns_order).map{ |c| c[:name].to_s }.sort
+            init_column_names != stored_column_names
+          end
+
+          def filter_out_excluded_columns(cols)
+            cols.reject!{ |c| c[:included] == false }
+          end
+
+          # Stores modified columns in persistent storage
+          def save_columns!
+            # NetzkeFieldList.update_list_for_current_authority(global_id, columns(false), original_data_class.name) if persistent_config_enabled?
+          end
+
+          def load_columns
+            # NetzkeFieldList.read_list(global_id) if persistent_config_enabled?
+          end
+
+          def load_model_level_attrs
+            # NetzkeModelAttrList.read_list(data_class.name) if persistent_config_enabled?
+          end
+
+          # Column editor config for attribute type.
+          def editor_for_attr_type(type)
+            {:xtype => attr_type_to_editor_xtype_map[type] || :textfield}
+          end
+
+          # Column editor config for one-to-many association
+          def editor_for_association
+            {:xtype => :netzkeremotecombo}
+          end
+
+          # Hash that maps a column type to the editor xtype. Override if you want different editors.
+          def attr_type_to_editor_xtype_map
+            {
+              :integer => :numberfield,
+              :boolean => :checkbox,
+              :date => :datefield,
+              :datetime => :xdatetime,
+              :text => :textarea,
+              :string => :textfield
+            }
+          end
+
+          def attr_type_to_xtype_map
+            {
+              # :integer  => :numbercolumn, # don't like the default formatter
+              :boolean  => :checkcolumn,
+              :date     => :datecolumn,
+              #:datetime => :datecolumn # TODO: replace with datetimepicker
+            }
+          end
+
+          # Default fields that will be displayed in the Add/Edit/Search forms
+          # When overriding this method, keep in mind that the fields inside the layout must be expanded (each field represented by a hash, not just a symbol)
+          def default_fields_for_forms
+            selected_columns = columns.select do |c|
+              data_class.column_names.include?(c[:name]) ||
+              data_class.instance_methods.include?("#{c[:name]}=") ||
+              association_attr?(c[:name])
+            end
+
+            selected_columns.map do |c|
+              field_config = {
+                :name => c[:name],
+                :field_label => c[:text] || c[:header]
+              }
+
+              # scopes for combobox options
+              field_config[:scopes] = c[:editor][:scopes] if c[:editor].is_a?(Hash)
+
+              field_config.merge!(c[:editor] || {})
+
+              field_config
+            end
+          end
+
+          # default_fields_for_forms extended with default values (for new-record form)
+          # def default_fields_for_forms_with_default_values
+          #   res = default_fields_for_forms.dup
+          #   each_attr_in(res) do |a|
+          #     attr_name = a[:name].to_sym
+          #     a[:value] = a[:default_value] || columns_hash[attr_name].try(:fetch, :default_value, nil) || data_class.netzke_attribute_hash[attr_name].try(:fetch, :default_value, nil)
+          #   end
+          #   res
+          # end
+
+          def columns_default_values
+            columns.inject({}) do |r,c|
+              assoc_name, assoc_method = c[:name].split '__'
+              if c[:default_value].nil?
+                r
+              else
+                if assoc_method
+                  r.merge(data_adapter.foreign_key_for(assoc_name) || data_adapter.foreign_key_for(assoc_name) => c[:default_value])
+                else
+                  r.merge(c[:name] => c[:default_value])
+                end
+              end
+            end
+          end
+
+          # Recursively traversess items (an array) and yields each found field (a hash with :name set)
+          def each_attr_in(items)
+            items.each do |item|
+              if item.is_a?(Hash)
+                each_attr_in(item[:items]) if item[:items].is_a?(Array)
+                yield(item) if item[:name]
+              end
+            end
+          end
+
+          # Receives 2 arrays of columns. Merges the missing config from the +source+ into +dest+, matching columns by name
+          def reverse_merge_equally_named_columns(dest, source)
+            dest.each{ |dc| dc.reverse_merge!(source.detect{ |sc| sc[:name] == dc[:name] } || {}) }
+          end
+
+      end
+    end
+  end
+end

data/lib/netzke/basepack/grid_panel/javascripts/advanced_search.js

@@ -0,0 +1,27 @@
+{
+  onSearch: function(el){
+    if (this.searchWindow) {
+      this.searchWindow.show();
+    } else {
+      this.loadNetzkeComponent({name: 'search_form', callback: function(win){
+        this.searchWindow = win;
+        win.show();
+
+        win.items.first().on('apply', function(){
+          win.onSearch();
+          return false; // do not propagate the 'apply' event
+        }, this);
+
+        win.on('hide', function(){
+          var query = win.getQuery();
+          if (win.closeRes == 'search'){
+            var store = this.getStore(), proxy = store.getProxy();
+            proxy.extraParams.query = Ext.encode(query);
+            store.load();
+          }
+          el.toggle(query.length > 0); // toggle based on the state
+        }, this);
+      }, scope: this});
+    }
+  }
+}

data/lib/netzke/basepack/grid_panel/javascripts/check_column_fix.js

@@ -0,0 +1,6 @@
+Ext.override(Ext.ux.CheckColumn, {
+  processEvent: function() {
+    if (this.editable === false) return false;
+    else return this.callOverridden(arguments);
+  }
+});

data/lib/netzke/basepack/grid_panel/javascripts/edit_in_form.js

@@ -0,0 +1,51 @@
+{
+  onEditInForm: function(){
+    var selModel = this.getSelectionModel();
+    if (selModel.getCount() > 1) {
+      var recordId = selModel.selected.first().getId();
+      this.loadNetzkeComponent({name: "multi_edit_form",
+        params: {record_id: recordId},
+        callback: function(w){
+          w.show();
+          var form = w.items.first();
+          form.on('apply', function(){
+            var ids = [];
+            selModel.selected.each(function(r){
+              ids.push(r.getId());
+            });
+            if (!form.baseParams) form.baseParams = {};
+            form.baseParams.ids = Ext.encode(ids);
+          }, this);
+
+          w.on('close', function(){
+            if (w.closeRes === "ok") {
+              this.store.load();
+            }
+          }, this);
+        }, scope: this});
+    } else {
+      var recordId = selModel.selected.first().getId();
+      this.loadNetzkeComponent({name: "edit_form",
+        params: {record_id: recordId},
+        callback: function(w){
+          w.show();
+          w.on('close', function(){
+            if (w.closeRes === "ok") {
+              this.store.load();
+            }
+          }, this);
+        }, scope: this});
+    }
+  },
+
+  onAddInForm: function(){
+    this.loadNetzkeComponent({name: "add_form", callback: function(w){
+      w.show();
+      w.on('close', function(){
+        if (w.closeRes === "ok") {
+          this.store.load();
+        }
+      }, this);
+    }, scope: this});
+  }
+}