netzke-basepack-zh 0.7.6

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

@@ -0,0 +1,144 @@
+require "netzke/basepack/form_panel/fields"
+require "netzke/basepack/form_panel/services"
+# require "netzke/plugins/configuration_tool"
+
+module Netzke
+  module Basepack
+    # Ext.form.Panel-based component
+    #
+    # == Netzke-specific config options
+    #
+    # * +model+ - name of the ActiveRecord model that provides data to this GridPanel.
+    # * +record+ - record to be displayd in the form. Takes precedence over +:record_id+
+    # * +record_id+ - id of the record to be displayd in the form. Also see +:record+
+    # * +items+ - the layout of the fields as an array. See "Layout configuration".
+    # * +mode+ - render mode, accepted options:
+    #   * +lockable+ - makes the form panel load initially in "display mode", then lets "unlock" it, change the values, and "lock" it again, while updating the values on the server
+    # * +updateMask+ - +Ext.LoadMask+ config options for the mask shown while the form is submitting its values
+    #
+    # === Layout configuration
+    #
+    # The layout of the form is configured by supplying the +item+ config option, same way it would be configured in Ext (thus allowing for complex form layouts). FormPanel will expand fields by looking at their names (unless +no_binding+ set to +true+ is specified for a specific field).
+    #
+    # == Endpoints
+    # FormPanel implements the following endpoints:
+    #
+    # * +netzke_load+ - loads a record with a given id from the server, e.g.:
+    #
+    #     someFormPanel.netzkeLoad({id: 100});
+    #
+    # * +netzke_submit+ - gets called when the form gets submitted (e.g. by pressing the Apply button, or by calling onApply)
+    # * +get_combobox_options+ - gets called when a 'remote' combobox field gets expanded
+    class FormPanel < Netzke::Base
+
+      js_base_class "Ext.form.Panel"
+
+      # Class-level configuration
+      class_attribute :config_tool_available
+      self.config_tool_available = true
+
+      include self::Services
+      include self::Fields
+      include Netzke::Basepack::DataAccessor
+
+      delegates_to_dsl :model, :record_id
+
+      action :apply do
+        {
+          :text => I18n.t('netzke.basepack.form_panel.actions.apply'),
+          :tooltip => I18n.t('netzke.basepack.form_panel.actions.apply_tooltip'),
+          :icon => :tick
+        }
+      end
+
+      action :edit do
+        {
+          :text => I18n.t('netzke.basepack.form_panel.actions.edit'),
+          :tooltip => I18n.t('netzke.basepack.form_panel.actions.edit_tooltip'),
+          :icon => :pencil
+        }
+      end
+
+      action :cancel do
+        {
+          :text => I18n.t('netzke.basepack.form_panel.actions.cancel'),
+          :tooltip => I18n.t('netzke.basepack.form_panel.actions.cancel_tooltip'),
+          :icon => :cancel
+        }
+      end
+
+      def configuration
+        super.tap do |sup|
+          configure_locked(sup)
+          configure_bbar(sup)
+
+          sup[:record_id] = sup[:record] = nil if sup[:multi_edit] # never set record_id in multi-edit mode
+        end
+      end
+
+      def configure_locked(c)
+        c[:locked] = c[:locked].nil? ? (c[:mode] == :lockable) : c[:locked]
+      end
+
+      def configure_bbar(c)
+        c[:bbar] = [:apply.action] if c[:bbar].nil? && !c[:read_only]
+      end
+
+      # Extra JavaScripts and stylesheets
+      js_mixin :form_panel
+      js_include :comma_list_cbg
+      js_include :n_radio_group, :readonly_mode
+      css_include :readonly_mode
+
+      # WIP
+      # js_include Netzke::Core.ext_path.join("examples/ux/fileuploadfield/FileUploadField.js")
+      # css_include Netzke::Core.ext_path.join("examples/ux/fileuploadfield/css/fileuploadfield.css")
+
+      # WIP: Needed for FileUploadField
+      # js_include :misc
+
+      def js_config
+        super.tap do |res|
+          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.netzke_hash(fields).merge(:_meta => meta_field).literalize_keys
+      end
+
+      def record
+        @record ||= config[:record] || config[:record_id] && data_class && data_adapter.find_record(config[:record_id])
+      end
+
+      private
+
+        def self.server_side_config_options
+          super + [:record, :scope]
+        end
+
+        def meta_field
+          {}.tap do |res|
+            assoc_values = get_association_values
+            res[:association_values] = assoc_values.literalize_keys if record && !assoc_values.empty?
+          end
+        end
+
+        def get_association_values
+          fields_that_need_associated_values = fields.select{ |k,v| k.to_s.index("__") && !fields[k][:nested_attribute] }
+          # Take care of Ruby 1.8.7
+          if fields_that_need_associated_values.is_a?(Array)
+            fields_that_need_associated_values = fields_that_need_associated_values.inject({}){|r,(k,v)| r.merge(k => v)}
+          end
+
+          fields_that_need_associated_values.each_pair.inject({}) do |r,(k,v)|
+            r.merge(k => record.value_for_attribute(fields_that_need_associated_values[k], true))
+          end
+        end
+
+      # include ::Netzke::Plugins::ConfigurationTool if config_tool_available # it will load ConfigurationPanel into a modal window
+    end
+  end
+end

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

@@ -0,0 +1,208 @@
+module Netzke
+  module Basepack
+    class FormPanel < Netzke::Base
+      # Because FormPanel allows for arbitrary layout of fields, we need to have all fields configured in one place (the +fields+ method), and then have references to those fields from +items+.
+      module Fields
+        extend ActiveSupport::Concern
+
+        # Items with normalized fields (i.e. containing all the necessary attributes needed by Ext.form.FormPanel to render a field)
+        def items
+          @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.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
+
+        # Hash of fully configured fields, that are referenced in the items. E.g.:
+        #   {
+        #     :role__name => {:xtype => 'netzkeremotecombo', :disabled => true, :value => "admin"},
+        #     :created_at => {:xtype => 'datetime', :disabled => true, :value => "2010-10-10 10:10"}
+        #   }
+        def fields
+          @fields ||= begin
+            if static_layout?
+              # extract incomplete field configs from +config+
+              flds = fields_from_config
+              # and merged them with fields from the model
+              deep_merge_existing_fields(flds, fields_from_model) if data_class
+            else
+              # extract flds configs from the model
+              flds = fields_from_model
+            end
+            flds
+          end
+        end
+
+        # The array of fields as specified on the model level (using +netzke_attribute+ and alike)
+        def fields_array_from_model
+          data_class && data_class.netzke_attributes
+        end
+
+        # Hash of fields as specified on the model level
+        def fields_from_model
+          @fields_from_model ||= fields_array_from_model && fields_array_from_model.inject({}){ |hsh, f| hsh.merge(f[:name].to_sym => f) }
+        end
+
+        # Hash of normalized field configs extracted from :items, e.g.:
+        #
+        #     {:role__name => {:xtype => "netzkeremotecombo"}, :password => {:xtype => "passwordfield"}}
+        def fields_from_config
+          items if @fields_from_config.nil? # by calling +items+ we initiate building of @fields_from_config
+          @fields_from_config ||= {}
+        end
+
+        module ClassMethods
+          # Columns to be displayed by the FieldConfigurator, "meta-columns". Each corresponds to a configuration
+          # option for each field in the form.
+          def meta_columns
+            [
+              {:name => "included", :attr_type => :boolean, :width => 40, :header => "Incl", :default_value => true},
+              {:name => "name", :attr_type => :string, :editor => :netzkeremotecombo, :width => 200},
+              {:name => "label", :attr_type => :string, :header => "Label"},
+              {:name => "default_value", :attr_type => :string}
+            ]
+          end
+        end
+
+        private
+          def load_persistent_fields
+            # NetzkeFieldList.read_list(global_id) if persistent_config_enabled?
+          end
+
+          def load_model_level_attrs
+            # NetzkeModelAttrList.read_list(data_class.name) if persistent_config_enabled? && data_class
+          end
+
+          # This is where we expand our basic field config with all the defaults
+          def normalize_field(field)
+            # field can only be a string, a symbol, or a hash
+            if field.is_a?(Hash)
+              field = field.dup # we don't want to modify original hash
+              return field if field[:no_binding] # stop here if no normalization is needed
+              field[:name] = field[:name].to_s if field[:name] # all names should be strings
+            else
+              field = {:name => field.to_s}
+            end
+
+            field_from_model = fields_from_model && fields_from_model[field[:name].to_sym]
+
+            field_from_model && field.merge!(field_from_model)
+
+            detect_association_with_method(field) # xtype for an association field
+            set_default_field_label(field)
+            set_default_field_xtype(field) if field[:xtype].nil?
+            set_default_read_only(field)
+
+            # temporal datetime setup, while we don't have real datetime field
+            if field[:attr_type] == :date
+              field[:format] ||= "Y-m-d"
+            end
+
+            # provide our special combobox with our id
+            field[:parent_id] = self.global_id if field[:xtype] == :netzkeremotecombo
+
+            field[:hidden] = field[:hide_label] = true if field[:hidden].nil? && primary_key_attr?(field)
+
+            # checkbox setup
+            field[:checked] = field[:value] if field[:attr_type] == :boolean
+            field[:input_value] = true if field[:attr_type] == :boolean
+
+            field
+          end
+
+          # Sets the proper xtype of an asociation field
+          def detect_association_with_method(c)
+            if c[:name].index('__')
+              assoc_name, method = c[:name].split('__').map(&:to_sym)
+              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
+
+          # RECURSIVELY extracts fields configuration from :items
+          def normalize_fields(items)
+            @fields_from_config ||= {}
+            items.map do |item|
+              # at this moment, item is a hash or a symbol
+              if is_field_config?(item)
+                item = normalize_field(item)
+                @fields_from_config[item[:name].to_sym] = item
+                item #.reject{ |k,v| k == :name } # do we really need to remove the :name key?
+              elsif item.is_a?(Hash)
+                item = item.dup # we don't want to modify original hash
+                item[:items].is_a?(Array) ? item.merge(:items => normalize_fields(item[:items])) : item
+              else
+                item
+              end
+            end
+          end
+
+          def is_field_config?(item)
+            item.is_a?(String) || item.is_a?(Symbol) || item[:name] # && !is_component_config?(item)
+          end
+
+          # Deeply merges only those key/values at the top level that are already there
+          def deep_merge_existing_fields(dest, src)
+            dest.each_pair do |k,v|
+              v.deep_merge!(src[k] || {})
+            end
+          end
+
+          def set_default_field_label(c)
+            # multiple spaces (in case of association attrs) get replaced with one
+            c[:field_label] ||= data_class ? data_class.human_attribute_name(c[:name]) : c[:name].humanize
+            c[:field_label].gsub!(/\s+/, " ")
+          end
+
+          def set_default_field_xtype(field)
+            field[:xtype] = xtype_for_attr_type(field[:attr_type]) unless xtype_for_attr_type(field[:attr_type]).nil?
+          end
+
+          def set_default_read_only(field)
+            enabled_if = !data_class || data_class.column_names.include?(field[:name])
+            enabled_if ||= data_class.instance_methods.map(&:to_s).include?("#{field[:name]}=")
+            enabled_if ||= record && record.respond_to?("#{field[:name]}=")
+            enabled_if ||= association_attr?(field[:name])
+
+            field[:read_only] = !enabled_if if field[:read_only].nil?
+          end
+
+          def attr_type_to_xtype_map
+            {
+              :integer => :numberfield,
+              :boolean => config[:multi_edit] ? :tricheckbox : :checkboxfield,
+              :date => :datefield,
+              :datetime => :xdatetime,
+              :text => :textarea,
+              :json => :jsonfield,
+              :string => :textfield
+            }
+          end
+
+          def xtype_for_attr_type(type)
+            attr_type_to_xtype_map[type] || :textfield
+          end
+
+          def xtype_for_association
+            :netzkeremotecombo
+          end
+
+          # Are we provided with a static field layout?
+          def static_layout?
+            !!config[:items]
+          end
+
+      end
+    end
+  end
+end