netzke-basepack 0.3.1 → 0.3.3

data/lib/netzke/container.rb

@@ -37,7 +37,7 @@ module Netzke
       item_aggregatees.each_pair do |k,v|
         next if v[:late_aggregation]
         res << <<-JS
-        var #{k.to_js} = new Ext.componentCache['#{v[:widget_class_name]}'](config.#{k.to_js}Config);
+        var #{k.to_js} = new Ext.netzke.cache['#{v[:widget_class_name]}'](config.#{k.to_js}Config);
         JS
       end
       res
@@ -49,13 +49,10 @@ module Netzke
           :title      => i.to_s.humanize,
           :layout     => 'fit',
           :id         => i.to_s,
-          # :id       => "#{config[:name]}_#{i.to_s}",
           :items      => ([i.to_s.to_js.l] if !aggregatees[i][:late_aggregation]),
-          # these listeners will be different for tab_panel and accordion
           :collapsed  => !aggregatees[i][:active],
           :listeners  => {
-          # :activate => {:fn => "function(p){this.feedback(p.id)}".l, :scope => this},
-          :expand     => {:fn => "this.loadItemWidget".l, :scope => this}
+            :expand     => {:fn => "this.loadItemWidget".l, :scope => this}
           }
         }
       end
@@ -67,7 +64,6 @@ module Netzke
         :load_item_widget => <<-JS.l,
           function(panel) {
             if (!panel.getWidget()) panel.loadWidget(this.id + "__" + panel.id + "__get_widget");
-            // if (!this.getWidgetByPanel(panel)) this.loadWidget(panel, this.initialConfig[panel.id+'Config'].interface.getWidget);
           }
         JS
       }

data/lib/netzke/db_fields.rb

@@ -0,0 +1,40 @@
+module Netzke
+  module DbFields
+    def default_db_fields
+      config[:data_class_name].nil? && raise(ArgumentError, "No data_class_name specified for widget #{config[:name]}")
+      
+      data_class          = config[:data_class_name].constantize
+      exposed_columns     = normalize_columns(data_class.exposed_columns) # columns exposed from the data class
+      columns_from_config = (config[:fields] || config[:columns]) && normalize_columns(config[:fields] || config[:columns]) # columns specified in widget's config
+
+      if columns_from_config
+        # reverse-merge each column hash from config with each column hash from exposed_columns (columns from config have higher priority)
+        for c in columns_from_config
+          corresponding_exposed_column = exposed_columns.find{ |k| k[:name] == c[:name] }
+          c.reverse_merge!(corresponding_exposed_column) if corresponding_exposed_column
+        end
+        columns_for_create = columns_from_config
+      else
+        # we didn't have columns configured in widget's config, so, use the columns from the data class
+        columns_for_create = exposed_columns
+      end
+
+      res = []
+      for c in columns_for_create
+        # finally reverse-merge them with the defaults from the data_class
+        res << (self.class.widget_type == :grid ? data_class.default_column_config(c) : data_class.default_field_config(c))
+      end
+      
+      res
+    end
+
+    protected
+
+    # [:col1, {:name => :col2}, :col3] 
+    #    => [{:name => :col1}, {:name => :col2}, {:name => :col3}]
+    def normalize_columns(items)
+      items.map{|c| c.is_a?(Symbol) ? {:name => c} : c}
+    end
+    
+  end
+end

data/lib/netzke/fields_configurator.rb

@@ -1,38 +1,30 @@
 module Netzke
   class FieldsConfigurator < GridPanel
     interface :load_defaults
+
+    def self.js_base_class
+      GridPanel
+    end
     
     def initialize(*args)
       super
 
-      # process config[:layout]
-      config[:conditions] = {:layout_id => (config[:layout] && config[:layout].id)}
-      config[:columns] = [
-        :id, 
-        :label, 
-        {:name => :read_only, :label => "R/O"}, 
-        :hidden, 
-        {:name => :width, :width => 50}, 
-        {:name => :editor, :editor => :combo_box},
-        {:name => :renderer, :editor => :combo_box}
-      ]
-      
+      config[:conditions]         = {:layout_id => config[:layout].id}
+      config[:data_class_name]    = config[:layout].items_class
+      # config[:persistent_layout]  = false
     end
 
     def initial_config
       super.recursive_merge({
         :name              => 'columns',
         :widget_class_name => "GridPanel",
-        :data_class_name   => "NetzkeGridPanelColumn",
-        :ext_config        => {:title => false},
-        # :conditions        => {:layout_id => config[:layout].id},
-        :active            => true
+        :ext_config        => {:title => false}
       })
     end
     
     def actions
       super + [{
-        :text => 'Restore defaults', :handler => 'loadDefaults'
+        :text => 'Restore defaults', :handler_name => 'loadDefaults', :id => 'defaults'
       }]
     end
     
@@ -58,7 +50,7 @@ module Netzke
     
     def load_defaults(params)
       NetzkeLayout.destroy(config[:layout].id)
-      NetzkeGridPanelColumn.create_layout_for_widget(parent.parent)
+      config[:data_class_name].constantize.create_layout_for_widget(parent.parent)
       {}
     end
     

data/lib/netzke/form_panel.rb

@@ -1,164 +1,77 @@
 module Netzke
   class FormPanel < Base
+    include_extras(__FILE__)
     interface :submit, :load
-    
-    class << self
-      def js_base_class
-        "Ext.FormPanel"
-      end
-
-      def js_before_constructor
-        <<-JS
-        var fields = config.fields; // TODO: remove hidden fields
-        var recordFields = [];
-        var index = 0;
-        Ext.each(config.fields, function(field){recordFields.push({name:field.name, mapping:index++})});
-        var Record = Ext.data.Record.create(recordFields);
-        this.reader = new Ext.data.RecordArrayReader({}, Record);
-        
-        JS
-      end
-      
-      def js_default_config
-        super.merge({
-          :auto_scroll    => true,
-          :bbar           => "config.actions".l,
-          # :plugins      => "plugins".l,
-          :items          => "fields".l,
-          :default_type   => 'textfield',
-          :body_style     => 'padding:5px 5px 0',
-          :label_width    => 150,
-          :listeners      => {:afterlayout => {:fn => "this.afterlayoutHandler".l, :scope => this}},
 
-          #custom configs
-          :auto_load_data => true,
-        })
-      end
-      
-      
-    end
+    include Netzke::DbFields
     
-    def self.js_extend_properties
-      {
-        :load_record => <<-JS.l,
-          function(id, neighbour){
-            var proxy = new Ext.data.HttpProxy({url:this.initialConfig.interface.load});
-            proxy.load({id:id, neighbour:neighbour}, this.reader, function(data){
-              if (data){
-                this.form.loadRecord(data.records[0])
-              }
-            }, this)
-          }
-        JS
-        :afterlayout_handler => <<-JS.l,
-          function() {
-            // Load initial data into the form
-            if (this.initialConfig.recordData){
-              var record = this.reader.readRecord(this.initialConfig.recordData);
-              this.form.loadRecord(record);
-            }
-          }
-        JS
-        :refresh_click => <<-JS.l,
-          function() {
-            this.loadRecord(3)
-          }
-        JS
-        :previous => <<-JS.l,
-          function() {
-            var currentId = this.form.getValues().id;
-            this.loadRecord(currentId, 'previous');
-          }
-        JS
-        :next => <<-JS.l,
-          function() {
-            var currentId = this.form.getValues().id;
-            this.loadRecord(currentId, 'next');
-          }
-        JS
-        :submit => <<-JS.l,
-          function() {
-            this.form.submit({
-              url:this.initialConfig.interface.submit
-            })
-          }
-        JS
-      }
+    def self.widget_type
+      :form
     end
-
+    
     # default configuration
     def initial_config
       {
         :ext_config => {
-          :config_tool => false, 
-          :border => true
+          :config_tool => true
         },
         :layout_manager => "NetzkeLayout",
-        :field_manager => "NetzkeFormPanelField"
+        :field_manager => "NetzkeFormPanelField",
+
+        :persistent_layout => true,
+        :persistent_config => true
       }
     end
 
+    def property_widgets
+      res = []
+      res << {
+        :name              => 'fields',
+        :widget_class_name => "FieldsConfigurator",
+        :ext_config        => {:title => false},
+        :active            => true,
+        :layout            => NetzkeLayout.by_widget(id_name),
+        :fields_for        => :form
+      } if config[:persistent_layout]
+      res
+    end
+
     def tools
       [{:id => 'refresh', :on => {:click => 'refreshClick'}}]
     end
     
     def actions
       [{
-        :text => 'Previous', :handler => 'previous'
-      },{
-        :text => 'Next', :handler => 'next'
-      },{
-        :text => 'Apply', :handler => 'submit', :disabled => !@permissions[:update] && !@permissions[:create]
+      #   :text => 'Previous', :handler => 'previous'
+      # },{
+      #   :text => 'Next', :handler => 'next'
+      # },{
+        :text => 'Apply', :handler_name => 'submit', :disabled => !@permissions[:update] && !@permissions[:create], :id => 'apply'
       }]
     end
     
-    def js_config
-      res = super
-      # we pass column config at the time of instantiating the JS class
-      res.merge!(:fields => get_fields || config[:fields]) # first try to get columns from DB, then from config
-      res.merge!(:data_class_name => config[:data_class_name])
-      res.merge!(:record_data => config[:record].to_array(get_fields))
-      res
-    end
-    
     # get fields from layout manager
     def get_fields
       @fields ||=
-      if layout_manager_class && field_manager_class
+      if config[:persistent_layout] && layout_manager_class && field_manager_class
         layout = layout_manager_class.by_widget(id_name)
         layout ||= field_manager_class.create_layout_for_widget(self)
-        layout.items_hash  # TODO: bad name!
+        layout.items_arry_without_hidden
       else
-        Netzke::Column.default_columns_for_widget(self)
+        default_db_fields
       end
     end
-    
-    def submit(params)
-      params.delete(:authenticity_token)
-      params.delete(:controller)
-      params.delete(:action)
-      book = Book.find(params[:id])
-      if book.nil?
-        book = Book.create(params)
-      else
-        book.update_attributes(params)
-      end
-    rescue ActiveRecord::UnknownAttributeError # unknown attributes get ignored
-      book.save
-      [book.to_array(get_fields)].to_json
-    end
-    
-    def load(params)
-      logger.debug { "!!! params: #{params.inspect}" }
-      klass = config[:data_class_name].constantize
-      case params[:neighbour]
-      when "previous" then book = klass.previous(params[:id])
-      when "next"     then book = klass.next(params[:id])
-      else                 book = klass.find(params[:id])
-      end
-      [book && book.to_array(get_fields)].to_json
+
+    # parameters used to instantiate the JS object
+    def js_config
+      res = super
+      # we pass column config at the time of instantiating the JS class
+      res.merge!(:fields => get_fields || config[:fields]) # first try to get columns from DB, then from config
+      res.merge!(:data_class_name => config[:data_class_name])
+      res.merge!(:record_data => config[:record].to_array(get_fields)) if config[:record]
+      res
     end
-    
+ 
     protected
     
     def layout_manager_class
@@ -177,6 +90,7 @@ module Netzke
       %w(read update create delete)
     end
     
+    include PropertiesTool # it will load aggregation with name :properties into a modal window
       
   end
 end

data/lib/netzke/form_panel_extras/interface.rb

@@ -0,0 +1,49 @@
+module Netzke
+  module FormPanelExtras
+    module Interface
+      def submit(params)
+        params.delete(:authenticity_token)
+        params.delete(:controller)
+        params.delete(:action)
+
+        klass = config[:data_class_name].constantize
+        record = klass.find_by_id(params[:id])
+        success = true
+
+        if record.nil?
+          record = klass.create(params)
+        else
+          params.each_pair do |k,v|
+            begin
+              record.send("#{k}=",v)
+            rescue ArgumentError => exc
+              flash :error => exc.message
+              success = false
+              break
+            end
+          end
+        end
+    
+        if success && record.save
+          {:data => [record.to_array(get_fields)], :success => true}
+        else
+          # flash eventual errors
+          record.errors.each_full do |msg|
+            flash :error => msg
+          end
+          {:success => false, :flash => @flash}
+        end
+      end
+
+      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 => [record && record.to_array(get_fields)]}
+      end
+    end
+  end
+end

data/lib/netzke/form_panel_extras/js_builder.rb

@@ -0,0 +1,131 @@
+module Netzke
+  module FormPanelExtras
+    module JsBuilder
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def js_base_class
+          "Ext.FormPanel"
+        end
+
+        def js_before_constructor
+          <<-JS
+          var fields = config.fields;
+          var recordFields = [];
+          var index = 0;
+          Ext.each(fields, function(field){
+            recordFields.push({
+              name:field.name, 
+              mapping:index++
+            });
+            field.hideLabel = field.hidden; // completely hide the field marked "hidden"
+            var extConfig;
+            try{
+              extConfig = Ext.decode(field.extConfig)
+            }
+            catch(err){
+              extConfig = {}
+            }
+            delete(field.extConfig);
+            Ext.apply(field, extConfig);
+          });
+          var Record = Ext.data.Record.create(recordFields);
+          this.reader = new Ext.data.RecordArrayReader({root:"data"}, Record);
+          JS
+        end
+
+        def js_default_config
+          super.merge({
+            :auto_scroll    => true,
+            :bbar           => "config.actions".l,
+            # :plugins      => "plugins".l,
+            :items          => "fields".l,
+            :default_type   => 'textfield',
+            :body_style     => 'padding:5px 5px 0',
+            :label_width    => 150,
+            :listeners      => {
+      				:afterlayout => {
+      				  :fn => "this.afterlayoutHandler".l,
+      				  :scope => this
+  				    }
+				    },
+            :defaults       => {
+              :anchor       => '-20', # to leave some space for the scrollbar
+              :listeners      => {
+        				:specialkey => {
+        				  :fn => <<-JS.l,
+          				  function(field, event){
+            					if (event.getKey() == 13) this.submit();
+            				}
+        				  JS
+        				  :scope => this
+      				  }
+              }
+            }
+          })
+        end
+        
+        def js_extend_properties
+          {
+            :load_record => <<-JS.l,
+              function(id, neighbour){
+                var proxy = new Ext.data.HttpProxy({url:this.initialConfig.interface.load});
+                proxy.load({id:id, neighbour:neighbour}, this.reader, function(data){
+                  if (data){
+                    this.form.loadRecord(data.records[0])
+                  }
+                }, this)
+              }
+            JS
+            :afterlayout_handler => <<-JS.l,
+              function() {
+                // Load initial data into the form
+                if (this.initialConfig.recordData){
+                  var record = this.reader.readRecord(this.initialConfig.recordData);
+                  this.form.loadRecord(record);
+                }
+              }
+            JS
+            :refresh_click => <<-JS.l,
+              function() {
+                this.feedback('Implement me!');
+                // this.loadRecord(3)
+              }
+            JS
+            :previous => <<-JS.l,
+              function() {
+                var currentId = this.form.getValues().id;
+                this.loadRecord(currentId, 'previous');
+              }
+            JS
+            :next => <<-JS.l,
+              function() {
+                var currentId = this.form.getValues().id;
+                this.loadRecord(currentId, 'next');
+              }
+            JS
+            :submit => <<-JS.l,
+              function() {
+                this.form.submit({
+                  url:this.initialConfig.interface.submit,
+                  success :function(form, action){
+                    if (action.result.flash) this.feedback(action.result.flash);
+                    this.form.loadRecord(this.reader.readRecord(action.result.data[0]));
+                  },
+                  failure :function(form, action){
+                    this.feedback(action.result.flash)
+                  },
+                  scope :this
+                })
+              }
+            JS
+          }
+        end
+        
+      end
+      
+    end
+  end
+end