netzke-basepack 0.5.5.1 → 0.5.6

data/lib/netzke/grid_panel.rb

@@ -1,4 +1,7 @@
-require 'searchlogic'
+require "netzke/grid_panel/grid_panel_js"
+require "netzke/grid_panel/grid_panel_api"
+require "netzke/plugins/configuration_tool"
+require "netzke/data_accessor"
 
 module Netzke
   # == GridPanel
@@ -36,7 +39,7 @@ module Netzke
   # 
   # == Instance configuration
   # The following config options are available:
-  # * <tt>:data_class_name</tt> - name of the ActiveRecord model that provides data to this GridPanel.
+  # * <tt>:model</tt> - name of the ActiveRecord model that provides data to this GridPanel.
   # * <tt>:strong_default_attrs</tt> - a hash of attributes to be merged atop of every created/updated record.
   # * <tt>:scopes</tt> - an array of named scopes to filter grid data, e.g.:
   #     
@@ -48,7 +51,7 @@ module Netzke
   # * <tt>:enable_edit_in_form</tt> - provide buttons into the toolbar that activate editing/adding records via a form
   # * <tt>:enable_extended_search</tt> - provide a button into the toolbar that shows configurable search form
   # * <tt>:enable_context_menu</tt> - enable rows context menu
-  # * <tt>:enable_rows_reordering</tt> - enable reordering of rows with drag-n-drop; underlying model (specified in <tt>:data_class_name</tt>) must implement "acts_as_list"-compatible functionality; defaults to <tt>false</tt>
+  # * <tt>:enable_rows_reordering</tt> - enable reordering of rows with drag-n-drop; underlying model (specified in <tt>:model</tt>) must implement "acts_as_list"-compatible functionality; defaults to <tt>false</tt>
   # * <tt>:enable_pagination</tt> - enable pagination; defaults to <tt>true</tt>
   # * <tt>:rows_per_page</tt> - number of rows per page (ignored when <tt>:enable_pagination</tt> is set to <tt>false</tt>)
   # * <tt>:load_inline_data</tt> - load initial data into the grid right after its instantiation (saves a request to server); defaults to <tt>true</tt>
@@ -57,9 +60,9 @@ module Netzke
   # Additionally supports Netzke::Base config options.
   class GridPanel < Base
       # javascript (client-side)
-    include Netzke::GridPanelJs
+    include GridPanelJs
       # API (server-side)
-    include Netzke::GridPanelApi
+    include GridPanelApi
       # Code shared between GridPanel, FormPanel, and other widgets that serve as interface to database tables
     include Netzke::DataAccessor
 
@@ -108,7 +111,7 @@ module Netzke
       # Checkcolumn
       ext_examples = Netzke::Base.config[:ext_location] + "/examples/"
       res << ext_examples + "ux/CheckColumn.js"
-      # res << "#{File.dirname(__FILE__)}/grid_panel_extras/javascripts/check-column.js"
+      # res << "#{File.dirname(__FILE__)}/grid_panel/javascripts/check-column.js"
       
       
       # Filters
@@ -123,13 +126,13 @@ module Netzke
       #     res << ext_examples + "grid-filtering/grid/filter/#{f}Filter.js"
       #   end
       #   
-      #   res << "#{File.dirname(__FILE__)}/grid_panel_extras/javascripts/filters.js"
+      #   res << "#{File.dirname(__FILE__)}/grid_panel/javascripts/filters.js"
       #   
       # end
       
       # DD
       if config[:rows_reordering_available]
-        res << "#{File.dirname(__FILE__)}/grid_panel_extras/javascripts/rows-dd.js"
+        res << "#{File.dirname(__FILE__)}/grid_panel/javascripts/rows-dd.js"
       end
 
       res
@@ -142,10 +145,12 @@ module Netzke
     # Edit in form
     api :create_new_record if config[:edit_in_form_available]
 
+    # (We can't memoize this method because at some point we extend it, e.g. in Netzke::DataAccessor)
     def data_class
-      @data_class ||= config[:data_class_name].nil? ? raise(ArgumentError, "No data_class_name specified for widget #{global_id}") : config[:data_class_name].constantize
+      ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
+      model_name = config[:model] || config[:data_class_name]
+      @data_class ||= model_name.nil? ? raise(ArgumentError, "No model specified for widget #{global_id}") : model_name.constantize
     end
-
     
     def initialize(config = {}, parent = nil)
       super
@@ -198,6 +203,9 @@ module Netzke
       res << {:name => :ext_config__enable_extended_search, :type => :boolean} if config[:extended_search_available]
       res << {:name => :ext_config__enable_edit_in_form, :type => :boolean} if config[:edit_in_form_available]
       
+      # TODO: buggy thing
+      # res << {:name => :layout__columns,                 :type => :json}
+      
       res
       
     end
@@ -248,11 +256,10 @@ module Netzke
         :add          => {:text => 'Add',     :disabled      => ext_config[:prohibit_create]},
         :edit         => {:text => 'Edit',    :disabled      => true},
         :del          => {:text => 'Delete',  :disabled      => true},
-        :apply        => {:text => 'Apply',   :disabled      => ext_config[:prohibit_update] &&
-                                                                ext_config[:prohibit_create]},
+        :apply        => {:text => 'Apply',   :disabled      => ext_config[:prohibit_update] && ext_config[:prohibit_create]},
         :add_in_form  => {:text => 'Add in form', :disabled  => !ext_config[:enable_edit_in_form]},
         :edit_in_form => {:text => 'Edit in form', :disabled => true},
-        :search       => {:text => 'Search', :disabled       => !ext_config[:enable_extended_search]}
+        :search       => {:text => 'Search', :disabled       => !ext_config[:enable_extended_search], :checked => true}
       }
     end
 
@@ -262,14 +269,14 @@ module Netzke
       # Edit in form
       res.merge!({
         :add_form => {
-          :widget_class_name => "GridPanelExtras::RecordFormWindow",
+          :widget_class_name => "GridPanel::RecordFormWindow",
           :ext_config => {
-            :title => "Add #{config[:data_class_name].humanize}",
+            :title => "Add #{data_class.name.humanize}",
             :button_align => "right"
           },
           :item => {
             :widget_class_name => "FormPanel",
-            :data_class_name => config[:data_class_name],
+            :data_class_name => data_class.name,
             :persistent_config => config[:persistent_config],
             :strong_default_attrs => config[:strong_default_attrs],
             :ext_config => {
@@ -278,13 +285,13 @@ module Netzke
               :header => false,
               :mode => ext_config[:mode]
             },
-            :record => config[:data_class_name].constantize.new
+            :record => data_class.new
           }
         },
         
         :edit_form => {
           :widget_class_name => "FormPanel",
-          :data_class_name => config[:data_class_name],
+          :data_class_name => data_class.name,
           :persistent_config => config[:persistent_config],
           :ext_config => {
             :bbar => false,
@@ -295,7 +302,7 @@ module Netzke
         
         :multi_edit_form => {
           :widget_class_name => "FormPanel",
-          :data_class_name => config[:data_class_name],
+          :data_class_name => data_class.name,
           :persistent_config => config[:persistent_config],
           :ext_config => {
             :bbar => false,
@@ -306,7 +313,7 @@ module Netzke
         
         :new_record_form => {
           :widget_class_name => "FormPanel",
-          :data_class_name => config[:data_class_name],
+          :data_class_name => data_class.name,
           :persistent_config => config[:persistent_config],
           :strong_default_attrs => config[:strong_default_attrs],
           :ext_config => {
@@ -314,7 +321,7 @@ module Netzke
             :header => false,
             :mode => ext_config[:mode]
           },
-          :record => config[:data_class_name].constantize.new
+          :record => data_class.new
         }
       }) if ext_config[:enable_edit_in_form]
       
@@ -322,7 +329,7 @@ module Netzke
       res.merge!({
         :search_panel => {
           :widget_class_name => "SearchPanel",
-          :search_class_name => config[:data_class_name],
+          :search_class_name => data_class.name,
           :persistent_config => config[:persistent_config],
           :ext_config => {
             :header => false, 
@@ -349,8 +356,8 @@ module Netzke
 
     def get_columns
       if persistent_config_enabled?
-        persistent_config['layout__columns'] ||= default_columns
-        res = normalize_array_of_columns(persistent_config['layout__columns'])
+        columns = persistent_config['layout__columns'] || default_columns
+        res = normalize_array_of_columns(columns)
       else
         res = default_columns
       end
@@ -437,6 +444,8 @@ module Netzke
         c[:width] ||= 120 if c[:editor] == :xdatetime
         # hide ID column
         c[:hidden] = true if c[:name] == data_class.primary_key.to_sym && c[:hidden].nil?
+        # make ID column read-only
+        c[:editable] = false if c[:name] == data_class.primary_key.to_sym && c[:editable].nil?
         
         # Some default limitations for virtual columns
         if type == :virtual

data/lib/netzke/grid_panel/grid_panel_api.rb

@@ -0,0 +1,358 @@
+require 'activerecord'
+require 'searchlogic'
+require 'will_paginate'
+
+module Netzke
+  class GridPanel < Base
+    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])
+          data_class.destroy(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
+
+      # Given an index of a column among enabled (non-excluded) columns, provides the index (position) in the table
+      def normalize_index(index)
+        norm_index = 0
+        index.times do
+          while true do
+            norm_index += 1 
+            break unless normalized_columns[norm_index][:excluded]
+          end
+        end
+        norm_index
+      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(normalize_index(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(normalize_index(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
+        remove_from = normalize_index(params[:old_index].to_i)
+        insert_to = normalize_index(params[:new_index].to_i)
+        column_to_move = columns.delete_at(remove_from)
+        columns.insert(insert_to, 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 => data_class.options_for(column, query).map{|s| [s]}}
+      end
+
+      # Returns searchlogic's search with all the conditions
+      def get_search(params)
+        @search ||= begin
+          # 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 = data_class.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, true)
+            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]
+          modified_records = 0
+          data.each do |record_hash|
+            id = record_hash.delete('id')
+            record = operation == :create ? data_class.new : data_class.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] == 'editForm'
+          aggregatees[:edit_form].merge!(:record_id => params[:record_id])
+        end
+      
+        super
+      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.deep_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__netzke_submit(params)
+        res = aggregatee_instance(:new_record_form).netzke_submit(params)
+      
+        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__netzke_submit(params)
+        res = aggregatee_instance(:edit_form).netzke_submit(params)
+      
+        check_for_positive_result(res)
+      
+        res.to_nifty_json
+      end
+
+      def multi_edit_form__netzke_submit(params)
+        ids = ActiveSupport::JSON.decode(params.delete(:ids))
+
+        res = {}
+        ids.each do |id|
+          form_instance = aggregatee_instance(:edit_form, :record => data_class.find(id))
+          res = form_instance.netzke_submit(params)
+          break if !res[:set_form_values]
+        end
+      
+        check_for_positive_result(res)
+      
+        res.to_nifty_json
+      end
+    
+    end
+  end
+end