netzke-basepack 0.6.2 → 0.6.3

data/lib/netzke/basepack/form_panel/fields.rb

@@ -5,14 +5,12 @@ module Netzke
       module Fields
         extend ActiveSupport::Concern
 
-        # Items with normalized fields (i.e. containing all the necessary attributes needed by Ext.form.FormPanel to render
-        # a field)
+        # Items with normalized fields (i.e. containing all the necessary attributes needed by Ext.form.FormPanel to render a field)
         def items
           @form_panel_items ||= begin
-            res = normalize_fields(super || data_class && data_class.netzke_attributes || []) # take netzke_attributes as default items
-
+            res = normalize_fields(super || data_class && data_class.netzke_attributes || []) # netzke_attributes as default items
             # if primary key isn't there, insert it as first
-            if data_class && res.first && res.first[:name] != [data_class.primary_key]
+            if data_class && !res.detect{ |f| f[:name] == data_class.primary_key}
               primary_key_item = normalize_field(data_class.primary_key.to_sym)
               @fields_from_config[data_class.primary_key.to_sym] = primary_key_item
               res.insert(0, primary_key_item)
@@ -33,7 +31,7 @@ module Netzke
               # extract incomplete field configs from +config+
               flds = fields_from_config
               # and merged them with fields from the model
-              deep_merge_existing_fields(flds, fields_from_model)
+              deep_merge_existing_fields(flds, fields_from_model) if data_class
             else
               # extract flds configs from the model
               flds = fields_from_model
@@ -82,32 +80,37 @@ module Netzke
             # NetzkeModelAttrList.read_list(data_class.name) if persistent_config_enabled? && data_class
           end
 
-          # This is where we expand our basic field config with all the default and eventual value
+          # This is where we expand our basic field config with all the defaults
           def normalize_field(field)
             # field can only be a string, a symbol, or a hash
             if field.is_a?(Hash)
               field = field.dup # we don't want to modify original hash
+              return field if field[:no_binding] # stop here if no normalization is needed
               field[:name] = field[:name].to_s if field[:name] # all names should be strings
             else
               field = {:name => field.to_s}
             end
 
-            field.merge!(fields_from_model[field[:name].to_sym]) unless fields_from_model[field[:name].to_sym].nil?
+            field_from_model = fields_from_model && fields_from_model[field[:name].to_sym]
 
-            detect_association_with_method(field) # xtype for an association field
+            field_from_model && field.merge!(field_from_model)
 
+            detect_association_with_method(field) # xtype for an association field
             set_default_field_label(field)
-
             set_default_field_xtype(field) if field[:xtype].nil?
-
             set_default_field_value(field) if self.record
+            set_default_read_only(field)
+
+            field[:display_mode] = config[:display_mode] if config[:display_mode]
 
             # provide our special combobox with our id
             field[:parent_id] = self.global_id if field[:xtype] == :combobox
 
             field[:hidden] = field[:hide_label] = true if field[:hidden].nil? && primary_key_attr?(field)
 
-            field[:checked] = field[:value] if field[:attr_type] == "boolean"
+            # checkbox setup
+            field[:checked] = field[:value] if field[:attr_type] == :boolean
+            field[:input_value] = true if field[:attr_type] == :boolean
 
             field
           end
@@ -120,7 +123,11 @@ module Netzke
                 assoc_column = assoc.klass.columns_hash[method.to_s]
                 assoc_method_type = assoc_column.try(:type)
                 if assoc_method_type
-                  c[:xtype] ||= assoc_method_type == :boolean ? xtype_for_attr_type(assoc_method_type) : xtype_for_association
+                  if c[:nested_attribute]
+                    c[:xtype] ||= xtype_for_attr_type(assoc_method_type)
+                  else
+                    c[:xtype] ||= assoc_method_type == :boolean ? xtype_for_attr_type(assoc_method_type) : xtype_for_association
+                  end
                 end
               end
             end
@@ -149,7 +156,9 @@ module Netzke
           end
 
           def set_default_field_label(c)
-            c[:field_label] ||= c[:name].humanize.sub(/\s+/, " ") # multiple spaces get replaced with one
+            # multiple spaces (in case of association attrs) get replaced with one
+            c[:field_label] ||= data_class ? data_class.human_attribute_name(c[:name]) : c[:name].humanize
+            c[:field_label].gsub!(/\s+/, " ")
           end
 
           def set_default_field_value(field)
@@ -168,10 +177,19 @@ module Netzke
             field[:xtype] = xtype_for_attr_type(field[:attr_type]) unless xtype_for_attr_type(field[:attr_type]).nil?
           end
 
+          def set_default_read_only(field)
+            enabled_if = !data_class || data_class.column_names.include?(field[:name])
+            enabled_if ||= data_class.instance_methods.map(&:to_s).include?("#{field[:name]}=")
+            enabled_if ||= record && record.respond_to?("#{field[:name]}=")
+            enabled_if ||= association_attr?(field[:name])
+
+            field[:read_only] = !enabled_if if field[:read_only].nil?
+          end
+
           def attr_type_to_xtype_map
             {
               :integer => :numberfield,
-              :boolean => :xcheckbox,
+              :boolean => :checkbox,
               :date => :datefield,
               :datetime => :xdatetime,
               :text => :textarea,
@@ -181,7 +199,7 @@ module Netzke
           end
 
           def xtype_for_attr_type(type)
-            attr_type_to_xtype_map[type]
+            attr_type_to_xtype_map[type] || :textfield
           end
 
           def xtype_for_association
@@ -196,4 +214,4 @@ module Netzke
       end
     end
   end
-end
+end

data/lib/netzke/basepack/form_panel/javascripts/comma_list_cbg.js

@@ -0,0 +1,59 @@
+Ext.ns("Ext.netzke.form");
+
+/*
+A very simple CheckboxGroup extension, which serializes its checkboxes' "boxLabel" attributes into a string.
+Config options:
+* separator - separator of values in the string (defaults to ",")
+* options - all checkboxes, by boxLabel, e.g.: ["Cool", "To read", "Important"]
+*/
+Ext.netzke.form.CommaListCbg = Ext.extend(Ext.form.CheckboxGroup, {
+  separator: ",",
+
+  initComponent: function(){
+    Ext.netzke.form.CommaListCbg.superclass.initComponent.call(this);
+
+    this.items = [];
+    Ext.each(this.options, function(o){
+      this.items.push({boxLabel: o});
+    }, this);
+
+    this.on('change', function(el){
+      this.hiddenEl.dom.value = this.getValue();
+    }, this);
+  },
+
+  onRender: function(ct, position){
+    Ext.netzke.form.CommaListCbg.superclass.onRender.call(this, ct, position)
+    this.hiddenEl = Ext.DomHelper.append(ct, {tag:'input', type: 'hidden', name: this.name}, true);
+
+    // Don't submit individual checkboxes
+    this.items.each(function(i){
+      i.el.dom.removeAttribute("name");
+    });
+  },
+
+  getValue: function(){
+    var checkedBoxes = Ext.netzke.form.CommaListCbg.superclass.getValue.call(this);
+    var res = [];
+    Ext.each(checkedBoxes, function(cb){
+      res.push(cb.boxLabel);
+    });
+    res = res.join(this.separator);
+    return res;
+  },
+
+  setValue: function(v){
+    if (Ext.isString(v)) {
+      var passedValues = v.split(this.separator);
+      var values = [];
+      this.items.each(function(i){
+        values.push(passedValues.indexOf(i.boxLabel) >= 0);
+      });
+      Ext.netzke.form.CommaListCbg.superclass.setValue.call(this, values);
+    } else {
+      Ext.netzke.form.CommaListCbg.superclass.setValue.call(this, arguments);
+    }
+  }
+});
+
+Ext.reg('commalistcbg', Ext.netzke.form.CommaListCbg);

data/lib/netzke/basepack/form_panel/javascripts/display_mode.js

@@ -0,0 +1,62 @@
+Ext.override(Ext.form.Field, {
+
+  // By calling this, the field is instructed to replace itself with another instance, configured with displayModeConfig
+  setDisplayMode: function(onOff){
+    if (this.hidden) return;
+
+    var owner = this.ownerCt;
+    var newConfig = this.displayModeConfig(onOff);
+
+    var idx = this.removeSelf();
+    owner.insert(idx, newConfig);
+
+    this.destroy();
+  },
+
+  // Remove self from the container
+  removeSelf: function(){
+    var idx = this.ownerCt.items.indexOf(this);
+    this.ownerCt.remove(this);
+    return idx;
+  },
+
+  // Config for creating an instance in "displayMode" (if onOff is true), or normal mode (if onOff is false)
+  displayModeConfig: function(onOff){
+    return Ext.apply(this.initialConfig, onOff ? {xtype: 'displayfield', origXtype: this.xtype, value: this.getValue()} : {xtype: this.origXtype, value: this.getValue()});
+  }
+
+});
+
+Ext.override(Ext.netzke.form.NRadioGroup, {
+  setDisplayMode: function(onOff){
+    this.items.each(function(i){
+      i.setDisabled(onOff);
+    });
+  }
+});
+
+Ext.override(Ext.netzke.form.CommaListCbg, {
+  setDisplayMode: function(onOff){
+    this.items.each(function(i){
+      i.setDisabled(onOff);
+    });
+  }
+});
+
+Ext.override(Ext.form.Checkbox, {
+  setDisplayMode: function(onOff){
+    this.setDisabled(onOff);
+  }
+});
+
+// Composite field has to take care of its children, by setting them into the "display mode"
+Ext.override(Ext.form.CompositeField, {
+  displayModeConfig: function(onOff){
+    var newItems = [];
+    this.items.each(function(i){
+      newItems.push(Ext.apply(i.displayModeConfig(onOff)));
+      i.destroy();
+    });
+    return Ext.apply(this.initialConfig, {items: newItems, name: this.name});
+  }
+});

data/lib/netzke/basepack/form_panel/javascripts/main.js

@@ -0,0 +1,138 @@
+{
+  bodyStyle     : 'padding:5px 5px 0',
+  autoScroll    : true,
+  labelWidth    : 150,
+  applyMask     : {msg: "Updating..."},
+
+  defaults       : {
+    anchor       : '-20', // to leave some space for the scrollbar
+    listeners    : {
+      // On "return" key, submit the form
+      specialkey : {
+        fn : function(field, event){
+          if (event.getKey() == 13) this.ownerCt.onApply();
+        }
+      }
+    }
+  },
+
+  initComponent: function(){
+    if (!this.bbar) this.bbar = {xtype: 'toolbar'}; // an empty bbar by default, so that we can dynamically add buttons
+
+    // Now let Ext.form.FormPanel do the rest
+    Netzke.classes.Basepack.FormPanel.superclass.initComponent.call(this);
+
+    // Apply event
+    this.addEvents('apply');
+  },
+
+  afterRender: function(){
+    Netzke.classes.Basepack.FormPanel.superclass.afterRender.call(this);
+
+    // render in display mode?
+    if (this.locked) this.setDisplayMode(true);
+  },
+
+  onEdit: function(){
+    this.setDisplayMode(false);
+  },
+
+  onCancel: function(){
+    this.setDisplayMode(true, true);
+  },
+
+  updateToolbar: function(){
+    var tbar = this.getBottomToolbar();
+
+    if (this.inDisplayMode) {
+      var buttonIndex = tbar.items.findIndex("name", "apply");
+      var buttonToRemove = tbar.items.itemAt(buttonIndex);
+      if (buttonToRemove) {
+        tbar.remove(buttonToRemove);
+      }
+
+      var buttonIndex = tbar.items.findIndex("name", "cancel");
+      var buttonToRemove = tbar.items.itemAt(buttonIndex);
+      if (buttonToRemove) {
+        tbar.remove(buttonToRemove);
+      }
+      tbar.add(this.actions.edit);
+    } else {
+      var buttonIndex = tbar.items.findIndex("name", "edit");
+      var buttonToRemove = tbar.items.itemAt(buttonIndex);
+      if (buttonToRemove) {
+        tbar.remove(buttonToRemove);
+      }
+      tbar.insertButton(buttonIndex, this.actions.apply);
+      tbar.insertButton(buttonIndex, this.actions.cancel);
+    }
+
+    tbar.doLayout();
+  },
+
+
+  onApply: function() {
+    if (this.fireEvent('apply', this)) {
+      var values = this.getForm().getValues();
+
+      // do not send values from disabled fields and empty values
+      for (var fieldName in values) {
+        var field = this.getForm().findField(fieldName);
+        if (!field || field.disabled) delete values[fieldName];
+      }
+
+      if (!this.applyMaskCmp) this.applyMaskCmp = new Ext.LoadMask(this.bwrap, this.applyMask);
+
+      this.applyMaskCmp.show();
+
+      if (this.fileUpload) {
+        // Not a Netzke's standard endpoint call, because the form is multipart
+        this.getForm().submit({
+          url: this.endpointUrl("netzke_submit"),
+          params: {
+            data: Ext.encode(values)
+          },
+          failure: function(form, action){
+            // It will always be failure, as we don't play along with the Ext success indication (not returning {success: true})
+            this.bulkExecute(Ext.decode(action.response.responseText));
+            this.fireEvent('submitsuccess');
+            if (this.applyMaskCmp) this.applyMaskCmp.hide();
+          },
+          scope: this
+        });
+      } else {
+        // Submit the data and process the result
+        this.netzkeSubmit(Ext.apply((this.baseParams || {}), {data:Ext.encode(values)}), function(result){
+          if (result === "ok") {
+            this.fireEvent("submitsuccess");
+            if (this.mode == "lockable") this.setDisplayMode(true);
+          };
+          if (this.applyMaskCmp) this.applyMaskCmp.hide();
+        }, this);
+      }
+    }
+  },
+
+  setFormValues: function(values){
+    this.getForm().setValues(values);
+  },
+
+  setDisplayMode: function(onOff, cancel){
+    if (this.inDisplayMode == onOff) return;
+    this.getForm().items.each(function(i){i.setDisplayMode(onOff);});
+    this.getForm().cleanDestroyed(); // because fields inside of composite fields are not auto-cleaned!
+    this.doLayout();
+    this.inDisplayMode = onOff;
+    this.updateToolbar();
+  },
+
+  // recursively extract field names
+  extractFields: function(items){
+    Ext.each(items, function(i){
+      if (i.items) {this.extractFields(i.items);}
+      else if (i.name) {this.fieldNames.push(i.name);}
+    }, this);
+
+  }
+
+}

data/lib/netzke/basepack/form_panel/javascripts/n_radio_group.js

@@ -0,0 +1,25 @@
+Ext.ns("Ext.netzke.form");
+
+/*
+A very simple RadioGroup extension.
+Config options:
+* options - all radio buttons, by boxLabel, e.g.: ["Cool", "To read", "Important"]
+*/
+Ext.netzke.form.NRadioGroup = Ext.extend(Ext.form.RadioGroup, {
+  // defaultType: 'radio',
+  // groupCls : 'x-form-radio-group',
+
+  initComponent: function(){
+    Ext.netzke.form.NRadioGroup.superclass.initComponent.call(this);
+
+    this.items = [];
+
+    Ext.each(this.options, function(o){
+      this.items.push({boxLabel: o, name: this.name, inputValue: o});
+    }, this);
+
+    delete this.name;
+  }
+});
+
+Ext.reg('nradiogroup', Ext.netzke.form.NRadioGroup);

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

@@ -25,7 +25,6 @@ module Netzke
             field = fields[params[:column].to_sym]
             scope = field.to_options[:scope]
             query = params[:query]
-
             {:data => combobox_options_for_column(field, :query => query, :scope => scope, :record_id => params[:id])}
           end
 
@@ -52,7 +51,7 @@ module Netzke
           success = create_or_update_record(data)
 
           if success
-            {:set_form_values => values, :set_result => "ok"}
+            {:set_form_values => values.each_pair.inject({}){ |r,(k,v)| r.merge(k.l => v) }, :set_result => "ok"}
           else
             # flash eventual errors
             @record.errors.to_a.each do |msg|
@@ -74,15 +73,19 @@ module Netzke
             @record = data_class.new if @record.nil?
 
             hsh.each_pair do |k,v|
-              begin
-                @record.send("#{k}=",v)
-              rescue StandardError => exc
-                flash :error => exc.message
-                success = false
-                break
-              end
+              @record.set_value_for_attribute(fields[k.to_sym].nil? ? {:name => k} : fields[k.to_sym], v)
             end
 
+            #hsh.each_pair do |k,v|
+              #begin
+                #@record.send("#{k}=",v)
+              #rescue StandardError => exc
+                #flash :error => exc.message
+                #success = false
+                #break
+              #end
+            #end
+
             # did we have complete success?
             success && @record.save
           end