netzke-basepack-zh 0.7.6

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

@@ -0,0 +1,164 @@
+module Netzke::Basepack::DataAdapters
+  # A concrete adapter should implement all the public instance methods of this adapter in order to support all the functionality of Basepack components.
+  class AbstractAdapter
+
+    # Returns records based on passed params. Implements:
+    # * pagination
+    # * filtering
+    # * scopes
+    #
+    # `params` is a hash that contains the following keys:
+    #
+    # * :sort - sorting params, which is an array of hashes that contain the following keys in their turn:
+    #   * :property - the field that is being sorted on
+    #   * :direction - "asc" or "desc"
+    # * :limit - rows per page in pagination
+    # * :start - page number in pagination
+    # * :scope - the scope as described in Netzke::Basepack::GridPanel
+    # * :filter - Ext filters
+    #
+    # The `columns` parameter may be used to use joins to address the n+1 query problem, and receives an array of column configurations
+    def get_records(params, columns)
+      []
+    end
+
+    # gets the first record
+    def first
+      @model_class.first
+    end
+
+    # Returns record count based on passed params. Implements:
+    # * filtering
+    # * scopes
+    #
+    # `params` is a hash that contains the following keys:
+    #
+    # * :scope - the scope as described in Netzke::Basepack::GridPanel
+    # * :filter - Ext filters
+    #
+    # The `columns` parameter may be used to use joins to address the n+1 query problem, and receives an array of column configurations
+    def count_records(params, columns)
+      0
+    end
+
+    # Map a ORM type to a type symbol
+    # Possible types to return
+    # :integer
+    # :boolean
+    # :date
+    # :datetime
+    # :time
+    # :text
+    # :string
+    #
+    # Default implementation works for ActiveRecord
+    def map_type type
+      type
+    end
+
+    # gets the type of a model attribute for xtype mapping
+    # i.e. get_assoc_property_type :author,:first_name should return :string
+    # Possible types to return
+    # :integer
+    # :boolean
+    # :date
+    # :datetime
+    # :time
+    # :text
+    # :string
+    def get_assoc_property_type assoc_name, prop_name
+      raise NotImplementedError
+    end
+
+    # like get_assoc_property_type but for non-association columns
+    def get_property_type column
+      column.type
+    end
+ 
+    # should return true if column is virtual
+    def column_virtual? c
+      raise NotImplementedError
+    end
+
+    # Returns options for comboboxes in grids/forms
+    def combobox_options_for_column(column, method_options = {})
+      raise NotImplementedError
+    end
+
+    # Returns the foreign key name for an association
+    def foreign_key_for assoc_name
+      raise NotImplementedError
+    end
+
+    # Returns the model class for association columns
+    def class_for assoc_name
+      raise NotImplementedError
+    end
+
+    # Destroys records with the provided ids
+    def destroy(ids)
+    end
+
+    # Changes records position (e.g. when acts_as_list is used in ActiveRecord).
+    #
+    # `params` is a hash with the following keys:
+    #
+    # * :ids - ids of records to move
+    # * :new_index - new starting position for the records to move
+    def move_records(params)
+    end
+
+    # Returns a new record.
+    def new_record(params = {})
+      @model_class.new(params)
+    end
+
+    # give the data adapter the opportunity the set special options for
+    # saving, must return true on success
+    def save_record(record)
+      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
+    end
+
+    # Finds a record by id, return nil if not found
+    def find_record(id)
+      @model_class.find(id)
+    end
+
+    # Build a hash of foreign keys and the associated model
+    def hash_fk_model
+      raise NotImplementedError
+    end
+
+
+
+    # -- End of overridable methods
+
+    # Abstract-adapter specifics
+    #
+
+    # Used to determine if the given adapter should be used for the passed in class.
+    def self.for_class?(member_class)
+      false # override in subclass
+    end
+
+    def self.inherited(subclass)
+      @subclasses ||= []
+      @subclasses << subclass
+    end
+
+    def self.adapter_class(model_class)
+      @subclasses.detect { |subclass| subclass.for_class?(model_class) } || AbstractAdapter
+    end
+
+    def initialize(model_class)
+      @model_class = model_class
+    end
+
+  end
+end

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

@@ -0,0 +1,279 @@
+module Netzke::Basepack::DataAdapters
+  class ActiveRecordAdapter < AbstractAdapter
+    def self.for_class?(model_class)
+      model_class <= ActiveRecord::Base
+    end
+
+    def get_records(params, columns=[])
+      # build initial relation based on passed params
+      relation = get_relation(params)
+
+      # addressing the n+1 query problem
+      columns.each do |c|
+        assoc, method = c[:name].split('__')
+        relation = relation.includes(assoc.to_sym) if method
+      end
+
+      # apply sorting if needed
+      if params[:sort] && sort_params = params[:sort].first
+        assoc, method = sort_params["property"].split('__')
+        dir = sort_params["direction"].downcase
+
+        # if a sorting scope is set, call the scope with the given direction
+        column = columns.detect { |c| c[:name] == sort_params["property"] }
+        if column.has_key?(:sorting_scope)
+          relation = relation.send(column[:sorting_scope].to_sym, dir.to_sym)
+        else
+          relation = if method.nil?
+            relation.order("#{assoc} #{dir}")
+          else
+            assoc = @model_class.reflect_on_association(assoc.to_sym)
+            relation.joins(assoc.name).order("#{assoc.klass.table_name}.#{method} #{dir}")
+          end
+        end
+      end
+
+      page = params[:limit] ? params[:start].to_i/params[:limit].to_i + 1 : 1
+      if params[:limit]
+        relation.offset(params[:start]).limit(params[:limit])
+      else
+        relation.all
+      end
+    end
+
+    def count_records(params, columns=[])
+      # build initial relation based on passed params
+      relation = get_relation(params)
+
+      # addressing the n+1 query problem
+      columns.each do |c|
+        assoc, method = c[:name].split('__')
+        relation = relation.includes(assoc.to_sym) if method
+      end
+
+      relation.count
+    end
+
+    def get_assoc_property_type assoc_name, prop_name
+      if prop_name && assoc=@model_class.reflect_on_association(assoc_name)
+        assoc_column = assoc.klass.columns_hash[prop_name.to_s]
+        assoc_column.try(:type)
+      end
+    end
+
+    def column_virtual? c
+      assoc_name, asso = c[:name].split('__')
+      assoc, assoc_method = assoc_and_assoc_method_for_attr(c[:name])
+
+      if assoc
+        return !assoc.klass.column_names.map(&:to_sym).include?(assoc_method.to_sym)
+      else
+        return !@model_class.column_names.map(&:to_sym).include?(c[:name].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, assoc_method = assoc_and_assoc_method_for_attr(column[:name])
+
+        if assoc
+          # Options for an asssociation attribute
+
+          relation = assoc.klass.scoped
+
+          relation = relation.extend_with(method_options[:scope]) if method_options[:scope]
+
+          if assoc.klass.column_names.include?(assoc_method)
+            # apply query
+            relation = relation.where(["#{assoc_method} 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.reflect_on_association(assoc_name.to_sym).foreign_key
+    end
+
+    # Returns the model class for association columns
+    def class_for assoc_name
+      @model_class.reflect_on_association(assoc_name.to_sym).klass
+    end
+
+    def destroy(ids)
+      @model_class.destroy(ids)
+    end
+
+    def find_record(id)
+      @model_class.where(@model_class.primary_key => id).first
+    end
+
+    # Build a hash of foreign keys and the associated model
+    def hash_fk_model
+      foreign_keys = {}
+      @model_class.reflect_on_all_associations(:belongs_to).map{ |r|
+        foreign_keys[r.association_foreign_key.to_sym] = r.name
+      }
+      foreign_keys
+    end
+
+    def move_records(params)
+      if defined?(ActsAsList) && @model_class.ancestors.include?(ActsAsList::InstanceMethods)
+        ids = JSON.parse(params[:ids]).reverse
+        ids.each_with_index do |id, i|
+          r = @model_class.find(id)
+          r.insert_at(params[:new_index].to_i + i + 1)
+        end
+        on_data_changed
+      else
+        raise RuntimeError, "Model class should implement 'acts_as_list' to support reordering records"
+      end
+    end
+
+    # Returns association and association method for a column
+    def assoc_and_assoc_method_for_attr(column_name)
+      assoc_name, assoc_method = column_name.split('__')
+      assoc = @model_class.reflect_on_association(assoc_name.to_sym) if assoc_method
+      [assoc, assoc_method]
+    end
+
+
+    # An ActiveRecord::Relation instance encapsulating all the necessary conditions.
+    def get_relation(params = {})
+      @arel = @model_class.arel_table
+
+      relation = @model_class.scoped
+
+      relation = apply_column_filters(relation, params[:filter]) if params[:filter]
+
+      if params[:extra_conditions]
+        extra_conditions = normalize_extra_conditions(ActiveSupport::JSON.decode(params[:extra_conditions]))
+        relation = relation.extend_with_netzke_conditions(extra_conditions) if params[:extra_conditions]
+      end
+
+      query = params[:query] && ActiveSupport::JSON.decode(params[:query])
+
+      if query.present?
+        # array of arrays of conditions that should be joined by OR
+        and_predicates = query.map do |conditions|
+          predicates_for_and_conditions(conditions)
+        end
+
+        # join them by OR
+        predicates = and_predicates[1..-1].inject(and_predicates.first){ |r,c| r.or(c) }
+      end
+
+      relation = relation.where(predicates)
+
+      relation = relation.extend_with(params[:scope]) if params[:scope]
+
+      relation
+    end
+
+    # Parses and applies grid column filters, calling consequent "where" methods on the passed relation.
+    # Returns the updated relation.
+    #
+    # 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:
+    #
+    #      relation.where(["id > ?", 10]).where(["food_name like ?", "%pizza%"])
+    def apply_column_filters(relation, column_filter)
+      res = relation
+      operator_map = {"lt" => "<", "gt" => ">", "eq" => "="}
+
+      # these are still JSON-encoded due to the migration to Ext.direct
+      column_filter=JSON.parse(column_filter)
+      column_filter.each do |v|
+        assoc, method = v["field"].split('__')
+        if method
+          assoc = @model_class.reflect_on_association(assoc.to_sym)
+          field = [assoc.klass.table_name, method].join('.').to_sym
+        else
+          field = assoc.to_sym
+        end
+
+        value = v["value"]
+
+        op = operator_map[v['comparison']]
+
+        case v["type"]
+        when "string"
+          res = res.where(["#{field} like ?", "%#{value}%"])
+        when "date"
+          # convert value to the DB date
+          value.match /(\d\d)\/(\d\d)\/(\d\d\d\d)/
+          res = res.where("#{field} #{op} ?", "#{$3}-#{$1}-#{$2}")
+        when "numeric"
+          res = res.where(["#{field} #{op} ?", value])
+        else
+          res = res.where(["#{field} = ?", value])
+        end
+      end
+
+      res
+    end
+
+    def predicates_for_and_conditions(conditions)
+      return nil if conditions.empty?
+
+      predicates = conditions.map do |q|
+        value = q["value"]
+        case q["operator"]
+        when "contains"
+          @arel[q["attr"]].matches "%#{value}%"
+        else
+          if value == false || value == true
+            @arel[q["attr"]].eq(value ? 1 : 0)
+          else
+            @arel[q["attr"]].send(q["operator"], value)
+          end
+        end
+      end
+
+      # join them by AND
+      predicates[1..-1].inject(predicates.first){ |r,p| r.and(p)  }
+    end
+
+  end
+end

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

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