netzke-basepack 0.5.8 → 0.5.9

data/lib/netzke/basic_app.rb

@@ -182,6 +182,42 @@ module Netzke
           }
         END_OF_JAVASCRIPT
         
+        # NOT USED
+        :show_login_window => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            var w = new Ext.Window({
+              title: "Please, login",
+              modal: true,
+              width: 350,
+              height: 200,
+              layout: 'fit',
+              items: [{
+                xtype: 'form',
+                padding: 20,
+                defaults: {anchor: '100%'},
+                frame: true,
+                border: false,
+                items: [
+                  {xtype: 'textfield', fieldLabel: 'Username', name: 'login'},
+                  {name: 'password', xtype: 'textfield', inputType: 'password', fieldLabel: "Password"}
+                ],
+                buttons: [{
+                  name: "submit",
+                  text: "Login",
+                  app: this,
+                  handler: function() {
+                    this.ownerCt.ownerCt.getForm().submit({
+                      url: this.app.buildApiUrl("submit_login"),
+                    });
+                  }
+                }]
+              }],
+            });
+            
+            w.show();
+          }
+        END_OF_JAVASCRIPT
+        
         
         # Masquerade selector window
         :show_masquerade_selector => <<-END_OF_JAVASCRIPT.l
@@ -315,10 +351,17 @@ module Netzke
     api :masquerade_as
     def masquerade_as(params)
       session = Netzke::Base.session
-      session[:masq_world] = params[:world]
-      session[:masq_role] = params[:role]
-      session[:masq_user] = params[:user]
-      {:js => "window.location.reload()"}
+      session[:masq_world] = params[:world] == "true"
+      session[:masq_role] = params[:role].try(:to_i)
+      session[:masq_user] = params[:user].try(:to_i)
+      {:js => "window.location.reload();"}
+    end
+    
+    # Login request from the in-app login form
+    api :submit_login
+    def submit_login(params)
+      # TODO: implement me
+      {:feedback => "OK"}
     end
     
   end

data/lib/netzke/configuration_panel.rb

@@ -6,7 +6,7 @@ module Netzke
     def commit(params)
       commit_data = ActiveSupport::JSON.decode params[:commit_data]
       commit_data.each_pair do |k,v|
-        aggregatee_instance(k).commit(v)
+        aggregatee_instance(k).commit(v) if aggregatee_instance(k).respond_to?(:commit)
       end
       {:reload_parent => true, :feedback => (@flash.empty? ? nil : @flash)}
     end

data/lib/netzke/data_accessor.rb

@@ -14,38 +14,15 @@ module Netzke
       # Generic extensions to the data model
       if data_class # because some widgets, like FormPanel, may have it optional
         data_class.send(:include, Netzke::ActiveRecord::DataAccessor) if !data_class.include?(Netzke::ActiveRecord::DataAccessor)
-      
-        # Model helpers
-        const_name = "Netzke::Helpers::#{data_class.name}"
-        model_extensions = const_name.constantize rescue nil
-        data_class.send(:include, model_extensions) if model_extensions && !data_class.include?(model_extensions)
       end
     end
-
-    # Returns columns that are exposed by the class and the helpers
-    def predefined_columns
-      helper_module = "Netzke::Helpers::#{short_widget_class_name}#{data_class.name}".constantize rescue nil
-      
-      data_class_columns = data_class && data_class.column_names.map(&:to_sym) || []
-      
-      if helper_module
-        exposed_attributes = helper_module.respond_to?(:exposed_attributes) ? normalize_array_of_columns(helper_module.exposed_attributes) : nil
-        virtual_attributes = helper_module.respond_to?(:virtual_attributes) ? helper_module.virtual_attributes : []
-        excluded_attributes = helper_module.respond_to?(:excluded_attributes) ? helper_module.excluded_attributes : []
-        attributes_config = helper_module.respond_to?(:attributes_config) ? helper_module.attributes_config : {}
-        
-        res = exposed_attributes || data_class_columns + virtual_attributes
-        
-        res = normalize_columns(res)
-        
-        res.reject!{ |c| excluded_attributes.include? c[:name] }
-
-        res.map!{ |c| c.merge!(attributes_config[c[:name]] || {})}
-      else
-        res = normalize_columns(data_class_columns)
+    
+    # [:col1, "col2", {:name => :col3}] =>
+    #   [{:name => "col1"}, {:name => "col2"}, {:name => "col3"}]
+    def normalize_attr_config(cols)
+      cols.map do |c|
+        c.is_a?(Symbol) || c.is_a?(String) ? {:name => c.to_s} : c.merge(:name => c[:name].to_s)
       end
-      
-      res
     end
 
     # Make sure we have keys as symbols, not strings
@@ -61,7 +38,7 @@ module Netzke
     
     # From symbol to config hash
     def normalize_column(field)
-      field.is_a?(Symbol) ? {:name => field} : field
+      field.is_a?(Symbol) ? {:name => field.to_s} : field
     end
     
     # From symbols to config hashes

data/lib/netzke/fields_configurator.rb

@@ -3,42 +3,26 @@ module Netzke
   # Provides dynamic configuring columns/fields for GridPanel and FormPanel.
   # Configuration parameters:
   # * <tt>:widget</tt> - widget to configure columns/fields for
-  class FieldsConfigurator < GridPanel
+  class FieldsConfigurator < JsonArrayEditor
     api :load_defaults
 
-    def initialize(*args)
-      super
-      @auto_table_klass = is_for_grid? ? NetzkeAutoColumn : NetzkeAutoField
-      @auto_table_klass.widget = client_widget
-    end
-
-    # widget that uses us
-    def client_widget
-      @passed_config[:widget]
-    end
-
-    # is our client widget a grid (as opposed to a form)?
-    def is_for_grid?
-      client_widget.class.ancestors.include?(GridPanel)
-    end
-
     def default_config
       super.deep_merge({
         :name              => 'columns',
-        :model   => is_for_grid? ? "NetzkeAutoColumn" : "NetzkeAutoField",
         :ext_config        => {
+          :config_tool => false,
           :header => false,
           :enable_extended_search => false,
           :enable_edit_in_form => false,
           :enable_rows_reordering => GridPanel.config[:rows_reordering_available],
           :enable_pagination => false
-        },
+        }
       })
     end
     
     def actions
       super.merge(
-        :defaults => {:text => 'Restore defaults'}
+        :defaults => {:text => 'Restore defaults', :icon => Netzke::Base.config[:with_icons] && (Netzke::Base.config[:icons_uri] + "wand.png")}
       )
     end
     
@@ -46,12 +30,52 @@ module Netzke
       %w{ add edit apply del - defaults }
     end
         
-    def predefined_columns
-      [{:name => :id}, *config[:widget].class.config_columns]
+    # Default columns for the configurator
+    def default_columns
+      [
+        {:name => "id", :attr_type => :integer, :meta => true}, 
+        {:name => "position", :attr_type => :integer, :meta => true},
+        {:name => "attr_type", :attr_type => :string, :meta => true},
+        *config[:owner].class.meta_columns.map { |c| c[:name] == "name" ? inject_combo_for_name_column(c) : c }
+      ]
     end
         
     def self.js_extend_properties
       {
+        :init_component => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            #{js_full_class_name}.superclass.initComponent.call(this);
+            
+            // Automatically set the correct editor for the default_value column
+            this.on('beforeedit', function(e){
+              var column = this.getColumnModel().getColumnById(this.getColumnModel().getColumnId(e.column));
+              var record = this.getStore().getAt(e.row);
+              
+              if (column.dataIndex === "default_value") {
+                if (record.get("name") === this.pri) {
+                  // Don't allow setting default value for the primary key
+                  column.setEditor(null);
+                } else {
+                  // Auto set the editor, dependent on the field type
+                  var attrType = record.get("attr_type");
+                  column.setEditor(Ext.create({xtype: this.attrTypeEditorMap[attrType] || "textfield"}));
+                }
+              }
+              
+            }, this);
+            
+          }
+        END_OF_JAVASCRIPT
+        
+        :attr_type_editor_map => {
+          :integer  => "numberfield",
+          :boolean  => "checkbox",
+          :decimal  => "numberfield",
+          :datetime => "xdatetime",
+          :date     => "datefield",
+          :string   => "textfield"
+        },
+        
         # Disable the 'gear' tool for now
         :on_gear => <<-END_OF_JAVASCRIPT.l,
           function(){
@@ -79,31 +103,72 @@ module Netzke
     end
     
     def load_defaults(params)
-      config[:widget].persistent_config[:layout__columns] = config[:widget].default_columns
-      @auto_table_klass.rebuild_table
+      # Reload the temp table with default values
+      data_class.replace_data(default_owner_fields)
+
+      # ... and reflect it in the persistent storage
+      on_data_changed
+      
+      # Update the grid
       {:load_store_data => get_data}
     end
    
-    def commit(params)
-      defaults_hash = config[:widget].class.config_columns.inject({}){ |r, c| r.merge!(c[:name] => c[:default]) }
-      config[:widget].persistent_config[:layout__columns] = @auto_table_klass.all_columns.map do |c| 
-        # reject all keys that are 1) same as defaults, 2) 'position'
-        c.reject!{ |k,v| defaults_hash[k.to_sym].to_s == v.to_s || k == 'position'} 
-        c = c["name"] if c.keys.count == 1 # denormalize the column
-        c
-      end
-      {}
-    end
-   
-    # each time that we are loaded into the app, rebuild the table
-    def before_load
-      @auto_table_klass.rebuild_table
-    end
-   
-    # Don't show the config tool
+    # Never show the config tool
     def config_tool_needed?
       false
     end
    
+    private
+    
+      # An override
+      def process_data(data, operation)
+        if operation == :update
+          meta_attrs_to_update = data.inject({}) do |r,el|
+            r.merge({
+              data_class.find(el["id"]).name => el.reject{ |k,v| k == "id" }
+            })
+          end
+      
+          res = super
+      
+          NetzkeFieldList.update_fields(config[:owner].global_id, meta_attrs_to_update)
+        
+          res
+        else
+          super
+        end
+      end
+    
+      # An override
+      def store_data(data)
+        NetzkeFieldList.update_list_for_current_authority(config[:owner].global_id, data, config[:owner].data_class.name)
+      end
+      
+      # An override
+      def initial_data
+        NetzkeFieldList.read_list(config[:owner].global_id) || default_owner_fields
+      end
+
+      # Set strict combo for the "name" column, with options of the attributes provided by the data_class
+      def inject_combo_for_name_column(c)
+        netzke_attrs = config[:owner].data_class.netzke_attributes.map{ |a| a[:name] }
+        c.merge(:editor => {:xtype => :combo, :store => netzke_attrs, :force_selection => true})
+      end
+      
+      def default_owner_fields
+        config[:owner].initial_columns(false).map(&:deebeefy_values)
+      end
+   
+      # This is an override of GridPanel#on_data_changed
+      def on_data_changed
+        # Default column settings taken from 
+        defaults_hash = config[:owner].class.meta_columns.inject({}){ |r, c| r.merge!(c[:name] => c[:default_value]) }
+        stripped_columns = data_class.all_columns.map do |c| 
+          # reject all keys that are 1) same as defaults
+          c.reject{ |k,v| defaults_hash[k.to_sym].to_s == v.to_s } 
+        end
+        store_data(stripped_columns)
+      end
+   
   end
 end

data/lib/netzke/form_panel.rb

@@ -1,5 +1,6 @@
 require "netzke/form_panel/form_panel_js"
 require "netzke/form_panel/form_panel_api"
+require "netzke/form_panel/form_panel_fields"
 require "netzke/plugins/configuration_tool"
 require "netzke/data_accessor"
 
@@ -19,6 +20,7 @@ module Netzke
   class FormPanel < Base
     include FormPanelJs  # javascript (client-side)
     include FormPanelApi # API (server-side)
+    include FormPanelFields # fields
     include Netzke::DataAccessor # some code shared between GridPanel, FormPanel, and other widgets that use database attributes
 
     # Class-level configuration with defaults
@@ -61,14 +63,22 @@ module Netzke
     def initialize(*args)
       super
       apply_helpers
-      @record = config[:record] || config[:record_id] && data_class && data_class.find(:first, :conditions  => {data_class.primary_key => config[:record_id]})
     end
     
     # (We can't memoize this method because at some point we extend it, e.g. in Netzke::DataAccessor)
     def data_class
-      ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
-      model_name = config[:model] || config[:data_class_name]
-      @data_class ||= model_name && model_name.constantize
+      @data_class ||= begin
+        klass = "Netzke::ModelExtensions::#{config[:model]}For#{short_widget_class_name}".constantize rescue nil
+        klass || begin
+          ::ActiveSupport::Deprecation.warn("data_class_name option is deprecated. Use model instead", caller) if config[:data_class_name]
+          model_name = config[:model] || config[:data_class_name]
+          model_name && model_name.constantize
+        end
+      end
+    end
+    
+    def record
+      @record ||= config[:record] || config[:record_id] && data_class && data_class.find(:first, :conditions  => {data_class.primary_key => config[:record_id]})
     end
     
     def configuration_widgets
@@ -78,7 +88,7 @@ module Netzke
         :name              => 'fields',
         :class_name => "FieldsConfigurator",
         :active            => true,
-        :widget            => self,
+        :owner             => self,
         :persistent_config => true
       }
 
@@ -93,137 +103,30 @@ module Netzke
     end
 
     def actions
-      {
+      actions = {
         :apply => {:text => 'Apply'}
       }
+      
+      if Netzke::Base.config[:with_icons]
+        icons_uri = Netzke::Base.config[:icons_uri]
+        actions.deep_merge!(
+          :apply => {:icon => icons_uri + "tick.png"}
+        )
+      end
+      
+      actions
     end
     
-    def columns
-      @columns ||= get_columns.deep_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!(:model => data_class.name) if data_class
-      res.merge!(:pri => data_class.primary_key) if data_class
-      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, :editor => {:xtype => :combobox, :options => Netzke::Ext::FORM_FIELD_XTYPES}},
-        {:name => :value, :type => :string},
-        {:name => :field_label, :type => :string},
-        {:name => :input_type, :type => :string, :hidden => true}
-      ]
-    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__title",               :type => :string},
+        {:name => "ext_config__header",              :type => :boolean, :default => true},
+        # {:name => "ext_config__bbar",              :type => :json}
       ]
       
       res
     end
  
-    # Normalized columns
-    def normalized_columns
-      @normalized_columns ||= normalize_columns(columns)
-    end
-    
- 
-    def get_columns
-      if persistent_config_enabled?
-        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 '#{global_id}'"
-      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