netzke-basepack-zh 0.7.6

data/lib/netzke/basepack/action_column.rb

@@ -0,0 +1,68 @@
+module Netzke
+  module Basepack
+    module ActionColumn
+      extend ActiveSupport::Concern
+
+      included do |base|
+
+        # Returns registered actions
+        class_attribute :registered_column_actions
+        self.registered_column_actions = []
+
+        js_include :action_column
+      end
+
+      module ClassMethods
+        # Register an action
+        def register_column_action(name)
+          self.registered_column_actions |= [name]
+        end
+
+        # Use this method to define column actions in your component, e.g.:
+        #
+        #     column_action :edit, :icon => "/images/icons/edit.png"
+        #
+        # TODO: List all options.
+        # TODO: think how it'll be possible to override individual column_actions (if need to bother at all)
+        def column_action(name, params = {})
+          params[:name] = name
+          params[:column] ||= "actions"
+          params[:icon] ||= "/extjs/examples/shared/icons/fam/cog.png"
+          params[:tooltip] = params[:tooltip].presence || name.to_s.humanize
+          params[:handler] ||= "on_#{name}"
+          register_column_action(name);
+          define_method "#{name}_column_action" do |record=nil| # TODO: this won't work in Ruby 1.8.7
+            params[:row_config] && record ? params.merge(params[:row_config].call(record, self)) : params
+          end
+        end
+      end
+
+      def initial_columns(with_excluded = false)
+        orig_columns = super
+
+        action_column_names = column_actions.map{ |action| action[:column] }.uniq
+        action_columns = orig_columns.select{ |c| action_column_names.include? c[:name] }
+
+        # Append the column if none found AND no explicit column configuration was provided
+        if action_columns.empty? && !config[:columns]
+          action_columns = [{:name => "actions"}.merge(config[:override_columns].try(:fetch, :actions, nil) || {})]
+          orig_columns += action_columns
+        end
+
+        action_columns.each do |c|
+          c[:xtype] = :netzkeactioncolumn
+          c[:getter] = lambda do |r|
+            self.class.registered_column_actions.select{ |action_name| self.send("#{action_name}_column_action")[:column] == c[:name] }.map{ |action_name| self.send("#{action_name}_column_action", r) }.to_nifty_json
+          end
+        end
+
+        orig_columns
+      end
+
+      def column_actions
+        self.class.registered_column_actions.map{ |action_name| self.send("#{action_name}_column_action")}
+      end
+
+    end
+  end
+end

data/lib/netzke/basepack/action_column/javascripts/action_column.js

@@ -0,0 +1,61 @@
+Ext.define('Ext.grid.column.NetzkeAction', {
+    extend: 'Ext.grid.column.Action',
+    alias: ['widget.netzkeactioncolumn'],
+
+    constructor: function(config) {
+        var me = this,
+            cfg = Ext.apply({}, config),
+            i,
+            item;
+
+        me.callParent([cfg]);
+
+        me.renderer = function(actions, meta) {
+          // previous renderer
+          var v = Ext.isFunction(cfg.renderer) ? cfg.renderer.apply(this, arguments)||'' : '',
+              actions = Ext.decode(actions),
+              l = actions.length,
+              action;
+
+          meta.tdCls += ' ' + Ext.baseCSSPrefix + 'action-col-cell';
+
+          for (i = 0; i < l; i++) {
+            action = actions[i];
+            if (!action.hidden) {
+              v += '<img alt="' + (action.altText || me.altText) + '" src="' + (action.icon || Ext.BLANK_IMAGE_URL) +
+                  '" class="' + Ext.baseCSSPrefix + 'action-col-icon ' + Ext.baseCSSPrefix + 'action-col-' + String(i) + ' ' +  (action.iconCls || '') +
+                  ' ' + (Ext.isFunction(action.getClass) ? action.getClass.apply(action.scope||me.scope||me, arguments) : (me.iconCls || '')) + '"' +
+                  ((action.tooltip) ? ' data-qtip="' + action.tooltip + '"' : '') +
+                  ' data-name="' + action.name + '"' +
+                  ((action.handler) ? ' data-handler="' + action.handler + '"' : '') + ' />';
+            }
+          }
+
+          return v;
+        };
+    },
+
+    processEvent : function(type, view, cell, recordIndex, cellIndex, e){
+        var me = this,
+            target = e.getTarget(),
+            match = target.className.match("x-action-col-icon"),
+            fn, grid, record;
+        if (match) {
+            if (type == 'click') {
+                grid = me.ownerCt.ownerCt;
+                fn = (target.getAttribute("data-handler") || "").camelize(true);
+                fn = Ext.isFunction(grid[fn]) ? grid[fn] : undefined;
+                // if (fn) fn.call(grid, view, recordIndex, cellIndex, target, e);
+                if (fn) {
+                  record = grid.getStore().getAt(recordIndex);
+                  fn.call(grid, record, target, e);
+                } else {
+                  Netzke.warning("Undefined handler for column action '" + target.getAttribute("data-name") + "'");
+                }
+            } else if (type == 'mousedown') {
+                return false;
+            }
+        }
+        return me.callParent(arguments);
+    }
+});

data/lib/netzke/basepack/auth_app.rb

@@ -0,0 +1,159 @@
+module Netzke
+  module Basepack
+    # Extension to SimpleApp that brings in support for authentication and masquerading
+    # ** NOTE: it's WIP **
+    class AuthApp < SimpleApp
+
+      def default_config
+        super.tap do |c|
+          c[:login_url] = "/login"
+          c[:logout_url] = "/logout"
+        end
+      end
+
+      # class_config_option :login_url, "/login"
+      # # self.login_url = "/login"
+      #
+      # class_attribute :logout_url
+      # self.logout_url = "/logout"
+
+      js_method :on_login, <<-JS
+        function(){
+          window.location = this.loginUrl;
+        }
+      JS
+
+      js_method :on_logout, <<-JS
+        function(){
+          window.location = this.logoutUrl;
+        }
+      JS
+
+      js_method :on_toggle_config_mode, <<-JS
+        function(params){
+          this.toggleConfigMode();
+        }
+      JS
+# WIP: todo - rewrite Ext.lib calls below
+      js_method :show_masquerade_selector, <<-JS
+        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.getNetzkeComponent().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.getNetzkeComponent().masquerade || {});
+            }, scope: this}}
+          });
+
+          w.show(null, function(){
+            this.loadNetzkeComponent({id:"masqueradeSelector", container:w.id})
+          }, this);
+
+        }
+      JS
+
+      # Set the Logout button if Netzke::Core.current_user is set
+      def menu
+        [].tap do |menu|
+          user = Netzke::Core.current_user
+          if !user.nil?
+            user_name = user.respond_to?(:name) ? user.name : user.email # try to display user's name, fallback to email
+            menu << "->" <<
+            {
+              :text => user_name,
+              :menu => user_menu
+            }
+          else
+            menu << "->" << :login.action
+          end
+        end
+      end
+
+      def user_menu
+        [:logout.action]
+      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!(:mode => :config) if session[:config_mode]
+      end
+
+      action :masquerade_selector, :text => "Masquerade as ...", :handler => :show_masquerade_selector
+
+      action :toggle_config_mode do
+        {:text => "#{session[:config_mode] ? "Leave" : "Enter"} config mode"}
+      end
+
+      action :login, :icon => :door_in
+
+      action :logout, :icon => :door_out
+
+      #
+      # Interface section
+      #
+      endpoint :toggle_config_mode do |params|
+        session = Netzke::Base.session
+        session[:config_mode] = !session[:config_mode]
+        {:js => "window.location.reload();"}
+      end
+
+      endpoint :masquerade_as do |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
+
+    end
+  end
+end

data/lib/netzke/basepack/basic_app.rb

@@ -0,0 +1,7 @@
+module Netzke
+  module Basepack
+    # For backward compatibility only. Use AuthApp instead.
+    class BasicApp < AuthApp
+    end
+  end
+end

data/lib/netzke/basepack/border_layout_panel.rb

@@ -0,0 +1,53 @@
+module Netzke
+  module Basepack
+    # Panel with border layout.
+    #
+    # == Features
+    #   * When persistence enabled, remembers the sizes and collapsed/expanded states of its regions.
+    #
+    # == Example configuration:
+    #
+    #     :items => [
+    #       {:title => "Item One", :class_name => "Basepack::Panel", :region => :center},
+    #       {:title => "Item Two", :class_name => "Basepack::Panel", :region => :west, :width => 300, :split => true}
+    #     ]
+    class BorderLayoutPanel < Netzke::Base
+      js_mixin :border_layout_panel
+
+      def items
+        @border_layout_items ||= begin
+          updated_items = super
+
+          if config[:persistence]
+            updated_items.each do |item|
+              region = item[:region] || components[item[:netzke_component]][:region]
+              item.merge!({
+                :width => state[:"#{region}_region_width"],
+                :height => state[:"#{region}_region_height"],
+                :collapsed => state[:"#{region}_region_collapsed"]
+              })
+            end
+          end
+
+          updated_items
+        end
+      end
+
+      endpoint :region_resized do |params|
+        size_state_hash = {}
+        size_state_hash[:"#{params[:region]}_region_width"] = params[:width].to_i if params[:width]
+        size_state_hash[:"#{params[:region]}_region_height"] = params[:height].to_i if params[:height]
+        update_state(size_state_hash)
+      end
+
+      endpoint :region_collapsed do |params|
+        update_state(:"#{params[:region]}_region_collapsed" => true)
+      end
+
+      endpoint :region_expanded do |params|
+        update_state(:"#{params[:region]}_region_collapsed" => false)
+      end
+
+    end
+  end
+end

data/lib/netzke/basepack/border_layout_panel/javascripts/border_layout_panel.js

@@ -0,0 +1,40 @@
+{
+  layout: 'border',
+
+  initComponent: function(){
+    this.callParent();
+
+    // First time on "afterlayout", set resize events
+    if (this.persistence) {this.on('afterlayout', this.setRegionEvents, this, {single: true});}
+  },
+
+  setRegionEvents: function(){
+    this.items.each(function(item, index, length){
+      if (!item.oldSize) item.oldSize = item.getSize(); // remember initial size
+
+      item.on('resize', function(panel, w, h){
+        if (panel.region !== 'center' && w && h) {
+          var params = {region:panel.region};
+
+          if (panel.oldSize.width != w) {
+            params.width = w;
+          } else {
+            params.height = h;
+          }
+
+          panel.oldSize = panel.getSize();
+          this.regionResized(params);
+        }
+      }, this);
+
+      item.on('collapse', function(panel){
+        this.regionCollapsed({region: panel.region});
+      }, this);
+
+      item.on('expand', function(panel){
+        this.regionExpanded({region: panel.region});
+      }, this);
+
+    }, this);
+  }
+}

data/lib/netzke/basepack/data_accessor.rb

@@ -0,0 +1,53 @@
+module Netzke
+  module Basepack
+    # This module is included into such data-driven components as GridPanel, FormPanel, PagingFormPanel, etc.
+    module DataAccessor
+
+
+
+      # Returns options for comboboxes in grids/forms
+      def combobox_options_for_column(column, method_options = {})
+        data_adapter.combobox_options_for_column column, method_options
+      end
+
+      # Normalize array of attributes
+      # [:col1, "col2", {:name => :col3}] =>
+      #   [{:name => "col1"}, {:name => "col2"}, {:name => "col3"}]
+      def normalize_attrs(attrs)
+        attrs.map{ |a| normalize_attr(a) }
+      end
+
+      # Normalize an attribute, e.g.:
+      # :first_name =>
+      #   {:name => "first_name"}
+      def normalize_attr(a)
+        a.is_a?(Symbol) || a.is_a?(String) ? {:name => a.to_s} : a.merge(:name => a[:name].to_s)
+      end
+
+      def association_attr?(name)
+        !!name.to_s.index("__")
+      end
+
+      # Model class
+      def data_class
+        @data_class ||= config[:model].is_a?(String) ? config[:model].constantize : config[:model]
+      end
+
+      # Data adapter responsible for all DB-related operations
+      def data_adapter
+        @data_adapter ||= Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(data_class).new(data_class)
+      end
+
+      # whether a column is bound to the primary_key
+      def primary_key_attr?(a)
+        data_class && a[:name].to_s == data_class.primary_key.to_s
+      end
+
+      # Mark an attribute as "virtual" by default, when it doesn't reflect a model column, or a model column of an association
+      def set_default_virtual(c)
+        c[:virtual] = data_adapter.column_virtual?(c) if c[:virtual].nil?
+      end
+
+    end
+  end
+end