netzke-basepack 0.4.2 → 0.5.1

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,33 @@
+module Netzke::ActiveRecord
+  # Provides extensions to those ActiveRecord-based models that provide data to the "data accessor" widgets,
+  # like GridPanel, FormPanel, etc
+  module DataAccessor
+    
+    # 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
+    
+    # Transforms a record to array of values according to the passed columns.
+    def to_array(columns, widget = nil)
+      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]
+        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

@@ -1,18 +1,16 @@
 module Netzke
-  #
+  # == BasicApp
   # Basis for a Ext.Viewport-based application
   #
   # Features:
   # * dynamic loading of widgets
-  # * restoring of the last loaded widget (not working for now)
   # * 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
-    interface :app_get_widget # to dynamically load the widgets that are defined in initial_late_aggregatees
-    
     module ClassMethods
 
       def js_base_class
@@ -22,161 +20,259 @@ module Netzke
       # Global BasicApp configuration
       def config
         set_default_config({
-          :logout_url => "/logout" # logout url assumed by default
+          :logout_url => "/logout" # default logout url
         })
       end
       
-      # The layout
-      def js_default_config
-        super.merge({
-          :layout => 'border',
-          :items => [{
-            :id => 'main-panel',
-            :region => 'center',
-            :layout => 'fit'
-          },{
-      			:id => 'main-toolbar',
-      			:xtype => 'toolbar',
-            :region => 'north',
-            :height => 25
-          }]
-        })
-      end
-
-      def js_after_constructor
-        <<-JS.l
-          // call appLoaded() once after the application is fully rendered
-          // this.on("resize", function(){alert('show');this.appLoaded();}, this, {single:true});
-
-          // Initialize menus (upcoming support for dynamically loaded menus)
-          this.menus = {};
-          
-          Ext.History.on('change', this.processHistory, 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);
-          }
-          
-          if (this.initialConfig.menu) {this.addMenu(this.initialConfig.menu, this);}
-
-          // add initial menus to the tool-bar
-          var toolbar = this.findById('main-toolbar');
-          Ext.each(#{js_initial_menus.to_js}, function(menu){
-            toolbar.add(menu);
-          });
-        JS
-      end
-      
-      # Set the Logout button if Netzke::Base.user is set
-      def js_initial_menus
-        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 => "Logout #{user_name}",
-            :handler => <<-JS.l,
-              function(){
-                Ext.MessageBox.confirm('Confirm', 'Are you sure you want to logout?', function(btn){
-    							if( btn == "yes" ) {
-    								this.logout();
-    							}
-    						}.createDelegate(this));
-              }
-            JS
-  			    :scope => this
-          }
-        else
-          res << "->" <<
-          {
-            :text => "Login",
-            :handler => <<-JS.l,
-              function(){
-                window.location = "/login"
-              }
-            JS
-  			    :scope => this
-          }
+      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}"}
+        elsif session[:masq_world]
+          masq = %Q{World}
         end
-        res
+                
+        [{
+          :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
-        super.merge({
+        {
+          :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);
+              }
 
-          :host_menu => <<-JS.l,
+              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);
-            	  this.menus[owner.id].push(newMenu);
+                // 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);
           	}
-          JS
+          END_OF_JAVASCRIPT
 
-          :unhost_menu => <<-JS.l,
+          :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
-                });
-              }
+              // 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
+              //   });
+              // }
             }
-          JS
+          END_OF_JAVASCRIPT
 
-          :logout => <<-JS.l,
+          :logout => <<-END_OF_JAVASCRIPT.l,
             function(){
               window.location = "#{config[:logout_url]}"
             }
-          JS
+          END_OF_JAVASCRIPT
 
           # Event handler for history change
-          :process_history => <<-JS.l,
+          :process_history => <<-END_OF_JAVASCRIPT.l,
             function(token){
               if (token){
-                this.findById('main-panel').loadWidget(this.initialConfig.interface.appGetWidget, {widget:token})
+                this.loadAggregatee({id:token, container:'main-panel'});
               } else {
-                this.findById('main-panel').loadWidget(null)
               }
             }
-          JS
+          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 => <<-JS.l,
+          :app_load_widget => <<-END_OF_JAVASCRIPT.l,
             function(name){
-              Ext.History.add(name)
+              Ext.History.add(name);
             }
-          JS
+          END_OF_JAVASCRIPT
 
           # Loads widget by action
-          :load_widget_by_action => <<-JS.l
+          :load_widget_by_action => <<-END_OF_JAVASCRIPT.l,
             function(action){
-              this.appLoadWidget(action.widget || action.name)
+              this.appLoadWidget(action.widget || action.name);
             }
-          JS
-        })
+          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:'As World',
+                  handler:function(){
+                    Ext.Msg.confirm("Masquerading as World", "Caution! All settings that you will modify will be ovewritten for all roles and all users. Are you sure you know what you're doing?", function(btn){
+                      if (btn === "yes") {
+                        this.masquerade = {world:true};
+                        w.close();
+                      }
+                    }, this);
+                  },
+                  scope:this
+                },{
+                  text:'No masquerading',
+                  handler:function(){
+                    this.masquerade = {};
+                    w.close();
+                  },
+                  scope:this
+                },{
+                  text:'Cansel',
+                  handler:function(){
+                    w.hide();
+                  },
+                  scope:this
+                }],
+                listeners : {close: {fn: function(){
+                  this.masqueradeAs(this.masquerade || w.getWidget().masquerade || {});
+                }, scope: this}}
+        			});
+
+        			w.show(null, function(){
+        			  this.loadAggregatee({id:"masqueradeSelector", container:w.id})
+        			}, this);
+
+            }
+          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_world] = session[:masq_user] = session[:masq_roles] = nil
+      end
+
+      strong_children_config.deep_merge!({:ext_config => {:mode => :config}}) if session[:config_mode]
+    end
     
-    # Pass the last loaded widget from the persistent storage (DB) to the browser
-    def js_config
-      super.merge({:widget_to_load => persistent_config['last_loaded_widget']})
+    #
+    # 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{
@@ -194,18 +290,31 @@ module Netzke
 
     # Besides instantiating ourselves, also instantiate the FeedbackGhost
     def js_widget_instance
-      %Q{
+      <<-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();
-      } << super
+      END_OF_JAVASCRIPT
     end
+
+    #
+    # Interface section
+    #
     
-    # Interface implementation
-    def interface_app_get_widget(params)
-      widget = params.delete(:widget).underscore
-      persistent_config['last_loaded_widget'] = widget # store the last loaded widget in the persistent storage
-      send("#{widget}__get_widget", params)
+    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_world] = params[:world]
+      session[:masq_role] = params[:role]
+      session[:masq_user] = params[:user]
+      {:js => "window.location.reload()"}
     end
     
   end