netzke-basepack 0.4.2 → 0.5.1

data/lib/netzke/grid_panel_api.rb

@@ -0,0 +1,352 @@
+module Netzke
+  module GridPanelApi
+    def post_data(params)
+      success = true
+      mod_records = {}
+      [:create, :update].each do |operation|
+        data = ActiveSupport::JSON.decode(params["#{operation}d_records"]) if params["#{operation}d_records"]
+        if !data.nil? && !data.empty? # data may be nil for one of the operations
+          mod_records[operation] = process_data(data, operation)
+          mod_records[operation] = nil if mod_records[operation].empty?
+        end
+        break if !success
+      end
+      {
+        :update_new_records => mod_records[:create], 
+        :update_mod_records => mod_records[:update] || {},
+        :feedback => @flash
+      }
+    end
+
+    def get_data(params = {})
+      if !ext_config[:prohibit_read]
+        records = get_records(params)
+        {:data => records.map{|r| r.to_array(normalized_columns, self)}, :total => ext_config[:enable_pagination] && records.total_entries}
+      else
+        flash :error => "You don't have permissions to read data"
+        {:feedback => @flash}
+      end
+    end
+
+    def delete_data(params = {})
+      if !ext_config[:prohibit_delete]
+        record_ids = ActiveSupport::JSON.decode(params[:records])
+        klass = config[:data_class_name].constantize
+        klass.delete(record_ids)
+        {:feedback => "Deleted #{record_ids.size} record(s)", :load_store_data => get_data}
+      else
+        {:feedback => "You don't have permissions to delete data"}
+      end
+    end
+
+    def resize_column(params)
+      raise "Called api_resize_column while not configured to do so" if ext_config[:enable_column_resize] == false
+      column_at(params[:index].to_i)[:width] = params[:size].to_i
+      save_columns!
+      {}
+    end
+
+    def hide_column(params)
+      raise "Called api_hide_column while not configured to do so" if ext_config[:enable_column_hide] == false
+      column_at(params[:index].to_i)[:hidden] = params[:hidden].to_b
+      save_columns!
+      {}
+    end
+
+    def move_column(params)
+      raise "Called api_move_column while not configured to do so" if ext_config[:enable_column_move] == false
+      column_to_move = columns.delete_at(params[:old_index].to_i)
+      columns.insert(params[:new_index].to_i, column_to_move)
+      save_columns!
+
+      # reorder the columns on the client side (still not sure if it's not an overkill)
+      # {:reorder_columns => columns.map(&:name)} # Well, I think it IS an overkill - commented out 
+      # until proven to be necessary
+      {}
+    end
+
+    # Return the choices for the column
+    def get_combobox_options(params)
+      column = params[:column]
+      query = params[:query]
+  
+      {:data => config[:data_class_name].constantize.options_for(column, query).map{|s| [s]}}
+    end
+
+    # Returns searchlogic's search with all the conditions
+    def get_search(params)
+      @search ||= begin
+        raise ArgumentError, "No data_class_name specified for widget '#{name}'" if !config[:data_class_name]
+
+        # make params coming from Ext grid filters understandable by searchlogic
+        search_params = normalize_params(params)
+
+        # merge with conditions coming from the config
+        search_params[:conditions].deep_merge!(config[:conditions] || {})
+
+        # merge with extra conditions (in searchlogic format, come from the extended search form)
+        search_params[:conditions].deep_merge!(
+          normalize_extra_conditions(ActiveSupport::JSON.decode(params[:extra_conditions]))
+        ) if params[:extra_conditions]
+
+        search = config[:data_class_name].constantize.search(search_params)
+      
+        # applying scopes
+        scopes.each do |s|
+          if s.is_a?(Array)
+            scope_name, *args = s
+            search.send(scope_name, *args)
+          else
+            search.send(s)
+          end
+        end
+      
+        search
+      end
+    end
+
+    def configuration_panel__columns__get_combobox_options(params)
+      query = params[:query]
+      
+      data_arry = case params[:column]
+                  when "name"
+                    predefined_columns.map{ |c| c[:name].to_s }
+                  else
+                    raise RuntimeError, "Don't know about options for column '#{params[:column]}'"
+                  end
+      
+      {:data => data_arry.grep(/^#{query}/).map{ |n| [n] }}.to_nifty_json
+    end
+    
+    protected
+
+    # operation => :update || :create
+    def process_data(data, operation)
+      success = true
+      # mod_record_ids = []
+      mod_records = {}
+      if !ext_config["prohibit_#{operation}".to_sym]
+        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
+
+          # merge with strong default attirbutes
+          record_hash.merge!(config[:strong_default_attrs]) if config[:strong_default_attrs]
+          
+          # process all attirubutes for this record
+          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_records[id] = record.to_array(columns, self) 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_records
+    end
+
+    # get records
+    def get_records(params)
+      # Restore params from widget_session if requested
+      if params[:with_last_params]
+        params = widget_session[:last_params]
+      else
+        # remember the last params
+        widget_session[:last_params] = params
+      end
+      
+      search = get_search(params)
+      
+      # sorting
+      if params[:sort]
+        assoc, method = params[:sort].split('__')
+        sort_string = method.nil? ? assoc : "#{assoc}_#{method}"
+        sort_string = (params[:dir] == "ASC" ? "ascend_by_" : "descend_by_") + sort_string
+        search.order(sort_string)
+      end
+      
+      # pagination
+      if ext_config[:enable_pagination]
+        per_page = ext_config[:rows_per_page]
+        page = params[:limit] ? params[:start].to_i/params[:limit].to_i + 1 : 1
+        search.paginate(:per_page => per_page, :page => page)
+      else
+        search.all
+      end
+    end
+    
+    # Create record with form
+    def create_new_record(params)
+      form_data = ActiveSupport::JSON.decode(params[:data])
+      res = aggregatee_instance(:new_record_form).create_or_update_record(form_data)
+      
+      if res[:set_form_values]
+        # successful creation
+        res[:set_form_values] = nil
+        res[:on_successfull_record_creation] = true
+      end
+      res
+    end
+    
+    # Move rows 
+    def move_rows(params)
+      if defined?(ActsAsList) && data_class.ancestors.include?(ActsAsList::InstanceMethods)
+        ids = JSON.parse(params[:ids]).reverse
+        ids.each_with_index do |id, i|
+          r = data_class.find(id)
+          r.insert_at(params[:new_index].to_i + i + 1)
+        end
+      else
+        raise RuntimeError, "Data class should 'acts_as_list' to support moving rows"
+      end
+      {}
+    end
+
+    # When providing the edit_form aggregatee, fill in the form with the requested record
+    def load_aggregatee_with_cache(params)
+      if params[:id] == 'edit_form'
+        super(params.merge(:config => {:record_id => params[:record_id]}.to_json))
+      else
+        super
+      end
+    end
+    
+    # Search scopes, in searchlogic format
+    def scopes
+      @scopes ||= config[:scopes] || []
+    end
+
+    # Converts Ext.grid.GridFilters filters to searchlogic conditions, e.g.
+    # {"0" => {
+    #   "data" => {
+    #     "type" => "numeric", 
+    #     "comparison" => "gt", 
+    #     "value" => 10 }, 
+    #   "field" => "id"
+    # }, 
+    # "1" => {
+    #   "data" => {
+    #     "type" => "string",
+    #     "value" => "pizza"
+    #   },
+    #   "field" => "food_name"
+    # }}
+    #
+    #  => 
+    #
+    # {"id_gt" => 100, "food_name_contains" => "pizza"}
+    def convert_filters(column_filter)
+      res = {}
+      column_filter.each_pair do |k,v|
+        field = v["field"].dup
+        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
+
+    def normalize_extra_conditions(conditions)
+      conditions.convert_keys{|k| k.to_s.gsub("__", "_").to_sym}
+    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
+  
+      {:conditions => normalized_conditions}
+    end
+    
+    ## Edit in form specific API
+    def new_record_form__submit(params)
+      form_data = ActiveSupport::JSON.decode(params[:data])
+      
+      # merge with strong default attirbutes
+      form_data.merge!(config[:strong_default_attrs]) if config[:strong_default_attrs]
+      
+      res = aggregatee_instance(:new_record_form).create_or_update_record(form_data)
+      
+      if res[:set_form_values]
+        # successful creation
+        res[:set_form_values] = nil
+        res.merge!({
+          :parent => {:on_successfull_record_creation => true}
+        })
+      end
+      res.to_nifty_json
+    end
+
+    def check_for_positive_result(res)
+      if res[:set_form_values]
+        # successful creation
+        res[:set_form_values] = nil
+        res.merge!({
+          :parent => {:on_successfull_edit => true}
+        })
+      end
+    end
+
+    def edit_form__submit(params)
+      form_data = ActiveSupport::JSON.decode(params[:data])
+      res = aggregatee_instance(:new_record_form).create_or_update_record(form_data)
+      
+      check_for_positive_result(res)
+      
+      res.to_nifty_json
+    end
+
+    def multi_edit_form__submit(params)
+      form_data = ActiveSupport::JSON.decode(params[:data])
+      form_instance = aggregatee_instance(:new_record_form)
+      
+      ids = ActiveSupport::JSON.decode(params[:ids])
+
+      res = {}
+      ids.each do |id|
+        res = form_instance.create_or_update_record(form_data.merge("id" => id))
+        break if !res[:set_form_values]
+      end
+      
+      check_for_positive_result(res)
+      
+      res.to_nifty_json
+    end
+    
+    
+  end
+end

data/lib/netzke/grid_panel_extras/javascripts/rows-dd.js

@@ -0,0 +1,280 @@
+Ext.namespace('Ext.ux.dd');
+
+Ext.ux.dd.GridDragDropRowOrder = Ext.extend(Ext.util.Observable,
+{
+    copy: false,
+
+    scrollable: false,
+
+    constructor : function(config)
+    {
+        Ext.ux.dd.GridDragDropRowOrder.superclass.constructor.call(this);
+        if (config)
+            Ext.apply(this, config);
+
+        this.addEvents(
+        {
+            beforerowmove: true,
+            afterrowmove: true,
+            beforerowcopy: true,
+            afterrowcopy: true
+        });
+    },
+
+    init : function (grid)
+    {
+        this.grid = grid;
+        grid.enableDragDrop = true;
+
+        grid.on({
+            render: { fn: this.onGridRender, scope: this, single: true }
+        });
+    },
+
+    onGridRender : function (grid)
+    {
+        var self = this;
+
+        this.target = new Ext.dd.DropTarget(grid.getEl(),
+        {
+            ddGroup: grid.ddGroup || 'GridDD',
+            grid: grid,
+            gridDropTarget: this,
+
+            notifyDrop: function(dd, e, data)
+            {
+                // Remove drag lines. The 'if' condition prevents null error when drop occurs without dragging out of the selection area
+                if (this.currentRowEl)
+                {
+                    this.currentRowEl.removeClass('grid-row-insert-below');
+                    this.currentRowEl.removeClass('grid-row-insert-above');
+                }
+
+                // determine the row
+                var t = Ext.lib.Event.getTarget(e);
+                var rindex = this.grid.getView().findRowIndex(t);
+                if (rindex === false || rindex == data.rowIndex)
+                {
+                    return false;
+                }
+                // fire the before move/copy event
+                if (this.gridDropTarget.fireEvent(self.copy ? 'beforerowcopy' : 'beforerowmove', this.gridDropTarget, data.rowIndex, rindex, data.selections, 123) === false)
+                {
+                    return false;
+                }
+
+                // update the store
+                var ds = this.grid.getStore();
+
+                // Changes for multiselction by Spirit
+                var selections = new Array();
+                var keys = ds.data.keys;
+                for (var key in keys)
+                {
+                    for (var i = 0; i < data.selections.length; i++)
+                    {
+                        if (keys[key] == data.selections[i].id)
+                        {
+                            // Exit to prevent drop of selected records on itself.
+                            if (rindex == key)
+                            {
+                                return false;
+                            }
+                            selections.push(data.selections[i]);
+                        }
+                    }
+                }
+
+                // fix rowindex based on before/after move
+                if (rindex > data.rowIndex && this.rowPosition < 0)
+                {
+                    rindex--;
+                }
+                if (rindex < data.rowIndex && this.rowPosition > 0)
+                {
+                    rindex++;
+                }
+
+                // fix rowindex for multiselection
+                if (rindex > data.rowIndex && data.selections.length > 1)
+                {
+                    rindex = rindex - (data.selections.length - 1);
+                }
+
+                // we tried to move this node before the next sibling, we stay in place
+                if (rindex == data.rowIndex)
+                {
+                    return false;
+                }
+
+                // fire the before move/copy event
+                /* dupe - does it belong here or above???
+                if (this.gridDropTarget.fireEvent(self.copy ? 'beforerowcopy' : 'beforerowmove', this.gridDropTarget, data.rowIndex, rindex, data.selections, 123) === false)
+                {
+                    return false;
+                }
+                */
+
+                if (!self.copy)
+                {
+                    for (var i = 0; i < data.selections.length; i++)
+                    {
+                        ds.remove(ds.getById(data.selections[i].id));
+                    }
+                }
+
+                for (var i = selections.length - 1; i >= 0; i--)
+                {
+                    var insertIndex = rindex;
+                    ds.insert(insertIndex, selections[i]);
+                }
+
+                // re-select the row(s)
+                var sm = this.grid.getSelectionModel();
+                if (sm)
+                {
+                    sm.selectRecords(data.selections);
+                }
+                
+                // console.info(this.gridDropTarget);
+
+                // fire the after move/copy event
+                this.gridDropTarget.fireEvent(self.copy ? 'afterrowcopy' : 'afterrowmove', this.gridDropTarget, data.rowIndex, rindex, data.selections);
+                return true;
+            },
+
+            notifyOver: function(dd, e, data)
+            {
+                var t = Ext.lib.Event.getTarget(e);
+                var rindex = this.grid.getView().findRowIndex(t);
+
+                // Similar to the code in notifyDrop. Filters for selected rows and quits function if any one row matches the current selected row.
+                var ds = this.grid.getStore();
+                var keys = ds.data.keys;
+                for (var key in keys)
+                {
+                    for (var i = 0; i < data.selections.length; i++)
+                    {
+                        if (keys[key] == data.selections[i].id)
+                        {
+                            if (rindex == key)
+                            {
+                                if (this.currentRowEl)
+                                {
+                                    this.currentRowEl.removeClass('grid-row-insert-below');
+                                    this.currentRowEl.removeClass('grid-row-insert-above');
+                                }
+                                return this.dropNotAllowed;
+                            }
+                        }
+                    }
+                }
+
+                // If on first row, remove upper line. Prevents negative index error as a result of rindex going negative.
+                if (rindex < 0 || rindex === false)
+                {
+                    this.currentRowEl.removeClass('grid-row-insert-above');
+                    return this.dropNotAllowed;
+                }
+
+                try
+                {
+                    var currentRow = this.grid.getView().getRow(rindex);
+                    // Find position of row relative to page (adjusting for grid's scroll position)
+                    var resolvedRow = new Ext.Element(currentRow).getY() - this.grid.getView().scroller.dom.scrollTop;
+                    var rowHeight = currentRow.offsetHeight;
+
+                    // Cursor relative to a row. -ve value implies cursor is above the row's middle and +ve value implues cursor is below the row's middle.
+                    this.rowPosition = e.getPageY() - resolvedRow - (rowHeight/2);
+
+                    // Clear drag line.
+                    if (this.currentRowEl)
+                    {
+                        this.currentRowEl.removeClass('grid-row-insert-below');
+                        this.currentRowEl.removeClass('grid-row-insert-above');
+                    }
+
+                    if (this.rowPosition > 0)
+                    {
+                        // If the pointer is on the bottom half of the row.
+                        this.currentRowEl = new Ext.Element(currentRow);
+                        this.currentRowEl.addClass('grid-row-insert-below');
+                    }
+                    else
+                    {
+                        // If the pointer is on the top half of the row.
+                        if (rindex - 1 >= 0)
+                        {
+                            var previousRow = this.grid.getView().getRow(rindex - 1);
+                            this.currentRowEl = new Ext.Element(previousRow);
+                            this.currentRowEl.addClass('grid-row-insert-below');
+                        }
+                        else
+                        {
+                            // If the pointer is on the top half of the first row.
+                            this.currentRowEl.addClass('grid-row-insert-above');
+                        }
+                    }
+                }
+                catch (err)
+                {
+                    console.warn(err);
+                    rindex = false;
+                }
+                return (rindex === false)? this.dropNotAllowed : this.dropAllowed;
+            },
+
+            notifyOut: function(dd, e, data)
+            {
+                // Remove drag lines when pointer leaves the gridView.
+                if (this.currentRowEl)
+                {
+                    this.currentRowEl.removeClass('grid-row-insert-above');
+                    this.currentRowEl.removeClass('grid-row-insert-below');
+                }
+            }
+        });
+
+        if (this.targetCfg)
+        {
+            Ext.apply(this.target, this.targetCfg);
+        }
+
+        if (this.scrollable)
+        {
+            Ext.dd.ScrollManager.register(grid.getView().getEditorParent());
+            grid.on({
+                beforedestroy: this.onBeforeDestroy,
+                scope: this,
+                single: true
+            });
+        }
+    },
+
+    getTarget: function()
+    {
+        return this.target;
+    },
+
+    getGrid: function()
+    {
+        return this.grid;
+    },
+
+    getCopy: function()
+    {
+        return this.copy ? true : false;
+    },
+
+    setCopy: function(b)
+    {
+        this.copy = b ? true : false;
+    },
+
+    onBeforeDestroy : function (grid)
+    {
+        // if we previously registered with the scroll manager, unregister
+        // it (if we don't it will lead to problems in IE)
+        Ext.dd.ScrollManager.unregister(grid.getView().getEditorParent());
+    }
+});