netzke-basepack 0.12.0 → 0.12.1

data/lib/netzke/basepack/grid/services.rb

@@ -128,7 +128,9 @@ module Netzke
           attrs.merge!(config[:strong_default_attrs]) if config[:strong_default_attrs]
 
           attrs.each_pair do |k,v|
-            data_adapter.set_record_value_for_attribute(record, final_columns_hash[k.to_sym].nil? ? {:name => k} : final_columns_hash[k.to_sym], v, config.role || :default)
+            attr = final_columns_hash[k.to_sym]
+            next if attr.nil?
+            data_adapter.set_record_value_for_attribute(record, attr, v)
           end
 
           if record.save

data/lib/netzke/basepack/search_panel.rb

@@ -9,24 +9,24 @@ module Netzke
       i18n_path = "netzke.basepack.search_panel.%s"
 
       ATTRIBUTE_OPERATORS_MAP = {
-        :integer => [
+        integer: [
           ["eq", I18n.t(i18n_path % 'equals')],
           ["gt", I18n.t(i18n_path % 'greater_than')],
           ["lt", I18n.t(i18n_path % 'less_than')]
         ],
-        :text => [
+        text: [
           ["contains", I18n.t(i18n_path % 'contains')] # same as matches => %string%
         ],
-        :string => [
+        string: [
           ["contains", I18n.t(i18n_path % 'contains')], # same as matches => %string%
           ["matches", I18n.t(i18n_path % 'matches')]
         ],
-        :boolean => [
+        boolean: [
           ["is_any", I18n.t(i18n_path % 'is_true')],
           ["is_true", I18n.t(i18n_path % 'is_true')],
           ["is_false", I18n.t(i18n_path % 'is_false')]
         ],
-        :date => [
+        date: [
           ["eq", I18n.t(i18n_path % 'date_equals')],
           ["gt", I18n.t(i18n_path % 'after')],
           ["lt", I18n.t(i18n_path % 'before')],
@@ -36,6 +36,8 @@ module Netzke
       }
 
       ATTRIBUTE_OPERATORS_MAP[:datetime] = ATTRIBUTE_OPERATORS_MAP[:date]
+      ATTRIBUTE_OPERATORS_MAP[:decimal] = ATTRIBUTE_OPERATORS_MAP[:integer]
+      ATTRIBUTE_OPERATORS_MAP[:float] = ATTRIBUTE_OPERATORS_MAP[:integer]
 
       js_configure do |c|
         c.extend = "Ext.form.FormPanel"

data/lib/netzke/basepack/search_panel/javascripts/condition_field.js

@@ -142,9 +142,8 @@ Ext.define('Netzke.classes.Netzke.Basepack.SearchPanel.ConditionField', {
     var idx = this.ownerCt.items.indexOf(this);
     var owner = this.ownerCt;
     var newSelf = Ext.createByAlias('widget.netzkebasepacksearchpanelconditionfield', Ext.apply(this.initialConfig, {name: attr, attrType: attrType, attr: attr.underscore(), ownerCt: this.ownerCt, operator: null}));
-    owner.remove(this);
     owner.insert(idx, newSelf);
-    owner.doLayout();
+    setTimeout(function() { this.destroy(); }.bind(this), 1); // this gives time for pending events to get handled without errors
   },
 
   // Returns true if it should be in the query

data/lib/netzke/basepack/tree.rb

@@ -0,0 +1,223 @@
+module Netzke
+  module Basepack
+    # Ext.tree.Panel-based component with the following features:
+    #
+    # * CRUD operations (only R is implemented atm)
+    #
+    # == Simple example
+    #
+    #     class Files < Netzke::Basepack::Tree
+    #       def configure(c)
+    #         super
+    #         c.model = "FileRecord"
+    #         c.columns = [
+    #           {name: :name, xtype: :treecolumn},
+    #           :size
+    #         ]
+    #       end
+    #     end
+    #
+    # == Instance configuration
+    #
+    # The following config options are supported:
+    #
+    # [model]
+    #
+    #   Name of the ActiveRecord model that provides data to this Tree, e.g. "FileRecord"
+    #   The model must respond to the following methods:
+    #
+    #   * TreeModel.root - the root record
+    #   * TreeModel#children - child records
+    #
+    #   Note that the awesome_nested_set gem implements the above, so, feel free to use it.
+    #
+    # [columns]
+    #
+    #   An array of columns to be displayed in the tree. See the "Columns" section in the `Netzke::Basepack::Grid`.
+    #   Additionally, you probably will want to specify which column will have the tree nodes UI by providing the
+    #   `xtype` config option set to `:treecolumn`.
+    #
+    # [root]
+    #
+    #   By default, the component will pick whatever record is returned by `TreeModel.root`, and use it as the root
+    #   record. However, sometimes the model table has multiple root records (which `parent_id` set to `nil`), and all
+    #   of them should be shown in the panel. To achive this, you can define the `root` config option,
+    #   which will serve as a virtual root record for those records. You may set it to `true`, or a hash of
+    #   attributes, e.g.:
+    #
+    #       c.root = {name: 'Root', size: 1000}
+    #
+    #   Note, that the root record can be hidden from the tree by specifying the `Ext.tree.Panel`'s `root_visible`
+    #   config option set to `false`, which is probably what you want when you have multiple root records.
+    class Tree < Netzke::Base
+      NODE_ATTRS = {
+        boolean: %w[leaf checked expanded expandable qtip qtitle],
+        string: %w[icon icon_cls href href_target qtip qtitle]
+      }
+
+      include Netzke::Basepack::Grid::Endpoints
+      include Netzke::Basepack::Grid::Services
+      include Netzke::Basepack::Columns
+      include Netzke::Basepack::DataAccessor
+
+      js_configure do |c|
+        c.extend = "Ext.tree.Panel"
+        c.mixin
+        c.mixins << "Netzke.mixins.Basepack.Columns"
+        c.mixins << "Netzke.mixins.Basepack.GridEventHandlers"
+        c.translate *%w[are_you_sure confirmation]
+        c.require :extensions
+      end
+
+      def self.server_side_config_options
+        super + [:model]
+      end
+
+      def configure(c)
+        set_defaults(c)
+        super
+      end
+
+      def columns
+        add_node_interface_methods(super)
+      end
+
+      def get_records(params)
+        if params[:id] == 'root'
+          data_adapter.find_root_records
+        else
+          data_adapter.find_record_children(data_adapter.find_record(params[:id]))
+        end
+      end
+
+      # Override Grid::Services#read so we send records as key-value JSON (instead of array)
+      def read(params = {})
+        {}.tap do |res|
+          records = get_records(params)
+          res[:data] = records.map{|r| data_adapter.record_to_hash(r, final_columns(:with_meta => true)).netzke_literalize_keys}
+          res[:total] = count_records(params)  if config[:enable_pagination]
+        end
+      end
+
+      def js_configure(c)
+        super
+
+        c.title = c.title || self.class.js_config.properties[:title] || data_class.name.pluralize
+        c.bbar = bbar
+        # c.context_menu = context_menu
+        c.columns = js_columns
+        c.columns_order = columns_order
+        c.inline_data = read if c.load_inline_data
+        c.pri = data_adapter.primary_key
+
+        if c.default_filters
+          populate_cols_with_filters(c)
+        end
+
+        c.root ||= data_adapter.record_to_hash(data_adapter.root, final_columns(with_meta: true)).netzke_literalize_keys
+      end
+
+      action :add do |a|
+        a.handler = "onAddRecord" # overriding naming conventions as Ext 4 grid has its own onAdd method
+        a.icon = :add
+      end
+
+      action :edit do |a|
+        # a.disabled = true
+        a.handler = :onEdit
+        a.icon = :table_edit
+      end
+
+      action :apply do |a|
+        a.disabled = config[:prohibit_update] && config[:prohibit_create]
+        a.icon = :tick
+      end
+
+      action :del do |a|
+        # a.disabled = true
+        a.icon = :table_row_delete
+      end
+
+      component :add_window do |c|
+        preconfigure_record_window(c)
+        c.title = "Add #{data_class.model_name.human}"
+        c.items = [:add_form]
+        c.form_config.record = data_class.new(columns_default_values)
+      end
+
+      component :edit_window do |c|
+        preconfigure_record_window(c)
+        c.title = "Edit #{data_class.model_name.human}"
+        c.items = [:edit_form]
+      end
+
+      component :multi_edit_window do |c|
+        preconfigure_record_window(c)
+        c.title = "Edit #{data_class.model_name.human.pluralize}"
+        c.items = [:multi_edit_form]
+      end
+
+      endpoint :add_window__add_form__netzke_submit do |params, this|
+        data = ActiveSupport::JSON.decode(params[:data])
+        data["parent_id"] = params["parent_id"]
+        this.merge!(component_instance(:add_window).
+                    component_instance(:add_form).
+                    submit(data, this))
+        on_data_changed if this.set_form_values.present?
+        this.delete(:set_form_values)
+      end
+
+      protected
+
+      def bbar
+        config.has_key?(:bbar) ? config[:bbar] : default_bbar
+      end
+
+      # Override to change the default bottom toolbar
+      def default_bbar
+        %i[add edit apply del]
+      end
+
+      def preconfigure_record_window(c)
+        c.klass = RecordFormWindow
+
+        c.form_config = ActiveSupport::OrderedOptions.new.tap do |f|
+          f.model = config[:model]
+          f.persistent_config = config[:persistent_config]
+          f.strong_default_attrs = config[:strong_default_attrs]
+          f.mode = config[:mode]
+          f.items = default_fields_for_forms
+        end
+      end
+
+      private
+
+      # Adds attributes known to Ext.data.NodeInterface as meta columns (only those our model responds to)
+      def add_node_interface_methods(columns)
+        columns.clone.tap do |columns|
+          NODE_ATTRS.each do |type, attrs|
+            add_node_interface_methods_by_type!(columns, attrs, type)
+          end
+        end
+      end
+
+      def add_node_interface_methods_by_type!(columns, attrs, type)
+        attrs.each do |a|
+          next unless data_adapter.model_respond_to?(a.to_sym)
+          columns << {attr_type: type, name: a, meta: true}
+        end
+      end
+
+      def set_defaults(c)
+        # The nil? checks are needed because these can be already set in a subclass
+        c.enable_edit_in_form = true if c.enable_edit_in_form.nil?
+        c.enable_edit_inline = true if c.enable_edit_inline.nil?
+        c.enable_extended_search = true if c.enable_extended_search.nil?
+        c.enable_column_filters = true if c.enable_column_filters.nil?
+        c.enable_pagination = true if c.enable_pagination.nil?
+        c.rows_per_page = 30 if c.rows_per_page.nil?
+        c.tools = %w{ refresh } if c.tools.nil?
+      end
+    end
+  end
+end

data/lib/netzke/basepack/tree/javascripts/extensions.js

@@ -0,0 +1,101 @@
+Ext.define('Netzke.classes.Basepack.Tree.Proxy', {
+  extend: 'Ext.data.proxy.Server',
+
+  batch: function(options) {
+    if (!options) return;
+    for (operation in options.operations) {
+      var op = new Ext.data.Operation({action: operation, records: options.operations[operation]});
+      this[op.action](op, Ext.emptyFn, this);
+    }
+  },
+
+  read: function(operation, callback, scope) {
+    this.grid.serverRead(this.paramsFromOperation(operation), function(res) {
+      this.processResponse(true, operation, {}, res, callback, scope);
+    }, this);
+    return {};
+  },
+
+  update: function(op, callback, scope) {
+    var data = Ext.Array.map(op.getRecords(), function(r) { return r.getData(); });
+
+    this.grid.serverUpdate(data, function(res) {
+      var errors = [];
+      Ext.each(op.records, function(r) {
+        var rid = r.getId(),
+            recordData = res[rid].record,
+            error = res[rid].error;
+        if (recordData) {
+          serverRecord = this.getReader().read({data: [res[rid].record]}).records[0];
+          r.copyFrom(serverRecord);
+          r.commit();
+        }
+        if (error) { errors.push(error); }
+      }, this);
+
+      if (errors.length == 0) {
+        // this.grid.getStore().load();
+      } else {
+        this.grid.netzkeFeedback(errors);
+      }
+    }, this);
+  },
+
+  destroy: function(op, callback, scope) {
+    var data = Ext.Array.map(op.getRecords(), function(r) { return r.getData().id; });
+    var store = this.grid.getStore();
+    this.grid.serverDelete(data, function(res){
+      var errors = [];
+      for (id in res) {
+        var error;
+        if (error = res[id].error) {
+          errors.push(error);
+          store.getRemovedRecords().forEach(function(record, i){
+            if (record.getId() == id) {
+              store.insert(record.index, record);
+            }
+          });
+        }
+      }
+
+      // clear store state
+      store.commitChanges();
+
+      if (errors.length > 0) {
+        this.grid.netzkeFeedback([errors]);
+      }
+
+      // this.grid.getStore().load();
+
+    }, this);
+  },
+  // Build consistent request params
+  paramsFromOperation: function(operation) {
+    var params = Ext.apply({id: operation.getId()}, this.getParams(operation));
+
+    if (params.filter) {
+      params.filters = Ext.decode(params.filter);
+      delete params.filter;
+    }
+
+    if (params.sort) {
+      params.sorters = Ext.decode(params.sort);
+      delete params.sort;
+    }
+
+    Ext.apply(params, this.extraParams);
+
+    return params;
+  }
+});
+
+/**
+ * A fix for CheckColumn
+ */
+Ext.override(Ext.ux.CheckColumn, {
+  processEvent: function(type) {
+    // by returning true, we'll allow event propagation, so it reacts similarly to other columns
+    if (this.readOnly && type == 'mousedown') return true;
+    else return this.callOverridden(arguments);
+  }
+});

data/lib/netzke/basepack/tree/javascripts/tree.js

@@ -0,0 +1,112 @@
+{
+  multiSelect: true,
+
+  initComponent: function(){
+    this.netzkeProcessColumns();
+    this.netzkeBuildModel('Ext.data.TreeModel');
+    this.netzkeBuildStore();
+
+    delete this.root;
+
+    this.plugins = [];
+    this.plugins.push(Ext.create('Ext.grid.plugin.CellEditing', {pluginId: 'celleditor'}));
+
+    this.callParent();
+
+    this.setDynamicActionProperties(); // enable/disable actions (buttons) depending on selection
+  },
+
+  // Process selectionchange event to enable/disable actions
+  setDynamicActionProperties: function() {
+    this.getSelectionModel().on('selectionchange', function(selModel){
+      // if (this.actions.add) this.actions.add.setDisabled(selModel.getCount() != 1);
+      if (this.actions.edit) this.actions.edit.setDisabled(selModel.getCount() != 1);
+    }, this);
+  },
+
+  netzkeBuildStore: function() {
+    var store = Ext.create('Ext.data.TreeStore', Ext.apply({
+      proxy: this.netzkeBuildProxy(),
+      pruneModifiedRecords: true,
+      remoteSort: true,
+      remoteFilter: true,
+      pageSize: this.rowsPerPage,
+      root: this.root
+    }, this.dataStore));
+
+    delete this.dataStore;
+
+    store.getProxy().getReader().on('endpointcommands', function(commands) {
+      this.netzkeBulkExecute(commands);
+    }, this);
+
+    this.store = store;
+    return store; // for backward compatibility
+  },
+
+  netzkeBuildProxy: function() {
+    return Ext.create('Netzke.classes.Basepack.Tree.Proxy', {
+      reader: this.netzkeBuildReader(),
+      grid: this
+    });
+  },
+
+  netzkeBuildReader: function() {
+    var modelName = Netzke.modelName(this.id);
+    return Ext.create('Ext.data.reader.Json', {
+      model: modelName,
+      rootProperty: 'data'
+    });
+  },
+
+  // overriding
+  onAddRecord: function(){
+    var selected = this.getSelection()[0]
+
+    this.netzkeLoadComponent("add_window", {
+      callback: function(w){
+        w.show();
+        var form = w.items.first();
+        form.on('apply', function(){
+          if (!form.baseParams) form.baseParams = {};
+          form.baseParams.parent_id = (selected || {}).id;
+        }, this);
+
+        w.on('close', function(){
+          if (w.closeRes === "ok") {
+            if (selected) {
+              if (selected.isExpanded()) {
+                this.store.load({node: selected});
+              } else {
+                selected.expand();
+              }
+            } else {
+              this.store.load()
+            }
+          }
+        }, this);
+      }, scope: this
+    });
+  },
+
+  // overriding
+  onApply: function(){
+    var topModified = this.store.getModifiedRecords()[0]; // the most top-level modified record
+    this.store.sync();
+    this.store.load({node: topModified.parentNode});
+  },
+
+  // overriding
+  onDel: function() {
+    Ext.Msg.confirm(this.i18n.confirmation, this.i18n.areYouSure, function(btn){
+      if (btn == 'yes') {
+        var toDelete = this.getSelectionModel().getSelection();
+        store = this.getStore();
+        store.remove(toDelete);
+        store.removedNodes = toDelete; // HACK
+        store.sync();
+      }
+    }, this);
+  }
+
+}