netzke-basepack 0.12.9 → 1.0.0.0.pre

data/lib/netzke/grid/endpoints.rb

@@ -0,0 +1,99 @@
+module Netzke
+  module Grid
+    module Endpoints
+      extend ActiveSupport::Concern
+
+      included do
+        endpoint :read do |data|
+          attempt_operation(:read, data, client)
+        end
+
+        endpoint :create do |data|
+          attempt_operation(:create, data, client)
+        end
+
+        endpoint :update do |data|
+          attempt_operation(:update, data, client)
+        end
+
+        endpoint :destroy do |data|
+          attempt_operation(:destroy, data, client)
+        end
+
+        endpoint :save_columns do |cols|
+          state[:columns_order] = cols
+        end
+
+        # Returns options for a combobox
+        # params receive:
+        # +attr+ - column's name
+        # +query+ - what's typed-in in the combobox
+        # +id+ - selected record id
+        endpoint :get_combobox_options do |params|
+          column = non_meta_columns.detect{ |c| c[:name] == params[:attr] }
+          client.data = model_adapter.combo_data(column, params[:query])
+        end
+
+        endpoint :move_rows do |params|
+          model_adapter.move_records(params)
+        end
+
+        # Process the submit of multi-editing form ourselves
+        # TODO: refactor to let the form handle the validations
+        endpoint :multiedit_window__multiedit_form__submit do |params|
+          ids = ActiveSupport::JSON.decode(params.delete(:ids))
+          data = ids.collect{ |id| ActiveSupport::JSON.decode(params[:data]).merge("id" => id) }
+
+          data.map!{|el| el.select {|k,v| v.present? }} # only interested in set values
+
+          res = attempt_operation(:update, data, client)
+
+          errors = []
+          res.each do |id, out|
+            errors << out[:error] if out[:error]
+          end
+
+          if errors.empty?
+            on_data_changed
+            client.netzke_on_submit_success
+            "ok"
+          else
+            client.netzke_notify(errors)
+            "failure"
+          end
+        end
+
+        # The following two look a bit hackish, but serve to invoke on_data_changed when a form gets successfully
+        # submitted
+        endpoint :add_window__add_form__submit do |params|
+          client.merge!(component_instance(:add_window).
+                      component_instance(:add_form).
+                      invoke_endpoint(:submit, [params]))
+          on_data_changed if client.netzke_set_form_values.present?
+          client.delete(:netzke_set_form_values)
+        end
+
+        endpoint :edit_window__edit_form__submit do |params|
+          client.merge!(component_instance(:edit_window).
+                      component_instance(:edit_form).
+                      invoke_endpoint(:submit, [params]))
+          on_data_changed if client.netzke_set_form_values.present?
+          client.delete(:netzke_set_form_values)
+        end
+      end
+
+      # Attempts a given operation on the data. Checks permissions first.
+      # @param [Symbol] Operation: :create, :read, :update, or :delete
+      # @param [Array] Workload of operation data
+      # @param [Netzke::Core::EndpointResponse] Object collecting response to the client
+      def attempt_operation(op, data, client)
+        if allowed_to?(op)
+          send(op, data)
+        else
+          client.netzke_notify I18n.t("netzke.basepack.cannot_#{op}")
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/netzke/grid/permissions.rb

@@ -0,0 +1,18 @@
+module Netzke
+  module Grid
+    module Permissions
+      def allowed_to?(action)
+        return allowed_to_read? if action == :read
+        permissions[action].nil? ? !config.read_only : permissions[action]
+      end
+
+      def allowed_to_read?
+        permissions[:read] != false
+      end
+
+      def permissions
+        config.permissions || {}
+      end
+    end
+  end
+end

data/lib/netzke/grid/services.rb

@@ -0,0 +1,141 @@
+module Netzke
+  module Grid
+    # Implements Grid server-side operations. Used by the Endpoints module.
+    module Services
+      # Implementation for the "server_read" endpoint
+      def read(params = {})
+        {}.tap do |res|
+          records = get_records(params)
+          res[:data] = records.map{|r| model_adapter.record_to_array(r, final_columns)}
+          res[:total] = count_records(params)
+        end
+      end
+
+      # Returns hash with results per client (temporary) id, e.g.:
+      #
+      #   {
+      #     1: {errors: [], record: {title: 'New title'}},
+      #     2: {errors: ["Title must be present"], record: nil}
+      #   }
+      def create(data)
+        data.inject({}) do |out, attrs|
+          id = attrs.delete('internal_id')
+          record = model_adapter.new_record
+          out.merge(id => update_record(record, attrs))
+        end
+      end
+
+      # Receives an array of attribute hashes, e.g.:
+      #
+      #   [{"id": 1, title: "New title"}, {"id": 2, title: ""}]
+      #
+      # Returns hash with results per id, e.g.:
+      #
+      #   {
+      #     1: {errors: [], record: {title: 'New title'}},
+      #     2: {errors: ["Title must be present"], record: nil}
+      #   }
+      def update(data)
+        data.inject({}) do |out, attrs|
+          id = attrs.delete(model_adapter.primary_key)
+          record = model_adapter.find_record(id, scope: config.scope)
+          record.nil? ? out.merge(id => {error: "Not allowed to edit record #{id}"}) : out.merge(id => update_record(record, attrs))
+        end
+      end
+
+      # Destroys records by ids
+      # Returns hash with results per id, e.g.:
+      #
+      #   {
+      #     1: "ok",
+      #     2: "error: "This record could not be destroyed"
+      #   }
+      def destroy(ids)
+        out = {}
+
+        ids.each {|id|
+          record = model_adapter.find_record(id, scope: config[:scope])
+          next if record.nil?
+
+          if record.destroy
+            out[id] = "ok"
+          else
+            out[id] = {error: record.errors.to_a.first}
+          end
+        }
+
+        out
+      end
+
+      # Returns an array of records.
+      def get_records(params)
+        params[:filters] = normalize_filters(params[:filters]) if params[:filters]
+        params[:query] = normalize_query(params[:query]) if params[:query].present?
+        params[:scope] = config[:scope] # note, params[:scope] becomes ActiveSupport::HashWithIndifferentAccess
+
+        model_adapter.get_records(params, final_columns)
+      end
+
+      def count_records(params)
+        params[:scope] = config[:scope] # note, params[:scope] becomes ActiveSupport::HashWithIndifferentAccess
+
+        model_adapter.count_records(params, final_columns)
+      end
+
+      # Override this method to react on each operation that caused changing of data
+      def on_data_changed
+      end
+
+    protected
+
+      def normalize_filters(filters)
+        filters.map do |f|
+          { attr: f["property"], value: f["value"], operator: f["operator"] }.tap do |norm|
+
+            # Ext JS filters send us date in the American format
+            if f["value"].is_a?(String) && f["value"].match(/^(\d\d)\/(\d\d)\/(\d\d\d\d)$/)
+              norm[:value] = "#{$3}-#{$1}-#{$2}"
+            end
+
+            if filter_with = final_columns_hash[norm[:attr].to_sym][:filter_with]
+              norm[:proc] = filter_with
+            end
+
+            norm[:operator] = "contains" if f["type"] == "string"
+          end
+        end
+      end
+
+      def normalize_query(or_query)
+        or_query.each do |and_query|
+          and_query.each do |q|
+            column_config = final_columns_hash[q[:attr].to_sym] || {}
+            if filter_with = column_config[:filter_with]
+              q[:proc] = filter_with
+            end
+          end
+        end
+      end
+
+      def update_record(record, attrs)
+        attrs.each_pair do |k,v|
+          attr = final_columns_hash[k.to_sym]
+          next if attr.nil?
+          model_adapter.set_record_value_for_attribute(record, attr, v)
+        end
+
+        strong_attrs = config[:strong_values] || {}
+
+        strong_attrs.each_pair do |k,v|
+          model_adapter.set_record_value_for_attribute(record, {name: k.to_s}, v)
+        end
+
+        if record.save
+          {record: model_adapter.record_to_array(record, final_columns)}
+        else
+          {error: record.errors.to_a}
+        end
+      end
+    end
+  end
+end

data/lib/netzke/tree/base.rb

@@ -0,0 +1,173 @@
+module Netzke
+  module Tree
+    # Ext.tree.Panel-based component with the following features:
+    #
+    # * CRUD operations
+    # * Persistence of node expand/collapse state
+    # * Node reordering by DnD
+    #
+    # Client-side methods are documented here: http://api.netzke.org/client/classes/Netzke.Tree.Base.html.
+    #
+    # == Simple example
+    #
+    #     class Files < Netzke::Tree::Base
+    #       def configure(c)
+    #         super
+    #         c.model = "FileRecord"
+    #         c.columns = [
+    #           {name: :name, xtype: :treecolumn}, # this column will show tree nodes
+    #           :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::Grid::Base`.
+    #   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 (whith `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.
+    #
+    # [drag_drop]
+    #
+    #   Enables drag and drop in the tree.
+    #
+    # == Persisting nodes' expand/collapse state
+    #
+    # If the model includes the `expanded` DB field, the expand/collapse state will get stored in the DB.
+    class Base < Netzke::Base
+      NODE_ATTRS = {
+        boolean: %w[leaf checked expanded expandable qtip qtitle],
+        string: %w[icon icon_cls href href_target qtip qtitle]
+      }
+
+      include Netzke::Grid::Configuration
+      include Netzke::Grid::Endpoints
+      include Netzke::Grid::Services
+      include Netzke::Grid::Actions
+      include Netzke::Grid::Components
+      include Netzke::Grid::Permissions
+      include Netzke::Basepack::Columns
+      include Netzke::Basepack::Attributes
+      include Netzke::Basepack::DataAccessor
+      include Netzke::Tree::Endpoints
+
+      client_class do |c|
+        c.extend = "Ext.tree.Panel"
+        c.require :extensions
+        c.mixins << "Netzke.Grid.Columns"
+        c.mixins << "Netzke.Grid.EventHandlers"
+        c.translate *%w[are_you_sure confirmation]
+      end
+
+      action :search do |c|
+        c.excluded = true
+      end
+
+      class << self
+        def server_side_config_options
+          super + [:model]
+        end
+
+        # Borrow translations from the grid for now
+        def i18n_id
+          "netzke.grid.base"
+        end
+      end
+
+      def columns
+        add_node_interface_methods(super)
+      end
+
+      # Overrides Grid::Services#get_records
+      def get_records(params)
+        if params[:id] == 'root'
+          model_adapter.find_root_records
+        else
+          model_adapter.find_record_children(model_adapter.find_record(params[:id]))
+        end
+      end
+
+      # Overrides 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["children"] = records.map{|r| node_to_hash(r, final_columns).netzke_literalize_keys}
+          res["total"] = count_records(params)  if config[:enable_pagination]
+        end
+      end
+
+      def node_to_hash(record, columns)
+        model_adapter.record_to_hash(record, columns).tap do |hash|
+          if is_node_expanded?(record)
+            hash["children"] = record.children.map {|child| node_to_hash(child, columns).netzke_literalize_keys}
+          end
+        end
+      end
+
+      def is_node_expanded?(record)
+        record.respond_to?(:expanded) && record.expanded?
+      end
+
+      # Overrides `Grid::Configuration#configure_client`
+      def configure_client(c)
+        super
+
+        c.root ||= model_adapter.record_to_hash(model_adapter.root, final_columns).netzke_literalize_keys
+      end
+
+      private
+
+      def update_record(record, attrs)
+        if config.drag_drop && attrs['parentId']
+          parent_id = attrs['parentId'] == 'root' ? nil : attrs['parentId']
+          model_adapter.set_record_value_for_attribute(record, { name: 'parent_id' }, parent_id)
+        end
+
+        super
+      end
+
+      # 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 model_adapter.model_respond_to?(a.to_sym)
+          columns << {type: type, name: a, meta: true}
+        end
+      end
+    end
+  end
+end

data/lib/netzke/{basepack/tree/javascripts/tree.js → tree/base/client/base.js}

@@ -1,39 +1,45 @@
+/**
+ * Client-side code for [Netzke::Tree::Base](http://www.rubydoc.info/github/netzke/netzke-basepack/Netzke/Tree/Base)
+ * @class Netzke.Tree.Base
+ */
 {
   multiSelect: true,
 
   initComponent: function(){
     this.netzkeProcessColumns();
-    this.netzkeBuildModel('Ext.data.TreeModel');
     this.netzkeBuildStore();
 
     delete this.root;
 
+    if (this.config.dragDrop) {
+      this.netzkeSetDragDrop();
+    }
+
     this.plugins = this.plugins || [];
     this.plugins.push(Ext.create('Ext.grid.plugin.CellEditing', {pluginId: 'celleditor'}));
 
     this.callParent();
 
-    this.setDynamicActionProperties(); // enable/disable actions (buttons) depending on selection
-    this.getView().on('afteritemcollapse', this.handleNodeStateChange, this);
-    this.getView().on('afteritemexpand', this.handleNodeStateChange, this);
+    this.netzkeSetActionEvents();
+
+    this.getView().on('afteritemcollapse', this.netzkeOnNodeStateChange, this);
+    this.getView().on('afteritemexpand', this.netzkeOnNodeStateChange, this);
 
     this.store.on('load', function(){
       var root = this.getRootNode();
       root.collapse();
       root.expand(false);
     }, this);
-  },
 
-  handleNodeStateChange: function(node){
-    this.serverUpdateNodeState({id: node.get('id'), expanded: node.isExpanded()});
+    this.on('itemdblclick', this.netzkeHandleItemdblclick, this);
   },
 
-  // 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);
+  /**
+   * Called when a node gets expanded or collapsed.
+   * @method netzkeOnNodeStateChange
+   */
+  netzkeOnNodeStateChange: function(node){
+    this.server.updateNodeState({id: node.get('id'), expanded: node.isExpanded()});
   },
 
   netzkeBuildStore: function() {
@@ -57,23 +63,47 @@
   },
 
   netzkeBuildProxy: function() {
-    return Ext.create('Netzke.classes.Basepack.Tree.Proxy', {
-      reader: this.netzkeBuildReader(),
+    return Ext.create('Netzke.Tree.Proxy', {
+      reader: 'json',
       grid: this
     });
   },
 
-  netzkeBuildReader: function() {
-    var modelName = Netzke.modelName(this.id);
-    return Ext.create('Ext.data.reader.Json', {
-      model: modelName
-    });
+  netzkeSetDragDrop: function() {
+    this.nezkeInitViewConfig();
+
+    this.viewConfig.plugins.push(
+      Ext.create('Ext.tree.plugin.TreeViewDragDrop', {
+          enableDrag: true
+        })
+    );
+
+    this.viewConfig.listeners['drop'] = function( node, data, overModel, dropPosition, eOpts ) {
+      var parentId = (dropPosition == 'append') ? overModel.id : overModel.data.parentId;
+      var dataRecords = data.records;
+      var records = dataRecords.map(function(element){ return { id: element.id, parentId: parentId } });
+      this.panel.server.updateParentId(records, function(response){
+        dataRecords.forEach(function(record){
+          if (record.modified !== undefined &&
+            Object.keys(record.modified).length == 1
+            && record.modified["parentId"] !== undefined){
+              record.dirty = false;
+              delete record.modified["parentId"];
+          }
+        });
+      });
+    }
+  },
+
+  nezkeInitViewConfig: function() {
+    this.viewConfig = this.viewConfig || {};
+    this.viewConfig.plugins = this.viewConfig.plugins || [];
+    this.viewConfig.listeners = this.viewConfig.listeners || {};
   },
 
   // overriding
-  onAddRecord: function(){
+  netzkeOnAdd: function(){
     var selected = this.getSelection()[0]
-
     this.netzkeLoadComponent("add_window", {
       callback: function(w){
         w.show();
@@ -101,14 +131,14 @@
   },
 
   // overriding
-  onApply: function(){
+  netzkeOnApply: 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() {
+  netzkeOnDelete: function() {
     Ext.Msg.confirm(this.i18n.confirmation, this.i18n.areYouSure, function(btn){
       if (btn == 'yes') {
         var toDelete = this.getSelectionModel().getSelection();
@@ -118,6 +148,5 @@
         store.sync();
       }
     }, this);
-  },
-
+  }
 }