netzke-basepack 0.4.2 → 0.5.1

data/lib/netzke/form_panel.rb

@@ -1,39 +1,57 @@
 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_enabled_by_default       => false,
-        :persistent_layout_enabled_by_default => true,
-        :persistent_config_enabled_by_default => true
+        :config_tool_available       => true,
+        
+        :default_config => {
+          :ext_config => {
+            :bbar => %w{ apply },
+            :tools => %w{ }
+          },
+          :persistent_config => false
+        }
       })
     end
-
-    include Netzke::FormPanelExtras::JsBuilder
-    include Netzke::FormPanelExtras::Interface
-    include Netzke::DbFields # database field operations
     
-    # extra javascripts
-    js_include %w{ xcheckbox }.map{|js| "#{File.dirname(__FILE__)}/form_panel_extras/javascripts/#{js}.js"}
+    # Extra javascripts
+    def self.include_js
+      [
+        "#{File.dirname(__FILE__)}/form_panel_extras/javascripts/xcheckbox.js"
+      ]
+    end
     
-    interface :submit, :load, :get_cb_choices
+    api :submit, :load, :get_combobox_options
 
-    def self.widget_type
-      :form
+    attr_accessor :record
+    
+    def initialize(*args)
+      super
+      apply_helpers
+      @record = config[:record] || data_class && data_class.find_by_id(config[:record_id])
     end
     
-    # default instance-level configuration
-    def initial_config
-      {
-        :ext_config => {
-          :config_tool => self.class.config[:config_tool_enabled_by_default],
-        },
-
-        :persistent_layout => self.class.config[:persistent_layout_enabled_by_default],
-        :persistent_config => self.class.config[:persistent_config_enabled_by_default]
-      }
+    def data_class
+      @data_class ||= config[:data_class_name] && config[:data_class_name].constantize
     end
-
+    
     def configuration_widgets
       res = []
       
@@ -41,64 +59,156 @@ module Netzke
         :name              => 'fields',
         :widget_class_name => "FieldsConfigurator",
         :active            => true,
-        :widget            => self
-      } if config[:persistent_layout]
+        :widget            => self,
+        :persistent_config => true
+      }
 
       res << {
         :name               => 'general',
         :widget_class_name  => "PropertyEditor",
-        :widget_name        => id_name,
+        :widget             => self,
         :ext_config         => {:title => false}
       }
       
       res
     end
 
-    def tools
-      %w{ refresh }
-    end
-    
     def actions
       {
         :apply => {:text => 'Apply'}
       }
     end
     
-    def bbar
-      persistent_config[:bottom_bar] ||= config[:bbar] == false ? nil : config[:bbar] || %w{ apply }
+    def columns
+      @columns ||= get_columns.convert_keys{|k| k.to_sym}
     end
     
-    def fields
-      @fields ||= get_fields
-    end
-
     # parameters used to instantiate the JS object
     def js_config
       res = super
-      res.merge!(:fields => fields)
+      res.merge!(:clmns => columns)
       res.merge!(:data_class_name => config[:data_class_name])
-      res.merge!(:record_data => config[:record].to_array(fields)) if config[:record]
       res
     end
  
-    protected
+    # 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_fields
-      if config[:persistent_layout]
-        NetzkeLayoutItem.widget = id_name
-        NetzkeLayoutItem.data = default_db_fields if NetzkeLayoutItem.all.empty?
-        NetzkeLayoutItem.all
+ 
+    def get_columns
+      if config[:persistent_config]
+        persistent_config['layout__columns'] ||= default_columns
+        res = normalize_array_of_columns(persistent_config['layout__columns'])
       else
-        default_db_fields
-      end.map{ |r| r.reject{ |k,v| k == :id } }
+        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
-      
     
-    # def available_permissions
-    #   %w{ read update }
-    # end
+    XTYPE_MAP = {
+      :integer => :numberfield,
+      :boolean => :xcheckbox,
+      :date => :datefield,
+      :datetime => :xdatetime,
+      :text => :textarea,
+      :json => :jsonfield
+      # :string => :textfield
+    }
     
-    include ConfigurationTool # it will load aggregation with name :properties into a modal window
+    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 => array_of_values}
+      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 => array_of_values}
+    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, self)
+    end
+    
+  end
+end

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