netzke-basepack 0.7.4 → 0.7.5

data/lib/netzke/basepack/data_adapters/sequel_adapter.rb

@@ -0,0 +1,260 @@
+module Netzke::Basepack::DataAdapters
+  class SequelAdapter < AbstractAdapter
+    def self.for_class?(model_class)
+      model_class <= Sequel::Model
+    end
+
+    def get_records(params, columns=[])
+      get_dataset(params, columns).all
+    end
+
+    def count_records(params, columns=[])
+      # dont pass columns, JOINs will be done as necessary for filters
+      get_dataset(params, [], true).count
+    end
+
+    def map_type type
+      type
+    end
+
+    def get_assoc_property_type assoc_name, prop_name
+      db_schema=class_for(assoc_name.to_sym).db_schema
+      # return nil if prop_name not present in db schema (virtual column)
+      db_schema[prop_name.to_sym] ? db_schema[prop_name.to_sym][:type] : nil
+    end
+
+    # like get_assoc_property_type but for non-association columns
+    def get_property_type column
+      column[:type]
+    end
+
+    def column_virtual? c
+      assoc, method = c[:name].split '__'
+      if method
+        !class_for(assoc.to_sym).columns.include? method.to_sym
+      else
+        !@model_class.columns.include? assoc.to_sym
+      end
+    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
+          dataset = class_for(assoc_name)
+
+          dataset = dataset.extend_with(method_options[:scope]) if method_options[:scope]
+
+          if class_for(assoc_name).column_names.include?(assoc_method)
+            # apply query
+            dataset = dataset.where(assoc_method.to_sym.like("%#{query}%")) if query.present?
+            dataset.all.map{ |r| [r.id, r.send(assoc_method)] }
+          else
+            dataset.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.association_reflection(assoc_name.to_sym)[:key].to_s
+    end
+
+    # Returns the model class for an association
+    def class_for assoc_name
+      @model_class.association_reflection(assoc_name.to_sym)[:class_name].constantize
+    end
+
+    def destroy(ids)
+      @model_class.where(:id => ids).destroy
+    end
+
+    def find_record(id)
+      @model_class[id]
+    end
+
+    # Build a hash of foreign keys and the associated model
+    def hash_fk_model
+      @model_class.all_association_reflections.inject({}) do |res, assoc|
+        res[assoc[:key]] = assoc[:class_name].constantize.model_name.underscore.to_sym
+        res
+      end
+    end
+
+    # TODO: is this possible with Sequel?
+    def move_records(params)
+    end
+
+    # give the data adapter the opportunity the set special options for
+    # saving
+    def save_record(record)
+      # don't raise an error on saving. basepack will evaluate record.errors
+      # to get validation errors
+      record.raise_on_save_failure = false
+      record.save
+    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.inject([]) do |errors, error|
+        field, message = error
+        errors << "#{record.class.human_attribute_name(field)} #{message.join ', '}"
+        errors
+      end
+    end
+
+    # Needed for seed and tests
+    def last
+      @model_class.last
+    end
+
+    # Needed for seed and tests
+    def destroy_all
+      @model_class.destroy
+    end
+
+    private
+    def get_dataset params, columns, for_count=false
+      dataset = @model_class
+
+      graphed=[]
+
+      # 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"
+      #     }}
+      #
+
+      if params[:filter]
+        # these are still JSON-encoded due to the migration to Ext.direct
+        column_filter=JSON.parse(params[:filter])
+
+        column_filter.each do |v|
+          field = v["field"]
+          assoc, method = field.split('__')
+          if method
+            # when filtering on association's columns, we need to graph for LEFT OUTER JOIN
+            dataset = dataset.eager_graph assoc.to_sym unless graphed.include? assoc.to_sym
+            graphed << assoc.to_sym
+          end
+
+          value = v["value"]
+          type = v["type"]
+          op = v["comparison"]
+
+          if type == "string"
+            # strings are always LIKEd (case-insensitive)
+            dataset = dataset.filter field.to_sym.ilike("%#{value}%")
+          else
+            if type == "date"
+              # convert value to the DB date
+              value.match /(\d\d)\/(\d\d)\/(\d\d\d\d)/
+              value = "#{$3}-#{$1}-#{$2}"
+            end
+            # if it's NOT an association column, we need to qualify column name with model's table_name
+            qualified_column_name = method ? field.to_sym : field.to_sym.qualify(@model_class.table_name)
+            case op
+            when 'lt'
+              dataset = dataset.filter ":column < '#{value}'", :column => qualified_column_name
+            when 'gt'
+              dataset = dataset.filter ":column > '#{value}'", :column => qualified_column_name
+            else
+              dataset = dataset.filter qualified_column_name => value
+            end
+          end
+        end
+      end
+      # skip sorting, eager joining and paging if dataset is used for count
+      unless for_count
+        if params[:sort] && sort_params = params[:sort]
+          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)
+              dataset = dataset.send(column[:sorting_scope].to_sym, dir.to_sym)
+            else
+              if method # sorting on associations column
+                # graph the association for LEFT OUTER JOIN
+                dataset = dataset.eager_graph(assoc.to_sym) unless graphed.include? assoc.to_sym
+                graphed << assoc.to_sym
+              end
+              # coincidentally, netzkes convention of specifying association's attributes
+              # i.e. "author__name" on Book matches sequel's convention
+              # so we can just pass symbolized property here
+              dataset = dataset.order(sort_param["property"].to_sym.send(dir))
+            end
+          end
+        end
+
+        # eager load the associations indicated by columns,
+        # but only if we didn't eager_graph them before (for ordering/filtering)
+        # because this saves a ID IN query
+        columns.each do |column|
+          if column[:name].index('__')
+            assoc, _ = column[:name].split('__')
+            dataset = dataset.eager(assoc.to_sym) unless graphed.include? assoc.to_sym
+          end
+        end
+
+        # apply paging
+        if params[:limit]
+          if params[:start]
+            dataset = dataset.limit params[:limit], params[:start]
+          else
+            dataset = dataset.limit params[:limit]
+          end
+        end
+      end
+
+      # apply scope
+      # need to symbolize_keys, because when the request is made from client-side (as opposed
+      # to server-side on inital render), the scope's keys are given as string {"author_id" => 1}
+      # If we give Sequel a filter like this, it will (correctly) do WHERE 'author_id' = 1 - note the quotes
+      # making the database match the string author_id to 1 and to the column.
+      dataset = dataset.extend_with(params[:scope].symbolize_keys) if params[:scope]
+      dataset
+    end
+  end
+
+end

data/lib/netzke/basepack/form_panel.rb

@@ -99,18 +99,18 @@ module Netzke
 
       def js_config
         super.tap do |res|
-          res[:pri] = data_class && data_class.primary_key
+          res[:pri] = data_class && data_class.primary_key.to_s
           res[:record] = js_record_data if record
         end
       end
 
       # A hash of record data including the meta field
       def js_record_data
-        record.to_hash(fields).merge(:_meta => meta_field).literalize_keys
+        record.netzke_hash(fields).merge(:_meta => meta_field).literalize_keys
       end
 
       def record
-        @record ||= config[:record] || config[:record_id] && data_class && data_class.where(data_class.primary_key => config[:record_id]).first
+        @record ||= config[:record] || config[:record_id] && data_class && data_adapter.find_record(config[:record_id])
       end
 
       private

data/lib/netzke/basepack/form_panel/fields.rb

@@ -10,12 +10,11 @@ module Netzke
           @form_panel_items ||= begin
             res = normalize_fields(super || data_class && data_class.netzke_attributes || []) # netzke_attributes as default items
             # if primary key isn't there, insert it as first
-            if data_class && !res.detect{ |f| f[:name] == data_class.primary_key}
+            if data_class && !res.detect{ |f| f[:name] == data_class.primary_key.to_s}
               primary_key_item = normalize_field(data_class.primary_key.to_sym)
               @fields_from_config[data_class.primary_key.to_sym] = primary_key_item
               res.insert(0, primary_key_item)
             end
-
             res
           end
         end
@@ -121,14 +120,11 @@ module Netzke
           def detect_association_with_method(c)
             if c[:name].index('__')
               assoc_name, method = c[:name].split('__').map(&:to_sym)
-              if method && assoc = data_class.reflect_on_association(assoc_name)
-                assoc_column = assoc.klass.columns_hash[method.to_s]
-                assoc_method_type = assoc_column.try(:type)
-                if c[:nested_attribute]
-                  c[:xtype] ||= xtype_for_attr_type(assoc_method_type)
-                else
-                  c[:xtype] ||= assoc_method_type == :boolean ? xtype_for_attr_type(assoc_method_type) : xtype_for_association
-                end
+              assoc_method_type = data_adapter.get_assoc_property_type(assoc_name, method)
+              if c[:nested_attribute]
+                c[:xtype] ||= xtype_for_attr_type(assoc_method_type)
+              else
+                c[:xtype] ||= assoc_method_type == :boolean ? xtype_for_attr_type(assoc_method_type) : xtype_for_association
               end
             end
           end

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

@@ -172,6 +172,7 @@
         }, this);
       }
     }
+    this.fireEvent('afterApply', this);
   },
 
   setFormValues: function(values){

data/lib/netzke/basepack/form_panel/services.rb

@@ -18,7 +18,7 @@ module Netzke
           #
           #     someForm.netzkeLoad({id: 100});
           endpoint :netzke_load do |params|
-            @record = data_class && data_class.find_by_id(params[:id])
+            @record = data_class && data_adapter.find_record(params[:id])
             {:set_form_values => js_record_data}
           end
 
@@ -42,16 +42,19 @@ module Netzke
 
         # Returns array of form values according to the configured columns
         # def array_of_values
-        #   @record && @record.to_array(fields)
+        #   @record && @record.netzke_array(fields)
         # end
 
         def values
-          record && record.to_hash(fields)
+          record && record.netzke_hash(fields)
         end
 
         # Implementation for the "netzke_submit" endpoint (for backward compatibility)
         def netzke_submit(params)
           data = ActiveSupport::JSON.decode(params[:data])
+          data.each_pair do |k,v|
+            data[k]=nil if v.blank? || v == "null" # Ext JS returns "null" on empty date fields, or "" for not filled optional integer fields, which gives errors when passed to model (at least in DataMapper)
+          end
 
           # File uploads are in raw params instead of "data" hash, so, mix them in into "data"
           if config[:file_upload]
@@ -66,8 +69,8 @@ module Netzke
             {:set_form_values => js_record_data, :set_result => true}
           else
             # flash eventual errors
-            @record.errors.to_a.each do |msg|
-              flash :error => msg
+            data_adapter.errors_array(@record).each do |error|
+              flash :error => error
             end
             {:netzke_feedback => @flash, :apply_form_errors => build_form_errors(record)}
           end
@@ -78,14 +81,10 @@ module Netzke
           # Builds the form errors
           def build_form_errors(record)
             form_errors = {}
-            foreign_keys = {}
-
-            # Build a hash of foreign keys and the associated model
-            data_class.reflect_on_all_associations(:belongs_to).map{ |r|
-              foreign_keys[r.association_foreign_key.to_sym] = r.name
-            }
-
-            record.errors.map{|field, error|
+            foreign_keys = data_adapter.hash_fk_model
+            record.errors.to_hash.map{|field, error|
+              # some ORM return an array for error
+              error = error.join ', ' if error.kind_of? Array
               # Get the correct field name for the errors on foreign keys
               if foreign_keys.has_key?(field)
                 fields.each do |k, v|
@@ -93,7 +92,6 @@ module Netzke
                   field = k.to_s.gsub('__', '____') if k.to_s.split('__').first == foreign_keys[field].to_s
                 end
               end
-
               form_errors[field] ||= []
               form_errors[field] << error
             }
@@ -103,7 +101,8 @@ module Netzke
           # Creates/updates a record from hash
           def create_or_update_record(hsh)
             hsh.merge!(config[:strong_default_attrs]) if config[:strong_default_attrs]
-            @record ||= data_class.find(:first, :conditions => {data_class.primary_key => hsh.delete(data_class.primary_key)}) # only pick up the record specified in the params if it was not provided in the configuration
+            @record ||= data_adapter.find_record hsh.delete(data_class.primary_key.to_s) # only pick up the record specified in the params if it was not provided in the configuration
+              #data_class.find(:first, :conditions => {data_class.primary_key => hsh.delete(data_class.primary_key)}) 
             success = true
 
             @record = data_class.new if @record.nil?
@@ -123,7 +122,7 @@ module Netzke
             #end
 
             # did we have complete success?
-            success && @record.save
+            success && data_adapter.save_record(@record)
           end
 
           # API handling form load

data/lib/netzke/basepack/grid_panel.rb

@@ -126,6 +126,11 @@ module Netzke
     class GridPanel < Netzke::Base
       js_base_class "Ext.grid.Panel"
 
+      class_attribute :columns_attr
+
+      class_attribute :overridden_columns_attr
+      self.overridden_columns_attr = {}
+
       # Class-level configuration. These options directly influence the amount of generated
       # javascript code for this component's class. For example, if you don't want filters for the grid,
       # set column_filters_available to false, and the javascript for the filters won't be included at all.
@@ -198,15 +203,14 @@ module Netzke
         base.class_eval do
           class << self
             def column(name, config = {})
-              columns = self.read_inheritable_attribute(:columns) || []
-              columns << config.merge(:name => name.to_s)
-              self.write_inheritable_attribute(:columns, columns)
+              columns = self.columns_attr || []
+              columns |= [config.merge(:name => name.to_s)]
+              self.columns_attr = columns
             end
 
             def override_column(name, config)
-              columns = self.read_inheritable_attribute(:overridden_columns) || {}
-              columns.merge!(name.to_sym => config)
-              self.write_inheritable_attribute(:overridden_columns, columns)
+              columns = self.overridden_columns_attr.dup
+              self.overridden_columns_attr = columns.merge(name.to_sym => config)
             end
           end
         end
@@ -214,10 +218,10 @@ module Netzke
 
       def configuration
         super.tap do |c|
-          c[:columns] ||= self.class.read_inheritable_attribute(:columns)
+          c[:columns] ||= self.columns_attr
 
           # user-passed :override_columns option should get deep_merged with the defaults
-          c[:override_columns] = (self.class.read_inheritable_attribute(:overridden_columns) || {}).deep_merge(c[:override_columns] || {})
+          c[:override_columns] = self.overridden_columns_attr.deep_merge(c[:override_columns] || {})
         end
       end
 
@@ -243,8 +247,10 @@ module Netzke
 
       def get_default_association_values #:nodoc:
         columns.select{ |c| c[:name].index("__") && c[:default_value] }.each.inject({}) do |r,c|
-          assoc, assoc_method = assoc_and_assoc_method_for_attr(c)
-          assoc_instance = assoc.klass.find(c[:default_value])
+          assoc_name, assoc_method = c[:name].split '__'
+          assoc_class = data_adapter.class_for(assoc_name)
+          assoc_data_adapter = Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(assoc_class).new(assoc_class)
+          assoc_instance = assoc_data_adapter.find_record c[:default_value]
           r.merge(c[:name] => assoc_instance.send(assoc_method))
         end
       end