netzke-basepack 0.1.4.1 → 0.2.0

data/lib/netzke/container.rb

@@ -20,7 +20,7 @@ module Netzke
       dep
     end
 
-    def js_before_constructor
+    def self.js_before_constructor
       js_widget_items
     end
     
@@ -32,7 +32,7 @@ module Netzke
       config[:items] || []
     end
     
-    def js_widget_items
+    def self.js_widget_items
       res = ""
       item_aggregatees.each_pair do |k,v|
         next if v[:late_aggregation]
@@ -43,7 +43,7 @@ module Netzke
       res
     end
 
-    def js_items
+    def self.js_items
       items.inject([]) do |a,i|
         a << {
           :title => i.to_s.humanize,
@@ -61,7 +61,7 @@ module Netzke
       end
     end
     
-    def js_extend_properties
+    def self.js_extend_properties
       {
         # loads widget into the panel if it's not loaded yet
         :load_item_widget => <<-JS.l,
@@ -74,7 +74,7 @@ module Netzke
     end
 
     protected
-    def item_aggregatees
+    def self.item_aggregatees
       aggregatees.delete_if{|k,v| !@items.include?(k)}
     end
   end

data/lib/netzke/{grid.rb → grid_panel.rb}

@@ -4,42 +4,47 @@ module Netzke
   # Functionality:
   # * data operations - get, post, delete, create
   # * column resize and move
+  # * column hide - TODO
   # * permissions
   # * sorting
   # * pagination
+  # * filtering
   # * properties and column configuration
   #
-  class Grid < Base
-    include GridJsBuilder
-    include GridInterface
+  class GridPanel < Base
+    include GridPanelJsBuilder
+    include GridPanelInterface
 
-    # define connection points between client side and server side of Grid. See implementation of equally named methods in the GridInterface module.
+    # define connection points between client side and server side of GridPanel. See implementation of equally named methods in the GridPanelInterface module.
     interface :get_data, :post_data, :delete_data, :resize_column, :move_column, :get_cb_choices
 
+    # default grid configuration
     def initial_config
       {
-        :ext_config => {:properties => true, :column_filters => true},
-        :layout_manager => "NetzkeLayout",
-        :column_resize => true,
-        :column_move => true
+        :ext_config => {
+          :config_tool => false, 
+          :enable_column_filters => Netzke::Base.config[:grid_panel][:filters], 
+          :enable_column_move => true, 
+          :enable_column_resize => true,
+          :border => true
+        },
+        :layout_manager => "NetzkeLayout"
       }
     end
 
     def property_widgets
       [{
-        :columns => {
-          :widget_class_name => "Grid", 
-          :data_class_name => column_manager_class_name, 
-          :ext_config => {:title => false, :properties => false},
-          :active => true
-        }
+        :name => 'columns',
+        :widget_class_name => "GridPanel", 
+        :data_class_name => column_manager_class_name, 
+        :ext_config => {:title => false, :config_tool => false},
+        :active => true
       },{
-        :general => {
-          :widget_class_name => "PreferenceGrid", 
-          :host_widget_name => @id_name, 
-          :default_properties => available_permissions.map{ |k| {:name => "permissions.#{k}", :value => @permissions[k.to_sym]}},
-          :ext_config => {:title => false}
-        }
+        :name => 'general',
+        :widget_class_name => "PreferenceGrid", 
+        :host_widget_name => @id_name, 
+        :default_properties => available_permissions.map{ |k| {:name => "permissions.#{k}", :value => @permissions[k.to_sym]}},
+        :ext_config => {:title => false}
       }]
     end
 
@@ -68,7 +73,7 @@ module Netzke
     end
     
     def column_manager_class_name
-      "NetzkeGridColumn"
+      "NetzkeGridPanelColumn"
     end
     
     def column_manager_class
@@ -101,13 +106,13 @@ module Netzke
 
     def actions
       [{
-        :text => 'Add', :handler => 'add', :disabled => @pref['permissions.create'] == false
+        :text => 'Add', :handler => 'add', :disabled => !@permissions[:create]
       },{
-        :text => 'Edit', :handler => 'edit', :disabled => @pref['permissions.update'] == false
+        :text => 'Edit', :handler => 'edit', :disabled => !@permissions[:update]
       },{
-        :text => 'Delete', :handler => 'delete', :disabled => @pref['permissions.delete'] == false
+        :text => 'Delete', :handler => 'delete', :disabled => !@permissions[:delete]
       },{
-        :text => 'Apply', :handler => 'submit', :disabled => @pref['permissions.update'] == false && @pref['permissions.create'] == false
+        :text => 'Apply', :handler => 'submit', :disabled => !@permissions[:update] && !@permissions[:create]
       }]
     end
 

data/lib/netzke/{grid_interface.rb → grid_panel_interface.rb}

@@ -1,4 +1,4 @@
-module Netzke::GridInterface
+module Netzke::GridPanelInterface
   def post_data(params)
     [:create, :update].each do |operation|
       data = JSON.parse(params.delete("#{operation}d_records".to_sym)) if params["#{operation}d_records".to_sym]
@@ -32,16 +32,20 @@ module Netzke::GridInterface
   end
 
   def resize_column(params)
-    raise "Called interface_resize_column while not configured to do so" unless config[:column_resize]
-    l_item = layout_manager_class.by_widget(id_name).layout_items[params[:index].to_i]
-    l_item.width = params[:size]
-    l_item.save!
+    raise "Called interface_resize_column while not configured to do so" unless config[:ext_config][:enable_column_resize]
+    if layout_manager_class
+      l_item = layout_manager_class.by_widget(id_name).layout_items[params[:index].to_i]
+      l_item.width = params[:size]
+      l_item.save!
+    end
     {}
   end
   
   def move_column(params)
-    raise "Called interface_move_column while not configured to do so" unless config[:column_move]
-    layout_manager_class.by_widget(id_name).move_item(params[:old_index].to_i, params[:new_index].to_i)
+    raise "Called interface_move_column while not configured to do so" unless config[:ext_config][:enable_column_move]
+    if layout_manager_class
+      layout_manager_class.by_widget(id_name).move_item(params[:old_index].to_i, params[:new_index].to_i)
+    end
     {}
   end
 

data/lib/netzke/grid_panel_js_builder.rb

@@ -0,0 +1,282 @@
+module Netzke::GridPanelJsBuilder
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  def js_config
+    res = super
+    # we pass column config at the time of instantiating the JS class
+    res.merge!(:columns => get_columns || config[:columns]) # first try to get columns from DB, then from config
+    res.merge!(:data_class_name => config[:data_class_name])
+    res
+  end
+  
+  module ClassMethods
+
+    def js_base_class 
+      'Ext.grid.EditorGridPanel'
+    end
+
+    def js_bbar
+      <<-JS.l
+      (config.rowsPerPage) ? new Ext.PagingToolbar({
+        pageSize:config.rowsPerPage, 
+        items:config.actions, 
+        store:ds, 
+        emptyMsg:'Empty'}) : config.actions
+      JS
+    end
+
+    def js_default_config
+      super.merge({
+        :store => "ds".l,
+        :cm => "cm".l,
+        :sel_model => "new Ext.grid.RowSelectionModel()".l,
+        :auto_scroll => true,
+        :click_to_edit => 2,
+        :track_mouse_over => true,
+        # :bbar => "config.actions".l,
+        :bbar => js_bbar,
+        :plugins => "plugins".l,
+      
+        #custom configs
+        :auto_load_data => true
+      })
+    end
+  
+    def js_before_constructor
+      <<-JS
+      var plugins = [];
+    	if (!config.columns) this.feedback('No columns defined for grid '+config.id);
+      this.recordConfig = [];
+      Ext.each(config.columns, function(column){this.recordConfig.push({name:column.name})}, this);
+      this.Row = Ext.data.Record.create(this.recordConfig);
+
+      var ds = new Ext.data.Store({
+          proxy: this.proxy = new Ext.data.HttpProxy({url:config.interface.getData}),
+          reader: new Ext.data.ArrayReader({root: "data", totalProperty: "total", successProperty: "succes", id:0}, this.Row),
+          remoteSort: true,
+          listeners:{'loadexception':{
+            fn:this.loadExceptionHandler,
+            scope:this
+          }}
+      });
+    
+      this.cmConfig = [];
+      Ext.each(config.columns, function(c){
+        var editor = (c.readOnly || !config.permissions.update) ? null : Ext.netzke.editors[c.editor](c, config);
+
+        this.cmConfig.push({
+          header: c.label || c.name,
+          dataIndex: c.name,
+          hidden: c.hidden,
+          width: c.width,
+          editor: editor,
+          sortable: true
+        })
+      }, this);
+
+      var cm = new Ext.grid.ColumnModel(this.cmConfig);
+    
+      this.addEvents("refresh");
+    
+      // Filters
+      if (config.enableColumnFilters) {
+        var filters = []
+        Ext.each(config.columns, function(c){
+          filters.push({type:Ext.netzke.filterMap[c.editor], dataIndex:c.name})
+        })
+      	var gridFilters = new Ext.grid.GridFilters({filters:filters});
+        plugins.push(gridFilters);
+      }
+    
+      JS
+    end
+  
+    def js_listeners
+      super.merge({
+        :columnresize => {:fn => "this.onColumnResize".l, :scope => this},
+        :columnmove => {:fn => "this.onColumnMove".l, :scope => this}
+      })
+    end
+  
+    def js_extend_properties
+      {
+        :on_widget_load => <<-JS.l,
+          function(){
+            // auto-load
+            if (this.initialConfig.autoLoadData) {
+              // if we have a paging toolbar, load the first page, otherwise
+              if (this.getBottomToolbar().changePage) this.getBottomToolbar().changePage(0); else this.store.load();
+            }
+          }
+        JS
+      
+        :load_exception_handler => <<-JS.l,
+        function(proxy, options, response, error){
+          if (response.status == 200 && (responseObject = Ext.decode(response.responseText)) && responseObject.flash){
+            this.feedback(responseObject.flash)
+          } else {
+            if (error){
+              this.feedback(error.message);
+            } else {
+              this.feedback(response.statusText)
+            }  
+          }
+        }        
+        JS
+    
+        :add => <<-JS.l,
+          function(){
+            var rowConfig = {};
+            Ext.each(this.initialConfig.columns, function(c){
+              rowConfig[c.name] = c.defaultValue || ''; // FIXME: if the user is happy with all the defaults, the record won't be 'dirty'
+            }, this);
+          
+            var r = new this.Row(rowConfig); // TODO: add default values
+            r.set('id', -r.id); // to distinguish new records by negative values
+            this.stopEditing();
+        		this.store.add(r);
+        		this.store.newRecords = this.store.newRecords || []
+        		this.store.newRecords.push(r);
+            // console.info(this.store.newRecords);
+            this.tryStartEditing(this.store.indexOf(r));
+        	}
+        JS
+    
+        :edit => <<-JS.l,
+          function(){
+            var row = this.getSelectionModel().getSelected();
+            if (row){
+              this.tryStartEditing(this.store.indexOf(row))
+            }
+          }
+        JS
+    
+        # try editing the first editable (not hidden, not read-only) sell
+        :try_start_editing => <<-JS.l,
+        	function(row){
+        	  if (row == null) return;
+        		var editableColumns = this.getColumnModel().getColumnsBy(function(columnConfig, index){
+        			return !columnConfig.hidden && !!columnConfig.editor;
+        		});
+        		// console.info(editableColumns);
+        		var firstEditableColumn = editableColumns[0];
+        		if (firstEditableColumn){
+        			this.startEditing(row, firstEditableColumn.id);
+        		}
+        	}
+        JS
+
+        :delete => <<-JS.l,
+          function() {
+            if (this.getSelectionModel().hasSelection()){
+              Ext.Msg.confirm('Confirm', 'Are you sure?', function(btn){
+                if (btn == 'yes') {
+                  var records = []
+                  this.getSelectionModel().each(function(r){
+            		    records.push(r.get('id'));
+                  }, this);
+          		    Ext.Ajax.request({
+              			url: this.initialConfig.interface.deleteData,
+              			params: {records: Ext.encode(records)},
+              			success:function(r){ 
+              				var m = Ext.decode(r.responseText);
+              				this.store.reload();
+                      // this.loadWithFeedback();
+              				this.feedback(m.flash);
+              			},
+              			scope:this
+              		});
+                }
+              }, this);
+            }
+          }
+        JS
+        :submit => <<-JS.l,
+          function(){
+
+            var newRecords = [];
+            if (this.store.newRecords){
+          		Ext.each(this.store.newRecords, function(r){
+          		  newRecords.push(r.getChanges())
+          		  r.commit() // commit the changes, so that they are not picked up by getModifiedRecords() further down
+          		}, this);
+          		delete this.store.newRecords;
+          	}
+      		
+          	var updatedRecords = [];
+        		Ext.each(this.store.getModifiedRecords(),
+        			function(record) {
+        				var completeRecordData = {};
+        				Ext.apply(completeRecordData, Ext.apply(record.getChanges(), {id:record.get('id')}));
+        				updatedRecords.push(completeRecordData);
+        			}, 
+        		this);
+          
+            if (newRecords.length > 0 || updatedRecords.length > 0) {
+          		Ext.Ajax.request({
+          			url:this.initialConfig.interface.postData,
+          			params: {
+          			  updated_records: Ext.encode(updatedRecords), 
+          			  created_records: Ext.encode(newRecords),
+          			  filters: this.store.baseParams.filters
+          			},
+          			success:function(response){
+          				var m = Ext.decode(response.responseText);
+          				if (m.success) {
+          					this.store.reload();
+                    // this.loadWithFeedback();
+          					this.store.commitChanges();
+          					this.feedback(m.flash);
+          				} else {
+          					this.feedback(m.flash);
+          				}
+          			},
+          			failure:function(response){
+          				this.feedback('Bad response from server');
+          			},
+          			scope:this
+          		});
+            }
+          
+          }
+        JS
+   
+        :refresh_click => <<-JS.l,
+          function() {
+            // console.info(this);
+            // if (this.fireEvent('refresh', this) !== false) this.loadWithFeedback();
+            if (this.fireEvent('refresh', this) !== false) this.store.reload();
+          }
+        JS
+      
+        :on_column_resize => <<-JS.l,
+          function(index, size){
+            Ext.Ajax.request({
+              url:this.initialConfig.interface.resizeColumn,
+              params:{
+                index:index,
+                size:size
+              }
+            })
+          }
+        JS
+      
+        :on_column_move => <<-JS.l
+          function(oldIndex, newIndex){
+            Ext.Ajax.request({
+              url:this.initialConfig.interface.moveColumn,
+              params:{
+                old_index:oldIndex,
+                new_index:newIndex
+              }
+            })
+          }
+        JS
+      
+      }
+    end
+
+  end
+end