netzke-basepack 0.6.3 → 0.6.4

data/lib/netzke/basepack/grid_panel/record_form_window.rb

@@ -9,8 +9,13 @@ module Netzke
               :auto_height => true,
               :fbar => [:ok.action, :cancel.action]
 
-        action :ok, :text => 'OK'
-        action :cancel
+        action :ok do
+          { :text => I18n.t('netzke.basepack.grid_panel.record_form_window.actions.ok')}
+        end
+
+        action :cancel do
+          { :text => I18n.t('netzke.basepack.grid_panel.record_form_window.actions.cancel')}
+        end
 
         js_method :init_component, <<-JS
           function(params){

data/lib/netzke/basepack/grid_panel/services.rb

@@ -45,30 +45,33 @@ module Netzke
           end
 
           endpoint :resize_column do |params|
-            raise "Called api_resize_column while not configured to do so" if config[:enable_column_resize] == false
-            columns[normalize_index(params[:index].to_i)][:width] = params[:size].to_i
-            save_columns!
+            raise "Called api_resize_column while not configured to do so" if !config[:persistence]
+            current_columns_order = state[:columns_order] || initial_columns_order
+            current_columns_order[normalize_index(params[:index].to_i)][:width] = params[:size].to_i
+            update_state(:columns_order, current_columns_order)
             {}
           end
 
           endpoint :move_column do |params|
-            raise "Called api_move_column while not configured to do so" if config[:enable_column_move] == false
+            raise "Called api_move_column while not configured to do so" if !config[:persistence]
             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
+            current_columns_order = state[:columns_order] || initial_columns_order
+
+            column_to_move = current_columns_order.delete_at(remove_from)
+            current_columns_order.insert(insert_to, column_to_move)
+
+            update_state(:columns_order, current_columns_order)
+
             {}
           end
 
           endpoint :hide_column do |params|
-            raise "Called api_hide_column while not configured to do so" if config[:enable_column_hide] == false
-            columns[normalize_index(params[:index].to_i)][:hidden] = params[:hidden].to_b
-            save_columns!
+            raise "Called api_hide_column while not configured to do so" if !config[:persistence]
+            current_columns_order = state[:columns_order] || initial_columns_order
+            current_columns_order[normalize_index(params[:index].to_i)][:hidden] = params[:hidden].to_b
+            update_state(:columns_order, current_columns_order)
             {}
           end
 
@@ -77,7 +80,7 @@ module Netzke
             query = params[:query]
 
             column = columns.detect{ |c| c[:name] == params[:column] }
-            scope = column.to_options[:scope] || column.to_options[:editor].try(:fetch, :scope)
+            scope = column.to_options[:scope] || column.to_options[:editor].try(:fetch, :scope, nil)
             query = params[:query]
 
             {:data => combobox_options_for_column(column, :query => query, :scope => scope, :record_id => params[:id])}
@@ -155,16 +158,36 @@ module Netzke
         def get_data(*args)
           params = args.first || {} # params are optional!
           if !config[:prohibit_read]
-            records = get_records(params)
-            {:data => records.map{|r| r.to_array(columns)}, :total => config[:enable_pagination] && records.total_entries}
+            {}.tap do |res|
+              records = get_records(params)
+              res[:data] = records.map{|r| r.to_array(columns(:with_meta => true))}
+              res[:total] = records.total_entries if config[:enable_pagination]
+
+              # provide association values for all records at once
+              # assoc_values = get_association_values(records, columns)
+              # res[:set_association_values] = assoc_values.literalize_keys if assoc_values.present?
+            end
           else
             flash :error => "You don't have permissions to read data"
-            {:feedback => @flash}
+            { :feedback => @flash }
           end
         end
 
         protected
 
+          # Returns all values for association columns, per column, per associated record id, e.g.:
+          # {
+          #   :author__first_name => {1 => "Vladimir", 2 => "Herman"},
+          #   :author__last_name => {1 => "Nabokov", 2 => "Hesse"}
+          # }
+          # This is used to display the association by the specified method instead by the foreign key
+          # def get_association_values(records, columns)
+          #   columns.select{ |c| c[:name].index("__") }.each.inject({}) do |r,c|
+          #     column_values = {}
+          #     records.each{ |r| column_values[r.value_for_attribute(c)] = r.value_for_attribute(c, true) }
+          #     r.merge(c[:name] => column_values)
+          #   end
+          # end
           def get_records(params)
 
             # Restore params from component_session if requested
@@ -213,23 +236,6 @@ module Netzke
             end
           end
 
-          # An ActiveRecord::Relation instance encapsulating all the necessary conditions
-          def get_relation(params)
-            # make params coming from Ext grid filters understandable by meta_where
-            conditions = params[:filter] && convert_filters(params[:filter]) || {}
-
-            relation = data_class.where(conditions)
-
-            if params[:extra_conditions]
-              extra_conditions = normalize_extra_conditions(ActiveSupport::JSON.decode(params[:extra_conditions]))
-              relation = relation.extend_with_netzke_conditions(extra_conditions) if params[:extra_conditions]
-            end
-
-            relation = relation.extend_with(config[:scope]) if config[:scope]
-
-            relation
-          end
-
           # Override this method to react on each operation that caused changing of data
           def on_data_changed; end
 
@@ -277,7 +283,7 @@ module Netzke
 
                 # try to save
                 # modified_records += 1 if success && record.save
-                mod_records[id] = record.to_array(columns) if success && record.save
+                mod_records[id] = record.to_array(columns(:with_meta => true)) if success && record.save
                 # mod_record_ids << id if success && record.save
 
                 # flash eventual errors
@@ -316,8 +322,10 @@ module Netzke
           #
           #  metawhere:   :id.gt => 100, :food_name.matches => '%pizza%'
           def convert_filters(column_filter)
+            # these are still JSON-encoded due to the migration to Ext.direct
+            column_filter=JSON.parse(column_filter)
             res = {}
-            column_filter.each_pair do |k,v|
+            column_filter.each do |v|
               assoc, method = v["field"].split('__')
               if method
                 assoc = data_class.reflect_on_association(assoc.to_sym)
@@ -326,13 +334,14 @@ module Netzke
                 field = assoc.to_sym
               end
 
-              value = v["data"]["value"]
-              case v["data"]["type"]
+              value = v["value"]
+
+              case v["type"]
               when "string"
                 field = field.send :matches
                 value = "%#{value}%"
               when "numeric", "date"
-                field = field.send :"#{v['data']['comparison']}"
+                field = field.send :"#{v['comparison']}"
               end
               res.merge!({field => value})
             end
@@ -345,6 +354,16 @@ module Netzke
             end
           end
 
+          def initial_columns_order
+            columns.map do |c|
+              {
+                :name => c[:name],
+                :width => c[:width],
+                :hidden => c[:hidden]
+              }
+            end
+          end
+
           # def check_for_positive_result(res)
           #   if res[:set_form_values]
           #     # successful creation

data/lib/netzke/basepack/paging_form_panel.rb

@@ -15,6 +15,9 @@ module Netzke
     #   When it's a Proc, it's passed the model class, and is expected to return an ActiveRecord::Relation, e.g.:
     #
     #     :scope => { |rel| rel.where(:id.gt => 100).order(:created_at) }
+    #
+    # == ToDo
+    # * Update the number of records after form submit
     class PagingFormPanel < FormPanel
 
       # override
@@ -25,17 +28,75 @@ module Netzke
       # Pass total records amount and the first record to the JS constructor
       def js_config
         super.merge({
-          :total_records => total_records,
-          :record => record.to_hash(fields)
+          :total_records => total_records
         })
       end
 
       endpoint :get_data do |params|
-        record = get_relation.offset(params[:start].to_i).limit(1).first
-        record_hash = record && record.to_hash(fields).each_pair.inject({}){ |r,(k,v)| r.merge(k.l => v) }
-        {:records => record_hash && [record_hash] || [], :total => total_records}
+        @record = get_relation(params).offset(params[:start].to_i).limit(1).first
+        record_hash = @record && js_record_data
+        {:records => record_hash && [record_hash] || [], :total => total_records(params)}
+      end
+
+      action :search do
+        {
+          :text => I18n.t('netzke.basepack.paging_form_panel.actions.search'),
+          :tooltip => I18n.t('netzke.basepack.paging_form_panel.actions.search_tooltip'),
+          :icon => :find,
+          :select => true
+        }
       end
 
+      def configure_bbar(c)
+        super
+        c[:bbar] << :search.action
+      end
+
+      js_method :on_search, <<-JS
+        function(el){
+          if (this.searchWindow) {
+            this.searchWindow.show();
+          } else {
+            this.loadComponent({name: 'search_form', callback: function(win){
+              this.searchWindow = win;
+              var currentConditionsString = this.getStore().baseParams.extra_conditions;
+              if (currentConditionsString) {
+                win.items.first().getForm().setValues(Ext.decode(currentConditionsString));
+              }
+
+              win.items.first().on('apply', function(){
+                win.onSearch();
+                return false; // do not propagate the 'apply' event
+              }, this);
+
+              win.on('hide', function(){
+                var query = win.getQuery();
+                if (win.closeRes == 'search'){
+                  this.getStore().baseParams.query = Ext.encode(query);
+                  this.getStore().load();
+                }
+                el.toggle(query.length > 0); // toggle based on the state
+              }, this);
+            }, scope: this});
+          }
+        }
+      JS
+
+      js_method :get_store, <<-JS
+        function(){
+          return this.store;
+        }
+      JS
+
+      js_method :after_render, <<-JS
+        function(){
+          Netzke.classes.Basepack.PagingFormPanel.superclass.afterRender.call(this);
+
+          new Ext.LoadMask(this.bwrap, Ext.apply(this.applyMask, {store: this.store}));
+        }
+      JS
+
+
       js_method :init_component, <<-JS
         function(){
 
@@ -44,23 +105,20 @@ module Netzke
           // Otherwise, the things would be simpler, because this.getForm().items would already has all the fields in one place for us
           this.fieldNames = [];
           this.extractFields(this.items);
-          var fieldNames = this.fieldNames;
 
-          var store = new Ext.data.JsonStore({
-            url: this.endpointUrl('get_data'),
+          var store = new Ext.data.DirectStore({
+            directFn: Netzke.providers[this.id].getData,
             root: 'records',
-            fields: fieldNames,
+            fields: this.fieldNames.concat('_meta'),
             data: {records: [this.record], total: this.totalRecords}
           });
 
-          store.on('beforeload', function(){
-            if (!this.loadMaskCmp) this.loadMaskCmp = new Ext.LoadMask(this.bwrap, this.applyMask);
-            this.loadMaskCmp.show();
-          }, this);
-
           store.on('load', function(st, r){
-            this.setFormValues(r[0].data);
-            if (this.loadMaskCmp) this.loadMaskCmp.hide();
+            if (r.length == 0) {
+              this.getForm().reset();
+            } else {
+              this.setFormValues(r[0].data);
+            }
           }, this);
 
           this.bbar = new Ext.PagingToolbar({
@@ -70,21 +128,24 @@ module Netzke
             items: ["-"].concat(this.bbar || [])
           });
 
+          this.store = store;
+
           Netzke.classes.Basepack.PagingFormPanel.superclass.initComponent.call(this);
         }
       JS
 
-      protected
+      component :search_form do
+        {
+          :lazy_loading => true,
+          :class_name => "Netzke::Basepack::SearchWindow",
+          :model => config[:model]
+        }
+      end
 
-        # Returns ActiveRecord::Relation for the data
-        def get_relation
-          relation = data_class.scoped
-          relation = relation.extend_with(config[:scope]) if config[:scope]
-          relation
-        end
+      protected
 
-        def total_records
-          @total_records ||= get_relation.count
+        def total_records(params = {})
+          @total_records ||= get_relation(params).count
         end
 
     end

data/lib/netzke/basepack/query_builder.rb

@@ -0,0 +1,105 @@
+module Netzke
+  module Basepack
+    class QueryBuilder < Netzke::Base
+      js_base_class "Ext.TabPanel"
+
+      js_property :active_tab, 0
+
+      js_translate :overwrite_confirm, :overwrite_confirm_title, :delete_confirm, :delete_confirm_title
+
+      js_mixin :query_builder
+
+      component :search_panel do
+        {
+          :class_name => "Netzke::Basepack::SearchPanel",
+          :model => config[:model],
+          :query => config[:query],
+          :auto_scroll => config[:auto_scroll]
+        }
+      end
+
+      action :clear_all do
+        {
+          :text => I18n.t('netzke.basepack.query_builder.actions.clear_all'),
+          :tooltip => I18n.t('netzke.basepack.query_builder.actions.clear_all_tooltip'),
+          :icon => :cross
+        }
+      end
+
+      action :reset do
+        {
+          :text => I18n.t('netzke.basepack.query_builder.actions.reset'),
+          :tooltip => I18n.t('netzke.basepack.query_builder.actions.reset_tooltip'),
+          :icon => :application_form
+        }
+      end
+
+      action :save_preset do
+        {
+          :text => I18n.t('netzke.basepack.query_builder.actions.save_preset'),
+          :tooltip => I18n.t('netzke.basepack.query_builder.actions.save_preset_tooltip'),
+          :icon => :disk
+        }
+      end
+
+      action :delete_preset do
+        {
+          :text => I18n.t('netzke.basepack.query_builder.actions.delete_preset'),
+          :tooltip => I18n.t('netzke.basepack.query_builder.actions.delete_preset_tooltip'),
+          :icon => :cross
+        }
+      end
+
+      action :apply do
+        {
+          :text => I18n.t('netzke.basepack.query_builder.actions.apply'),
+          :tooltip => I18n.t('netzke.basepack.query_builder.actions.apply_tooltip'),
+          :icon => :accept
+        }
+      end
+
+      def js_config
+        super.tap do |s|
+          s[:bbar] = (config[:bbar] || []) + [:clear_all.action, :reset.action, "->",
+            I18n.t('netzke.basepack.query_builder.presets'),
+            {
+              :xtype => "combo",
+              :triggerAction => "all",
+              :value => super[:load_last_preset] && last_preset.try(:fetch, "name"),
+              :store => state[:presets].blank? ? [[[], ""]] : state[:presets].map{ |s| [s["query"], s["name"]] },
+              :ref => "../presetsCombo",
+              :listeners => {:before_select => {
+                :fn => "function(combo, record){
+                  var form = Ext.getCmp('#{global_id}');
+                  form.buildFormFromQuery(record.data.field1);
+                }".l
+              }}
+            }, :save_preset.action, :delete_preset.action
+          ]
+        end
+      end
+
+      endpoint :save_preset do |params|
+        saved_searches = state[:presets] || []
+        existing = saved_searches.detect{ |s| s["name"] == params[:name] }
+        query = ActiveSupport::JSON.decode(params[:query])
+        if existing
+          existing["query"].replace(query)
+        else
+          saved_searches << {"name" => params[:name], "query" => query}
+        end
+        update_state(:presets, saved_searches)
+        {:feedback => I18n.t('netzke.basepack.query_builder.preset_saved')}
+      end
+
+      endpoint :delete_preset do |params|
+        saved_searches = state[:presets]
+        saved_searches.delete_if{ |s| s["name"] == params[:name] }
+        update_state(:presets, saved_searches)
+        {:feedback => I18n.t('netzke.basepack.query_builder.preset_deleted')}
+      end
+
+
+    end
+  end
+end