netzke-basepack 0.5.14 → 0.6.0

data/lib/netzke/grid_panel/grid_panel_api.rb

@@ -1,364 +0,0 @@
-require 'active_record'
-require 'searchlogic'
-require 'will_paginate'
-
-module Netzke
-  class GridPanel < Base
-    module GridPanelApi
-      
-      #
-      # Grid's native API
-      # 
-      
-      def get_data(params = {})
-        if !ext_config[:prohibit_read]
-          records = get_records(params)
-          {:data => records.map{|r| r.to_array(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 post_data(params)
-        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
-        end
-        
-        on_data_changed
-        
-        {
-          :update_new_records => mod_records[:create], 
-          :update_mod_records => mod_records[:update] || {},
-          :feedback => @flash
-        }
-      end
-
-      def delete_data(params)
-        if !ext_config[:prohibit_delete]
-          record_ids = ActiveSupport::JSON.decode(params[:records])
-          data_class.destroy(record_ids)
-          on_data_changed
-          {: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
-        columns[normalize_index(params[:index].to_i)][:width] = params[:size].to_i
-        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
-
-      def hide_column(params)
-        raise "Called api_hide_column while not configured to do so" if ext_config[:enable_column_hide] == false
-        columns[normalize_index(params[:index].to_i)][:hidden] = params[:hidden].to_b
-        save_columns!
-        {}
-      end
-
-      # Returns choices for a column
-      def get_combobox_options_DELETME(params)
-        column = params[:column]
-        query = params[:query]
-        {:data => data_class.options_for(column, query).map{|s| [s]}}
-        # {:data => data_class.options_for(column, query).map{|s| [s]}}
-      end
-
-      # Returns choices for a column
-      def get_combobox_options(params)
-        column = columns.detect{ |c| c[:name] == params[:column] }.try(:to_options!)
-        scopes = (column[:editor].is_a?(Hash) && column[:editor] || {}).to_options[:scopes]
-        query = params[:query]
-        
-        {:data => combobox_options_for_column(column, :query => query, :scopes => scopes)}
-      end
-
-      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
-          on_data_changed
-        else
-          raise RuntimeError, "Data class should 'acts_as_list' to support moving rows"
-        end
-        {}
-      end
-      
-      #
-      # Some aggregatees' overridden API 
-      # 
-    
-      ## Edit in form specific API
-      def add_form__item__netzke_submit(params)
-        res = aggregatee_instance(:add_form__item).netzke_submit(params)
-      
-        if res[:set_form_values]
-          # successful creation
-          on_data_changed
-          res[:set_form_values] = nil
-        end
-        res.to_nifty_json
-      end
-
-      def edit_form__item__netzke_submit(params)
-        res = aggregatee_instance(:edit_form__item).netzke_submit(params)
-
-        if res[:set_form_values]
-          on_data_changed
-          res[:set_form_values] = nil
-        end
-      
-        res.to_nifty_json
-      end
-
-      def multi_edit_form__item__netzke_submit(params)
-        ids = ActiveSupport::JSON.decode(params.delete(:ids))
-        data = ids.collect{ |id| ActiveSupport::JSON.decode(params[:data]).merge("id" => id) }
-        
-        mod_records_count = process_data(data, :update).count
-        
-        # remove duplicated flash messages
-        @flash = @flash.inject([]){ |r,hsh| r.include?(hsh) ? r : r.push(hsh) }
-        
-        if mod_records_count > 0
-          on_data_changed
-          flash :notice => "Updated #{mod_records_count} records."
-          {:set_result => "ok", :feedback => @flash}.to_nifty_json
-        else
-          {:feedback => @flash}.to_nifty_json
-        end
-      end
-      
-      protected
-        # Override this method to react on each operation that caused changing of data
-        def on_data_changed; 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 columns[norm_index][:included] == false
-            end
-          end
-          norm_index
-        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.searchlogic(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
-
-        # Params: 
-        # <tt>:operation</tt>: :update or :create
-        def process_data(data, operation)
-          success = true
-          # mod_record_ids = []
-          mod_records = {}
-          if !ext_config[:"prohibit_#{operation}"]
-            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
-    
-        # 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][:item].merge!(:record_id => params[:record_id])
-          end
-      
-          super
-        end
-    
-        # Search scopes, in searchlogic format
-        def scopes
-          @scopes ||= config[:scopes] || []
-        end
-
-        # Converts Ext.ux.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", "date"
-              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|
-            normalized_conditions.merge!(k.gsub("__", "_") => v)
-          end
-  
-          {:conditions => normalized_conditions}
-        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}
-        #     })
-        #     true
-        #   else
-        #     false
-        #   end
-        # end
-
-    end
-  end
-end

data/lib/netzke/grid_panel/grid_panel_columns.rb

@@ -1,232 +0,0 @@
-module Netzke
-  class GridPanel < Base
-    module GridPanelColumns
-      module ClassMethods
-        # Columns to be displayed by the FieldConfigurator, "meta-columns". Each corresponds to a configuration
-        # option for each column in the grid.
-        def meta_columns
-          [
-            # Whether the column will be present in the grid, also in :hidden or :meta state. The value for this column will
-            # always be sent to/from the JS grid to the server
-            {:name => "included",      :attr_type => :boolean, :width => 40, :header => "Incl", :default_value => true},
-
-            # The name of the column. May be any accessible method or attribute of the data_class.
-            {:name => "name",          :attr_type => :string, :width => 200},
-
-            # The header for the column.
-            {:name => "label",         :attr_type => :string, :width => 200, :header => "Header"},
-
-            # The default value of this column. Is used when a new row in the grid gets created.
-            {:name => "default_value", :attr_type => :string, :width => 200},
-
-            # Options for drop-downs
-            {:name => "combobox_options",       :attr_type => :string, :editor => :textarea, :width => 200},
-
-            # Whether the column is editable in the grid.
-            {:name => "read_only",     :attr_type => :boolean, :header => "R/O", :tooltip => "Read-only"},
-
-            # Whether the column will be in the hidden state (hide/show columns from the column menu, if it's enabled).
-            {:name => "hidden",        :attr_type => :boolean},
-
-            # Whether the column should have "grid filters" enabled 
-            # (see here: http://www.extjs.com/deploy/dev/examples/grid-filtering/grid-filter-local.html)
-            {:name => "with_filters",  :attr_type => :boolean, :default_value => true, :header => "Filters"},
-
-            #
-            # Below some rarely used parameters, hidden by default (you can always un-hide them from the column menu).
-            #
-
-            # The column's width
-            {:name => "width",         :attr_type => :integer, :hidden => true},
-
-            # Whether the column should be hideable
-            {:name => "hideable",      :attr_type => :boolean, :default_value => true, :hidden => true},
-
-            # Whether the column should be sortable (why change it? normally it's hardcoded)
-            {:name => "sortable",      :attr_type => :boolean, :default_value => true, :hidden => true},
-          ]
-        end
-        
-      end
-      
-      # Normalized columns for the grid, e.g.:
-      # [{:name => :id, :hidden => true, ...}, {:name => :name, :editable => false, ...}, ...]
-      def columns(only_included = true)
-        @columns ||= begin
-          if cols = load_columns
-            filter_out_excluded_columns(cols) if only_included
-            reverse_merge_equally_named_columns(cols, initial_columns)
-            cols
-          else
-            initial_columns(only_included)
-          end
-        end
-      end
-      
-      # Columns that we fall back to when neither persistent columns, nor configured columns are present.
-      # If there's a model-level field configuration, it's being used.
-      # Otherwise the defaults straight from the ActiveRecord model ("netzke_attributes").
-      # Override this method if you want to provide a fix set of columns in your subclass.
-      def default_columns
-        @default_columns ||= load_model_level_attrs || data_class.netzke_attributes
-      end
-      
-      # Columns that represent a smart merge of default_columns and columns passed during the configuration.
-      def initial_columns(only_included = true)
-        # Normalize here, as from the config we can get symbols (names) instead of hashes
-        columns_from_config = config[:columns] && normalize_attr_config(config[:columns])
-
-        if columns_from_config
-          # reverse-merge each column hash from config with each column hash from exposed_attributes (columns from config have higher priority)
-          for c in columns_from_config
-            corresponding_default_column = default_columns.find{ |k| k[:name] == c[:name] }
-            c.reverse_merge!(corresponding_default_column) if corresponding_default_column
-          end
-          columns_for_create = columns_from_config
-        else
-          # we didn't have columns configured in widget's config, so, use the columns from the data class
-          columns_for_create = default_columns
-        end
-        
-        filter_out_excluded_columns(columns_for_create) if only_included
-        
-        # Make the column config complete with the defaults
-        columns_for_create.each do |c|
-          detect_association(c)
-          set_default_header(c)
-          set_default_editor(c)
-          set_default_width(c)
-          set_default_hidden(c)
-          set_default_editable(c)
-          set_default_sortable(c)
-          set_default_filterable(c)
-        end
-
-        columns_for_create
-      end
-      
-      private
-        def filter_out_excluded_columns(cols)
-          cols.reject!{ |c| c[:included] == false }
-        end
-      
-        # Stores modified columns in persistent storage
-        def save_columns!
-          NetzkeFieldList.update_list_for_current_authority(global_id, columns(false), original_data_class.name) if persistent_config_enabled?
-        end
-      
-        def load_columns
-          NetzkeFieldList.read_list(global_id) if persistent_config_enabled?
-        end
-        
-        def load_model_level_attrs
-          NetzkeModelAttrList.read_list(data_class.name) if persistent_config_enabled?
-        end
-        
-        # whether a column is bound to the primary_key
-        def reflects_primary_key?(c)
-          c[:name] == data_class.primary_key
-        end
-      
-        def set_default_header(c)
-          c[:label] ||= c[:name].humanize
-        end
-        
-        def set_default_editor(c)
-          c[:editor] ||= editor_for_attr_type(c[:attr_type])
-          c[:editor] = {:xtype => c[:editor]} if c[:editor].is_a?(Symbol)
-        end
-        
-        def set_default_width(c)
-          c[:width] ||= 50 if c[:attr_type] == :boolean
-          c[:width] ||= 150 if c[:attr_type] == :datetime
-        end
-        
-        def set_default_hidden(c)
-          c[:hidden] = true if reflects_primary_key?(c) && c[:hidden].nil?
-        end
-        
-        def set_default_editable(c)
-          c[:editable] = c[:read_only].nil? ? !(reflects_primary_key?(c) || c[:virtual]) : !c[:read_only]
-          c.delete(:read_only)
-        end
-        
-        def set_default_sortable(c)
-          c[:sortable] = !c[:virtual] if c[:sortable].nil?
-        end
-        
-        def set_default_filterable(c)
-          c[:filterable] = !c[:virtual] if c[:filterable].nil?
-        end
-        
-        # Returns editor's xtype for a column type
-        def editor_for_attr_type(type)
-          attr_type_to_editor_map[type]
-        end
-        
-        def editor_for_association
-          :combobox
-        end
-   
-        # Returns a hash that maps a column type to the editor xtype. Override if you want different editors.
-        def attr_type_to_editor_map
-          {
-            :integer => :numberfield,
-            :boolean => :checkbox,
-            :date => :datefield,
-            :datetime => :xdatetime,
-            :text => :textarea,
-            :string => :textfield
-          }
-        end
-      
-        # Detects an association column and sets up the proper editor.
-        def detect_association(c)
-          # double-underscore notation? surely an association column
-          if c[:name].index('__')
-            assoc_name, assoc_method = c[:name].split('__')
-            assoc = data_class.reflect_on_association(assoc_name.to_sym)
-          
-            if assoc && assoc_method
-              assoc_column = assoc.klass.columns_hash[assoc_method]
-              assoc_method_type = assoc_column.try(:type)
-            
-              # if association column is boolean, display a checkbox (or alike), otherwise - a combobox (or alike)
-              c[:editor] ||= assoc_method_type == :boolean ? editor_for_attr_type(:boolean) : editor_for_association
-            end
-          end
-        end
-        
-        # Default fields that will be displayed in the Add/Edit/Search forms
-        def default_fields_for_forms
-          form_klass = "Netzke::ModelExtensions::#{config[:model]}ForFormPanel".constantize rescue nil
-          form_klass ||= original_data_class
-          
-          # Select only those fields that are known to the form_klass
-          selected_columns = columns.select do |c|
-            form_klass.column_names.include?(c[:name]) ||
-            form_klass.instance_methods.include?("#{c[:name]}=") ||
-            association_attr?(c[:name])
-          end
-          
-          selected_columns.map do |c|
-            field_config = {:name => c[:name]}
-            
-            # scopes for combobox options
-            field_config[:scopes] = c[:editor].is_a?(Hash) && c[:editor][:scopes]
-            
-            field_config
-          end
-        end
-        
-        # Receives 2 arrays of columns. Merges the missing config from the +source+ into +dest+, matching columns by name
-        def reverse_merge_equally_named_columns(dest, source)
-          dest.each{ |dc| dc.reverse_merge!(source.detect{ |sc| sc[:name] == dc[:name] } || {}) }
-        end
-
-      def self.included(receiver)
-        receiver.extend         ClassMethods
-      end
-    end
-  end
-end