netzke-basepack 0.12.9 → 1.0.0.0.pre

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

@@ -1,111 +0,0 @@
-module Netzke
-  module Basepack
-    class Grid < Netzke::Base
-      module Endpoints
-        extend ActiveSupport::Concern
-
-        included do
-          endpoint :server_read do |data, this|
-            attempt_operation(:read, data, this)
-          end
-
-          endpoint :server_create do |data, this|
-            attempt_operation(:create, data, this)
-          end
-
-          endpoint :server_update do |data, this|
-            attempt_operation(:update, data, this)
-          end
-
-          endpoint :server_delete do |data, this|
-            attempt_operation(:destroy, data, this)
-          end
-
-          endpoint :server_save_columns do |cols, this|
-            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, this|
-            column = final_columns.detect{ |c| c[:name] == params[:attr] }
-            this.data = data_adapter.combo_data(column, params[:query])
-          end
-
-          endpoint :move_rows do |params, this|
-            data_adapter.move_records(params)
-          end
-
-          # Process the submit of multi-editing form ourselves
-          # TODO: refactor to let the form handle the validations
-          endpoint :multi_edit_window__multi_edit_form__netzke_submit do |params, this|
-            ids = ActiveSupport::JSON.decode(params.delete(:ids))
-            data = ids.collect{ |id| ActiveSupport::JSON.decode(params[:data]).merge("id" => id) }
-
-            data.map!{|el| el.delete_if{ |k,v| v.is_a?(String) && v.blank? }} # only interested in set values
-
-            res = attempt_operation(:update, data, this)
-
-            errors = []
-            res.each do |id, out|
-              errors << out[:error] if out[:error]
-            end
-
-            if errors.empty?
-              on_data_changed
-              this.netzke_set_result("ok")
-              this.on_submit_success
-            end
-
-            this.netzke_feedback(errors)
-          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__netzke_submit do |params, this|
-            this.merge!(component_instance(:add_window).
-                        component_instance(:add_form).
-                        invoke_endpoint(:netzke_submit, params))
-            on_data_changed if this.set_form_values.present?
-            this.delete(:set_form_values)
-          end
-
-          endpoint :edit_window__edit_form__netzke_submit do |params, this|
-            this.merge!(component_instance(:edit_window).
-                        component_instance(:edit_form).
-                        invoke_endpoint(:netzke_submit, params))
-            on_data_changed if this.set_form_values.present?
-            this.delete(:set_form_values)
-          end
-        end
-
-        # Operations:
-        #   create, read, update, delete
-        def attempt_operation(op, data, this)
-          # if data is ActionController::Parameters and a scope is in the component config
-          # then ran this in an ActiveModel::ForbiddenAttributesError (rails 4 strong parameters)
-          # solution: in this case convert ActionController::Parameters to a Hash
-          if data.is_a?ActionController::Parameters
-            dataHash = {}
-            data.each do |k,v|
-              #preserve keys as symbol
-              dataHash[k.to_sym] = v
-            end
-            data = dataHash
-          end
-          if !config["prohibit_#{op}"]
-            res = send(op, data)
-            this.netzke_set_result res
-            res
-          else
-            this.netzke_feedback I18n.t("netzke.basepack.grid.cannot_#{op}")
-            this.netzke_set_result(data: [], total: 0)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-{
-  onEditInForm: function(){
-    var selModel = this.getSelectionModel();
-    if (selModel.getCount() > 1) {
-      var recordId = selModel.selected.first().getId();
-      this.netzkeLoadComponent("multi_edit_window", {
-        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.netzkeLoadComponent("edit_window", {
-        clientConfig: {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.netzkeLoadComponent("add_window", {callback: function(w){
-      w.show();
-      w.on('close', function(){
-        if (w.closeRes === "ok") {
-          this.store.load();
-        }
-      }, this);
-    }, scope: this});
-  }
-}

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

@@ -1,148 +0,0 @@
-module Netzke
-  module Basepack
-    class Grid < Netzke::Base
-      # 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| data_adapter.record_to_array(r, final_columns(:with_meta => true))}
-            res[:total] = count_records(params)  if config[:enable_pagination]
-          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 = data_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(data_adapter.primary_key)
-            record = data_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 = data_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?
-          if config[:enable_pagination]
-            params[:limit] = config[:rows_per_page]
-          else
-            params.delete(:limit)
-          end
-          params[:scope] = config[:scope] # note, params[:scope] becomes ActiveSupport::HashWithIndifferentAccess
-
-          data_adapter.get_records(params, final_columns)
-        end
-
-        def count_records(params)
-          params[:scope] = config[:scope] # note, params[:scope] becomes ActiveSupport::HashWithIndifferentAccess
-
-          data_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?
-            data_adapter.set_record_value_for_attribute(record, attr, v)
-          end
-
-          strong_attrs = config[:strong_default_attrs] || {}
-
-          strong_attrs.each_pair do |k,v|
-            data_adapter.set_record_value_for_attribute(record, {name: k.to_s}, v)
-          end
-
-          if record.save
-            {record: data_adapter.record_to_array(record, final_columns(:with_meta => true))}
-          else
-            {error: record.errors.to_a}
-          end
-        end
-      end
-    end
-  end
-end

data/lib/netzke/basepack/tab_panel.rb

@@ -1,22 +0,0 @@
-module Netzke
-  module Basepack
-    # = TabPanel
-    #
-    # Features:
-    # * Dynamically loads components for the tabs that get activated for the first time
-    # * (TODO) Provides the method markTabsOutdated to mark all inactive tabs as 'outdated', and calls "update" method on components in tabs when they get activated
-    # * (TODO) Stores the last active tab in persistent config
-    #
-    # ToDo:
-    # * Introduce a second or two delay before informing the server about a tab switched
-    class TabPanel < Netzke::Base
-
-      include WrapLazyLoaded
-
-      js_configure do |c|
-        c.extend = "Ext.tab.Panel"
-        c.mixin
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-{
-  initComponent: function(params){
-    this.callParent();
-    this.on('tabchange', function(self, tab){
-      if (tab && tab.wrappedComponent && !tab.items.first() && !tab.beingLoaded) {
-        tab.beingLoaded = true; // prevent more than one request per tab in case of fast clicking
-        this.netzkeLoadComponent(tab.wrappedComponent, {container: tab.id, callback: function(){tab.beingLoaded = false}});
-      }
-    }, this);
-  }
-}

data/lib/netzke/basepack/tree.rb

@@ -1,269 +0,0 @@
-module Netzke
-  module Basepack
-    # Ext.tree.Panel-based component with the following features:
-    #
-    # * CRUD operations
-    # * Persistence of node expand/collapse state
-    # * (TODO) Node reordering by DnD
-    #
-    # == Simple example
-    #
-    #     class Files < Netzke::Basepack::Tree
-    #       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::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 (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.
-    #
-    # [scope]
-    #
-    #   Specifies how the records should be scoped.
-    #
-    #   When it's a symbol, it's used as a scope name.
-    #   When it's a string, it's a SQL statement (passed directly to +where+).
-    #   When it's a hash, it's a conditions hash (passed directly to +where+).
-    #   When it's an array, it's expanded into an SQL statement with arguments (passed directly to +where+), e.g.:
-    #
-    #     scope: ["id > ?", 100])
-    #
-    #   When it's a Proc, it gets the current relation passed as the only parameter and is expected to return a
-    #   relation, e.g.:
-    #
-    #     scope: ->(relation) { relation.where(user_id: 100) }
-    #
-    # == Persisting nodes' expand/collapse state
-    #
-    # If the model includes the `expanded` DB field, the expand/collapse state will get stored in the DB.
-    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(config[:scope])
-        else
-          data_adapter.find_record_children(data_adapter.find_record(params[:id]), config[:scope])
-        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["children"] = records.map{|r| node_to_hash(r, final_columns(with_meta: true)).netzke_literalize_keys}
-          res["total"] = count_records(params)  if config[:enable_pagination]
-        end
-      end
-
-      def node_to_hash(record, columns)
-        data_adapter.record_to_hash(record, columns).tap do |hash|
-          if is_node_expanded?(record)
-            hash["children"] = record.children.extend_with(config.scope).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
-
-      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 = {items: js_columns}
-        c.columns_order = columns_order
-        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
-
-      endpoint :server_update_node_state do |params, this|
-        node = data_adapter.find_record(params[:id])
-        if node.respond_to?(:expanded)
-          node.expanded = params[:expanded]
-          data_adapter.save_record(node)
-        end
-      end
-
-      protected
-
-      def bbar
-        config.has_key?(:bbar) ? config[:bbar] : default_bbar
-      end
-
-      # Override to change the default bottom toolbar
-      def default_bbar
-        [: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
-
-      def self.server_side_config_options
-        super + [:scope]
-      end
-
-    end
-  end
-end