netzke-basepack 0.5.14 → 0.6.0

data/lib/netzke/accordion_panel.rb

@@ -1,115 +0,0 @@
-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(){
-            #{js_full_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"];
-                var klass = this.classifyScopedName(preloadedItemConfig.scopedClassName);
-                i.add(new klass(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
-              var klass = this.classifyScopedName(preloadedItemConfig.scopedClassName);
-              panel.add(new klass(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] && global_id + '_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] && !item[:preloaded]
-        res.merge!(item[:name].to_sym => item)
-      end
-      res
-    end
-
-    
-  end
-end

data/lib/netzke/active_record/data_accessor.rb

@@ -1,25 +0,0 @@
-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, widget = nil)
-      # self.netzke_widget = widget
-      res = []
-      for c in columns
-        begin
-          next if c[:included] == false
-          v = send(c[:name])
-          # a work-around for to_json not taking the current timezone into account when serializing ActiveSupport::TimeWithZone
-          v = v.to_datetime.to_s(:db) if v.is_a?(ActiveSupport::TimeWithZone)
-          res << v 
-        rescue NoMethodError
-          # So that we don't crash at a badly configured column
-          res << "UNDEF"
-        end
-      end
-      res
-    end
-  end
-end
-

data/lib/netzke/attributes_configurator.rb

@@ -1,195 +0,0 @@
-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

data/lib/netzke/basic_app.rb

@@ -1,368 +0,0 @@
-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
-    def self.include_js
-      res = []
-      ext_examples = Netzke::Base.config[:ext_location] + "/examples/"
-      res << ext_examples + "ux/statusbar/StatusBar.js"
-      res << "#{File.dirname(__FILE__)}/basic_app/statusbar_ext.js"
-    end
-
-    def self.js_base_class
-      "Ext.Viewport"
-    end
-
-    # Global BasicApp configuration
-    def self.config
-      set_default_config({
-        :logout_url => "/logout" # default logout url
-      })
-    end
-    
-    
-    # def self.include_css
-    #   res = []
-    #   res << Netzke::Base.config[:ext_location] + "/examples/ux/css/StatusBar.css"
-    #   res
-    # end
-    
-    def self.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
-              
-      [{
-        :id => 'main-panel',
-        :region => 'center',
-        :layout => 'fit'
-      },{
-        :id => 'main-toolbar',
-        :xtype => 'toolbar',
-        :region => 'north',
-        :height => 25
-      },{
-        :id => 'main-statusbar',
-        :xtype => 'statusbar',
-        :region => 'south',
-        :height => 22,
-        :statusAlign => 'right',
-        :busyText => 'Busy...',
-        :default_text => masq.nil? ? "Ready #{"(config mode)" if session[:config_mode]}" : "Masquerading as #{masq}",
-        :default_icon_cls => ""
-      }]
-    end
-    
-    def self.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
-            
-            #{js_full_class_name}.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);
-            
-            // Initialize history
-            Ext.History.init();
-          }
-        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);
-          	toolbar.doLayout(); // required since Ext 3.0.3
-        	}
-        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
-
-        :on_login => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            window.location = "/login"
-          }
-        END_OF_JAVASCRIPT
-        
-        :on_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 {
-              Ext.getCmp('main-panel').removeChild();
-            }
-          }
-        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
-        
-        :on_toggle_config_mode => <<-END_OF_JAVASCRIPT.l,
-          function(){
-            this.toggleConfigMode();
-          }
-        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
-          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 overwritten 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:'Cancel',
-                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
-    
-    # Set the Logout button if Netzke::Base.user is set
-    def menu
-      res = []
-      user = User.find_by_id(session[:netzke_user_id])
-      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 << "->" << :login
-      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
-    
-    #
-    # Available actions
-    #
-    def actions
-      { 
-        :masquerade_selector => {:text => "Masquerade as ...", :fn => "showMasqueradeSelector"},
-        :toggle_config_mode => {:text => "#{session[:config_mode] ? "Leave" : "Enter"} config mode"},
-        :login => {:text => "Login"},
-        :logout => {:text => "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
-
-    #
-    # 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_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
-end