netzke-basepack 0.7.7 → 0.8.0

data/lib/netzke/basepack/grid_panel/record_form_window.rb

@@ -1,41 +0,0 @@
-module Netzke
-  module Basepack
-    class GridPanel < Netzke::Base
-      class RecordFormWindow < Window
-
-        js_properties :button_align => :right,
-                      :width => 400,
-                      :auto_height => true,
-                      :modal => true,
-                      :fbar => [:ok.action, :cancel.action]
-
-        action :ok do
-          { :text => I18n.t('netzke.basepack.grid_panel.record_form_window.actions.ok')}
-        end
-
-        action :cancel do
-          { :text => I18n.t('netzke.basepack.grid_panel.record_form_window.actions.cancel')}
-        end
-
-        js_method :init_component, <<-JS
-          function(params){
-            this.callParent();
-            this.items.first().on("submitsuccess", function(){ this.closeRes = "ok"; this.close(); }, this);
-          }
-        JS
-
-        js_method :on_ok, <<-JS
-          function(params){
-            this.items.first().onApply();
-          }
-        JS
-
-        js_method :on_cancel, <<-JS
-          function(params){
-            this.close();
-          }
-        JS
-      end
-    end
-  end
-end

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

@@ -1,235 +0,0 @@
-module Netzke
-  module Basepack
-    class GridPanel < Netzke::Base
-      module Services
-        extend ActiveSupport::Concern
-
-        included do
-
-          endpoint :get_data do |params|
-            get_data(params)
-          end
-
-          endpoint :post_data do |params|
-            mod_records = {}
-            [:create, :update].each do |operation|
-              data = ActiveSupport::JSON.decode(params["#{operation}d_records"]) if params["#{operation}d_records"]
-              if !data.nil? && !data.empty? # data may be nil for one of the operations
-                mod_records[operation] = process_data(data, operation)
-                mod_records[operation] = nil if mod_records[operation].empty?
-              end
-            end
-
-            on_data_changed
-
-            {
-              :update_new_records => mod_records[:create],
-              :update_mod_records => mod_records[:update] || {},
-              :netzke_feedback => @flash
-            }
-          end
-
-          endpoint :delete_data do |params|
-            if !config[:prohibit_delete]
-              record_ids = ActiveSupport::JSON.decode(params[:records])
-              data_adapter.destroy(record_ids)
-              on_data_changed
-              {:netzke_feedback => I18n.t('netzke.basepack.grid_panel.deleted_n_records', :n => record_ids.size), :load_store_data => get_data}
-            else
-              {:netzke_feedback => I18n.t('netzke.basepack.grid_panel.cannot_delete')}
-            end
-          end
-
-          endpoint :resize_column do |params|
-            raise "Called resize_column endpoint while not configured to do so" if !config[:persistence]
-            current_columns_order = state[:columns_order] || initial_columns_order
-            current_columns_order[normalize_index(params[:index].to_i)][:width] = params[:size].to_i
-            update_state(:columns_order, current_columns_order)
-            {}
-          end
-
-          endpoint :move_column do |params|
-            raise "Called move_column endpoint while not configured to do so" if !config[:persistence]
-            remove_from = normalize_index(params[:old_index].to_i)
-            insert_to = normalize_index(params[:new_index].to_i)
-
-            current_columns_order = state[:columns_order] || initial_columns_order
-
-            column_to_move = current_columns_order.delete_at(remove_from)
-            current_columns_order.insert(insert_to, column_to_move)
-
-            update_state(:columns_order, current_columns_order)
-
-            {}
-          end
-
-          endpoint :hide_column do |params|
-            raise "Called hide_column endpoint while not configured to do so" if !config[:persistence]
-            current_columns_order = state[:columns_order] || initial_columns_order
-            current_columns_order[normalize_index(params[:index].to_i)][:hidden] = params[:hidden]
-            update_state(:columns_order, current_columns_order)
-            {}
-          end
-
-          # Returns choices for a column
-          endpoint :get_combobox_options do |params|
-            query = params[:query]
-
-            column = columns.detect{ |c| c[:name] == params[:column] }
-            scope = column.to_options[:scope] || column.to_options[:editor].try(:fetch, :scope, nil)
-            query = params[:query]
-
-            {:data => combobox_options_for_column(column, :query => query, :scope => scope, :record_id => params[:id])}
-          end
-
-          endpoint :move_rows do |params|
-            data_adapter.move_records(params)
-            {}
-          end
-
-        end
-        #
-        # Some components' overridden endpoints
-        #
-
-        ## Edit in form specific endpoint
-        def add_form__form_panel0__netzke_submit_endpoint(params)
-          res = component_instance(:add_form__form_panel0).netzke_submit(params)
-
-          if res[:set_form_values]
-            # successful creation
-            on_data_changed
-            res[:set_form_values] = nil
-          end
-          res.to_nifty_json
-        end
-
-        def edit_form__form_panel0__netzke_submit_endpoint(params)
-          res = component_instance(:edit_form__form_panel0).netzke_submit(params)
-
-          if res[:set_form_values]
-            on_data_changed
-            res[:set_form_values] = nil
-          end
-
-          res.to_nifty_json
-        end
-
-        def multi_edit_form__multi_edit_form0__netzke_submit_endpoint(params)
-          ids = ActiveSupport::JSON.decode(params.delete(:ids))
-          data = ids.collect{ |id| ActiveSupport::JSON.decode(params[:data]).merge("id" => id) }
-
-          data.map!{|el| el.delete_if{ |k,v| v.is_a?(String) && v.blank? }} # only interested in set values
-
-          mod_records_count = process_data(data, :update).count
-
-          # remove duplicated flash messages
-          @flash = @flash.inject([]){ |r,hsh| r.include?(hsh) ? r : r.push(hsh) }
-
-          if mod_records_count > 0
-            on_data_changed
-            {:set_result => "ok", :netzke_feedback => @flash}.to_nifty_json
-          else
-            {:netzke_feedback => @flash}.to_nifty_json
-          end
-        end
-
-        # When providing the edit_form component, fill in the form with the requested record
-        def deliver_component_endpoint(params)
-          components[:edit_form][:items].first.merge!(:record_id => params[:record_id].to_i) if params[:name] == 'edit_form'
-          super
-        end
-
-        # Implementation for the "get_data" endpoint
-        def get_data(*args)
-          params = args.first || {} # params are optional!
-          if !config[:prohibit_read]
-            {}.tap do |res|
-              records = get_records(params)
-              res[:data] = records.map{|r| r.netzke_array(columns(:with_meta => true))}
-              res[:total] = count_records(params)  if config[:enable_pagination]
-            end
-          else
-            flash :error => "You don't have permissions to read data"
-            { :netzke_feedback => @flash }
-          end
-        end
-
-        protected
-
-          # Returns an array of records.
-          def get_records(params)
-            params[:limit] = config[:rows_per_page] if config[:enable_pagination]
-            params[:scope] = config[:scope] # note, params[:scope] becomes ActiveSupport::HashWithIndifferentAccess
-
-            data_adapter.get_records(params, columns)
-          end
-
-          def count_records(params)
-            params[:scope] = config[:scope] # note, params[:scope] becomes ActiveSupport::HashWithIndifferentAccess
-
-            data_adapter.count_records(params, columns)
-          end
-
-          # Override this method to react on each operation that caused changing of data
-          def on_data_changed; end
-
-          # Given an index of a column among enabled (non-excluded) columns, provides the index (position) in the table
-          def normalize_index(index)
-            norm_index = 0
-            index.times do
-              while true do
-                norm_index += 1
-                break unless columns[norm_index][:included] == false
-              end
-            end
-            norm_index
-          end
-
-          # Params:
-          # <tt>:operation</tt>: :update or :create
-          def process_data(data, operation)
-            success = true
-            mod_records = {}
-            if !config[:"prohibit_#{operation}"]
-              modified_records = 0
-              data.each do |record_hash|
-                id = record_hash.delete('id')
-                record = operation == :create ? data_adapter.new_record : data_adapter.find_record(id)
-                success = true
-
-                # merge with strong default attirbutes
-                record_hash.merge!(config[:strong_default_attrs]) if config[:strong_default_attrs]
-
-                record_hash.each_pair do |k,v|
-                  record.set_value_for_attribute(columns_hash[k.to_sym].nil? ? {:name => k} : columns_hash[k.to_sym], v)
-                end
-
-                # try to save
-                mod_records[id] = record.netzke_array(columns(:with_meta => true)) if success && record.save
-
-                # flash eventual errors
-                if !record.errors.empty?
-                  success = false
-                  record.errors.to_a.each do |msg|
-                    flash :error => msg
-                  end
-                end
-              end
-            else
-              success = false
-              flash :error => "You don't have permissions to #{operation} data"
-            end
-            mod_records
-          end
-
-          def normalize_extra_conditions(conditions)
-            conditions.each_pair do |k,v|
-              conditions[k] = "%#{v}%" if ["like", "matches"].include?(k.to_s.split("__").last)
-            end
-          end
-
-      end
-    end
-  end
-end

data/lib/netzke/basepack/panel.rb

@@ -1,11 +0,0 @@
-module Netzke
-  module Basepack
-    class Panel < Netzke::Base
-      js_method :update_body_html, <<-JS
-        function(html){
-          this.body.update(html);
-        }
-      JS
-    end
-  end
-end

data/lib/netzke/basepack/wrapper.rb

@@ -1,28 +0,0 @@
-module Netzke
-  module Basepack
-    # = Wrapper
-    #
-    # Simple Ext.Panel with layout 'fit' that wraps up another Netzke component. Can be useful in HTML pages where
-    # a component should be dynamically configured, to not reload the entire page after configuration (Wrapper
-    # will reload the component automatically).
-    #
-    # == Configuration
-    # * <tt>:item</tt> - configuration hash for wrapped component
-    #
-    # Example:
-    #
-    #   netzke :wrapper, :item => {
-    #     :class_name => "FormPanel",
-    #     :model => "User"
-    #   }
-    class Wrapper < Netzke::Base
-      js_properties(
-        :layout => 'fit',
-
-        # invisible
-        :header => false,
-        :border => false
-      )
-    end
-  end
-end

data/lib/netzke/data_mapper.rb

@@ -1,18 +0,0 @@
-require 'netzke/data_mapper/attributes'
-require 'netzke/data_mapper/combobox_options'
-require 'netzke/data_mapper/relation_extensions'
-
-module Netzke
-  module DataMapper
-  end
-end
-
-if defined? DataMapper
-  # Extend DataMapper
-
-  DataMapper::Model.append_extensions(Netzke::DataMapper::Attributes::ClassMethods)
-  DataMapper::Model.append_inclusions(Netzke::DataMapper::Attributes)
-  DataMapper::Model.append_extensions(Netzke::DataMapper::ComboboxOptions)
-  DataMapper::Model.append_extensions(Netzke::DataMapper::RelationExtensions)
-end
-

data/lib/netzke/data_mapper/attributes.rb

@@ -1,273 +0,0 @@
-module Netzke
-  module DataMapper
-    module Attributes
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :netzke_declared_attr
-        self.netzke_declared_attr = []
-
-        class_attribute :netzke_excluded_attr
-        self.netzke_excluded_attr = []
-
-        class_attribute :netzke_exposed_attr
-      end
-
-      module ClassMethods
-        def data_adapter
-          Netzke::Basepack::DataAdapters::AbstractAdapter.adapter_class(self).new(self)
-        end
-
-        # Define or configure an attribute.
-        # Example:
-        #   netzke_attribute :recent, :type => :boolean, :read_only => true
-        def netzke_attribute(name, options = {})
-          name = name.to_s
-          options[:attr_type] = options.delete(:type) || options.delete(:attr_type) || :string
-          declared_attrs = self.netzke_declared_attr.dup
-          # if the attr was declared already, simply merge it with the new options
-          existing = declared_attrs.detect{ |va| va[:name] == name }
-          if existing
-            existing.merge!(options)
-          else
-            attr_config = {:name => name}.merge(options)
-            # if primary_key, insert in front, otherwise append
-            if name == self.primary_key
-              declared_attrs.insert(0, attr_config)
-            else
-              declared_attrs << {:name => name}.merge(options)
-            end
-          end
-          self.netzke_declared_attr = declared_attrs
-        end
-
-        # Exclude attributes from being picked up by grids and forms.
-        # Accepts an array of attribute names (as symbols).
-        # Example:
-        #   netzke_expose_attributes :created_at, :updated_at, :crypted_password
-        def netzke_exclude_attributes(*args)
-          self.netzke_excluded_attr = args.map(&:to_s)
-        end
-
-        # Explicitly expose attributes that should be picked up by grids and forms.
-        # Accepts an array of attribute names (as symbols).
-        # Takes precedence over <tt>netzke_exclude_attributes</tt>.
-        # Example:
-        #   netzke_expose_attributes :name, :role__name
-        def netzke_expose_attributes(*args)
-          self.netzke_exposed_attr = args.map(&:to_s)
-        end
-
-        # Returns the attributes that will be picked up by grids and forms.
-        def netzke_attributes
-          exposed = netzke_exposed_attributes
-          exposed ? netzke_attrs_in_forced_order(exposed) : netzke_attrs_in_natural_order
-        end
-
-        def netzke_attribute_hash
-          netzke_attributes.inject({}){ |r,a| r.merge(a[:name].to_sym => a) }
-        end
-
-        def netzke_exposed_attributes
-          exposed = self.netzke_exposed_attr
-          if exposed && !exposed.include?(self.primary_key)
-            # automatically declare primary key as a netzke attribute
-            netzke_attribute(self.primary_key)
-            exposed.insert(0, self.primary_key)
-          end
-          exposed
-        end
-
-        def primary_key
-          key.first.name.to_s
-        end
-
-        def column_names
-          properties.map(&:name).map(&:to_s)
-        end
-
-        def columns
-          properties
-        end
-
-        def columns_hash
-          properties.inject({}) { |hsh, prop|
-            hsh[prop.name.to_s] = prop
-            hsh
-          }
-        end
-
-        def property_with(name)
-          properties.find{|p| p.name == name.to_sym}
-        end
-
-        private
-        def netzke_attrs_in_forced_order(attrs)
-          attrs.collect do |attr_name|
-            declared = self.netzke_declared_attr.detect { |va| va[:name] == attr_name } || {}
-            in_columns_hash = columns_hash[attr_name] && {:name => attr_name, :attr_type => data_adapter.map_type(columns_hash[attr_name].class), :default_value => columns_hash[attr_name].default} || {} # {:virtual => true} # if nothing found in columns, mark it as "virtual" or not?
-            if in_columns_hash.empty?
-              # If not among the model columns, it's either virtual, or an association
-              merged = association_attr?(attr_name) ? declared.merge!(:name => attr_name) : declared.merge(:virtual => true)
-            else
-              # .. otherwise merge with what's declared
-              merged = in_columns_hash.merge(declared)
-            end
-
-            # We didn't find it among declared, nor among the model columns, nor does it seem association attribute
-            merged[:name].nil? && raise(ArgumentError, "Unknown attribute '#{attr_name}' for model #{self.name}", caller)
-
-            merged
-          end
-        end
-
-        # Returns netzke attributes in the order of columns in the table, followed by extra declared attributes
-        # Detects one-to-many association columns and replaces the name of the column with association column name (Netzke style), e.g.:
-        #
-        #   role_id => role__name
-        def netzke_attrs_in_natural_order
-          (
-            declared_attrs = self.netzke_declared_attr
-
-            column_names.map do |name|
-              c = {:name => name, :attr_type => data_adapter.map_type(property_with(name).class)}
-
-              # If it's named as foreign key of some association, then it's an association column
-              # assoc = reflect_on_all_associations.detect { |a| foreign_key_for_assoc(a) == c[:name] }
-              assoc = relationships.detect { |r| r.child_key.first.name.to_s == c[:name] }
-              if assoc
-                assoc_class = assoc.parent_model
-                candidates = %w{name title label} << c[:name]
-                assoc_method = candidates.detect{|m| (assoc_class.instance_methods.map(&:to_s) + assoc_class.column_names).include?(m) }
-                c[:name] = "#{assoc.name}__#{assoc_method}"
-                c[:attr_type] = data_adapter.map_type(columns_hash[assoc_method]).try(:class) || :string # when it's an instance method rather than a column, fall back to :string
-              end
-
-              # auto set up the default value from the column settings
-              c.merge!(:default_value => property_with(name).default) if property_with(name).default
-
-              # if there's a declared attr with the same name, simply merge it with what's taken from the model's columns
-              if declared = declared_attrs.detect{ |va| va[:name] == c[:name] }
-                c.merge!(declared)
-                declared_attrs.delete(declared)
-              end
-              c
-            end +
-            declared_attrs
-          ).reject { |attr| self.netzke_excluded_attr.include?(attr[:name]) }
-        end
-
-        def association_attr?(attr_name)
-          !!attr_name.index("__") # probably we can't do much better than this, as we don't know at this moment if the associated model has a specific attribute, and we don't really want to find it out
-        end
-      end
-
-      # Transforms a record to array of values according to the passed attributes
-      def netzke_array(attributes = self.class.netzke_attributes)
-        res = []
-        for a in attributes
-          next if a[:included] == false
-          res << value_for_attribute(a, a[:nested_attribute])
-        end
-        res
-      end
-
-      def netzke_json
-        netzke_hash.to_nifty_json
-      end
-
-      # Accepts both hash and array of attributes
-      def netzke_hash(attributes = self.class.netzke_attributes)
-        res = {}
-        for a in (attributes.is_a?(Hash) ? attributes.values : attributes)
-          next if a[:included] == false
-          res[a[:name].to_sym] = self.value_for_attribute(a, a[:nested_attribute])
-        end
-        res
-      end
-
-      # Fetches the value specified by an (association) attribute
-      # If +through_association+ is true, get the value of the association by provided method, *not* the associated record's id
-      # E.g., author__name with through_association set to true may return "Vladimir Nabokov", while with through_association set to false, it'll return author_id for the current record
-      def value_for_attribute(a, through_association = false)
-        v = if a[:getter]
-              a[:getter].call(self)
-            elsif respond_to?("#{a[:name]}")
-              send("#{a[:name]}")
-            elsif is_association_attr?(a)
-              split = a[:name].to_s.split(/\.|__/)
-              assoc = self.class.relationships[split.first.to_sym]
-
-              if through_association
-                split.inject(self) do |r,m| # TODO: do we really need to descend deeper than 1 level?
-                  if r.respond_to?(m)
-                    r.send(m)
-                  else
-                    ::Rails.logger.debug "Netzke::Basepack: Wrong attribute name: #{a[:name]}" unless r.nil?
-                    nil
-                  end
-                end
-              else
-                self.send assoc.child_key.first.name
-              end
-            end
-
-        # a work-around for to_json not taking the current timezone into account when serializing ActiveSupport::TimeWithZone
-        v = v.to_datetime.to_s(:db) if [ActiveSupport::TimeWithZone].include?(v.class)
-        v = v.to_s(:db) if [DateTime, Date].include?(v.class)
-        v
-      end
-
-      # Assigns new value to an (association) attribute
-      def set_value_for_attribute(a, v)
-        v = v.to_time_in_current_zone if v.is_a?(Date) # convert Date to Time
-
-        if a[:setter]
-          a[:setter].call(self, v)
-        elsif respond_to?("#{a[:name]}=")
-          send("#{a[:name]}=", v)
-        elsif is_association_attr?(a)
-          split = a[:name].to_s.split(/\.|__/)
-          if a[:nested_attribute]
-            # We want:
-            #     set_value_for_attribute({:name => :assoc_1__assoc_2__method, :nested_attribute => true}, 100)
-            # =>
-            #     self.assoc_1.assoc_2.method = 100
-            split.inject(self) { |r,m| m == split.last ? (r && r.send("#{m}=", v) && r.save) : r.send(m) }
-          else
-            if split.size == 2
-              # search for association and assign it to self
-              assoc_name, assoc_method = split
-              relationship=self.class.relationships[assoc_name]
-
-              if relationship
-                if relationship.kind_of? ::DataMapper::Associations::OneToOne::Relationship
-                  assoc_instance=self.send(assoc_name)
-                  if assoc_instance
-                    assoc_instance.send("#{assoc_method}=", v)
-                    assoc_instance.save # what should we do when this fails?..
-                  else
-                    # what should we do in this case?
-                  end
-                else
-                  self.send("#{self.class.data_adapter.foreign_key_for assoc_name}=", v)
-                end
-              else
-                ::Rails.logger.debug "Netzke::Basepack: Association #{assoc} is not known for class #{self.class.name}"
-              end
-            else
-              ::Rails.logger.debug "Netzke::Basepack: Wrong attribute name: #{a[:name]}"
-            end
-          end
-        end
-      end
-
-      protected
-      # Returns true if passed attribute is an "association attribute"
-      def is_association_attr?(a)
-        # maybe the check is too simplistic, but will do for now
-        !!a[:name].to_s.index("__")
-      end
-    end
-  end
-end