netzke-basepack 0.5.8 → 0.5.9

data/lib/app/models/netzke_model_attr_list.rb

@@ -0,0 +1,21 @@
+# Holds attribute lists for application models.
+# Is used to configure attributes in the layer between a model and its representation in the Netzke application, thus providing default attributes
+# for grids and panels.
+class NetzkeModelAttrList < NetzkeFieldList
+  
+  # Updates attributes for all lists owned by owner_id and below the current authority level
+  def self.update_fields(owner_id, attrs_hash)
+    super
+    
+    NetzkeFieldList.find_all_lists_under_current_authority(owner_id).each do |list|
+      list.update_attrs(attrs_hash)
+    end
+  end
+  
+  def self.add_attrs(attrs)
+    NetzkeFieldList.find_all_lists_under_current_authority(owner_id).each do |list|
+      attrs.each{ |attr_hash| list.append_attr(attr_hash) }
+    end
+  end
+  
+end

data/lib/app/models/netzke_persistent_array_auto_model.rb

@@ -0,0 +1,58 @@
+require 'acts_as_list'
+class NetzkePersistentArrayAutoModel < ActiveRecord::Base
+  set_table_name "netzke_temp_table"
+  connection.create_table(table_name){} if !connection.table_exists?(table_name)  
+
+  acts_as_list
+  default_scope :order => "position"
+
+  cattr_accessor :config
+  
+  def self.all_columns
+    self.all.map{ |c| c.attributes.reject{ |k,v| k == 'id' || k == 'position' } }
+  end
+  
+  # Configuration
+  def self.configure(config)
+    self.config = config
+    if NetzkePreference.first(:conditions => {:name => "netzke_persistent_array_refresh_token"}).try(:value) != refresh_token || !connection.table_exists?(table_name)
+      rebuild_table#(:columns => config[:columns], :initial_data => config[:initial_data])
+    end
+    NetzkePreference.find_or_create_by_name("netzke_persistent_array_refresh_token").update_attribute(:value, refresh_token)
+  end
+  
+  def self.rebuild_table#(config)
+    connection.drop_table(table_name) if connection.table_exists?(table_name)
+    # create the table with the fields
+    self.connection.create_table(table_name) do |t|
+      config[:columns].each do |c|
+        c = c.dup # to make next line shorter
+        t.column c.delete(:name), c.delete(:type), c
+      end
+    end
+
+    self.reset_column_information
+
+    # self.create config[:initial_data]
+    self.replace_data(config[:initial_data])
+  end
+  
+  def self.replace_data(data)
+    # only select those attributes that were provided to us as columns. The rest is ignored.
+    column_names = config[:columns].map{ |c| c[:name] }
+    clean_data = data.collect{ |c| c.reject{ |k,v| !column_names.include?(k.to_s) } } 
+    
+    self.delete_all
+    self.create(clean_data)
+  end
+  
+  private
+  
+    def self.refresh_token
+      @@refresh_token ||= begin
+        session = Netzke::Base.session
+        config[:owner] + (session[:masq_user] || session[:masq_role] || session[:masq_world] || session[:netzke_user_id]).to_s
+      end
+    end
+  
+end

data/lib/netzke-basepack.rb

@@ -4,6 +4,7 @@ require 'netzke-core'
 
 # ExtJS-related constants
 require 'netzke/ext'
+require 'netzke/active_record'
 
 # Make widget classes auto-loadable with help of ActiveSupport
 path = File.dirname(__FILE__)
@@ -25,5 +26,19 @@ end
 Netzke::Base.config[:javascripts] << "#{File.dirname(__FILE__)}/../javascripts/basepack.js"
 Netzke::Base.config[:stylesheets] << "#{File.dirname(__FILE__)}/../stylesheets/basepack.css"
 
-# FIXME: doesn't belong here
-Netzke::Base.config[:stylesheets] << Netzke::Base.config[:ext_location] + "/examples/ux/fileuploadfield/css/fileuploadfield.css" if Netzke::Base.config[:ext_location]
+
+# FIXME: The following stylesheet inclusion doesn't *really* belong here, being widget-specific, 
+# but I don't see any other solution for now. The problem is that these stylesheets come straight from
+# Ext JS, having *relative* URLs to the images, which doesn't allow us to include them all together as those stylesheets 
+# from Netzke.
+
+# Used by FormPanel (file upload field)
+Netzke::Base.config[:external_css] << "/extjs/examples/ux/fileuploadfield/css/fileuploadfield"
+
+# Used by GridPanel
+Netzke::Base.config[:external_css] << "/extjs/examples/ux/gridfilters/css/RangeMenu"
+Netzke::Base.config[:external_css] << "/extjs/examples/ux/gridfilters/css/GridFilters"
+
+if Netzke::Base.config[:with_icons].nil? && defined?(RAILS_ROOT)
+  Netzke::Base.config[:with_icons] = File.exists?("#{RAILS_ROOT}/public#{Netzke::Base.config[:icons_uri]}")
+end

data/lib/netzke/active_record.rb

@@ -0,0 +1,10 @@
+module Netzke::ActiveRecord
+  
+  # Extend ActiveRecord
+  ActiveRecord::Base.class_eval do
+    include AssociationAttributes
+    include Attributes
+    include ComboboxOptions
+  end
+  
+end

data/lib/netzke/active_record/association_attributes.rb

@@ -0,0 +1,102 @@
+require "active_record"
+
+module Netzke::ActiveRecord
+  # Provides extensions to all ActiveRecord-based classes
+  module AssociationAttributes
+    module ClassMethods
+    end
+
+    module InstanceMethods
+      # Allow nested association access (assocs separated by "." or "__"), e.g.: proxy_service.asset__gui_folder__name
+      # Example:
+      # 
+      #   Book.first.genre__name = 'Fantasy'
+      # 
+      # is the same as:
+      # 
+      #   Book.first.genre = Genre.find_by_name('Fantasy')
+      #
+      # The result - easier forms and grids that handle nested models: simply specify column/field name as "genre__name".
+      def method_missing_with_basepack(method, *args, &block)
+        # if refering to a column, just pass it to the original method_missing
+        return method_missing_without_basepack(method, *args, &block) if self.class.column_names.include?(method.to_s)
+    
+        split = method.to_s.split(/\.|__/)
+        if split.size > 1
+          if split.last =~ /=$/ 
+            if split.size == 2
+              # search for association and assign it to self
+              assoc = self.class.reflect_on_association(split.first.to_sym)
+              assoc_method = split.last.chop
+              if assoc
+                begin
+                  assoc_instance = assoc.klass.send("find_by_#{assoc_method}", *args)
+                rescue NoMethodError
+                  assoc_instance = nil
+                  logger.debug "!!! no find_by_#{assoc_method} method for class #{assoc.klass.name}\n"
+                end
+                if (assoc_instance)
+                  self.send("#{split.first}=", assoc_instance)
+                else
+                  logger.debug "!!! Couldn't find association #{split.first} by #{assoc_method} '#{args.first}'"
+                end
+              else
+                method_missing_without_basepack(method, *args, &block)
+              end
+            else
+              method_missing_without_basepack(method, *args, &block)
+            end
+          else
+            res = self
+            split.each do |m|
+              if res.respond_to?(m)
+                res = res.send(m) unless res.nil?
+              else
+                res.nil? ? nil : method_missing_without_basepack(method, *args, &block)
+              end
+            end
+            res
+          end
+        else
+          method_missing_without_basepack(method, *args, &block)
+        end
+      end
+    
+      # Make respond_to? return true for association assignment method, like "genre__name="
+      def respond_to_with_basepack?(method, include_private = false)
+        split = method.to_s.split(/__/)
+        if split.size > 1
+          if split.last =~ /=$/ 
+            if split.size == 2
+              # search for association and assign it to self
+              assoc = self.class.reflect_on_association(split.first.to_sym)
+              assoc_method = split.last.chop
+              if assoc
+                assoc.klass.respond_to?("find_by_#{assoc_method}")
+              else
+                respond_to_without_basepack?(method, include_private)
+              end
+            else
+              respond_to_without_basepack?(method, include_private)
+            end
+          else
+            # self.respond_to?(split.first) ? self.send(split.first).respond_to?(split[1..-1].join("__")) : false
+            respond_to_without_basepack?(method, include_private)
+          end
+        else
+          respond_to_without_basepack?(method, include_private)
+        end
+      end
+    end
+
+    def self.included(receiver)
+      receiver.extend ClassMethods
+      
+      receiver.send :include, InstanceMethods
+      receiver.alias_method_chain :method_missing, :basepack
+      receiver.alias_method_chain :respond_to?, :basepack
+    end
+    
+  end
+end
+

data/lib/netzke/active_record/attributes.rb

@@ -0,0 +1,100 @@
+module Netzke::ActiveRecord::Attributes
+  module ClassMethods
+    
+    # Define or configure an attribute.
+    # Example:
+    #   netzke_attribute :recent, :type => :boolean, :read_only => true
+    def netzke_attribute(name, options = {})
+      name = name.to_s
+      options[:attr_type] = options.delete(:type) || :string
+      declared_attrs = read_inheritable_attribute(:netzke_declared_attributes) || []
+      # if the attr was declared already, simply merge it with the new options
+      existing = declared_attrs.detect{ |va| va[:name] == name }
+      if existing
+        existing.merge!(options)
+      else
+        declared_attrs << {:name => name}.merge(options)
+      end
+      write_inheritable_attribute(:netzke_declared_attributes, declared_attrs)
+    end
+    
+    # Exclude attributes from being picked up by grids and forms.
+    # Accepts an array of attribute names (as symbols).
+    # Example:
+    #   netzke_expose_attributes :created_at, :updated_at, :crypted_password
+    def netzke_exclude_attributes(*args)
+      write_inheritable_attribute(:netzke_excluded_attributes, args.map(&:to_s))
+    end
+    
+    # Explicitly expose attributes that should be picked up by grids and forms.
+    # Accepts an array of attribute names (as symbols).
+    # Takes precedence over <tt>netzke_exclude_attributes</tt>.
+    # Example:
+    #   netzke_expose_attributes :name, :role__name
+    def netzke_expose_attributes(*args)
+      write_inheritable_attribute(:netzke_exposed_attributes, args.map(&:to_s))
+    end
+    
+    # Returns the attributes that will be picked up by grids and forms.
+    def netzke_attributes
+      exposed = read_inheritable_attribute(:netzke_exposed_attributes)
+      exposed ? netzke_attrs_in_forced_order(exposed) : netzke_attrs_in_natural_order
+    end
+    
+    private
+      def netzke_declared_attributes
+        read_inheritable_attribute(:netzke_declared_attributes) || []
+      end
+    
+      def netzke_excluded_attributes
+        read_inheritable_attribute(:netzke_excluded_attributes) || []
+      end
+
+      def netzke_attrs_in_forced_order(attrs)
+        attrs.collect do |attr_name|
+          declared = netzke_declared_attributes.detect { |va| va[:name] == attr_name } || {}
+          in_columns_hash = columns_hash[attr_name] && {:name => attr_name, :attr_type => columns_hash[attr_name].type, :default_value => columns_hash[attr_name].default} || {} # {:virtual => true} # if nothing found in columns, mark it as "virtual" or not?
+          if in_columns_hash.empty?
+            # If not among the model columns, it's either virtual, or an association
+            merged = association_attr?(attr_name) ? {:name => attr_name} : declared.merge(:virtual => true)
+          else
+            # .. otherwise merge with what's declared
+            merged = in_columns_hash.merge(declared)
+          end
+          
+          # We didn't find it among declared, nor among the model columns, nor does it seem association attribute
+          merged[:name].nil? && raise(ArgumentError, "Unknown attribute '#{attr_name}' for model #{self.name}", caller)
+          
+          merged
+        end
+      end
+      
+      def netzke_attrs_in_natural_order
+        (
+          declared_attrs = netzke_declared_attributes
+          column_names.map do |name|
+            c = {:name => name, :attr_type => columns_hash[name].type}
+            # auto set up the default value from the column settings
+            c.merge!(:default_value => columns_hash[name].default) if columns_hash[name].default
+            
+            # if there's a declared attr with the same name, simply merge it with what's taken from the model's columns
+            if declared = declared_attrs.detect{ |va| va[:name] == name }
+              c.merge!(declared)
+              declared_attrs.delete(declared)
+            end
+            c
+          end +
+          declared_attrs
+        ).reject { |attr| netzke_excluded_attributes.include?(attr[:name]) }
+      end
+      
+      def association_attr?(attr_name)
+        !!attr_name.index("__") # probably we can't do much better than this, as we don't know at this moment if the associated model has a specific attribute, and we don't really want to find it out
+      end
+      
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+  end
+end

data/lib/netzke/active_record/combobox_options.rb

@@ -0,0 +1,43 @@
+module Netzke::ActiveRecord::ComboboxOptions
+  module ClassMethods
+    # TODO: rename to netzke_options_for (to avoid polluting the namespace)
+    def options_for(column, query = "")
+      # First, check if we have options for this class and column defined in persistent storage
+      # NetzkePreference.widget_name = self.name
+      # options = NetzkePreference[:combobox_options] || {}
+      # if options[column]
+      #   options[column].select{ |o| o.index(/^#{query}/) }
+      if respond_to?("#{column}_combobox_options")
+        # AR model provides the choices itself
+        send("#{column}_combobox_options", query)
+      else
+        # Returns all unique values for a column, filtered with <tt>query</tt>
+        if (assoc_name, *assoc_method = column.split('__')).size > 1
+          # column is an association column
+          assoc_method = assoc_method.join('__') # in case we get something like country__continent__name
+          association = reflect_on_association(assoc_name.to_sym) || raise(NameError, "Association #{assoc_name} not known for class #{name}")
+          association.klass.options_for(assoc_method, query)
+        else
+          column = assoc_name
+          if self.column_names.include?(column)
+            # it's simply a column in the table
+            records = query.empty? ? find_by_sql("select distinct #{column} from #{table_name}") : find_by_sql("select distinct #{column} from #{table_name} where #{column} like '#{query}%'")
+            records.map{|r| r.send(column)}
+          else
+            # it's a "virtual" column - the least effective search
+            records = self.find(:all).map{|r| r.send(column)}.uniq
+            query.empty? ? records : records.select{|r| r.index(/^#{query}/)}
+          end
+        end
+      end
+    end
+  end
+  
+  module InstanceMethods
+  end
+  
+  def self.included(receiver)
+    receiver.extend         ClassMethods
+    receiver.send :include, InstanceMethods
+  end
+end

data/lib/netzke/active_record/data_accessor.rb

@@ -1,5 +1,3 @@
-require 'netzke/active_record/basepack'
-
 module Netzke::ActiveRecord
   # Provides extensions to those ActiveRecord-based models that provide data to the "data accessor" widgets,
   # like GridPanel, FormPanel, etc
@@ -7,22 +5,21 @@ module Netzke::ActiveRecord
     
     # Allow specify the netzke widget that requires this data. Virtual attributes may be using it to produce
     # widget-dependent result.
-    def netzke_widget=(widget)
-      @netzke_widget = widget
-    end
-    
-    def netzke_widget
-      @netzke_widget
-    end
+    # def netzke_widget=(widget)
+    #   @netzke_widget = widget
+    # end
+    # 
+    # def netzke_widget
+    #   @netzke_widget
+    # end
     
     # Transforms a record to array of values according to the passed columns.
     def to_array(columns, widget = nil)
-      self.netzke_widget = widget
+      # self.netzke_widget = widget
       res = []
       for c in columns
-        nc = c.is_a?(Symbol) ? {:name => c} : c
         begin
-          res << send(nc[:name]) unless nc[:excluded]
+          res << send(c[:name]) unless c[:included] == false
         rescue
           # So that we don't crash at a badly configured column
           res << "UNDEF"

data/lib/netzke/attributes_configurator.rb

@@ -0,0 +1,195 @@
+module Netzke
+  # == AttributesConfigurator
+  # Provides dynamic configuring of attributes for a specific model. This will be picked up by Grid/FormPanels as defaults.
+  # Configuration parameters:
+  # * <tt>:model</tt> - model to configure attributes for
+  class AttributesConfigurator < JsonArrayEditor
+    api :load_defaults
+
+    def default_columns
+      [{
+        :name => "id",
+        :attr_type => :integer
+      },{
+        :name => "included",
+        :attr_type => :boolean,
+        :default_value => true
+      },{
+        :name => "name",
+        :attr_type => :string,
+        :width => 200,
+        :editor => {
+          :xtype => :combo, 
+          :store => config[:model].constantize.netzke_attributes.map{ |attr| attr[:name] },
+          :force_selection => true
+        }
+      },{
+        :name => "label",
+        :attr_type => :string,
+        :width => 200
+      },{
+        :name => "default_value",
+        :attr_type => :string,
+        :width => 200
+      },{
+        :name => "combobox_options",
+        :attr_type => :string,
+        :width => 200,
+        :editor => :textarea
+      },{
+        :name => "read_only",
+        :attr_type => :boolean,
+        :default_value => false,
+        :header => "R/O"
+      },{
+        :name => "position",
+        :attr_type => :integer,
+        :included => false
+      },{
+        :name => "attr_type",
+        :attr_type => :string,
+        :meta => :true
+      }]
+    end
+    
+    def default_config
+      super.deep_merge({
+        :name              => 'columns',
+        :ext_config        => {
+          :header                 => false,
+          :enable_extended_search => false,
+          :enable_edit_in_form    => false,
+          :enable_pagination      => false,
+          :enable_rows_reordering => GridPanel.config[:rows_reordering_available]
+        }
+      })
+    end
+    
+    def config_tool_needed?
+      false
+    end
+    
+    def actions
+      super.merge(
+        :defaults => {:text => 'Restore defaults', :icon => Netzke::Base.config[:with_icons] && (Netzke::Base.config[:icons_uri] + "wand.png")}
+      )
+    end
+    
+    def default_bbar
+      %w{ add edit apply del - defaults }
+    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);
+            
+            // Add push menu item to column context menus
+            this.on("viewready", this.extendColumnMenu, this);
+          }
+        END_OF_JAVASCRIPT
+        
+        :extend_column_menu => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            this.getView().hmenu.add("-", {text: "Propagate", handler: this.onPushToViews, scope: this});
+          }
+        END_OF_JAVASCRIPT
+        
+        :on_push_to_views => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            var columnIndex = this.getView().hdCtxIndex,
+                dataIndex   = this.getColumnModel().getDataIndex(columnIndex);
+                
+            this.pushDefaultsForAttr({name: dataIndex});
+          }
+        END_OF_JAVASCRIPT
+        
+        :on_defaults => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            Ext.Msg.confirm('Confirm', 'Are you sure?', function(btn){
+              if (btn == 'yes') {
+                this.loadDefaults();
+              }
+            }, this);
+          }
+        END_OF_JAVASCRIPT
+      }
+    end
+    
+    api :push_defaults_for_attr
+    def push_defaults_for_attr(params)
+      NetzkeFieldList.update_children_on_attr(config[:model], params[:name])
+      {:feedback => "Done."}
+    end
+    
+    def load_defaults(params)
+      data_class.replace_data(default_model_attrs)
+      on_data_changed
+      {:load_store_data => get_data}
+    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
+          NetzkeModelAttrList.update_fields(config[:model], meta_attrs_to_update)
+          # NetzkeFieldList.update_children(config[:model], meta_attrs_to_update)
+          res
+        else
+          # NetzkeModelAttrList.add_attrs(config[:model], data.reject{ |k,v| k == "id" })
+          super
+        end
+      end
+    
+      # An override
+      def store_data(data)
+        NetzkeModelAttrList.update_list_for_current_authority(config[:model], data)
+        # Let's try to do it through process_data
+        # NetzkeFieldList.write_attrs_for_model(config[:model], data)
+      end
+      
+      # An override
+      def initial_data
+        # NetzkeModelAttrList.attrs_for_model(config[:model])
+        NetzkeModelAttrList.read_list(config[:model]) || default_model_attrs
+        # NetzkeModelAttrList.read_attrs_for_model(config[:model]) || default_model_attrs
+      end
+      
+      # Default model attributes, along with their defaults meta-attributes (like :label)
+      def default_model_attrs
+        @default_model_attrs ||= begin
+          config[:model].constantize.netzke_attributes.map do |attr| 
+            attr.merge(
+              :label => attr[:label] || attr[:name].humanize,
+              :attr_type => attr[:attr_type].to_s
+            )
+          end
+        end
+      end
+  end
+end