netzke-basepack 0.5.14 → 0.6.0

data/app/components/netzke/basepack/border_layout_panel.rb

@@ -0,0 +1,39 @@
+module Netzke
+  module Basepack
+    # Panel with border layout
+    # == Example configuration:
+    # 
+    #     :items => [
+    #       {:title => "Item One", :class_name => "Basepack::Panel", :region => :center},
+    #       {:title => "Item Two", :class_name => "Basepack::Panel", :region => :west, :width => 300, :split => true}
+    #     ]
+    class BorderLayoutPanel < Netzke::Base
+      
+      def self.js_properties
+        {
+          :layout => 'border',
+          :init_component => <<-END_OF_JAVASCRIPT.l,
+            function(){
+              Ext.each(['center', 'west', 'east', 'south', 'north'], function(r){
+                // A function to access a region component (even if the component gets reloaded, the function will work).
+                // E.g.: getEastComponent()
+                var methodName = 'get'+r.capitalize()+'Component';
+                this[methodName] = function(){
+                  Netzke.deprecationWarning("Instead of '" + methodName + "' use getChildComponent('<name of your component>').");
+                  return this.find('region', r)[0];
+                }.createDelegate(this);
+              }, this);
+
+              // Now let Ext.Panel do the rest
+              #{js_full_class_name}.superclass.initComponent.call(this);
+
+              // First time on "afterlayout", set resize events
+              if (this.persistentConfig) {this.on('afterlayout', this.setResizeEvents, this, {single: true});}
+            }
+          END_OF_JAVASCRIPT
+        }
+      end
+
+    end
+  end
+end

data/app/components/netzke/basepack/form_panel.rb

@@ -0,0 +1,102 @@
+require "netzke/basepack/form_panel/fields"
+require "netzke/basepack/form_panel/services"
+# require "netzke/plugins/configuration_tool"
+# require "netzke/data_accessor"
+
+module Netzke
+  module Basepack
+    # = FormPanel
+    # 
+    # Represents Ext.form.FormPanel
+    # 
+    # == Configuration
+    # * <tt>:model</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>
+    class FormPanel < Netzke::Base
+      # Class-level configuration
+      class_attribute :config_tool_available
+      self.config_tool_available = true
+      
+      class_attribute :default_config
+      self.default_config = {} # To be filled in
+    
+      include self::Services
+      include self::Fields
+    
+      include Netzke::DataAccessor 
+    
+      js_base_class "Netzke.pre.FormPanel"
+    
+      js_property :bbar, [:apply.action]
+    
+      # def initial_config
+      #   res = super
+      #   res[:bbar] = default_bbar if res[:bbar].nil?
+      #   res
+      # end
+      # 
+      # def default_bbar
+      #   [:apply.action]
+      # end
+    
+      # Extra javascripts
+      js_include "#{File.dirname(__FILE__)}/form_panel/javascripts/pre.js",
+                  "#{File.dirname(__FILE__)}/form_panel/javascripts/xcheckbox.js"
+          # Netzke::Base.config[:ext_location] + "/examples/ux/fileuploadfield/FileUploadField.js",
+          # "#{File.dirname(__FILE__)}/form_panel/javascripts/netzkefileupload.js"
+                  
+      def js_config
+        super.merge(
+          # :fields => fields,
+          :pri    => data_class && data_class.primary_key
+        )
+      end
+    
+      def record
+        @record ||= config[:record] || config[:record_id] && data_class && data_class.where(data_class.primary_key => config[:record_id]).first
+      end
+    
+      def configuration_components
+        res = []
+      
+          res << {
+            :name              => 'fields',
+            :class_name => "FieldsConfigurator",
+            :active            => true,
+            :owner             => self,
+            :persistent_config => true
+          }
+
+          res << {
+            :name               => 'general',
+            :class_name  => "PropertyEditor",
+            :component             => self,
+            :title => false
+          }
+      
+          res
+        end
+
+        action :apply, :text => 'Apply', :icon => :tick
+
+        def self.property_fields
+          res = [
+            # {:name => "ext_config__title",               :attr_type => :string},
+            # {:name => "ext_config__header",              :attr_type => :boolean, :default => true},
+            # {:name => "ext_config__bbar",              :attr_type => :json}
+          ]
+      
+          res
+        end
+ 
+        private
+      
+          def self.server_side_config_options
+            super + [:record]
+          end
+ 
+      # include ::Netzke::Plugins::ConfigurationTool if config_tool_available # it will load ConfigurationPanel into a modal window      
+    end
+  end
+end

data/app/components/netzke/basepack/form_panel/fields.rb

@@ -0,0 +1,206 @@
+module Netzke
+  module Basepack
+    class FormPanel < Netzke::Base
+      # Because FormPanel allows for arbitrary layout of fields, we need to have all fields configured in one place (the +fields+ method), and then have references to those fields from +items+.
+      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)
+        def items
+          @form_panel_items ||= begin
+            res = normalize_fields(super || data_class && data_class.netzke_attributes || []) # take 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]
+              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)
+            end
+
+            res
+          end
+        end
+        
+        # Hash of fully configured fields, that are referenced in the items. E.g.:
+        #   {
+        #     :role__name => {:xtype => 'combobox', :disabled => true, :value => "admin"},
+        #     :created_at => {:xtype => 'datetime', :disabled => true, :value => "2010-10-10 10:10"}
+        #   }
+        def fields
+          @fields ||= begin
+            if static_layout?
+              # 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)
+            else
+              # extract flds configs from the model
+              flds = fields_from_model
+            end
+            flds
+          end
+        end
+      
+        # The array of fields as specified on the model level (using +netzke_attribute+ and alike)
+        def fields_array_from_model
+          data_class && data_class.netzke_attributes
+        end
+        
+        # Hash of fields as specified on the model level
+        def fields_from_model
+          @fields_from_model ||= fields_array_from_model && fields_array_from_model.inject({}){ |hsh, f| hsh.merge(f[:name].to_sym => f) }
+        end
+      
+        # Hash of normalized field configs extracted from :items, e.g.:
+        # 
+        #     {:role__name => {:xtype => "combobox"}, :password => {:xtype => "passwordfield"}}
+        def fields_from_config
+          items if @fields_from_config.nil? # by calling +items+ we initiate building of @fields_from_config
+          @fields_from_config ||= {}
+        end
+
+        module ClassMethods
+          # Columns to be displayed by the FieldConfigurator, "meta-columns". Each corresponds to a configuration
+          # option for each field in the form.
+          def meta_columns
+            [
+              {:name => "included", :attr_type => :boolean, :width => 40, :header => "Incl", :default_value => true},
+              {:name => "name", :attr_type => :string, :editor => :combobox, :width => 200},
+              {:name => "label", :attr_type => :string, :header => "Label"},
+              {:name => "default_value", :attr_type => :string}
+            ]
+          end
+        end
+        
+        private
+          def load_persistent_fields
+            # NetzkeFieldList.read_list(global_id) if persistent_config_enabled?
+          end
+        
+          def load_model_level_attrs
+            # 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
+          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
+              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?
+            
+            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
+            
+            # 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"
+            
+            field
+          end
+          
+          # Sets the proper xtype of an asociation field
+          def detect_association_with_method(c)
+            if c[:name].to_s.index('__')
+              assoc_name, method = c[:name].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] ||= assoc_method_type == :boolean ? xtype_for_attr_type(assoc_method_type) : xtype_for_association
+                end
+              end
+            else
+              # are we reflecting some association's foreign key (e.g. :category_id)?
+              if assoc = data_class.reflect_on_all_associations.detect{|a| a.primary_key_name == c[:name]}
+                c[:xtype] ||= xtype_for_association
+                assoc_method = (%w{name title label} << assoc.primary_key_name).detect{|m| (assoc.klass.instance_methods + assoc.klass.column_names).include?(m) } || assoc.klass.primary_key
+                c[:name] = "#{assoc.name}__#{assoc_method}"
+              end
+            end
+          end
+
+          # RECURSIVELY extracts fields configuration from :items
+          def normalize_fields(items)
+            @fields_from_config ||= {}
+            items.map do |item|
+              # at this moment, item is a hash or a symbol
+              if is_field_config?(item)
+                item = normalize_field(item)
+                @fields_from_config[item[:name].to_sym] = item
+                item #.reject{ |k,v| k == :name } # do we really need to remove the :name key?
+              elsif item.is_a?(Hash)
+                item = item.dup # we don't want to modify original hash
+                item[:items].is_a?(Array) ? item.merge(:items => normalize_fields(item[:items])) : item
+              else
+                item
+              end
+            end
+          end
+        
+          def is_field_config?(item)
+            item.is_a?(String) || item.is_a?(Symbol) || item[:name] # && !is_component_config?(item)
+          end
+          
+          def set_default_field_label(c)
+            c[:field_label] ||= c[:name].humanize.sub(/\s+/, " ") # multiple spaces get replaced with one
+          end
+      
+          def set_default_field_value(field)
+            value = record.value_for_attribute(field)
+            field[:value] ||= value unless value.nil?
+          end
+   
+          # Deeply merges only those key/values at the top level that are already there
+          def deep_merge_existing_fields(dest, src)
+            dest.each_pair do |k,v|
+              v.deep_merge!(src[k] || {})
+            end
+          end
+     
+          def set_default_field_xtype(field)
+            field[:xtype] = xtype_for_attr_type(field[:attr_type]) unless xtype_for_attr_type(field[:attr_type]).nil?
+          end
+       
+          def attr_type_to_xtype_map
+            {
+              :integer => :numberfield,
+              :boolean => :xcheckbox,
+              :date => :datefield,
+              :datetime => :xdatetime,
+              :text => :textarea,
+              :json => :jsonfield,
+              :string => :textfield
+            }
+          end
+          
+          def xtype_for_attr_type(type)
+            attr_type_to_xtype_map[type]
+          end
+        
+          def xtype_for_association
+            :combobox
+          end
+   
+          # Are we provided with a static field layout?
+          def static_layout?
+            !!config[:items]
+          end
+    
+      end
+    end
+  end
+end

data/app/components/netzke/basepack/form_panel/javascripts/pre.js

@@ -0,0 +1,76 @@
+/* 
+  Static part of FormPanel's JavaScript class.
+*/
+Netzke.pre.FormPanel = Ext.extend(Ext.form.FormPanel, {
+  bodyStyle     : 'padding:5px 5px 0',
+  autoScroll    : true,
+  labelWidth    : 150,
+  
+  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(){
+    this.recordFields = []; // Record
+    this.recordIndex = 0;
+    
+    var Record = Ext.data.Record.create(this.recordFields);
+    this.reader = new Ext.data.RecordArrayReader({root:"data"}, Record);
+    
+    // Now let Ext.form.FormPanel do the rest
+    Netzke.pre.FormPanel.superclass.initComponent.call(this);
+
+    // Apply event
+    this.addEvents('apply');
+  },
+
+  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.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');
+          },
+          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")};
+        }, this);
+      }
+    }
+  },
+  
+  setFormValues   : function(values){
+    var normValues = {};
+    for (var key in values) {
+      normValues[key.underscore()] = values[key];
+    }
+    this.getForm().setValues(normValues);
+  }
+  
+});

data/app/components/netzke/basepack/form_panel/services.rb

@@ -0,0 +1,99 @@
+module Netzke
+  module Basepack
+    class FormPanel < Netzke::Base
+      module Services
+        extend ActiveSupport::Concern
+    
+        included do
+      
+          #
+          # Endpoints
+          # 
+          endpoint :netzke_submit do |params|
+            data = ActiveSupport::JSON.decode(params[:data])
+            success = create_or_update_record(data)
+
+            if success
+              {:set_form_values => values, :set_result => "ok"}
+            else
+              # flash eventual errors
+              @record.errors.to_a.each do |msg|
+                flash :error => msg
+              end
+              {:feedback => @flash}
+            end
+          end
+      
+          endpoint :netzke_load do |params|
+            @record = data_class && data_class.find_by_id(params[:id])
+            {:set_form_values => @record.to_hash(fields)}
+          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.to_array(fields)
+        # end
+    
+        def values
+          record && record.to_hash(fields)
+        end
+
+        private
+    
+          # 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_class.find(:first, :conditions => {data_class.primary_key => hsh.delete(data_class.primary_key)}) # only pick up the record specified in the params if it was not provided in the configuration
+            success = true
+
+            @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
+            end
+  
+            # did we have complete success?
+            success && @record.save
+          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