toolbox 0.1.4 → 0.3.0

data/lib/toolbox/default_controller.rb

@@ -1,393 +0,0 @@
-require File.expand_path("../dirs", File.dirname(__FILE__))
-require 'fastercsv'
-
-module Toolbox
-
-  #
-  # Defines the default action.
-  #
-  module DefaultController
-
-    def self.setup #:nodoc:
-      ActionController::Base.send(:extend, ClassMethods)
-      #ActionController::Base.send(:include, InstanceMethods)
-      ActionView::Base.send(:include, HelperMethods)
-    end
-
-    module HelperMethods
-      def get_record
-        instance_variable_get ('@' + controller.model_name).to_sym
-      end
-
-      def context_menu_link(rec, context = nil)
-        if controller.respond_to? :menu_config
-          context_records = []
-          # get the record in show-mode
-          context_records << get_record if get_record.is_a? ActiveRecord::Base
-          context_records << context if context
-          p = {}
-          context_records.each { |r| p["#{r.class.name.to_s}_id".to_sym] = r }
-          ctx_url =send("context_menu_#{rec.class.to_s.underscore}_path".to_sym, rec, p)
-          link_to_function('&#9660;', "show_context_menu(event, '#{ctx_url}')")
-        else
-          ''
-        end
-      end
-
-      # returns html necessary to load javascript and css to make the toolbox work
-      def toolbox_includes()
-        return "" if @toolbox_already_included
-        @toolbox_already_included = true
-
-
-        js = javascript_include_tag "toolbox-#{Toolbox::VERSION}/toolbox", "toolbox-#{Toolbox::VERSION}/popup"
-        cs = stylesheet_link_tag 'toolbox/context_menu', 'toolbox/popup', 'toolbox/toolbox'
-        js + "\n" + cs + "\n"
-      end
-
-
-    end
-
-    module ClassMethods
-
-      # The listed associations are included in when using find together with
-      # search fields. Thus if a search field defintion contains "foreign" fields
-      # one may include the corresponding association.
-      def include_assoc *assoc
-        write_inheritable_attribute('include_assoc', assoc)
-      end
-
-    end
-
-    module InstanceMethods #:nodoc:all
-
-      def index
-        obj = paging
-        instance_variable_set :@recs, obj
-
-        respond_to do |format|
-          format.html  do
-            begin
-              render # allow to overwrite the view of an action
-            rescue  ActionView::MissingTemplate
-              render :template => 'toolbox/index'
-            end
-          end
-          format.xml  { render :xml => obj }
-        end
-      end
-
-      def show
-        rec = model_class.find(params[:id])
-        set_record rec
-
-        @show_config = show_config rec
-        @embedded_list = nil
-        if @show_config.embedded_lists.length > 0
-          prefix = params[:list] || @show_config.embedded_lists.first.prefix
-          @show_config.embedded_lists.each do |embedded_list|
-            @embedded_list = embedded_list if embedded_list.prefix == prefix
-          end
-        end
-
-        respond_to do |format|
-          format.html do
-            begin
-              render # allow to overwrite the view of an action
-            rescue ActionView::MissingTemplate
-              render :template => 'toolbox/show'
-            end
-          end
-          format.xml  { render :xml => rec }
-          format.pdf #{ render @show_config.pdf_options }
-          format.csv  { stream_csv show_csv(rec, params) }
-        end
-      end
-
-
-      def new
-        # Handle dublicate command
-        param_name = "#{model_name}_id".to_sym
-        attr = {}
-        attr = model_class.find(params[param_name]).attributes if params[param_name]
-        obj = model_class.new attr
-
-        set_record obj
-
-        # context support
-        # set all _id fields, if available from params
-        params.each_pair do | key,value |
-          if key.to_s.ends_with? '_id' and obj.respond_to? key + '='
-            obj.send(key + '=', value)
-          end
-        end
-
-        respond_to do |format|
-          format.html { render :template => 'toolbox/new' }
-          format.xml  { render :xml => obj }
-          format.js do
-            render :update do |page|
-              locals = {:widgetsets => controller.edit_config(obj).controlsets, :dialog => true }
-              page.replace_html  'dialog_id', :partial => "toolbox/form", :object => obj, :locals => locals
-              page << "$('dialog_id').popup.show();"
-            end
-          end
-        end
-      end
-
-      def edit
-        obj = model_class.find(params[:id])
-        set_record obj
-
-        respond_to do |format|
-          format.html { render :template => 'toolbox/edit' }
-          format.js do
-            render :update do |page|
-              locals = {:widgetsets => controller.edit_config(obj).controlsets, :dialog => true }
-              page.replace_html  'dialog_id', :partial => "toolbox/form", :object => obj, :locals => locals
-              page << "$('dialog_id').popup.show();"
-            end
-          end
-        end
-      end
-
-      def create
-        if params[:save] # save or ok clicked
-          p = params[model_name.to_sym]
-          preprocess_params nil, p
-          obj = model_class.new p
-          set_record obj
-
-          respond_to do |format|
-            if obj.save
-              obj = redirect_create obj if respond_to? :redirect_create
-              flash[:notice] = Messages.created % { :object => s_(controller_name.singularize.humanize.downcase)}
-              format.html { redirect_to(obj) }
-              format.js do
-                render :update do
-                  |page| page << 'window.location.reload();'  # TODO improvment?
-                end
-              end
-              format.xml  { render :xml => obj, :status => :created, :location => obj }
-            else
-              format.html { render :template => "toolbox/new" }
-              format.xml  { render :xml => obj.errors, :status => :unprocessable_entity }
-              format.js do
-                render :update do |page|
-                  locals = {:widgetsets => controller.edit_config(obj).controlsets, :dialog => true }
-                  page.replace_html  'dialog_id', :partial => "toolbox/form", :object => obj, :locals => locals
-                end
-              end
-            end
-          end
-        else # cancel clicked
-          redirect_to eval("#{controller_name}_path")
-        end
-      end
-
-
-      def update
-        obj = model_class.find(params[:id])
-        set_record obj
-
-        if params[:save]
-          par = params[model_name.to_sym]
-          preprocess_params obj, par
-          # Ensure that the the collection attributes exist - create them if not
-          # This is needed, if all collection items have been deleted.
-          edit_config(obj).controlsets.each do |controlset|
-            if controlset.collection_config
-              attr = Toolbox::Helpers.collection_attribute_name(controlset.collection_config, obj)
-              par[attr] ||= {}
-            end
-          end
-
-          respond_to do |format|
-            if obj.update_attributes(par)
-              flash[:notice] = Messages.updated % { :object => s_(controller_name.singularize.humanize.downcase)}
-              format.html { redirect_to(obj) }
-              format.xml  { head :ok }
-              format.js do
-                render :update do |page|
-                  page << 'window.location.reload();'  # TODO improve ?
-                end
-              end
-            else
-              format.html { render :template => "toolbox/edit" }
-              format.xml  { render :xml => obj.errors, :status => :unprocessable_entity }
-              format.js do
-                render :update do |page|
-                  locals = {:widgetsets => controller.edit_config(obj).controlsets, :dialog => true }
-                  page.replace_html  'dialog_id', :partial => "toolbox/form", :object => obj, :locals => locals
-                end
-              end
-            end
-          end
-        else # cancel clicked
-          respond_to do |format|
-            format.html { redirect_to(obj) }
-            format.xml  { head :ok }
-          end
-        end
-      end
-
-      def destroy
-        obj = model_class.find(params[:id])
-        set_record obj
-        obj.destroy
-
-        respond_to do |format|
-          format.html { redirect_to(send(controller_name + '_url')) }
-          format.xml  { head :ok }
-          format.js do
-            render :update do |page|
-              page << 'window.location.reload();' # TODO: improve?
-            end
-          end
-        end
-      end
-
-      def context_menu
-        rec = model_class.find(params[:id])
-        set_record rec
-        context = {}
-        params.select { |k,v| k.ends_with? '_id' }.each {|a| context[a[0]] = a[1] }
-        locals = { :context => context, :widget_list => menu_config(rec, context)}
-        respond_to do |format|
-          format.html { render :partial => "toolbox/context_menu", :object => rec, :locals => locals  }
-          format.js do
-            render :update do |page|
-              page.replace_html  'context_menu_id', :partial => "toolbox/context_menu", :object => rec, :locals => locals
-            end
-          end
-        end
-      end
-
-      def model_name
-        controller_name.singularize
-      end
-
-      def model_class
-        controller_name.classify.constantize
-      end
-
-      def embedded_list_collection rec
-        options = {}
-        options[:order] = Toolbox::Sorting.order_by params, @embedded_list.widget_list.widgets, @embedded_list.prefix
-        options[:include] = @embedded_list.include_assoc if @embedded_list.include_assoc
-        rec.send(@embedded_list.collection_config.model_method).find(:all, options)
-      end
-
-      protected
-
-      def stream_csv options
-        field_renderers = options[:widget_list].widgets.map { |f| Toolbox::FieldRenderer.new self, f }
-
-        csv_string = FasterCSV.generate do |csv|
-          # Title
-          csv << field_renderers.map { |fr| fr.label(false, false) }
-          options[:collection].each do |rec|
-            csv <<  field_renderers.map { |fr| fr.render_value(rec, false) }
-          end
-        end
-        send_data csv_string, :type => "text/csv",
-          :filename=> options[:filename],
-          :disposition => 'attachment'
-      end
-
-
-      # check the consitency between the visible input-field
-      # and the invisible id field of autocomplete fields and
-      # parses date-fields
-      def preprocess_params rec, params
-        edit_config(rec).controlsets.each do |controlset|
-          controlset.widget_list.widgets.each do |widget|
-            case widget.type
-              when :auto_complete
-              if controlset.collection_config
-                # remove autocomplete text field for new or existing entries
-                a = Toolbox::Helpers.collection_attribute_name(controlset.collection_config, rec)
-                coll = params[a]
-                if coll
-                  coll.each { |p| remove_autocomplete_text p, widget} if coll.is_a? Array
-                  coll.each_value { |p| remove_autocomplete_text p, widget} if coll.is_a? Hash
-                end
-                if rec # may also have new entries...
-                  a = Toolbox::Helpers.collection_attribute_name(controlset.collection_config, nil)
-                  coll = params[a] 
-                  coll.each { |p| remove_autocomplete_text p, widget} if coll
-                end
-              else
-                remove_autocomplete_text params, widget
-              end
-            when :date
-              #params[widget.name] = Date.strptime(params[widget.name], '%d.%m.%y')
-            end
-          end
-        end
-        params
-      end
-
-      # do the paging for the index
-      def paging
-        filter = (params[:query] || params[:filter] || '')
-        cond = Toolbox::Searching.create_search_condition filter, search_fields
-        order = Toolbox::Sorting.order_by params, index_config.widgets
-        options = { :page => params[:page], :conditions => cond }
-        options[:order] = order if order
-        options[:include] = include_assoc if include_assoc
-        if respond_to? :index_data
-          index_data.paginate options
-        else
-          model_class.paginate options
-        end
-      end
-
-      private
-
-      def remove_autocomplete_text param, widget
-        value = param.delete widget.name
-        param[widget.name.to_s.foreign_key] = nil if value == '' || value == nil
-      end
-
-      def set_record obj
-        instance_variable_set "@#{model_name}".to_sym, obj
-      end
-
-      def include_assoc
-        self.class.read_inheritable_attribute('include_assoc')
-      end
-
-    end
-
-  end
-
-  # needed for not to conflict with the textdomain from the application controller
-  module Messages #:nodoc:all
-    include GetText
-    bindtextdomain('toolbox', :path => Toolbox::Dirs::LOCALE)
-    def self.created
-      _('%{object} was successfully created.')
-    end
-    def self.updated
-      _('%{object} was successfully updated.')
-    end
-
-    def self.create
-      _('Create')
-    end
-
-    def self.save
-      _('Save')
-    end
-
-    def self.cancel
-      _('Cancel')
-    end
-
-    def self.nothing_found
-      _('Nothing found')
-    end
-  end
-
-end

data/lib/toolbox/helpers.rb

@@ -1,11 +0,0 @@
-
-module Toolbox
-  module Helpers
-
-    def self.collection_attribute_name collection_config, rec
-      new_or_existing = rec && !rec.new_record? ? 'existing' : 'new'
-      "#{new_or_existing}_#{collection_config.type.name.to_s.underscore}_attributes"
-    end
-
-  end
-end