netzke-basepack 0.6.3 → 0.6.4

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

@@ -0,0 +1,140 @@
+{
+  initComponent: function() {
+    Netzke.classes.Basepack.QueryBuilder.superclass.initComponent.call(this);
+    this.add({title: "+"});
+
+    this.on('beforetabchange', function(c, newTab, curentTab){
+      if (newTab.title === '+') {
+        this.addTab(true);
+        return false;
+      } else {
+        if (this.maxTabHeight) newTab.setHeight(this.maxTabHeight);
+      }
+    }, this);
+
+    this.addEvents('conditionsupdate');
+
+  },
+
+  buildFormFromQuery: function(query) {
+    this.onClearAll();
+
+    if (query.length !== 0) {
+      Ext.each(query, function(f, i){
+        if (this.items.getCount() < i + 2) { this.addTab(); }
+        this.items.get(i).buildFormFromQuery(query[i]);
+      }, this);
+    }
+
+    this.doLayout();
+  },
+
+  addTab: function(activate){
+    var newTabConfig = Ext.apply({}, this.components.searchPanel);
+    newTabConfig.id = Ext.id(); // We need a unique ID every time
+    newTabConfig.title = "OR";
+    newTabConfig.closable = true;
+    var newTab = Ext.create(newTabConfig);
+
+    this.insert(this.items.getCount() - 1, newTab);
+
+    if (activate) {
+      this.suspendEvents();
+      this.activate(newTab);
+      this.resumeEvents();
+    }
+  },
+
+  getQuery: function(all) {
+    var query = [];
+    this.eachTab(function(i) {
+      var q = i.getQuery();
+      if (q.length > 0) query.push(i.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, i) {
+      if (this.items.last() !== f) {
+        fn.call(scope || f, f);
+      }
+    }, this);
+  },
+
+  onClearAll: function() {
+    this.removeAllTabs(true);
+    this.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, String.format(this.i18n.overwriteConfirm, searchName), 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);
+        var r = new presetsComboStore.recordType({field1: this.getQuery(true), field2: searchName});
+        presetsComboStore.add(r);
+      }
+    }
+  },
+
+  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, String.format(this.i18n.overwriteConfirm, searchName), 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

@@ -1,59 +1,76 @@
 module Netzke
   module Basepack
-    class SearchPanel < FormPanel
-
-      js_properties :header => false,
-                    :bbar => false
-
-      # An override
-      def normalize_field(f)
-        f = if f.is_a?(Symbol) || f.is_a?(String)
-          {:name => f.to_s, :operator => default_operator}
-        else
-          search_condition = f[:name]
-          if search_condition.is_a?(MetaWhere::Column)
-            {:name => search_condition.column, :operator => search_condition.method}
-          else
-            {:name => search_condition.to_s}
-          end
-        end
+    # == Configuration
+    # +load_last_preset+ - on load, tries to load the latest saved preset
+    class SearchPanel < Base
 
-        f = super(f)
+      js_base_class "Ext.form.FormPanel"
 
-        f[:disabled] = primary_key_attr?(f)
+      js_properties(
+        :padding => 5,
+        :auto_scroll => true
+      )
 
-        # Association field
-        if f[:name].to_s.index("__")
-          f[:xtype] ||= xtype_for_attr_type(:string)
-          f[:attr_type] = :string
-        end
+      js_include :condition_field
 
-        f[:operator] ||= "gt" if [:datetime, :integer, :date].include?(f[:attr_type])
-        f[:operator] ||= "eq" if f[:attr_type] == :boolean
-        f[:operator] ||= default_operator
+      js_mixin :search_panel
 
-        f[:field_label] = [f[:field_label], f[:operator]].join(" ")
-        f.merge(:name => [f[:name], f[:operator]].join("__"))
-      end
+      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')]
+        ]
+      }
 
-      private
-        def default_operator
-          "like"
+      # 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
 
-        # we need to correct the queries to cut off the condition suffixes, otherwise the FormPanel gets confused
-        def get_combobox_options(params)
-          column_name = params[:column]
-          CONDITIONS.each { |c| column_name.sub!(/_#{c}$/, "") }
-          super(:column => column_name)
-        end
+      def data_class
+        @data_class ||= config[:model].constantize
+      end
 
-        def attr_type_to_xtype_map
-          super.merge({
-            :boolean => :tricheckbox
-          })
+      def js_config
+        super.merge(
+          :attrs => attributes,
+          :attrs_hash => data_class.column_names.inject({}){ |hsh,c| hsh.merge(c => data_class.columns_hash[c].type) },
+          :query => (config[:load_last_preset] ? last_preset.try(:fetch, "query") : config[:query]) || []
+        )
+      end
+
+      def attributes
+        data_class.column_names.map do |name|
+          [name, data_class.human_attribute_name(name)]
         end
+      end
+
+      def last_preset
+        (state[:presets] || []).last
+      end
 
     end
   end
-end
+end

data/lib/netzke/basepack/search_panel/javascripts/condition_field.js

@@ -0,0 +1,153 @@
+Ext.ns("Netzke.classes.Basepack.SearchPanel");
+
+Netzke.classes.Basepack.SearchPanel.ConditionField = Ext.extend(Ext.form.CompositeField, {
+  hideLabel: true,
+
+  // Config refinements for the value field
+  valueFieldConfigs: {
+    string: {
+      xtype : 'textfield'
+    },
+    datetime: {
+      xtype : 'datefield'
+    },
+    integer: {
+      xtype: 'numberfield'
+    }
+  },
+
+  initComponent: function(){
+    // if (!this.attrType) this.attrType = 'string';
+    var items = [
+      // attribute combo
+      {
+        xtype     : 'combo',
+        store: this.ownerCt.attrs,
+        allowBlank: true,
+        name: this.attr + '_attr',
+        ref: 'attrCombo',
+        emptyText: 'Attribute',
+        triggerAction: 'all',
+        value: this.attr ? this.attr.underscore() : "",
+        listeners: {
+          select: this.onAttributeChange,
+          scope: this
+        }
+      }
+    ];
+
+    if (this.attr) {
+
+      var operators = this.ownerCt.attributeOperatorsMap[this.attrType] || [[]];
+
+      if (this.attrType === 'boolean') {
+        items.push({
+          xtype     : 'tricheckbox',
+          width: 100,
+          name: this.attr + '_value',
+          ref: 'valueField',
+          checked: this.value
+        });
+
+        items.push({
+          flex: 1,
+          xtype: 'displayfield'
+        });
+      } else {
+        // operator combo
+        items.push(
+          {
+            width: 100,
+            xtype     : 'combo',
+            fieldLabel: 'Operator',
+            store: operators,
+            name: this.attr + '_operator',
+            value: this.operator || operators[0][0],
+            autoSelect: true,
+            triggerAction: 'all',
+            emptyText: "Operator",
+            ref: "operatorCombo"
+          }
+        );
+
+        // value field
+        items.push(Ext.apply(
+          {
+            xtype     : 'textfield',
+            emptyText: "Value",
+            flex: 1,
+            name: this.attr + '_value',
+            ref: 'valueField',
+            value: this.value,
+            ref: "valueField"
+          },
+          this.valueFieldConfigs[this.attrType] // refining the config dependent on the attr type
+        ));
+      }
+
+      // delete button
+      items.push({
+        xtype: 'button',
+        cls: 'x-btn-icon',
+        icon: Netzke.RelativeUrlRoot + "/images/icons/cross.png",
+        handler: this.removeSelf,
+        scope: this
+      });
+    }
+
+    this.items = items;
+
+    // Why on Earth is this not working? Netzke.classes.Basepack.SearchPanel.ConditionField undefined???
+    // Netzke.classes.Basepack.SearchPanel.ConditionField.superclass.initComponent.call(this);
+    Ext.form.CompositeField.prototype.initComponent.call(this); // workaround
+
+    this.addEvents('configured'); // user selects the attribute from the attribute combo
+  },
+
+  isConfigured: function() {
+    return !!this.attrCombo.getValue();
+  },
+
+  removeSelf: function(){
+    var ownerCt = this.ownerCt;
+    this.destroy();
+    ownerCt.fireEvent('fieldsnumberchange');
+  },
+
+  onAttributeChange: function(e){
+    this.fireEvent('configured');
+    this.changeAttribute(e.value.camelize(true));
+  },
+
+  // Dynamically replace self with a field with different attrType
+  changeAttribute: function(attr){
+    var attrType = this.ownerCt.attrsHash[attr];
+    var idx = this.ownerCt.items.indexOf(this);
+    var owner = this.ownerCt;
+    var newSelf = Ext.create(Ext.apply(this.initialConfig, {name: attr, attrType: attrType, attr: attr.underscore(), ownerCt: this.ownerCt, operator: null}));
+    owner.remove(this);
+    owner.insert(idx, newSelf);
+    owner.doLayout();
+  },
+
+  // Returns true if it should be in the query
+  valueIsSet: function(){
+    return !!(this.attrCombo.getValue() && (this.attrType === 'boolean' || this.operatorCombo.getValue()) && !Ext.isEmpty(this.valueField.getValue()));
+  },
+
+  // Returns the query object
+  buildValue: function(){
+    var res = {attr: this.attrCombo.getValue(), value: this.valueField.getValue()};
+    if (this.attrType !== 'boolean') {
+      res.operator = this.operatorCombo.getValue();
+    }
+    return res;
+  },
+
+  clearValue: function() {
+    this.valueField.reset();
+  }
+
+});
+
+Ext.reg('netzkebasepacknewsearchpanelconditionfield', Netzke.classes.Basepack.SearchPanel.ConditionField);

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

@@ -0,0 +1,64 @@
+{
+  initComponent: function() {
+    Netzke.classes.Basepack.SearchPanel.superclass.initComponent.call(this);
+    this.buildFormFromQuery(this.query);
+
+    this.onAddCondition();
+
+  },
+
+  // Will probably need to be performance-optimized in the future, as recreating the fields is expensive
+  buildFormFromQuery: function(query) {
+    this.onClearAll();
+    Ext.each(query, function(f){
+      this.insert(this.items.length - 1, Ext.apply(f, {xtype: 'netzkebasepacknewsearchpanelconditionfield'}));
+    }, this);
+    this.doLayout();
+  },
+
+  onAddCondition: function() {
+    var condField = Ext.create({xtype: 'netzkebasepacknewsearchpanelconditionfield', ownerCt: this});
+    condField.on('configured', function() {
+      this.onAddCondition();
+    }, this, {single: true});
+    this.add(condField);
+    this.doLayout();
+    this.fireEvent('fieldsnumberchange');
+  },
+
+  onReset: function() {
+    this.items.each(function(f){
+      if (f.valueField) {f.clearValue();}
+    });
+  },
+
+  onClearAll: function() {
+    this.eachConfiguredField(function(f) {
+      this.remove(f);
+    }, this);
+
+    this.fireEvent('fieldsnumberchange');
+  },
+
+  // Returns each condition field which has attribute selected
+  eachConfiguredField: function(fn, scope) {
+    this.items.each(function(f, i) {
+      if (this.items.last() !== f) {
+        fn.call(scope || f, f);
+      }
+    }, this);
+  },
+
+  // When "all" is "true", also includes the fields with empty values
+  getQuery: function(all) {
+    var query = [];
+    this.eachConfiguredField(function(f){
+      if (f.valueIsSet() || all) {
+        var cond = f.buildValue();
+        if (all) {cond.attrType = f.attrType;}
+        query.push(cond);
+      }
+    });
+    return query;
+  }
+}