netzke-basepack 0.3.1 → 0.3.3

data/lib/netzke/grid_panel.rb

@@ -12,13 +12,17 @@ module Netzke
   # * properties and column configuration
   #
   class GridPanel < Base
-    include GridPanelJsBuilder
-    include GridPanelInterface
+    include_extras(__FILE__)
 
     # 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
 
+    include Netzke::DbFields
+
     module ClassMethods
+      def widget_type
+        :grid
+      end
 
       # Global GridPanel configuration
       def config
@@ -51,7 +55,6 @@ module Netzke
           :enable_column_filters => Netzke::Base.config[:grid_panel][:filters],
           :enable_column_move    => true,
           :enable_column_resize  => true,
-          :border                => true,
           :load_mask             => true
         },
         :persistent_layout => true,
@@ -64,19 +67,24 @@ module Netzke
     end
 
     def property_widgets
-      [{
+      res = []
+      res << {
         :name              => 'columns',
         :widget_class_name => "FieldsConfigurator",
         :ext_config        => {:title => false},
         :active            => true,
         :layout            => NetzkeLayout.by_widget(id_name)
-      },{
+      } if config[:persistent_layout]
+
+      res << {
         :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}
-      }]
+      }
+      
+      res
     end
 
     def properties__general__load_source(params = {})
@@ -98,9 +106,9 @@ module Netzke
       if config[:persistent_layout] && layout_manager_class && column_manager_class
         layout = layout_manager_class.by_widget(id_name)
         layout ||= column_manager_class.create_layout_for_widget(self)
-        layout.items_hash  # TODO: bad name!
+        layout.items_arry
       else
-        Netzke::Column.default_columns_for_widget(self)
+        default_db_fields
       end
     end
     
@@ -110,13 +118,13 @@ module Netzke
 
     def actions
       [{
-        :text => 'Add', :handler => 'add', :disabled => !@permissions[:create]
+        :text => 'Add', :handler_name => 'add', :disabled => !@permissions[:create], :id => 'add'
       },{
-        :text => 'Edit', :handler => 'edit', :disabled => !@permissions[:update]
+        :text => 'Edit', :handler_name => 'edit', :disabled => !@permissions[:update], :id => 'edit'
       },{
-        :text => 'Delete', :handler => 'delete', :disabled => !@permissions[:delete]
+        :text => 'Delete', :handler_name => 'delete', :disabled => !@permissions[:delete], :id => 'delete'
       },{
-        :text => 'Apply', :handler => 'submit', :disabled => !@permissions[:update] && !@permissions[:create]
+        :text => 'Apply', :handler_name => 'submit', :disabled => !@permissions[:update] && !@permissions[:create], :id => 'apply'
       }]
     end
 

data/lib/netzke/grid_panel_extras/interface.rb

@@ -0,0 +1,181 @@
+module Netzke
+  module GridPanelExtras
+    module Interface
+      def post_data(params)
+        success = true
+        mod_record_ids = {}
+        [:create, :update].each do |operation|
+          data = JSON.parse(params.delete("#{operation}d_records".to_sym)) if params["#{operation}d_records".to_sym]
+          if !data.nil? && !data.empty? # data may be nil for one of the operations
+            mod_record_ids[operation] = process_data(data, operation)
+          end
+          break if !success
+        end
+        {:success => success, :flash => @flash, :mod_record_ids => mod_record_ids}
+      end
+  
+      def get_data(params = {})
+        if @permissions[:read]
+          records = get_records(params)
+          {:data => records, :total => records.total_records}
+        else
+          flash :error => "You don't have permissions to read data"
+          {:success => false, :flash => @flash}
+        end
+      end
+
+      def delete_data(params = {})
+        if @permissions[:delete]
+          record_ids = JSON.parse(params.delete(:records))
+          klass = config[:data_class_name].constantize
+          klass.delete(record_ids)
+          flash :notice => "Deleted #{record_ids.size} record(s)"
+          success = true
+        else
+          flash :error => "You don't have permissions to delete data"
+          success = false
+        end
+        {:success => success, :flash => @flash}
+      end
+
+      def resize_column(params)
+        raise "Called interface_resize_column while not configured to do so" unless config[:ext_config][:enable_column_resize]
+        if config[:persistent_layout] && layout_manager_class
+          l_item = layout_manager_class.by_widget(id_name).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[:ext_config][:enable_column_move]
+        if config[:persistent_layout] && layout_manager_class
+          layout_manager_class.by_widget(id_name).move_item(params[:old_index].to_i, params[:new_index].to_i)
+        end
+        {}
+      end
+
+      # Return the choices for the column
+      def get_cb_choices(params)
+        column = params[:column]
+        query = params[:query]
+    
+        {:data => config[:data_class_name].constantize.choices_for(column, query).map{|s| [s]}}
+      end
+  
+  
+      protected
+
+      # operation => :update || :create
+      def process_data(data, operation)
+        success = true
+        mod_record_ids = []
+        if @permissions[operation]
+          klass = config[:data_class_name].constantize
+          modified_records = 0
+          data.each do |record_hash|
+            id = record_hash.delete('id')
+            record = operation == :create ? klass.new : klass.find(id)
+            success = true
+        
+            # process all attirubutes for the same record (OPTIMIZE: we can use update_attributes separately for regular attributes to speed things up)
+            record_hash.each_pair do |k,v|
+              begin
+                record.send("#{k}=",v)
+              rescue ArgumentError => exc
+                flash :error => exc.message
+                success = false
+                break
+              end
+            end
+        
+            # try to save
+            # modified_records += 1 if success && record.save
+            mod_record_ids << id if success && record.save
+
+            # flash eventual errors
+            if !record.errors.empty?
+              success = false
+              record.errors.each_full do |msg|
+                flash :error => msg
+              end
+            end
+          end
+          # flash :notice => "#{operation.to_s.capitalize}d #{modified_records} record(s)"
+        else
+          success = false
+          flash :error => "You don't have permissions to #{operation} data"
+        end
+        mod_record_ids
+      end
+  
+      # get records
+      def get_records(params)
+        search_params = normalize_params(params)  # make params coming from the browser understandable by searchlogic
+        search_params[:conditions].recursive_merge!(config[:conditions] || {})  # merge with conditions coming from the config
+    
+        raise ArgumentError, "No data_class_name specified for widget '#{config[:name]}'" if !config[:data_class_name]
+        records = config[:data_class_name].constantize.all(search_params.clone) # clone needed as searchlogic removes :conditions key from the hash
+        # output_array = []
+        columns = get_columns
+        output_array = records.map{|r| r.to_array(columns)}
+    
+        # records.each do |r|
+        #   r_array = []
+        #   self.get_columns.each do |column|
+        #     r_array << r.send(column[:name])
+        #   end
+        #   output_array << r_array
+        #   output_array << r.to_array(columns)
+        # end
+
+        # add total_entries accessor to the result
+        class << output_array
+          attr :total_records, true
+        end
+        total_records_count = config[:data_class_name].constantize.count(search_params)
+        output_array.total_records = total_records_count
+
+        output_array
+      end
+  
+      def convert_filters(column_filter)
+        res = {}
+        column_filter.each_pair do |k,v|
+          field = v["field"]
+          case v["data"]["type"]
+          when "string"
+            field << "_contains"
+          when "numeric"
+            field << "_#{v["data"]["comparison"]}"
+          end
+          value = v["data"]["value"]
+          res.merge!({field => value})
+        end
+        res
+      end
+  
+      # make params understandable to searchlogic
+      def normalize_params(params)
+        # filters
+        conditions = params[:filter] && convert_filters(params[:filter])
+    
+        normalized_conditions = {}
+        conditions && conditions.each_pair do |k, v|
+          assoc, method = k.split('__')
+          normalized_conditions.merge!(method.nil? ? {assoc => v} : {assoc => {method => v}})
+        end
+    
+        # sorting
+        order_by = if params[:sort]
+          assoc, method = params[:sort].split('__')
+          method.nil? ? assoc : {assoc => method}
+        end
+    
+        page = params[:start].to_i/params[:limit].to_i + 1 if params[:limit]
+        {:per_page => params[:limit], :page => page, :order_by => order_by, :order_as => params[:dir], :conditions => normalized_conditions}
+      end
+    end
+  end
+end

data/lib/netzke/grid_panel_extras/js_builder.rb

@@ -0,0 +1,322 @@
+module Netzke
+  module GridPanelExtras
+    module JsBuilder
+      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 extConfig;
+            try{
+              extConfig = Ext.decode(c.extConfig);
+            }
+            catch(err){
+              extConfig = {}
+            }
+            delete(c.extConfig);
+        
+            if (c.editor == 'checkbox') {
+              var plugin = new Ext.grid.CheckColumn(Ext.apply({
+          			header    : c.label || c.name,
+          			dataIndex : c.name,
+          			disabled  : c.readOnly,
+          			hidden    : c.hidden,
+          			width     : c.width
+              }, extConfig));
+
+              plugins.push(plugin);
+              this.cmConfig.push(plugin);
+          
+            } else {
+              var editor = (c.readOnly || !config.permissions.update) ? null : Ext.netzke.editors[c.editor](c, config);
+              var renderer = Ext.netzke.renderer(c.renderer);
+
+              this.cmConfig.push(Ext.apply({
+                header    : c.label || c.name,
+                dataIndex : c.name,
+                hidden    : c.hidden,
+                width     : c.width,
+                editor    : editor,
+                renderer  : renderer,
+                sortable  : true
+              }, extConfig))
+            }
+
+          }, 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.new = true; // to distinguish new records
+                r.set('id', r.id); // otherwise later r.get('id') returns empty string
+                this.stopEditing();
+                this.store.add(r);
+                // this.store.newRecords = this.store.newRecords || []
+                // this.store.newRecords.push(r);
+                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.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())
+                //   }, this);
+                //   // delete this.store.newRecords;
+                // }
+          
+                var updatedRecords = [];
+
+                Ext.each(this.store.getModifiedRecords(),
+                  function(r) {
+                    if (r.new) {
+                      newRecords.push(Ext.apply(r.getChanges(), {id:r.get('id')}));
+                    } else {
+                      updatedRecords.push(Ext.apply(r.getChanges(), {id:r.get('id')}));
+                    }
+                  }, 
+                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) {
+                        // commit those rows that have successfully been updated/created
+                        var modRecords = [].concat(this.store.getModifiedRecords()) // there must be a better way to clone an array...
+                        Ext.each(modRecords, function(r){
+                          var idsToSearch = r.new ? m.modRecordIds.create : m.modRecordIds.update
+                          if (idsToSearch.indexOf(r.id) >= 0) r.commit();
+                        })
+
+                        // reload the grid only when there were no errors
+                        // (we need to reload because of filtering, sorting, etc)
+                        if (this.store.getModifiedRecords().length == 0){
+                          this.store.reload();
+                        }
+
+                        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
+  end
+end