netzke-basepack 0.5.8 → 0.5.9

data/CHANGELOG.rdoc

@@ -1,3 +1,21 @@
+= v0.6.0 - EDGE
+* !!!: after updating to this version, run script/generate netzke_basepack
+* New: tri-state checkbox introduced into the search form
+* Impr: better defaults for the search form
+* Impr: GridPanel now displays the total amount of records
+* Fix: GridPanel's "local filters" are back (they were out since the release of Ext 3.0)
+* Impr: obey "preloaded" option for tabs better: really add the widgets into their respective tabs from the start
+* Fix: datetime filters now also are take into account when searching in GridPanel is performed
+* Fix: FieldsConfigurator should now work on Heroku
+* Fix: GridPanel date filter now should work
+* New: GridPanel now has a method on_data_changed that can be overridden by children to detect actions that modify data
+* New: New way of Netzke virtual attributes in AR models.
+* New: Grid/FormPanel refactoring.
+* Impr: Multi-level column/fields configuration reworked and made more consistent.
+* New: New configuration layer introduced between the AR models and the rest of Netzke widgets. Use AttributesConfigurator to access it.
+* New: FamFamFam Silk icons support.
+* Impr: Reworked Netzke (virtual) attributes for Grid/FormPanel
+
 = v0.5.8 - 2010-03-12
 * Fix: GertThiel's method_missing-related fix enabling better compatibility with other Ruby libs
 * Fix: acts_as_list runtime dependency

data/README.rdoc

@@ -1,7 +1,7 @@
 = netzke-basepack
 A pack of basic Rails/ExtJS widgets as a part of the Netzke framework. Live demo/tutorials on http://blog.writelesscode.com. Introduction to the Netzke framework and the Wiki: http://github.com/skozlov/netzke
 
-= Prerequisites
+== Prerequisites
 1. Rails >= 2.2
 2. Netzke assumes that your ExtJS library is in public/extjs, which may be a symbolic link, e.g:
 
@@ -28,7 +28,7 @@ Or install as gem:
 
     gem install netzke-basepack
 
-= Usage
+== Usage
 If using as gem, include it into environment.rb:
 
     config.gem "netzke-basepack"
@@ -37,10 +37,14 @@ Include mapping for Netzke controller providing Netzke javascripts and styles (i
 
     map.netzke
 
-To be able to use persistent on-the-fly configuration of widgets, run netzke-core generators to have the necessary migrations:
+Run the generators (some assets and a migration for dynamically configured columns/fields):
+    
+    ./script/generate netzke_basepack
 
-    ./script/generate netzke_core
+To be able to use persistent on-the-fly configuration of widgets, run netzke-core generators:
 
+    ./script/generate netzke_core
+    
 ... then run the migrations:
 
     rake db:migrate
@@ -64,6 +68,9 @@ Now embed a widget into a view like this:
 
 For more examples, see http://netzke-demo.writelesscode.com
 
+== Icons support
+Netzke-basepack supports FamFamFam Silk icon set (http://www.famfamfam.com/archive/silk-icons-thats-your-lot/). To enable it, download it and put the "icons" folder into your app's public/images folder. Then restart your application.
+
 == More info
 Introduction to Netzke framework and wiki: http://github.com/skozlov/netzke
 

data/Rakefile

@@ -1,7 +1,7 @@
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gemspec|
-    gemspec.version = "0.5.8"
+    gemspec.version = "0.5.9"
     gemspec.name = "netzke-basepack"
     gemspec.summary = "Pre-built Rails + ExtJS widgets for your RIA"
     gemspec.description = "A set of full-featured extendible Netzke widgets (such as FormPanel, GridPanel, Window, BorderLayoutPanel, etc) which can be used as building block for your RIA"
@@ -9,14 +9,30 @@ begin
     gemspec.homepage = "http://github.com/skozlov/netzke-basepack"
     gemspec.rubyforge_project = "netzke-basepack"
     gemspec.authors = ["Sergei Kozlov"]
-    gemspec.add_dependency("netzke-core", ">=0.5.1")
+    gemspec.add_dependency("netzke-core", ">=0.5.2")
     gemspec.add_dependency("searchlogic", ">=2.0.0")
     gemspec.add_dependency("will_paginate", ">=2.0.0")
     gemspec.add_dependency("acts_as_list", ">=0.1.2")
+    gemspec.post_install_message = <<-MESSAGE
+
+    ========================================================================
+
+               Thanks for installing Netzke Basepack!
+               
+      Run "./script/generate netzke_basepack" to finish the installation.
+
+      Netzke home page:     http://netzke.org
+      Netzke Google Groups: http://groups.google.com/group/netzke
+      Netzke tutorials:     http://blog.writelesscode.com
+
+    ========================================================================
+
+    MESSAGE
+    
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
 require 'rake/rdoctask'

data/TODO.rdoc

@@ -1,10 +1,10 @@
 == Priority
-* Introduce three-state checkbox for SearchPanel
 * Add icons to buttons to actions (toolbars/menus)
 * On grid refresh, reset the dirty fields, so that the "Apply" button doesn't do anything
 
 == Foolproof
 * Should not be possible delete the "ID" field from grids/forms
+* Should not be possible to put the "ID" field on any place but first for grids (otherwise record ID is not correct)
 
 == Optimizations
 * Check persistent_config-related queries (aren't they too many?)

data/generators/netzke_basepack/netzke_basepack_generator.rb

@@ -0,0 +1,13 @@
+# class NetzkeCoreGenerator < Rails::Generator::NamedBase
+class NetzkeBasepackGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.directory 'public/netzke/basepack'
+      m.file 'public_assets/ts-checkbox.gif', "public/netzke/basepack/ts-checkbox.gif"
+
+      m.migration_template 'create_netzke_field_lists.rb', 'db/migrate', :assigns => {
+        :migration_name => "CreateNetzkeFieldLists"
+      }, :migration_file_name => "create_netzke_field_lists"
+    end
+  end
+end

data/generators/netzke_basepack/templates/create_netzke_field_lists.rb

@@ -0,0 +1,18 @@
+class CreateNetzkeFieldLists < ActiveRecord::Migration
+  def self.up
+    create_table :netzke_field_lists do |t|
+      t.string  :name
+      t.text    :value
+      t.string  :model_name
+      t.integer :user_id
+      t.integer :role_id
+      t.string  :type
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :netzke_field_lists
+  end
+end

data/install.rb

@@ -1 +1 @@
-# Install hook code here
+# Install hook code here

data/javascripts/basepack.js

@@ -6,7 +6,7 @@ Ext.netzke.PassField = Ext.extend(Ext.form.TextField, {
 });
 Ext.reg('passfield', Ext.netzke.PassField);
 
-// Combobox that knows to talk to the server side (used in both grids and panels)
+// ComboBox that gets options from the server (used in both grids and panels)
 Ext.netzke.ComboBox = Ext.extend(Ext.form.ComboBox, {
   displayField  : 'id',
   valueField    : 'id',
@@ -14,29 +14,22 @@ Ext.netzke.ComboBox = Ext.extend(Ext.form.ComboBox, {
   typeAhead     : true,
   
   initComponent : function(){
-    if (this.options) {
-      Ext.apply(this, {
-        store : this.options,
-        mode : "local"
-      });
-    } else {
-      var row = Ext.data.Record.create([{name:'id'}]);
-      var store = new Ext.data.Store({
-        proxy         : new Ext.data.HttpProxy({url: Ext.getCmp(this.parentId).buildApiUrl("get_combobox_options"), jsonData:{column:this.name}}),
-        reader        : new Ext.data.ArrayReader({root:'data', id:0}, row)
-      });
-    
-      Ext.apply(this, {
-        store : store
-      });
-    }
+    var row = Ext.data.Record.create([{name:'id'}]);
+    var store = new Ext.data.Store({
+      proxy         : new Ext.data.HttpProxy({url: Ext.getCmp(this.parentId).buildApiUrl("get_combobox_options"), jsonData:{column:this.name}}),
+      reader        : new Ext.data.ArrayReader({root:'data', id:0}, row)
+    });
+  
+    Ext.apply(this, {
+      store : store
+    });
     
     Ext.netzke.ComboBox.superclass.initComponent.apply(this, arguments);
     
     this.on('blur', function(cb){
       cb.setValue(cb.getRawValue());
     });
-
+  
     this.on('specialkey', function(cb, event){
       if (event.getKey() == 9 || event.getKey() == 13) {cb.setValue(cb.getRawValue());}
     });
@@ -85,17 +78,6 @@ Ext.util.Format.mask = function(v){
   return "********";
 };
 
-// Mapping of editor field to grid filters
-Ext.netzke.filterMap = {
-  numberfield:'Numeric',
-  textfield:'String',
-  textarea:'String',
-  xdatetime:'String',
-  checkbox:'Boolean',
-  combobox:'String',
-  datefield:'Date'
-};
-
 Ext.data.RecordArrayReader = Ext.extend(Ext.data.JsonReader, {
   /**
    * Create a data block containing Ext.data.Records from an Array.
@@ -865,4 +847,116 @@ Ext.override(Ext.Panel, {
         this.syncShadow();
         Ext.Panel.superclass.onResize.call(this, w, h, rw, rh);
     }
-});
+});
+
+Ext.ns('Ext.ux.form');
+Ext.ux.form.TriCheckbox = Ext.extend(Ext.form.Checkbox, {
+	checked: null,
+	valueList: [null, false, true],	
+	stateClassList: ['x-checkbox-undef', null, 'x-checkbox-checked'],
+	overClass: 'x-form-check-over',
+	clickClass: 'x-form-check-down',
+	triState: true,
+	defaultAutoCreate: {tag: 'input', type: 'hidden', autocomplete: 'off'},
+	initComponent: function() {
+		this.value = this.checked;
+		Ext.ux.form.TriCheckbox.superclass.initComponent.apply(this, arguments);
+		// make a copy before modifying valueList and stateClassList arrays
+		this.vList = this.valueList.slice(0);
+		this.cList = this.stateClassList.slice(0);
+		if(this.triState !== true) {
+			// consider 'undefined' value and its class go first in arrays
+			this.vList.shift();
+			this.cList.shift();
+		}
+		if(this.overCls !== undefined) {
+			this.overClass = this.overCls;
+			delete this.overCls;
+		}
+		this.value = this.normalizeValue(this.value);
+	},
+	onRender : function(ct, position){
+		Ext.form.Checkbox.superclass.onRender.call(this, ct, position);
+		
+		this.innerWrap = this.el.wrap({tag: 'span', cls: 'x-form-check-innerwrap'});
+		this.wrap = this.innerWrap.wrap({cls: 'x-form-check-wrap'});
+		
+		this.currCls = this.getCls(this.value);
+		this.wrap.addClass(this.currCls);
+		if(this.clickClass && !this.disabled && !this.readOnly)
+			this.innerWrap.addClassOnClick(this.clickClass);
+		if(this.overClass && !this.disabled && !this.readOnly)
+			this.innerWrap.addClassOnOver(this.overClass);
+		
+		this.imageEl = this.innerWrap.createChild({
+			tag: 'img',
+			src: Ext.BLANK_IMAGE_URL,
+			cls: 'x-form-tscheckbox'
+		}, this.el);
+		if(this.fieldClass) this.imageEl.addClass(this.fieldClass);
+		
+		if(this.boxLabel){
+			this.innerWrap.createChild({
+				tag: 'label', 
+				htmlFor: this.el.id, 
+				cls: 'x-form-cb-label', 
+				html: this.boxLabel
+			});
+		}
+		
+		// Need to repaint for IE, otherwise positioning is broken
+		if(Ext.isIE){
+			this.wrap.repaint();
+		}
+		this.resizeEl = this.positionEl = this.wrap;
+	},
+	onResize : function(){
+		Ext.form.Checkbox.superclass.onResize.apply(this, arguments);
+		if(!this.boxLabel && !this.fieldLabel && this.imageEl){
+			this.imageEl.alignTo(this.wrap, 'c-c');
+		}
+	},
+	initEvents : function(){
+		Ext.form.Checkbox.superclass.initEvents.call(this);
+		this.mon(this.innerWrap, {
+			scope: this,
+			click: this.onClick
+		});
+	},
+	onClick : function(){
+		if (!this.disabled && !this.readOnly) {
+			this.setValue(this.vList[(this.vList.indexOf(this.value) + 1) % this.vList.length]);
+		}
+	},
+	getValue : function(){
+		return this.value;
+	},
+	setValue : function(v){
+		var value = this.value;
+		this.value = this.normalizeValue(v);
+		if(this.rendered) this.el.dom.value = this.value;
+
+		if(value !== this.value){
+			this.updateView();
+			this.fireEvent('check', this, this.value);
+			if(this.handler) this.handler.call(this.scope || this, this, this.value);
+		}
+		return this;
+	},
+	normalizeValue: function(v) {
+		return (v === null || v === undefined) && this.triState ? null : 
+			(v === true || (['true', 'yes', 'on', '1']).indexOf(String(v).toLowerCase()) != -1);
+	},
+	getCls: function(v) {
+		var idx = this.vList.indexOf(this.value);
+		return idx > -1 ? this.cList[idx] : undefined;
+	},
+	updateView: function() {
+		var cls = this.getCls(this.value);
+		if (!this.wrap || cls === undefined) return;
+		
+		this.wrap.replaceClass(this.currCls, cls);
+		this.currCls = cls;
+	}
+});
+Ext.reg('tricheckbox', Ext.ux.form.TriCheckbox);  

data/lib/app/models/netzke_field_list.rb

@@ -0,0 +1,261 @@
+# TODO: clean up, document and test
+class NetzkeFieldList < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :role
+  belongs_to :parent, :class_name => "NetzkeFieldList"
+  has_many :children, :class_name => "NetzkeFieldList", :foreign_key => "parent_id"
+
+
+  def self.update_fields(owner_id, attrs_hash)
+    self.find_all_below_current_authority_level(owner_id).each do |list|
+      list.update_attrs(attrs_hash)
+    end
+  end
+
+  # Updates attributes in the list
+  def update_attrs(attrs_hash)
+    list = ActiveSupport::JSON.decode(self.value)
+    list.each do |field|
+      field.merge!(attrs_hash[field["name"]]) if attrs_hash[field["name"]]
+    end
+    update_attribute(:value, list.to_json)
+  end
+  
+  def append_attr(attr_hash)
+    list = ActiveSupport::JSON.decode(self.value)
+    list << attr_hash
+    update_attribute(:value, list.to_json)
+  end
+
+  def self.find_all_below_current_authority_level(pref_name)
+    authority_level, authority_id = Netzke::Base.authority_level
+    case authority_level
+    when :world
+      self.all(:conditions => {:name => pref_name})
+    when :role
+      role = Role.find(authority_id)
+      role.users.inject([]) do |r, user|
+        r += self.all(:conditions => {:user_id => user.id, :name => pref_name})
+      end
+    else
+      []
+    end
+  end
+  
+  def self.find_all_lists_under_current_authority(model_name)
+    authority_level, authority_id = Netzke::Base.authority_level
+    case authority_level
+    when :world
+      self.all(:conditions => {:model_name => model_name})
+    when :role
+      role = Role.find(authority_id)
+      role.users.inject([]) do |r, user|
+        r += self.all(:conditions => {:user_id => user.id, :model_name => model_name})
+      end
+    when :user
+      self.all(:conditions => {:user_id => authority_id, :model_name => model_name})
+    when :self
+      self.all(:conditions => {:user_id => authority_id, :model_name => model_name})
+    else
+      []
+    end
+    
+  end
+  
+  
+  # Replaces the list with the data - only for the list found for the current authority. 
+  # If the list is not found, it's created.
+  def self.update_list_for_current_authority(pref_name, data, model_name = nil)
+    pref = find_or_create_pref_to_read(pref_name)
+    pref.value = data.to_json
+    pref.model_name = model_name
+    pref.save!
+  end
+  
+
+  # If the <tt>model</tt> param is provided, then this preference will be assigned a parent preference
+  # that configures the attributes for that model. This way we can track all preferences related to a model.
+  def self.write_list(name, list, model = nil)
+    pref_to_store_the_list = self.pref_to_write(name)
+    pref_to_store_the_list.try(:update_attribute, :value, list.to_json)
+    
+    # link this preference to the parent that contains default attributes for the same model
+    if model
+      model_level_attrs_pref = self.pref_to_read("#{model.tableize}_model_attrs")
+      model_level_attrs_pref.children << pref_to_store_the_list if model_level_attrs_pref && pref_to_store_the_list
+    end
+  end
+  
+  def self.read_list(name)
+    json_encoded_value = self.pref_to_read(name).try(:value)
+    ActiveSupport::JSON.decode(json_encoded_value).map(&:symbolize_keys) if json_encoded_value
+  end
+
+  # Read model-level attrs
+  # def self.read_attrs_for_model(model_name)
+  #   read_list(model_name)
+  #   # read_list("#{model.tableize}_model_attrs")
+  # end
+  
+  # Write model-level attrs
+  # def self.write_attrs_for_model(model_name, data)
+  #   # write_list("#{model_name.tableize}_model_attrs", data)
+  #   write_list(model_name, data)
+  # end
+  
+  # Options:
+  # :attr - attribute to propagate. If not specified, all attrs found in configuration for the model
+  # will be propagated.
+  def self.update_children_on_attr(model, options = {})
+    attr_name = options[:attr].try(:to_s)
+    
+    parent_pref = pref_to_read("#{model.tableize}_model_attrs")
+    
+    if parent_pref
+      parent_list = ActiveSupport::JSON.decode(parent_pref.value)
+      parent_pref.children.each do |ch|
+        child_list = ActiveSupport::JSON.decode(ch.value)
+        
+        if attr_name
+          # propagate a certain attribute
+          propagate_attr(attr_name, parent_list, child_list)
+        else
+          # propagate all attributes found in parent
+          all_attrs = parent_list.first.try(:keys)
+          all_attrs && all_attrs.each{ |attr_name| propagate_attr(attr_name, parent_list, child_list) }
+        end
+        
+        ch.update_attribute(:value, child_list.to_json)
+      end
+    end
+  end
+  
+  # meta_attrs:
+  #   {"city"=>{"included"=>true}, "building_number"=>{"default_value"=>100}}
+  def self.update_children(model, meta_attrs)
+    parent_pref = pref_to_read("#{model.tableize}_model_attrs")
+
+
+    if parent_pref
+      parent_pref.children.each do |ch|
+        child_list = ActiveSupport::JSON.decode(ch.value)
+        
+        meta_attrs.each_pair do |k,v|
+          child_list.detect{ |child_attr| child_attr["name"] == k }.try(:merge!, v)
+        end
+        
+        ch.update_attribute(:value, child_list.to_json)
+      end
+    end
+  end
+
+  private
+  
+    def self.propagate_attr(attr_name, src_list, dest_list)
+      for src_field in src_list
+        dest_field = dest_list.detect{ |df| df["name"] == src_field["name"] }
+        dest_field[attr_name] = src_field[attr_name] if dest_field && src_field[attr_name]
+      end
+    end
+  
+    # Overwrite pref_to_read, pref_to_write methods, and find_all_for_widget if you want a different way of 
+    # identifying the proper preference based on your own authorization strategy.
+    #
+    # The default strategy is:
+    #   1) if no masq_user or masq_role defined
+    #     pref_to_read will search for the preference for user first, then for user's role
+    #     pref_to_write will always find or create a preference for the current user (never for its role)
+    #   2) if masq_user or masq_role is defined
+    #     pref_to_read and pref_to_write will always take the masquerade into account, e.g. reads/writes will go to
+    #     the user/role specified
+    #   
+    def self.pref_to_read(name)
+      name = name.to_s
+      session = Netzke::Base.session
+      cond = {:name => name}
+    
+      if session[:masq_user]
+        # first, get the prefs for this user it they exist
+        res = self.find(:first, :conditions => cond.merge({:user_id => session[:masq_user]}))
+        # if it doesn't exist, get them for the user's role
+        user = User.find(session[:masq_user])
+        res ||= self.find(:first, :conditions => cond.merge({:role_id => user.role.id}))
+        # if it doesn't exist either, get them for the World (role_id = 0)
+        res ||= self.find(:first, :conditions => cond.merge({:role_id => 0}))
+      elsif session[:masq_role]
+        # first, get the prefs for this role
+        res = self.find(:first, :conditions => cond.merge({:role_id => session[:masq_role]}))
+        # if it doesn't exist, get them for the World (role_id = 0)
+        res ||= self.find(:first, :conditions => cond.merge({:role_id => 0}))
+      elsif session[:masq_world]
+        res = self.find(:first, :conditions => cond.merge({:role_id => 0}))
+      elsif session[:netzke_user_id]
+        user = User.find(session[:netzke_user_id])
+        # first, get the prefs for this user
+        res = self.find(:first, :conditions => cond.merge({:user_id => user.id}))
+        # if it doesn't exist, get them for the user's role
+        res ||= self.find(:first, :conditions => cond.merge({:role_id => user.role.id}))
+        # if it doesn't exist either, get them for the World (role_id = 0)
+        res ||= self.find(:first, :conditions => cond.merge({:role_id => 0}))
+      else
+        res = self.find(:first, :conditions => cond)
+      end
+    
+      res      
+    end
+    
+    def self.find_or_create_pref_to_read(name)
+      name = name.to_s
+      attrs = {:name => name}
+      extend_attrs_for_current_authority(attrs)
+      self.first(:conditions => attrs) || self.new(attrs)
+    end
+    
+    def self.extend_attrs_for_current_authority(hsh)
+      authority_level, authority_id = Netzke::Base.authority_level
+      case authority_level
+      when :world
+        hsh.merge!(:role_id => 0)
+      when :role
+        hsh.merge!(:role_id => authority_id)
+      when :user
+        hsh.merge!(:user_id => authority_id)
+      when :self
+        hsh.merge!(:user_id => authority_id)
+      end
+    end
+  
+    def self.pref_to_write(name)
+      name = name.to_s
+      session = Netzke::Base.session
+      cond = {:name => name}
+    
+      if session[:masq_user]
+        cond.merge!({:user_id => session[:masq_user]})
+        # first, try to find the preference for masq_user
+        res = self.find(:first, :conditions => cond)
+        # if it doesn't exist, create it
+        res ||= self.new(cond)
+      elsif session[:masq_role]
+        # first, delete all the corresponding preferences for the users that have this role
+        Role.find(session[:masq_role]).users.each do |u|
+          self.delete_all(cond.merge({:user_id => u.id}))
+        end
+        cond.merge!({:role_id => session[:masq_role]})
+        res = self.find(:first, :conditions => cond)
+        res ||= self.new(cond)
+      elsif session[:masq_world]
+        # first, delete all the corresponding preferences for all users and roles
+        self.delete_all(cond)
+        # then, create the new preference for the World (role_id = 0)
+        res = self.new(cond.merge(:role_id => 0))
+      elsif session[:netzke_user_id]
+        res = self.find(:first, :conditions => cond.merge({:user_id => session[:netzke_user_id]}))
+        res ||= self.new(cond.merge({:user_id => session[:netzke_user_id]}))
+      else
+        res = self.find(:first, :conditions => cond)
+        res ||= self.new(cond)
+      end
+      res
+    end
+end