skozlov-netzke-basepack 0.1.1.2 → 0.5.0

data/lib/app/models/netzke_auto_column.rb

@@ -0,0 +1,56 @@
+require 'acts_as_list'
+class NetzkeAutoColumn < ActiveRecord::Base
+  
+  acts_as_list
+  default_scope :order => "position"
+
+  # Returns an array of column configuration hashes (without the "id" attribute)
+  def self.all_columns
+    self.all.map do |c|
+      column_hash = c.attributes.reject{ |k,v| k == 'id' }
+      column_hash.each_pair do |k,v|
+        # try to detect JSON format
+        begin
+          normalized_value = v.is_a?(String) ? ActiveSupport::JSON.decode(v) : v
+        rescue ActiveSupport::JSON::ParseError
+          normalized_value = v
+        end
+        column_hash[k] = normalized_value
+      end
+      column_hash
+    end
+  end
+
+  # Build the table with columns for this widget
+  def self.rebuild_table
+    connection.drop_table('netzke_auto_columns') if table_exists?
+  
+    normalized_config_columns = []
+    
+    @@widget.class.config_columns.each do |mc|
+      column_hash = mc.is_a?(Symbol) ? {:name => mc} : mc
+      column_hash[:type] ||= :string
+      normalized_config_columns << column_hash
+    end
+    
+    # create the table with the fields
+    self.connection.create_table('netzke_auto_columns') do |t|
+      normalized_config_columns.each do |mc|
+        t.column mc[:name], mc[:type], :default => mc[:default]
+      end
+      t.column :position, :integer
+    end
+
+    # populate the table with data
+    NetzkeAutoColumn.create @@widget.normalized_columns.map(&:deebeefy_values)
+    
+  end
+
+  def self.widget=(widget)
+    @@widget = widget
+    if Netzke::Base.session["netzke_auto_column_last_widget"] != @@widget.id_name
+      rebuild_table
+      Netzke::Base.session["netzke_auto_column_last_widget"] = @@widget.id_name
+    end
+  end
+end

data/lib/netzke/accordion_panel.rb

@@ -0,0 +1,113 @@
+module Netzke
+  # == AccordionPanel
+  # 
+  # == Features:
+  # * Dynamically loads widgets for the panels that get expanded for the first time
+  # * Is loaded along with the active widget - saves a request to the server
+  #
+  # Future features:
+  # * Stores the last active panel in persistent_config
+  class AccordionPanel < Base
+    
+    # JavaScript part
+    def self.js_extend_properties
+      {
+        :layout => 'accordion',
+        :defaults => {:layout => 'fit'},
+        :init_component => <<-END_OF_JAVASCRIPT.l,
+          function(){
+            Ext.netzke.cache.#{short_widget_class_name}.superclass.initComponent.call(this);
+
+            // Set events
+            this.items.each(function(i){
+              // Set the expand event
+              i.on('expand', this.loadItemWidget, this);
+              
+              // If not collapsed, add the active aggregatee (item) into it
+              if (!i.collapsed) {
+                var preloadedItemConfig = this[i.widget.camelize(true) + "Config"];
+                i.add(new Ext.netzke.cache[preloadedItemConfig.widgetClassName](preloadedItemConfig));
+                i.doLayout(); // always needed after adding a component
+              }
+            }, this);
+          }
+        END_OF_JAVASCRIPT
+        
+        # Loads widget into the panel if it wasn't loaded yet
+        :load_item_widget => <<-END_OF_JAVASCRIPT.l,
+          function(panel) {
+            // if (!panel.getWidget()) panel.loadWidget(this.id + "__" + panel.widget + "__get_widget");
+            var preloadedItemConfig = this[panel.widget.camelize(true) + "Config"];
+            
+            if (preloadedItemConfig){
+              // preloaded widget only needs to be instantiated, as its class and configuration have already been loaded
+              panel.add(new Ext.netzke.cache[preloadedItemConfig.widgetClassName](preloadedItemConfig));
+              panel.doLayout(); // always needed after adding a component
+            } else {
+              // load the widget from the server
+              this.loadAggregatee({id:panel.widget, container:panel.id});
+            }
+            
+          }
+        END_OF_JAVASCRIPT
+      }
+    end
+
+    # Some normalization of config
+    def initialize(*args)
+      super
+
+      seen_active = false
+      
+      config[:items].each_with_index do |item, i|
+        # if some items are provided without names, give them generated names
+        item[:name] ||= "item#{i}"
+      
+        # remove duplucated :active configuration
+        if item[:active]
+          item[:active] = nil if seen_active
+          seen_active ||= true
+        end
+      end
+    end
+    
+    # Returns items configs
+    def items
+      @items ||= config[:items]
+    end
+
+    # Provides configs for fit panels (which will effectively be accordion panels)
+    def js_config
+      super.merge({
+        # these "items" are not related to the "items" of the config, rather these are the items required by the the accordion panel
+        :items => fit_panels
+      })
+    end
+
+    # "Fit-panels" - panels of layout 'fit' (effectively the accordion panels) that will contain the widgets ("items")
+    def fit_panels
+      res = []
+      config[:items].each_with_index do |item, i|
+        res << {
+          # :id => item[:active] && id_name + '_active', # to mark the fit-panel which will contain the active widget
+          :title => item[:title] || (item[:name] && item[:name].to_s.humanize),
+          :widget => item[:name], # to know which fit panel will load which widget
+          :collapsed => !(item[:active] || false)
+        }
+      end
+      res
+    end
+
+    # All items become *late* aggregatees, besides the ones that are marked "active"
+    def initial_aggregatees
+      res = {}
+      config[:items].each_with_index do |item, i|
+        item[:late_aggregation] = !item[:active]
+        res.merge!(item[:name].to_sym => item)
+      end
+      res
+    end
+
+    
+  end
+end

data/lib/netzke/active_record/basepack.rb

@@ -0,0 +1,104 @@
+module Netzke::ActiveRecord
+  # Provides extensions to all ActiveRecord-based classes
+  module Basepack
+    def self.included(base)
+      base.extend ClassMethods
+    end
+    
+    # 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(method, *args, &block)
+      # if refering to a column, just pass it to the original method_missing
+      return super 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
+              super
+            end
+          else
+            super
+          end
+        else
+          res = self
+          split.each do |m|
+            if res.respond_to?(m)
+              res = res.send(m) unless res.nil?
+            else
+              res.nil? ? nil : super
+            end
+          end
+          res
+        end
+      else
+        super
+      end
+    end
+
+    module ClassMethods
+
+      def options_for(column, query = nil)
+        # 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}/) }
+        elsif respond_to?("#{column}_combobox_options")
+          # AR class 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.nil? ? 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.nil? ? records : records.select{|r| r.index(/^#{query}/)}
+            end
+          end
+        end
+      end
+      
+    end
+      
+  end
+end
+
+# Extend ActiveRecord
+ActiveRecord::Base.class_eval do
+  include Netzke::ActiveRecord::Basepack
+end

data/lib/netzke/active_record/data_accessor.rb

@@ -0,0 +1,21 @@
+module Netzke::ActiveRecord
+  # Provides extensions to those ActiveRecord-based models that provide data to the "data accessor" widgets,
+  # like GridPanel, FormPanel, etc
+  module DataAccessor
+    # Transforms a record to array of values according to the passed columns.
+    def to_array(columns)
+      res = []
+      for c in columns
+        nc = c.is_a?(Symbol) ? {:name => c} : c
+        begin
+          res << send(nc[:name]) unless nc[:excluded]
+        rescue
+          # So that we don't crash at a badly configured column
+          res << "UNDEF"
+        end
+      end
+      res
+    end
+  end
+end
+

data/lib/netzke/basic_app.rb

@@ -0,0 +1,325 @@
+module Netzke
+  # == BasicApp
+  # Basis for a Ext.Viewport-based application
+  #
+  # Features:
+  # * dynamic loading of widgets
+  # * authentification support
+  # * browser history support (press the "Back"-button to go to the previously loaded widget)
+  # * FeedbackGhost-powered feedback
+  # * aggregation of widget's own menus
+  # * masquerade support
+  # * AJAX activity indicator
+  class BasicApp < Base
+    module ClassMethods
+
+      def js_base_class
+        "Ext.Viewport"
+      end
+
+      # Global BasicApp configuration
+      def config
+        set_default_config({
+          :logout_url => "/logout" # default logout url
+        })
+      end
+      
+      def js_panels
+        # In status bar we want to show what we are masquerading as
+        if session[:masq_user]
+          user = User.find(session[:masq_user])
+          masq = %Q{user "#{user.login}"}
+        elsif session[:masq_role]
+          role = Role.find(session[:masq_role])
+          masq = %Q{role "#{role.name}"}
+        end
+                
+        [{
+          :id => 'main-panel',
+          :region => 'center',
+          :layout => 'fit'
+        },{
+          :id => 'main-toolbar',
+          :xtype => 'toolbar',
+          :region => 'north',
+          :height => 25
+          # :items => ["-"]
+        },{
+          :id => 'main-statusbar',
+          :xtype => 'statusbar',
+          :region => 'south',
+          :statusAlign => 'right',
+          :busyText => 'Busy...',
+          :default_text => masq.nil? ? "Ready #{"(config mode)" if session[:config_mode]}" : "Masquerading as #{masq}",
+          :default_icon_cls => ""
+        }]
+      end
+      
+      def js_extend_properties
+        {
+          :layout => 'border',
+
+          :panels => js_panels,
+          
+          :init_component => <<-END_OF_JAVASCRIPT.l,
+            function(){
+              this.items = this.panels; // a bit weird, but working; can't assign it straight
+              
+              Ext.netzke.cache.BasicApp.superclass.initComponent.call(this);
+
+              // If we are given a token, load the corresponding widget, otherwise load the last loaded widget
+              var currentToken = Ext.History.getToken();
+              if (currentToken != "") {
+                this.processHistory(currentToken)
+              } else {
+                var lastLoaded = this.initialConfig.widgetToLoad; // passed from the server
+                if (lastLoaded) Ext.History.add(lastLoaded);
+              }
+
+              Ext.History.on('change', this.processHistory, this);
+              
+              // Hosted menus
+              this.menus = {};
+              
+              // Setting the "busy" indicator for Ajax requests
+              Ext.Ajax.on('beforerequest', function(){this.findById('main-statusbar').showBusy()}, this);
+              Ext.Ajax.on('requestcomplete', function(){this.findById('main-statusbar').hideBusy()}, this);
+              Ext.Ajax.on('requestexception', function(){this.findById('main-statusbar').hideBusy()}, this);
+            }
+          END_OF_JAVASCRIPT
+          
+          :host_menu => <<-END_OF_JAVASCRIPT.l,
+            function(menu, owner){
+              var toolbar = this.findById('main-toolbar');
+              if (!this.menus[owner.id]) this.menus[owner.id] = [];
+              Ext.each(menu, function(item) {
+                // var newMenu = new Ext.Toolbar.Button(item);
+                // var position = toolbar.items.getCount() - 2;
+                // position = position < 0 ? 0 : position;
+                // toolbar.insertButton(position, newMenu);
+
+                toolbar.add(item);
+                // this.menus[owner.id].push(newMenu); // TODO: remember the menus from this owner in some other way
+            	}, this);
+          	}
+          END_OF_JAVASCRIPT
+
+          :unhost_menu => <<-END_OF_JAVASCRIPT.l,
+            function(owner){
+              // var toolbar = this.findById('main-toolbar');
+              // if (this.menus[owner.id]) {
+              //   Ext.each(this.menus[owner.id], function(menu){
+              //     toolbar.items.remove(menu); // remove the item from the toolbar
+              //     menu.destroy(); // ... and destroy it
+              //   });
+              // }
+            }
+          END_OF_JAVASCRIPT
+
+          :logout => <<-END_OF_JAVASCRIPT.l,
+            function(){
+              window.location = "#{config[:logout_url]}"
+            }
+          END_OF_JAVASCRIPT
+
+          # Event handler for history change
+          :process_history => <<-END_OF_JAVASCRIPT.l,
+            function(token){
+              if (token){
+                this.loadAggregatee({id:token, container:'main-panel'});
+              } else {
+              }
+            }
+          END_OF_JAVASCRIPT
+          
+          :instantiate_aggregatee => <<-END_OF_JAVASCRIPT.l,
+            function(config){
+              this.findById('main-panel').instantiateChild(config);
+            }
+          END_OF_JAVASCRIPT
+          
+          # Loads widget by name
+          :app_load_widget => <<-END_OF_JAVASCRIPT.l,
+            function(name){
+              Ext.History.add(name);
+            }
+          END_OF_JAVASCRIPT
+
+          # Loads widget by action
+          :load_widget_by_action => <<-END_OF_JAVASCRIPT.l,
+            function(action){
+              this.appLoadWidget(action.widget || action.name);
+            }
+          END_OF_JAVASCRIPT
+          
+          # Masquerade selector window
+          :show_masquerade_selector => <<-END_OF_JAVASCRIPT.l,
+            function(){
+              var w = new Ext.Window({
+        				title: 'Masquerade as',
+        				modal: true,
+        				width: Ext.lib.Dom.getViewWidth() * 0.6,
+                height: Ext.lib.Dom.getViewHeight() * 0.6,
+                layout: 'fit',
+        	      closeAction :'destroy',
+                buttons: [{
+                  text: 'Select',
+                  handler : function(){
+                    if (role = w.getWidget().masquerade.role) {
+                      Ext.Msg.confirm("Masquerading as a role", "Individual preferences for all users with this role will get overwritten as you make changes. Continue?", function(btn){
+                        if (btn === 'yes') {
+                          w.close();
+                        }
+                      });
+                    } else {
+                      w.close();
+                    }
+                  },
+                  scope:this
+                },{
+                  text:'Turn off masquerading',
+                  handler:function(){
+                    this.masquerade = {};
+                    w.close();
+                  },
+                  scope:this
+                },{
+                  text:'Cansel',
+                  handler:function(){
+                    w.hide();
+                  },
+                  scope:this
+                }],
+                listeners : {close: {fn: function(){
+                  this.masqAs(this.masquerade || w.getWidget().masquerade || {});
+                }, scope: this}}
+        			});
+
+        			w.show(null, function(){
+        			  this.loadAggregatee({id:"masqueradeSelector", container:w.id})
+        			}, this);
+
+            }
+          END_OF_JAVASCRIPT
+
+          # Masquerade as...
+          :masq_as => <<-END_OF_JAVASCRIPT.l
+            function(masqConfig){
+              params = {};
+
+              if (masqConfig.user) {
+                params.user = masqConfig.user
+              }
+
+              if (masqConfig.role) {
+                params.role = masqConfig.role
+              }
+
+              this.masqueradeAs(params);
+
+            }
+          END_OF_JAVASCRIPT
+        }
+      end
+    end
+    
+    extend ClassMethods
+        
+    # Set the Logout button if Netzke::Base.user is set
+    def menu
+      res = []
+      user = Netzke::Base.user
+      if !user.nil?
+        user_name = user.respond_to?(:name) ? user.name : user.login # try to display user's name, fallback to login
+        res << "->" <<
+        {
+          :text => "#{user_name}",
+          :menu => user_menu
+        }
+      else
+        res << "->" <<
+        {
+          :text => "Login",
+          :handler => <<-END_OF_JAVASCRIPT.l,
+            function(){
+              window.location = "/login"
+            }
+          END_OF_JAVASCRIPT
+          :scope => this
+        }
+      end
+      res
+    end
+
+    def user_menu
+      ['logout']
+    end
+
+    def initialize(*args)
+      super
+
+      if session[:netzke_just_logged_in] || session[:netzke_just_logged_out]
+        session[:config_mode] = false
+        session[:masq_user] = session[:masq_roles] = nil
+      end
+
+      strong_children_config.deep_merge!({:ext_config => {:mode => :config}}) if session[:config_mode]
+    end
+    
+    #
+    # Available actions
+    #
+    def actions
+      { 
+        :masquerade_selector => {:text => "Masquerade as ...", :fn => "showMasqueradeSelector"},
+        :toggle_config_mode => {:text => "#{session[:config_mode] ? "Leave" : "Enter"} config mode", :fn => "toggleConfigMode"},
+        :logout => {:text => "Log out", :fn => "logout"}
+      }
+    end
+    
+    
+    # Html required for Ext.History to work
+    def js_widget_html
+      super << %Q{
+<form id="history-form" class="x-hidden">
+    <input type="hidden" id="x-history-field" />
+    <iframe id="x-history-frame"></iframe>
+</form>
+      }
+    end
+
+    # We rely on the FeedbackGhost (to not need to implement our own feedback management)
+    def initial_aggregatees
+      {:feedback_ghost => {:widget_class_name => "FeedbackGhost"}}
+    end
+
+    # Besides instantiating ourselves, also instantiate the FeedbackGhost
+    def js_widget_instance
+      <<-END_OF_JAVASCRIPT << super
+        new Ext.netzke.cache['FeedbackGhost']({id:'feedback_ghost'})
+        // Initialize history (can't say why it's not working well inside the appLoaded handler)
+        Ext.History.init();
+      END_OF_JAVASCRIPT
+    end
+
+    #
+    # Interface section
+    #
+    
+    api :toggle_config_mode
+    def toggle_config_mode(params)
+      session = Netzke::Base.session
+      session[:config_mode] = !session[:config_mode]
+      {:js => "window.location.reload();"}
+    end
+
+    api :masquerade_as
+    def masquerade_as(params)
+      session = Netzke::Base.session
+      session[:masq_role] = params[:role]
+      session[:masq_user] = params[:user]
+      {:js => "window.location.reload()"}
+    end
+    
+  end
+end