netzke-basepack-zh 0.7.6

data/lib/netzke/basepack/paging_form_panel.rb

@@ -0,0 +1,72 @@
+module Netzke
+  module Basepack
+    # A FormPanel with paging toolbar. Allows browsing and editing records one-by-one.
+    #
+    # == Configuration
+    # Besides +Netzke::Basepack::FormPanel+ config options, accepts:
+    # * +scope+ - specifies how the data should be filtered.
+    #   When it's a symbol, it's used as a scope name.
+    #   When it's a string, it's a SQL statement (passed directly to +ActiveRecord::Relation#where+).
+    #   When it's a hash, it's a conditions hash (passed directly to +ActiveRecord::Relation#where+).
+    #   When it's an array, it's expanded into an SQL statement with arguments (passed directly to +ActiveRecord::Relation#where+), e.g.:
+    #
+    #     :scope => ["id > ?", 100])
+    #
+    #   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
+      js_mixin :paging_form_panel
+
+      # override
+      def record
+        @record ||= data_adapter.first
+      end
+
+      # Pass total records amount and the first record to the JS constructor
+      def js_config
+        super.merge({
+          :total_records => total_records
+        })
+      end
+
+      endpoint :get_data do |params|
+        @record = data_adapter.get_records(params).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
+
+      component :search_form do
+        {
+          :lazy_loading => true,
+          :class_name => "Netzke::Basepack::SearchWindow",
+          :model => config[:model]
+        }
+      end
+
+      protected
+
+        def total_records(params = {})
+          @total_records ||= data_adapter.count_records(params, [])
+        end
+
+    end
+  end
+end

data/lib/netzke/basepack/paging_form_panel/javascripts/paging_form_panel.js

@@ -0,0 +1,76 @@
+{
+  onSearch: function(el) {
+    if (this.searchWindow) {
+      this.searchWindow.show();
+    } else {
+      this.loadNetzkeComponent({name: 'search_form', callback: function(win){
+        this.searchWindow = win;
+        win.show();
+
+        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'){
+            var store = this.getStore(), proxy = store.getProxy();
+            proxy.extraParams.query = Ext.encode(query);
+            store.load();
+          }
+          el.toggle(query.length > 0); // toggle based on the state
+        }, this);
+      }, scope: this});
+    }
+  },
+
+  getStore: function() {
+    return this.store;
+  },
+
+  afterRender: function() {
+    // delete this.record so our parent FormPanel doesn't have to load it - we do it ourselves
+    var record = this.record;
+    delete (this.record);
+
+    this.callParent();
+
+    if (record) this.store.loadRawData({records: [record], total: this.totalRecords});
+
+    new Ext.LoadMask(this, Ext.apply(this.applyMask, {store: this.store}));
+  },
+
+  initComponent: function() {
+    // Extract field names from items recursively. We have to do it before callParent(),
+    // because we need to build the store for PagingToolbar that cannot be created after superclass.initComponent
+    // Otherwise, the things would be simpler, because this.getForm().items would already have all the fields in one place for us
+    this.fieldNames = [];
+    this.extractFields(this.items);
+
+    var store = new Ext.data.DirectStore({
+      directFn: Netzke.providers[this.id].getData,
+      root: 'records',
+      fields: this.fieldNames.concat('_meta'),
+      pageSize: 1
+    });
+
+    store.on('load', function(st, r){
+      if (r.length == 0) {
+        this.getForm().reset();
+      } else {
+        this.setFormValues(r[0].data);
+      }
+    }, this);
+
+    this.bbar = Ext.create('Ext.toolbar.Paging', {
+      beforePageText: "Record",
+      store: store,
+      items: ["-"].concat(this.bbar || [])
+    });
+
+    this.store = store;
+
+    this.callParent();
+  }
+}

data/lib/netzke/basepack/panel.rb

@@ -0,0 +1,11 @@
+module Netzke
+  module Basepack
+    class Panel < Netzke::Base
+      js_method :update_body_html, <<-JS
+        function(html){
+          this.body.update(html);
+        }
+      JS
+    end
+  end
+end

data/lib/netzke/basepack/query_builder.rb

@@ -0,0 +1,107 @@
+module Netzke
+  module Basepack
+    class QueryBuilder < Netzke::Base
+      js_base_class "Ext.tab.Panel"
+
+      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],
+          :fields => config[:fields],
+          :preset_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'),
+            {
+              :itemId => "presetsCombo",
+              :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)
+        {:netzke_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)
+        {:netzke_feedback => I18n.t('netzke.basepack.query_builder.preset_deleted')}
+      end
+
+
+    end
+  end
+end

data/lib/netzke/basepack/query_builder/javascripts/query_builder.js

@@ -0,0 +1,153 @@
+{
+  initComponent: function() {
+    this.callParent();
+
+    this.presetsCombo = this.getDockedItems()[1].getComponent('presetsCombo');
+
+    this.add({title: "+"});
+
+    this.on('beforetabchange', function(c, newTab, curentTab){
+      if (newTab.title === '+') {
+        this.addTab(true, true);
+        return false;
+      } else {
+        if (this.maxTabHeight) newTab.setHeight(this.maxTabHeight);
+      }
+    }, this);
+
+    this.addTab(true, false);
+
+    this.addEvents('conditionsupdate');
+
+  },
+
+  buildFormFromQuery: function(query) {
+    this.onClearAll();
+
+    if (query.length !== 0) {
+      Ext.each(query, function(f, i){
+        var closable = i === 0 ? false : true;
+        if (this.items.getCount() < i + 2) { this.addTab(false, closable); }
+          this.items.get(i).items.first().buildFormFromQuery(query[i]);
+      }, this);
+    }
+
+    this.doLayout();
+  },
+
+  addTab: function(activate, closable){
+    var newTabConfig = Ext.apply({}, this.netzkeComponents.searchPanel);
+    newTabConfig.id = Ext.id(); // We need a unique ID every time
+    newTabConfig.preventHeader = true;
+    newTabConfig.border = false;
+
+    var newTab = this.insert(
+      this.items.getCount() - 1,
+      {
+        title: "OR",
+        closable: closable,
+        items: [
+          Ext.createByAlias(newTabConfig.alias, newTabConfig)
+        ]
+      }
+    );
+
+    if (activate) {
+      this.suspendEvents();
+      this.setActiveTab(newTab);
+      this.resumeEvents();
+    }
+  },
+
+  getQuery: function(all) {
+    var query = [];
+    this.eachTab(function(i) {
+      var q = i.items.first().getQuery();
+      if (q.length > 0) query.push(i.items.first().getQuery(all));
+    });
+    return query;
+  },
+
+  getTabs: function() {
+    var res = [];
+    this.items.each(function(i) {
+      if (i.title !== "+") { res.push(i); }
+    });
+    return res;
+  },
+
+  eachTab: function(fn, scope) {
+    this.items.each(function(f) {
+      if (f.title !== "+") {
+        fn.call(scope || f, f);
+      }
+    }, this);
+  },
+
+  onClearAll: function() {
+    this.removeAllTabs(true);
+    this.getActiveTab().items.first().onClearAll();
+  },
+
+  onReset: function() {
+    this.eachTab(function(t) { t.onReset(); });
+  },
+
+  removeAllTabs: function(exceptLast) {
+    this.eachTab(function(t) { if (this.items.getCount() > (exceptLast ? 2 : 1)) {this.remove(t);} }, this);
+  },
+
+  onSavePreset: function(){
+    var searchName = this.presetsCombo.getRawValue();
+
+    if (searchName !== "") {
+      var presetsComboStore = this.presetsCombo.getStore();
+      var existingPresetIndex = presetsComboStore.find('field2', searchName);
+      if (existingPresetIndex !== -1) {
+        // overwriting
+        Ext.Msg.confirm(this.i18n.overwriteConfirmTitle, this.i18n.overwriteConfirm, function(btn, text){
+          if (btn == 'yes') {
+            var r = presetsComboStore.getAt(existingPresetIndex);
+            r.set('field1', this.getQuery(true));
+            r.commit();
+            this.doSavePreset(searchName);
+          }
+        }, this);
+      } else {
+        this.doSavePreset(searchName);
+        presetsComboStore.add({field1: this.getQuery(true), field2: searchName});
+      }
+    }
+  },
+
+  doSavePreset: function(name){
+    this.savePreset({
+      name: name,
+      query: Ext.encode(this.getQuery(true))
+    });
+  },
+
+  onDeletePreset: function(){
+    var searchName = this.presetsCombo.getRawValue();
+    if (searchName !== "") {
+      Ext.Msg.confirm(this.i18n.deleteConfirmTitle, this.i18n.overwriteConfirm, function(btn, text){
+        if (btn == 'yes') {
+          this.removePresetFromList(searchName);
+          this.deletePreset({
+            name: searchName
+          });
+        }
+      }, this);
+    }
+  },
+
+  onApply: function() {
+    this.fireEvent('conditionsupdate', this.getQuery());
+  },
+
+  removePresetFromList: function(name){
+    var presetsComboStore = this.presetsCombo.getStore();
+    presetsComboStore.removeAt(presetsComboStore.find('field2', name));
+    this.presetsCombo.reset();
+  }
+}

data/lib/netzke/basepack/search_panel.rb

@@ -0,0 +1,79 @@
+module Netzke
+  module Basepack
+    # == Configuration
+    # +load_last_preset+ - on load, tries to load the latest saved preset
+    class SearchPanel < Base
+
+      include Netzke::Basepack::DataAccessor
+
+      js_base_class "Ext.form.FormPanel"
+
+      js_properties(
+        :padding => 5,
+        :auto_scroll => true
+      )
+
+      js_include :condition_field
+
+      js_mixin :search_panel
+
+      js_property :attribute_operators_map, {
+        :integer => [
+          ["eq", I18n.t('netzke.basepack.search_panel.equals')],
+          ["gt", I18n.t('netzke.basepack.search_panel.greater_than')],
+          ["lt", I18n.t('netzke.basepack.search_panel.less_than')]
+        ],
+        :text => [
+          ["contains", I18n.t('netzke.basepack.search_panel.contains')] # same as matches => %string%
+        ],
+        :string => [
+          ["contains", I18n.t('netzke.basepack.search_panel.contains')], # same as matches => %string%
+          ["matches", I18n.t('netzke.basepack.search_panel.matches')]
+        ],
+        :boolean => [
+          ["is_any", I18n.t('netzke.basepack.search_panel.is_true')],
+          ["is_true", I18n.t('netzke.basepack.search_panel.is_true')],
+          ["is_false", I18n.t('netzke.basepack.search_panel.is_false')]
+        ],
+        :datetime => [
+          ["eq", I18n.t('netzke.basepack.search_panel.date_equals')],
+          ["gt", I18n.t('netzke.basepack.search_panel.after')],
+          ["lt", I18n.t('netzke.basepack.search_panel.before')]
+        ]
+      }
+
+      # Builds default query search panel, where each field is presented
+      def default_query
+        data_class.column_names.map do |c|
+          column_type = data_class.columns_hash[c].type
+          operator = (self.class.js_property(:attribute_operators_map)[column_type] || []).first.try(:fetch, 0) || "matches"
+          {:attr => c, :attr_type => column_type, :operator => operator}
+        end
+      end
+
+      def data_class
+        @data_class ||= config[:model].constantize
+      end
+
+      def js_config
+        super.merge(
+          :attrs => attributes,
+          :attrs_hash => data_class.column_names.inject({}){ |hsh,c| 
+            hsh.merge(c => data_adapter.get_property_type(data_class.columns_hash[c])) },
+          :preset_query => (config[:load_last_preset] ? last_preset.try(:fetch, "query") : config[:query]) || []
+        )
+      end
+
+      def attributes
+        config[:fields].map do |field|
+          [field[:name], field[:field_label]]
+        end
+      end
+
+      def last_preset
+        (state[:presets] || []).last
+      end
+
+    end
+  end
+end