netzke-basepack-zh 0.7.6

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

@@ -0,0 +1,51 @@
+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.define('Ext.netzke.form.CommaListCbg', {
+  extend: 'Ext.form.CheckboxGroup',
+  alias: 'widget.commalistcbg',
+  separator: ",",
+
+  initComponent: function(){
+    this.items = [];
+    Ext.each(this.options, function(o){
+      this.items.push({ boxLabel: o, displayOnly:true });
+    }, this);
+
+    this.callParent();
+  },
+
+  getSubmitData: function(){
+    var res = [];
+    Ext.each(this.getChecked(), function( item ){ res.push( item.boxLabel ) });
+    res = res.join(this.separator);
+    var o = {};
+    o[this.name]=res;
+    return o;
+  },
+
+  setValue: function(v){
+    if (Ext.isString(v)) {
+      var passedValues = v.split(this.separator);
+      this.items.each(function(i){
+        i.setValue( passedValues.indexOf(i.boxLabel) >= 0 );
+      });
+    // we can alse set values the Ext way
+    } else {
+      this.callParent(arguments);
+    }
+  },
+
+  setReadonlyMode: function(onOff) {
+    this.items.each(function(i){
+      i.setReadonlyMode(onOff);
+    });
+  }
+
+});
+

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

@@ -0,0 +1,225 @@
+{
+  bodyStyle     : 'padding:5px 5px 0',
+  autoScroll    : true,
+  fieldDefaults : { 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(){
+    // passing config options to BasicForm is possible via initialConfig only
+    // see Ext.form.Panel documentation
+    this.initialConfig = {
+      // form tracks it's default field values so they can be reset()
+      trackResetOnLoad: true,
+    }
+
+    if (!this.bbar && !this.readOnly) this.bbar = {xtype: 'toolbar'}; // an empty bbar by default, so that we can dynamically add buttons
+
+    // Custom error reader. We don't use it to process form values, but rather to normalize the response from the server in case of "real" (iframe) form submit.
+    ErrorReader = function(){};
+
+    ErrorReader.prototype.read = function(xhr) {
+      var unescapeHTML = function(str) {
+        return str.replace(/&lt;/g,'<').replace(/&gt;/g,'>').replace(/&amp;/g,'&');
+      }
+      xhr.responseText = unescapeHTML(xhr.responseText.replace(/<pre.*?>/, "").replace("</pre>", ""));
+      return {records: [], success: true};
+    };
+
+    this.initialConfig.errorReader = new ErrorReader();
+
+    // Now let Ext.form.FormPanel do the rest
+    this.callParent(arguments);
+
+    // To inform the parent about the apply event
+    this.addEvents('apply', 'cancel');
+  },
+
+  afterRender: function(){
+    this.callParent();
+
+    // have a record to be displayed?
+    if (this.record) { this.setFormValues(this.record); }
+
+    // render in display mode?
+    if (this.locked || this.readOnly) this.setReadonlyMode(true);
+  },
+
+  onEdit: function(){
+    this.setReadonlyMode(false);
+  },
+
+  onCancel: function(){
+    this.getForm().reset();
+    this.setReadonlyMode(true, true);
+  },
+
+  updateToolbar: function(){
+    var tbar = this.child('toolbar');
+
+    if ( this.inReadonlyMode ) {
+      //   if the form in readonly mode, remove "Apply" and "Cancel"
+      //   buttons from toolbar and add "Edit" button
+      var buttonToRemove = tbar.child("button[name='apply']");
+      if ( buttonToRemove ) {
+        tbar.remove( buttonToRemove );
+      }
+
+      var buttonToRemove = tbar.child("button[name='cancel']");
+      if ( buttonToRemove ) {
+        tbar.remove( buttonToRemove );
+      }
+
+      tbar.add( this.actions.edit );
+
+    } else {
+      // if the form editable, remove "edit" button and
+      // insert "apply" and "cancel" instead
+
+      var buttonIndex = tbar.items.findIndex("name", "edit");
+      var buttonToRemove = tbar.items.getAt(buttonIndex);
+      if (buttonToRemove) {
+        tbar.remove(buttonToRemove);
+      }
+      tbar.insert( buttonIndex, this.actions.cancel );
+      tbar.insert( buttonIndex, this.actions.apply );
+    }
+
+    tbar.doLayout();
+  },
+
+  onApply: function() {
+    if (this.fireEvent('apply', this)) {
+      var values = this.getForm().getValues();
+      for (var fieldName in values) {
+        var field = this.getForm().findField(fieldName);
+
+        // TODO: move the following checks to the server side (through the :display_only option)
+
+        // do not submit values from disabled fields
+        if (!field || field.disabled) {
+          delete values[fieldName];
+        }
+
+        // do not submit values from read-only association fields
+        if (field
+          && field.name.indexOf("__") !== -1
+          && (field.readOnly || !field.isXType('combobox'))
+          && (!field.nestedAttribute) // except for "nested attributes"
+        ) {
+          delete values[fieldName];
+        }
+
+        // do not submit values from displayfields
+        if (field.isXType('displayfield')) {
+          delete values[fieldName];
+        }
+
+        // do not submit displayOnly fields
+        if (field.displayOnly) {
+          delete values[fieldName];
+        }
+      }
+      // WIP: commented out on 2011-05-11 because of fatal errors
+      // apply mask
+      // if (!this.applyMaskCmp) this.applyMaskCmp = new Ext.LoadMask(this.bwrap, this.applyMask);
+      // this.applyMaskCmp.show();
+
+      // We must use a different approach when the form is multipart, as we can't use the endpoint
+      if (this.fileUpload) {
+        this.getForm().submit({ // normal submit
+          url: this.endpointUrl("netzke_submit"),
+          params: {
+            data: Ext.encode(values) // here are the correct values that may be different from display values
+          },
+          failure: function(form, action){
+            if (this.applyMaskCmp) this.applyMaskCmp.hide();
+          },
+          success: function(form, action) {
+            try {
+              var respObj = Ext.decode(action.response.responseText);
+              delete respObj.success;
+              this.bulkExecute(respObj);
+              this.fireEvent('submitsuccess');
+            }
+            catch(e) {
+              Ext.Msg.alert('File upload error', action.response.responseText);
+            }
+            if (this.applyMaskCmp) this.applyMaskCmp.hide();
+          },
+          scope: this
+        });
+      } else {
+        this.netzkeSubmit(Ext.apply((this.baseParams || {}), {data:Ext.encode(values)}), function(success){
+          if (success) {
+            this.fireEvent("submitsuccess");
+            if (this.mode == "lockable") this.setReadonlyMode(true);
+          };
+          if (this.applyMaskCmp) this.applyMaskCmp.hide();
+        }, this);
+      }
+    }
+    this.fireEvent('afterApply', this);
+  },
+
+  setFormValues: function(values){
+    var assocValues = values._meta.associationValues || {};
+    for (var assocFieldName in assocValues) {
+
+      var assocField = this.getForm().getFields().filter('name', assocFieldName).first();
+      if (assocField.isXType('combobox')) {
+        assocField.emptyText = assocField.emptyText || "---";
+        // HACK: using private property 'store' here!
+        assocField.store.loadData([[values[assocFieldName], assocValues[assocFieldName]]]);
+        delete assocField.lastQuery; // force loading the store next time user clicks the trigger
+      } else {
+        assocField.setValue(assocValues[assocFieldName]);
+        delete values[assocFieldName]; // we don't want this to be set once more below with setValues()
+      }
+    }
+
+    this.getForm().setValues(values);
+  },
+
+  setReadonlyMode: function(onOff, cancel){
+    if (this.inReadonlyMode == onOff) return;
+    this.getForm().getFields().each(function(i){
+      if (i.setReadonlyMode) i.setReadonlyMode(onOff);
+    });
+
+    // this.getForm().cleanDestroyed(); // because fields inside of composite fields are not auto-cleaned!
+    this.doLayout();
+    this.inReadonlyMode = onOff;
+    if (this.mode == "lockable") 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);
+  },
+
+  applyFormErrors: function(errors) {
+    var field;
+    Ext.iterate(errors, function(fieldName, message){
+      fieldName = fieldName.underscore();
+      if ( field = this.getForm().findField(fieldName) || this.getForm().findField(fieldName.replace(/([a-z]+)([0-9])/g, '$1_$2'))) {
+        field.markInvalid(message.join('<br/>'));
+      }
+    }, this);
+  }
+
+}

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

@@ -0,0 +1,4 @@
+Ext.override(Ext.ux.form.FileUploadField, {
+  // FormPanel won't submit this by default
+  displayOnly: true
+});

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

@@ -0,0 +1,43 @@
+Ext.ns("Ext.netzke.form");
+/*
+A very simple RadioGroup extension.
+Config options:
+* options:
+  1) all radio buttons, by boxLabel, e.g.: ["Cool", "To read", "Important"]
+  2) array of arrays in format [value, label], e.g.: [[1, "Good"], [2, "Average"], [3, "Poor"]]
+*/
+Ext.define('Ext.netzke.form.NRadioGroup', {
+  extend: 'Ext.form.RadioGroup',
+  alias:  'widget.nradiogroup',
+  initComponent: function(){
+    this.callParent();
+
+    this.items = [];
+
+    Ext.each(this.options, function(o){
+      if (Ext.isArray(o)){
+        this.items.push({boxLabel: o[1], name: this.name, inputValue: o[0]});
+      } else {
+        this.items.push({boxLabel: o, name: this.name, inputValue: o});
+      }
+    }, this);
+
+    // delete this.name;
+  },
+
+  getValue: function() {
+    var value;
+    this.items.each(function(i) {
+      value = i.inputValue;
+      return !i.getValue();
+    });
+    return value;
+  },
+
+  setReadonlyMode: function(onOff) {
+    this.items.each(function(i){
+      i.setReadonlyMode(onOff);
+    });
+  }
+});
+

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

@@ -0,0 +1,35 @@
+// Overrides that implement setReadonlyMode for form fields.
+//
+
+Ext.form.field.Base.override({
+  setReadonlyMode: function(onOff){
+    if (this.hidden) return;
+
+    if (!this.initialConfig.readOnly) {
+      this.setReadOnly(onOff);
+    }
+
+    if (onOff) {
+      this.addCls("readonly");
+      if (this.label) this.label.addCls("readonly");
+    } else {
+      this.removeCls("readonly");
+      if (this.label) this.label.removeCls("readonly");
+    }
+  }
+});
+
+// Also the FieldContainer
+Ext.form.FieldContainer.override({
+  setReadonlyMode: function(onOff){
+    this.items.each(function(i){
+      i.setReadonlyMode(onOff);
+    });
+  }
+});
+
+Ext.form.field.Checkbox.override({
+  setReadonlyMode: function(onOff){
+    this.setDisabled(onOff);
+  }
+});

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

@@ -0,0 +1,142 @@
+module Netzke
+  module Basepack
+    class FormPanel < Netzke::Base
+      module Services
+        extend ActiveSupport::Concern
+
+        included do
+
+          #
+          # Endpoints
+
+          # Called when the form gets submitted (e.g. by pressing the Apply button)
+          endpoint :netzke_submit, :pre => true do |params|
+            netzke_submit(params)
+          end
+
+          # Can be called when the form needs to load a record with given ID. E.g.:
+          #
+          #     someForm.netzkeLoad({id: 100});
+          endpoint :netzke_load do |params|
+            @record = data_class && data_adapter.find_record(params[:id])
+            {:set_form_values => js_record_data}
+          end
+
+          # Returns options for a combobox
+          endpoint :get_combobox_options do |params|
+            query = params[:query]
+
+            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
+
+        end
+
+        # Overriding configuration_panel's get_combobox_options endpoint call
+        def configuration_panel__fields__get_combobox_options(params)
+          query = params[:query]
+          {:data => (default_columns.map{ |c| c[:name].to_s }).grep(/^#{query}/).map{ |n| [n] }}.to_nifty_json
+        end
+
+        # Returns array of form values according to the configured columns
+        # def array_of_values
+        #   @record && @record.netzke_array(fields)
+        # end
+
+        def values
+          record && record.netzke_hash(fields)
+        end
+
+        # Implementation for the "netzke_submit" endpoint (for backward compatibility)
+        def netzke_submit(params)
+          data = ActiveSupport::JSON.decode(params[:data])
+          data.each_pair do |k,v|
+            data[k]=nil if v.blank? || v == "null" # Ext JS returns "null" on empty date fields, or "" for not filled optional integer fields, which gives errors when passed to model (at least in DataMapper)
+          end
+
+          # File uploads are in raw params instead of "data" hash, so, mix them in into "data"
+          if config[:file_upload]
+            Netzke::Core.controller.params.each_pair do |k,v|
+              data[k] = v if v.is_a?(ActionDispatch::Http::UploadedFile)
+            end
+          end
+
+          success = create_or_update_record(data)
+
+          if success
+            {:set_form_values => js_record_data, :set_result => true}
+          else
+            # flash eventual errors
+            data_adapter.errors_array(@record).each do |error|
+              flash :error => error
+            end
+            {:netzke_feedback => @flash, :apply_form_errors => build_form_errors(record)}
+          end
+        end
+
+        private
+
+          # Builds the form errors
+          def build_form_errors(record)
+            form_errors = {}
+            foreign_keys = data_adapter.hash_fk_model
+            record.errors.to_hash.map{|field, error|
+              # some ORM return an array for error
+              error = error.join ', ' if error.kind_of? Array
+              # Get the correct field name for the errors on foreign keys
+              if foreign_keys.has_key?(field)
+                fields.each do |k, v|
+                  # Hack to stop to_nifty_json from camalizing model__field
+                  field = k.to_s.gsub('__', '____') if k.to_s.split('__').first == foreign_keys[field].to_s
+                end
+              end
+              form_errors[field] ||= []
+              form_errors[field] << error
+            }
+            form_errors
+          end
+
+          # Creates/updates a record from hash
+          def create_or_update_record(hsh)
+            hsh.merge!(config[:strong_default_attrs]) if config[:strong_default_attrs]
+            @record ||= data_adapter.find_record hsh.delete(data_class.primary_key.to_s) # only pick up the record specified in the params if it was not provided in the configuration
+              #data_class.find(:first, :conditions => {data_class.primary_key => hsh.delete(data_class.primary_key)}) 
+            success = true
+
+            @record = data_class.new if @record.nil?
+
+            hsh.each_pair do |k,v|
+              @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 && data_adapter.save_record(@record)
+          end
+
+          # API handling form load
+          # def load(params)
+          #   klass = config[:model].constantize
+          #   case params[:neighbour]
+          #     when "previous" then @record = klass.previous(params[:id])
+          #     when "next"     then @record = klass.next(params[:id])
+          #     else                 @record = klass.find(params[:id])
+          #   end
+          #   {:data => [array_of_values]}
+          # end
+
+      end
+    end
+  end
+end