skozlov-netzke-basepack 0.1.1.2 → 0.5.0

data/lib/netzke/form_panel.rb

@@ -0,0 +1,214 @@
+module Netzke
+  # = FormPanel
+  # 
+  # Represents Ext.form.FormPanel
+  # 
+  # == Configuration
+  # * <tt>:data_class_name</tt> - name of the ActiveRecord model that provides data to this GridPanel.
+  # * <tt>:record</tt> - record to be displayd in the form. Takes precedence over <tt>:record_id</tt>
+  # * <tt>:record_id</tt> - id of the record to be displayd in the form. Also see <tt>:record</tt>
+  # 
+  # In the <tt>:ext_config</tt> hash (see Netzke::Base) the following FormPanel specific options are available:
+  # 
+  # * <tt>:mode</tt> - when set to <tt>:config</tt>, FormPanel loads in configuration mode
+  class FormPanel < Base
+    include Netzke::FormPanelJs  # javascript (client-side)
+    include Netzke::FormPanelApi # API (server-side)
+    include Netzke::DataAccessor # some code shared between GridPanel, FormPanel, and other widgets that use database attributes
+
+    # Class-level configuration with defaults
+    def self.config
+      set_default_config({
+        :config_tool_available       => true,
+        
+        :default_config => {
+          :ext_config => {
+            :bbar => %w{ apply },
+            :tools => %w{ }
+          },
+          :persistent_config => false
+        }
+      })
+    end
+    
+    # Extra javascripts
+    def self.include_js
+      [
+        "#{File.dirname(__FILE__)}/form_panel_extras/javascripts/xcheckbox.js"
+      ]
+    end
+    
+    api :submit, :load, :get_combobox_options
+
+    attr_accessor :record
+    
+    def initialize(*args)
+      super
+      apply_helpers
+      @record = config[:record] || data_class && data_class.find_by_id(config[:record_id])
+    end
+    
+    def data_class
+      @data_class ||= config[:data_class_name] && config[:data_class_name].constantize
+    end
+    
+    def configuration_widgets
+      res = []
+      
+      res << {
+        :name              => 'fields',
+        :widget_class_name => "FieldsConfigurator",
+        :active            => true,
+        :widget            => self,
+        :persistent_config => true
+      }
+
+      res << {
+        :name               => 'general',
+        :widget_class_name  => "PropertyEditor",
+        :widget             => self,
+        :ext_config         => {:title => false}
+      }
+      
+      res
+    end
+
+    def actions
+      {
+        :apply => {:text => 'Apply'}
+      }
+    end
+    
+    def columns
+      @columns ||= get_columns.convert_keys{|k| k.to_sym}
+    end
+    
+    # parameters used to instantiate the JS object
+    def js_config
+      res = super
+      res.merge!(:clmns => columns)
+      res.merge!(:data_class_name => config[:data_class_name])
+      res
+    end
+ 
+    # columns to be displayed by the FieldConfigurator (which is GridPanel-based)
+    def self.config_columns
+      [
+        {:name => :name, :type => :string, :editor => :combobox, :width => 200},
+        {:name => :hidden, :type => :boolean, :editor => :checkbox, :width => 40, :header => "Excl"},
+        {:name => :disabled, :type => :boolean, :editor => :checkbox, :width => 40, :header => "Dis"},
+        {:name => :xtype, :type => :string},
+        {:name => :value, :type => :string},
+        {:name => :field_label, :type => :string},
+        {:name => :input_type, :type => :string}
+      ]
+    end
+ 
+    def self.property_fields
+      res = [
+        {:name => :ext_config__title,               :type => :string},
+        {:name => :ext_config__header,              :type => :boolean, :default => true}
+         # {:name => :ext_config__bbar,              :type => :json},
+        # {:name => :ext_config__prohibit_create,     :type => :boolean},
+        # {:name => :ext_config__prohibit_update,     :type => :boolean},
+        # {:name => :ext_config__prohibit_delete,     :type => :boolean},
+        # {:name => :ext_config__prohibit_read,       :type => :boolean}
+      ]
+      
+      res
+      
+    end
+ 
+    # Normalized columns
+    def normalized_columns
+      @normalized_columns ||= normalize_columns(columns)
+    end
+    
+ 
+    def get_columns
+      if config[:persistent_config]
+        persistent_config['layout__columns'] ||= default_columns
+        res = normalize_array_of_columns(persistent_config['layout__columns'])
+      else
+        res = default_columns
+      end
+
+      # merge values for each field if the record is specified
+      @record && res.map! do |c|
+        value = @record.send(normalize_column(c)[:name])
+        value.nil? ? c : normalize_column(c).merge(:value => value)
+      end
+
+      res
+    end
+    
+    XTYPE_MAP = {
+      :integer => :numberfield,
+      :boolean => :xcheckbox,
+      :date => :datefield,
+      :datetime => :xdatetime,
+      :text => :textarea,
+      :json => :jsonfield
+      # :string => :textfield
+    }
+    
+    def default_columns
+      # columns specified in widget's config
+      columns_from_config = config[:columns] && normalize_columns(config[:columns])
+      
+      if columns_from_config
+        # reverse-merge each column hash from config with each column hash from exposed_attributes (columns from config have higher priority)
+        for c in columns_from_config
+          corresponding_exposed_column = predefined_columns.find{ |k| k[:name] == c[:name] }
+          c.reverse_merge!(corresponding_exposed_column) if corresponding_exposed_column
+        end
+        columns_for_create = columns_from_config
+      elsif predefined_columns
+        # we didn't have columns configured in widget's config, so, use the columns from the data class
+        columns_for_create = predefined_columns
+      else
+        raise ArgumentError, "No columns specified for widget '#{id_name}'"
+      end
+      
+      columns_for_create.map! do |c|
+        if data_class
+          # Try to figure out the configuration from data class
+          # detect :assoc__method
+          if c[:name].to_s.index('__')
+            assoc_name, method = c[:name].to_s.split('__').map(&:to_sym)
+            if assoc = data_class.reflect_on_association(assoc_name)
+              assoc_column = assoc.klass.columns_hash[method.to_s]
+              assoc_method_type = assoc_column.try(:type)
+              if assoc_method_type
+                c[:xtype] ||= XTYPE_MAP[assoc_method_type] == :xcheckbox ? :xcheckbox : :combobox
+              end
+            end
+          end
+      
+          # detect association column (e.g. :category_id)
+          if assoc = data_class.reflect_on_all_associations.detect{|a| a.primary_key_name.to_sym == c[:name]}
+            c[:xtype] ||= :combobox
+            assoc_method = %w{name title label id}.detect{|m| (assoc.klass.instance_methods + assoc.klass.column_names).include?(m) } || assoc.klass.primary_key
+            c[:name] = "#{assoc.name}__#{assoc_method}".to_sym
+          end
+          c[:hidden] = true if c[:name] == data_class.primary_key.to_sym && c[:hidden].nil? # hide ID column by default
+
+        end
+        
+        # detect column type
+        type = c[:type] || data_class && data_class.columns_hash[c[:name].to_s].try(:type) || :string
+        c[:type] ||= type
+        
+        c[:xtype] ||= XTYPE_MAP[type] unless XTYPE_MAP[type].nil?
+
+        # if the column is finally simply {:name => "something"}, cut it down to "something"
+        c.reject{ |k,v| k == :name }.empty? ? c[:name] : c
+      end
+      
+      columns_for_create
+      
+    end
+     
+    include Plugins::ConfigurationTool if config[:config_tool_available] # it will load ConfigurationPanel into a modal window      
+  end
+end

data/lib/netzke/form_panel_api.rb

@@ -0,0 +1,74 @@
+module Netzke
+  module FormPanelApi
+    # API handling form submission
+    def submit(params)
+      data_hsh = ActiveSupport::JSON.decode(params[:data])
+      create_or_update_record(data_hsh)
+    end
+
+    # Creates/updates a record from hash
+    def create_or_update_record(hsh)
+      klass = config[:data_class_name].constantize
+      @record = klass.find_by_id(hsh.delete("id"))
+      success = true
+
+      @record = klass.new if @record.nil?
+
+      hsh.each_pair do |k,v|
+        begin
+          @record.send("#{k}=",v)
+        rescue StandardError => exc
+          logger.debug "!!! FormPanelApi#create_or_update_record exception: #{exc.inspect}\n"
+          flash :error => exc.message
+          success = false
+          break
+        end
+      end
+  
+      if success && @record.save
+        {:set_form_values => @record.to_array(columns)}
+      else
+        # flash eventual errors
+        @record.errors.each_full do |msg|
+          flash :error => msg
+        end
+        {:feedback => @flash}
+      end
+    end
+
+    # API handling form load
+    # def load(params)
+    #   klass = config[:data_class_name].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
+    
+    def load(params)
+      record = data_class && data_class.find_by_id(params[:id])
+      {:set_form_values => record.to_array(columns)}
+    end
+    
+    # API that returns options for a combobox
+    def get_combobox_options(params)
+      column = params[:column]
+      query = params[:query]
+  
+      {:data => config[:data_class_name].constantize.options_for(column, query).map{|s| [s]}}
+    end
+    
+    def configuration_panel__fields__get_combobox_options(params)
+      query = params[:query]
+      {:data => (predefined_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.to_array(columns)
+    end
+    
+  end
+end

data/lib/netzke/form_panel_extras/javascripts/xcheckbox.js

@@ -0,0 +1,82 @@
+/**
+ * Ext.ux.form.XCheckbox - checkbox with configurable submit values
+ *
+ * @author  Ing. Jozef Sakalos
+ * @version $Id: Ext.ux.form.XCheckbox.js 441 2009-01-12 11:10:10Z jozo $
+ * @date    10. February 2008
+ *
+ *
+ * @license Ext.ux.form.XCheckbox is licensed under the terms of
+ * the Open Source LGPL 3.0 license.  Commercial use is permitted to the extent
+ * that the code/component(s) do NOT become part of another Open Source or Commercially
+ * licensed development library or toolkit without explicit permission.
+ * 
+ * License details: http://www.gnu.org/licenses/lgpl.html
+ */
+
+/*global Ext */
+
+/**
+  * @class Ext.ux.XCheckbox
+  * @extends Ext.form.Checkbox
+  */
+Ext.ns('Ext.ux.form');
+Ext.ux.form.XCheckbox = Ext.extend(Ext.form.Checkbox, {
+     submitOffValue:'false'
+    ,submitOnValue:'true'
+
+    ,onRender:function() {
+
+        this.inputValue = this.submitOnValue;
+
+        // call parent
+        Ext.ux.form.XCheckbox.superclass.onRender.apply(this, arguments);
+
+        // create hidden field that is submitted if checkbox is not checked
+        this.hiddenField = this.wrap.insertFirst({tag:'input', type:'hidden'});
+
+        // support tooltip
+        if(this.tooltip) {
+            this.imageEl.set({qtip:this.tooltip});
+        }
+
+        // update value of hidden field
+        this.updateHidden();
+
+    } // eo function onRender
+
+    /**
+     * Calls parent and updates hiddenField
+     * @private
+     */
+    ,setValue:function(v) {
+        v = this.convertValue(v);
+        this.updateHidden(v);
+        Ext.ux.form.XCheckbox.superclass.setValue.apply(this, arguments);
+    } // eo function setValue
+
+    /**
+     * Updates hiddenField
+     * @private
+     */
+    ,updateHidden:function(v) {
+        v = undefined !== v ? v : this.checked;
+        v = this.convertValue(v);
+        if(this.hiddenField) {
+            this.hiddenField.dom.value = v ? this.submitOnValue : this.submitOffValue;
+            this.hiddenField.dom.name = v ? '' : this.el.dom.name;
+        }
+    } // eo function updateHidden
+
+    /**
+     * Converts value to boolean
+     * @private
+     */
+    ,convertValue:function(v) {
+        return (v === true || v === 'true' || v == 1 || v === this.submitOnValue || String(v).toLowerCase() === 'on');
+    } // eo function convertValue
+
+}); // eo extend
+
+// register xtype
+Ext.reg('xcheckbox', Ext.ux.form.XCheckbox);

data/lib/netzke/form_panel_js.rb

@@ -0,0 +1,129 @@
+module Netzke
+  module FormPanelJs
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def js_base_class
+        "Ext.FormPanel"
+      end
+
+      def js_extend_properties
+        {
+          :body_style     => 'padding:5px 5px 0',
+          :auto_scroll    => true,
+          :label_width    => 150,
+          :default_type   => 'textfield',
+          # :label_align => 'top',
+
+          :init_component => <<-END_OF_JAVASCRIPT.l,
+            function(){
+              var recordFields = []; // Record
+              this.items = [];
+              var index = 0;
+              
+              // Process columns
+              Ext.each(this.clmns, function(field){
+                if (typeof field == 'string') field = {name:field}; // normalize field
+                if (!field.hidden || field.name == 'id') {
+                  recordFields.push({name:field.name, mapping:index++});
+
+                  var defaultColumnConfig = Ext.apply({}, this.defaultColumnConfig);
+                  var columnConfig = Ext.apply(defaultColumnConfig, field);
+
+                  // apply dynamically defined properties
+                  Ext.apply(columnConfig, {
+                    fieldLabel: columnConfig.fieldLabel || columnConfig.name.humanize(),
+                    hideLabel: columnConfig.hidden, // completely hide fields marked "hidden"
+                    parentId: this.id,
+                    name: columnConfig.name,
+                    checked: columnConfig.xtype == "xcheckbox" ? columnConfig.value : null // checkbox state
+                  });
+
+                  this.items.push(columnConfig);
+                }
+              }, this);
+              
+              var Record = Ext.data.Record.create(recordFields);
+              this.reader = new Ext.data.RecordArrayReader({root:"data"}, Record);
+              
+              delete this.clmns; // we don't need them anymore
+              
+              // Now let Ext.form.FormPanel do the rest
+              Ext.netzke.cache.FormPanel.superclass.initComponent.call(this);
+              
+              // Apply event
+              this.addEvents('apply');
+            }
+          END_OF_JAVASCRIPT
+
+          # Defaults for each field
+          :defaults       => {
+            # :anchor       => '-20', # to leave some space for the scrollbar
+            :width => 180,
+            :listeners    => {
+              # On "return" key, submit the form
+      				:specialkey => {
+      				  :fn => <<-END_OF_JAVASCRIPT.l
+        				  function(field, event){
+          					if (event.getKey() == 13) this.ownerCt.apply();
+          				}
+      				  END_OF_JAVASCRIPT
+    				  }
+            }
+          },
+          
+          :default_column_config => config_columns.inject({}){ |r, c| r.merge!({
+            c[:name] => c[:default]
+          }) },
+          
+          :set_form_values => <<-END_OF_JAVASCRIPT.l,
+            function(values){
+              this.form.loadRecord(this.reader.readRecords({data:[values]}).records[0]);
+            }
+          END_OF_JAVASCRIPT
+
+          :load_record => <<-END_OF_JAVASCRIPT.l,
+            function(id, neighbour){
+              this.load({id:id});
+              // var proxy = new Ext.data.HttpProxy({url:this.initialConfig.api.load});
+              // proxy.load({id:id, neighbour:neighbour}, this.reader, function(data){
+              //   if (data){
+              //     this.form.loadRecord(data.records[0])
+              //   }
+              // }, this)
+            }
+          END_OF_JAVASCRIPT
+          
+          # :previous => <<-END_OF_JAVASCRIPT.l,
+          #   function() {
+          #     var currentId = this.form.getValues().id;
+          #     this.loadRecord(currentId, 'previous');
+          #   }
+          # END_OF_JAVASCRIPT
+          # 
+          # :next => <<-END_OF_JAVASCRIPT.l,
+          #   function() {
+          #     var currentId = this.form.getValues().id;
+          #     this.loadRecord(currentId, 'next');
+          #   }
+          # END_OF_JAVASCRIPT
+          
+          :apply => <<-END_OF_JAVASCRIPT.l
+            function() {
+              if (this.fireEvent('apply', this)) {
+                var values = this.form.getValues();
+                for (var k in values) {
+                  if (values[k] == "") {delete values[k]}
+                }
+                this.submit(Ext.apply((this.baseParams || {}), {data:Ext.encode(values)}));
+              }
+            }
+          END_OF_JAVASCRIPT
+        }
+      end
+      
+    end
+  end
+end