netzke-basepack 0.7.7 → 0.8.0

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

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

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

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

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

@@ -1,40 +0,0 @@
-{
-  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_adapters/data_mapper_adapter.rb

@@ -1,264 +0,0 @@
-module Netzke::Basepack::DataAdapters
-  class DataMapperAdapter < AbstractAdapter
-    def self.for_class?(model_class)
-      model_class <= DataMapper::Resource
-    end
-
-    def get_records(params, columns=[])
-      search_query = @model_class
-
-      # used for specifying models to join (for ordering and column selection)
-      links = []
-      # join association models into query if they are specified in query
-      # NOTE: AFAIK, in DataMapper there is no possibility to do
-      # OUTER JOINs, and inner join is not correct if a foreign key is
-      # nullable, so we don't join at all and instead rely on strategic
-      # eager loading.
-
-      #columns.each do |column|
-        #if column[:name].index('__')
-          #assoc, _ = column[:name].split('__')
-          #link = @model_class.relationships[assoc.to_sym].inverse
-          #links << link unless links.include? link
-        #end
-      #end
-
-      # apply filter
-      search_query = apply_column_filters search_query, params[:filter] if params[:filter]
-      query_options = {}
-
-      # apply sorting
-      if params[:sort] && sort_params = params[:sort]
-        order = []
-        sort_params.each do |sort_param|
-          assoc, method = sort_param["property"].split("__")
-          dir = sort_param["direction"].downcase
-
-          # if a sorting scope is set, call the scope with the given direction
-          column = columns.detect { |c| c[:name] == sort_param["property"] }
-          if column.try(:'has_key?', :sorting_scope)
-            search_query = search_query.send(column[:sorting_scope].to_sym, dir.to_sym)
-          else
-            if method
-              order << @model_class.send(assoc).send(method).send(dir)
-              link = @model_class.relationships[assoc.to_sym].inverse
-              links << link unless links.include? link
-            else
-              order << assoc.to_sym.send(dir)
-            end
-          end
-        end
-        query_options[:order] = order unless order.empty?
-        query_options[:links] = links unless links.empty?
-      end
-
-      # apply paging
-      query_options[:limit]=params[:limit] if params[:limit]
-      query_options[:offset]=params[:start] if params[:start]
-
-      # apply scope
-      search_query = search_query.extend_with(params[:scope]) if params[:scope]
-
-      search_query.all(query_options)
-    end
-
-    def count_records(params, columns=[])
-      # delete pagig related params, as this would break the query
-      params=params.reject { |k, v|
-        [:start, :limit, :page].include? k.to_sym
-      }
-      # this will NOT do a SELECT *, but a SELECT COUNT(*)
-      get_records(params, columns).count
-    end
-
-    def map_type type
-      @typemap ||= {
-        DataMapper::Property::Integer => :integer,
-        DataMapper::Property::Serial => :integer,
-        DataMapper::Property::Boolean => :boolean,
-        DataMapper::Property::Date => :date,
-        DataMapper::Property::DateTime => :datetime,
-        DataMapper::Property::Time => :time,
-        DataMapper::Property::String => :string,
-        DataMapper::Property::Text => :text
-      }
-      @typemap[type]
-    end
-
-    def get_assoc_property_type assoc_name, prop_name
-      assoc = @model_class.send(assoc_name)
-      # prop_name could be a virtual column, check it first, return nil in this case
-      assoc.respond_to?(prop_name) ? map_type(assoc.send(prop_name).property.class) : nil
-    end
-
-    # like get_assoc_property_type but for non-association columns
-    def get_property_type column
-      map_type(column.class)
-    end
-
-    def column_virtual? c
-      assoc_name, assoc_method = c[:name].split '__'
-      if assoc_method
-        column_names=@model_class.send(assoc_name).model.column_names
-        column_name=assoc_method
-      else
-        column_names=@model_class.column_names
-        column_name=c[:name]
-      end
-      !column_names.include? column_name
-    end
-
-    # Returns options for comboboxes in grids/forms
-    def combobox_options_for_column(column, method_options = {})
-      query = method_options[:query]
-
-      # First, check if we have options for this column defined in persistent storage
-      options = column[:combobox_options] && column[:combobox_options].split("\n")
-      if options
-        query ? options.select{ |o| o.index(/^#{query}/) }.map{ |el| [el] } : options
-      else
-        assoc_name, assoc_method = column[:name].split '__'
-
-        if assoc_name
-          # Options for an asssociation attribute
-          relation = @model_class.send(assoc_name).model
-
-          relation = relation.extend_with(method_options[:scope]) if method_options[:scope]
-
-          if class_for(assoc_name).column_names.include?(assoc_method)
-            # apply query
-            relation = relation.all(assoc_method.to_sym.send(:like) => "%#{query}%") if query.present?
-            relation.all.map{ |r| [r.id, r.send(assoc_method)] }
-          else
-            relation.all.map{ |r| [r.id, r.send(assoc_method)] }.select{ |id,value| value =~ /^#{query}/ }
-          end
-        else
-          # Options for a non-association attribute
-          res=@model_class.netzke_combo_options_for(column[:name], method_options)
-
-          # ensure it is an array-in-array, as Ext will fail otherwise
-          raise RuntimeError, "netzke_combo_options_for should return an Array" unless res.kind_of? Array
-          return [[]] if res.empty?
-
-          unless res.first.kind_of? Array
-            res=res.map do |v|
-              [v]
-            end
-          end
-          return res
-        end
-      end
-    end
-
-    def foreign_key_for assoc_name
-      @model_class.relationships[assoc_name].child_key.first.name.to_s
-    end
-
-    # Returns the model class for an association
-    def class_for assoc_name
-      @model_class.send(assoc_name).model
-    end
-
-    def destroy(ids)
-      @model_class.all(:id => ids).destroy
-    end
-
-    def find_record(id)
-      @model_class.get(id)
-    end
-
-    # Build a hash of foreign keys and the associated model
-    def hash_fk_model
-      @model_class.relationships.inject({}) do |foreign_keys, rel|
-        if rel.kind_of? DataMapper::Associations::ManyToOne::Relationship
-          foreign_keys[rel.child_key.first.name]=rel.parent_model.to_s.downcase.to_sym
-          foreign_keys
-        end
-      end || {}
-    end
-
-    def move_records(params)
-      @model_class.all(:id => params[:ids]).each_with_index do |item, index|
-        item.move(:to => params[:new_index] + index)
-      end
-    end
-
-    # give the data adapter the opporunity to process error messages
-    # must return an raay of the form ["Title can't be blank", "Foo can't be blank"]
-    def errors_array(record)
-      record.errors.to_a.flatten
-    end
-
-    # Needed for seed and tests
-    def last
-      @model_class.last
-    end
-
-    def destroy_all
-      @model_class.all.destroy
-    end
-
-    private
-
-    # Parses and applies grid column filters
-    #
-    # Example column grid data:
-    #
-    #     {"0" => {
-    #       "data" => {
-    #         "type" => "numeric",
-    #         "comparison" => "gt",
-    #         "value" => 10 },
-    #       "field" => "id"
-    #     },
-    #     "1" => {
-    #       "data" => {
-    #         "type" => "string",
-    #         "value" => "pizza"
-    #       },
-    #       "field" => "food_name"
-    #     }}
-    #
-    # This will result in:
-    #      Clazz.get(:id => 10, :food_name.like => "%pizza")
-    def apply_column_filters(relation, column_filter)
-      # these are still JSON-encoded due to the migration to Ext.direct
-      column_filter=JSON.parse(column_filter)
-
-      conditions = {}
-      column_filter.each do |v|
-        assoc, method = v["field"].split('__')
-        if method
-          query_path = relation.send(assoc).send(method) # Book.athor.last_name.like
-        else
-          query_path = assoc.to_sym # :last_name.like
-        end
-
-        value = v["value"]
-        type = v["type"]
-        case v["comparison"]
-        when "lt"
-          query_path=query_path.lt if ["date","numeric"].include? type
-        when "gt"
-          query_path=query_path.gt if ["date","numeric"].include? type
-        else
-          query_path=query_path.like if type == "string"
-        end
-
-        case type
-        when "string"
-          conditions[query_path]="%#{value}%"
-        when "date"
-          # convert value to the DB date
-          value.match /(\d\d)\/(\d\d)\/(\d\d\d\d)/
-          conditions[query_path]="#{$3}-#{$1}-#{$2}"
-        else
-          conditions[query_path]=value
-        end
-      end
-      relation.all conditions
-    end
-
-  end
-
-end