erp_forms 2.0.6 → 2.1.0

data/app/controllers/erp_forms/erp_app/desktop/dynamic_forms/forms_controller.rb

@@ -2,7 +2,7 @@ class ErpForms::ErpApp::Desktop::DynamicForms::FormsController < ErpForms::ErpAp
   
   # get tree of dynamic models and forms
   def get_tree
-    models = params[:node] == "root" ? DynamicFormModel.all(:order => :model_name) : DynamicFormModel.find_all_by_id(id)
+    models = params[:node] == "root" ? DynamicFormModel.all(:order => :model_name) : DynamicFormModel.find_all_by_id(params[:id])
     tree = []
 
     models.each do |form_model|
@@ -13,10 +13,15 @@ class ErpForms::ErpApp::Desktop::DynamicForms::FormsController < ErpForms::ErpAp
         :text => form_model.model_name,
         :iconCls => 'icon-data',
         :id => "form_model_#{form_model.id}",
-        :modelId => form_model.id,
-        :isModel => true, 
+        :formModelId => form_model.id,
+        :isFormModel => true, 
+        :allow_comments => form_model.allow_comments, 
+        :allow_files => form_model.allow_files, 
+        :file_security_default => form_model.file_security_default, 
+        :show_in_multitask => form_model.show_in_multitask, 
         :isForm => false, 
         :leaf => false,
+        :expanded => true,
         :children => []
       }
 
@@ -27,9 +32,9 @@ class ErpForms::ErpApp::Desktop::DynamicForms::FormsController < ErpForms::ErpAp
           :iconCls => (form.default ? 'icon-document_ok' : 'icon-document'), 
           :id => "form_#{form.id}",
           :formId => form.id, 
-          :isModel => false, 
-          :isDefault => form.default,
-          :modelName => form_model.model_name,
+          :isFormModel => false, 
+          :isDefaultForm => form.default,
+          :formModelName => form_model.model_name,
           :isForm => true, 
           :leaf => true 
         }
@@ -46,15 +51,34 @@ class ErpForms::ErpApp::Desktop::DynamicForms::FormsController < ErpForms::ErpAp
 
   # get a single form definition
   def get_definition
-    form = DynamicForm.get_form(params[:model_name], params[:internal_identifier])
+    dform = DynamicForm.find_by_id(params[:id]) if params[:id]
+    dform = DynamicForm.get_form(params[:model_name], params[:internal_identifier]) if dform.nil? and params[:model_name]
+
+    if dform.nil?
+      render :json => {:success => false}
+    else
+      render :json => dform.definition
+    end
+  end
 
-    render :json => form.definition
+  # get a single form record
+  def get_record
+    dform = DynamicForm.find(params[:id]) rescue nil
+
+    unless dform.nil?
+      dform_hash = dform.to_hash
+      dform_hash[:created_by] = dform.created_by.username rescue 'Unknown'
+      dform_hash[:updated_by] = dform.updated_by.username rescue 'Unknown'
+      dform_hash[:created_at] = dform.created_at.getlocal.strftime(@@datetime_format)
+      dform_hash[:updated_at] = dform.updated_at.getlocal.strftime(@@datetime_format)      
+    end
+    render :json => [dform_hash]
   end
 
   # get a single form
   def get
     dform = DynamicForm.find_by_id(params[:id]) if params[:id]
-    dform = DynamicForm.get_form(params[:model_name]) if dform.nil? and params[:model_name]
+    dform = DynamicForm.get_form(params[:model_name], params[:internal_identifier]) if dform.nil? and params[:model_name]
 
     if dform.nil? 
       render :json => {:success => false, :error => "Don't know how to find form"} and return
@@ -70,25 +94,96 @@ class ErpForms::ErpApp::Desktop::DynamicForms::FormsController < ErpForms::ErpAp
 
   # get related data for a related field
   def related_field
-    related_model = params[:model].camelize.constantize
-    data = related_model.all
+    if params[:model].blank? or (params[:displayField].blank? and params[:search_fields].blank?)
+      render :inline => '[]'
+    else
+      related_model = params[:model].camelize.constantize
+      query = related_model
+
+      unless params[:search_fields].blank?
+        #related_searchbox
+        search_fields = params[:search_fields].split(',')
+        unless params[:query].blank?
+          sql = ''
+          search_fields.each_with_index do |f,i|
+            sql += " OR " if i > 0
+            sql += "UPPER(#{f}) LIKE UPPER('%#{params[:query]}%')"
+          end
+          query = query.where(sql)
+        end
+        query = query.paginate(:page => page, :per_page => per_page)
+      end
 
-    render :inline => data.to_json(:only => [:id, params[:displayField].to_sym])
+      total = query.count
+      data = query.all
+      render :inline => { :data => data, :total => total}.to_json
+    end
   end
 
   # delete dynamic form
   def delete
-    
+    dform = DynamicForm.find_by_id(params[:id])
+    unless dform.nil?
+      begin
+         dform.destroy 
+         render :json => {:success => true}
+      rescue Exception => e
+        render :json => {:success => false, :error => e.message} 
+      end         
+    else
+      render :json => {:success => false, :error => 'Could not find form.'}
+    end
   end
 
   # update dynamic form
   def update
-    
+    dform = DynamicForm.find_by_id(params[:id])
+    dform = assign_form_attributes(dform)
+    dform.updated_by_id = current_user.id
+
+    # update solr config for model (doesn't work yet)
+    # DynamicFormModel.get_constant(dform.model_name).sunspot_setup if $USE_SOLR_FOR_DYNAMIC_FORM_MODELS
+
+    if dform.save
+      render :json => {:success => true}
+    else
+      render :json => {:success => false}
+    end
   end
   
   # create dynamic form
   def create
-    
+    if params[:form_definition] and params[:description] and params[:model_name]
+      dform = DynamicForm.new
+      dform = assign_form_attributes(dform)
+      dform.dynamic_form_model_id = DynamicFormModel.find_by_model_name(params[:model_name]).id
+      dform.default = false
+      dform.created_by_id = current_user.id
+      if dform.save
+        render :json => {:success => true, :id => dform.id}
+      else
+        render :json => {:success => false}
+      end    
+    else
+      render :json => {:success => false, :error => 'Insufficient info to create form.'}
+    end
   end
   
+  protected
+  def assign_form_attributes(dform)
+    dform.description = params[:description] unless params[:description].nil?
+    dform.definition = params[:form_definition] unless params[:form_definition].nil?
+    dform.model_name = params[:model_name] unless params[:model_name].nil?
+    dform.widget_action = params[:widget_action] unless params[:widget_action].nil?
+    dform.widget_email_recipients = params[:widget_email_recipients] unless params[:widget_email_recipients].nil?
+    dform.focus_first_field = params[:focus_first_field] unless params[:focus_first_field].nil?
+    dform.show_in_multitask = params[:show_in_multitask] unless params[:show_in_multitask].nil?
+    dform.msg_target = params[:msg_target] unless params[:msg_target].nil?
+    dform.submit_empty_text = params[:submit_empty_text] unless params[:submit_empty_text].nil?
+    dform.submit_button_label = params[:submit_button_label] unless params[:submit_button_label].nil?
+    dform.cancel_button_label = params[:cancel_button_label] unless params[:cancel_button_label].nil?
+    dform.comment = params[:comment] unless params[:comment].nil?
+    dform
+  end
+
 end

data/app/controllers/erp_forms/erp_app/desktop/dynamic_forms/models_controller.rb

@@ -8,7 +8,9 @@ class ErpForms::ErpApp::Desktop::DynamicForms::ModelsController < ErpForms::ErpA
     dynamic_form_models.each do |m|
       model_hash = {
         :id => m.id,
-        :model_name => m.model_name   
+        :model_name => m.model_name,
+        :file_security_default => m.file_security_default,
+        :show_in_multitask => m.show_in_multitask
       }
       
       models << model_hash
@@ -34,12 +36,26 @@ class ErpForms::ErpApp::Desktop::DynamicForms::ModelsController < ErpForms::ErpA
   
   # create a dynamic form model
   def create
-    model_name = params[:model_name]
     DynamicFormModel.create({
-      :model_name => model_name
+      :model_name => params[:model_name],
+      :allow_comments => params[:allow_comments],
+      :allow_files => params[:allow_files],
+      :file_security_default => params[:file_security_default]
     })
 	
     render :json => {:success => true}
   end
+
+  # update a dynamic form model
+  def update
+    m = DynamicFormModel.find(params[:id])
+    m.allow_comments = params[:allow_comments] unless params[:allow_comments].nil?
+    m.allow_files = params[:allow_files] unless params[:allow_files].nil?
+    m.file_security_default = params[:file_security_default] unless params[:file_security_default].blank?
+    m.show_in_multitask = params[:show_in_multitask] unless params[:show_in_multitask].nil?
+    m.save
+    
+    render :json => {:success => true}
+  end
   
 end

data/app/mailers/dynamic_form_mailer.rb

@@ -0,0 +1,35 @@
+class DynamicFormMailer < ActionMailer::Base
+
+  # def widget_email(form, dynamicObject, subject='')
+  #   subject = "#{model_name} Submission" if subject.blank?
+  #   @dynamicObject = dynamicObject
+
+  #   mail( :to => form.widget_email_recipients,
+  #         :from => ErpTechSvcs::Config.email_notifications_from,
+  #         :subject => subject,
+  #         :content_type => 'text/plain'
+  #       )
+  # end
+
+  # uses mail_alternatives_with_attachments gem
+  # ActionMailer doesn't handle attachments well without this gem
+  def widget_email_with_attachments(form, dynamicObject, subject='', files=[])
+    related_fields = dynamicObject.form.related_fields rescue []
+    @dynamicData = dynamicObject.data.dynamic_attributes_with_related_data(related_fields, true)
+    subject = "#{model_name} Submission" if subject.blank?
+    message = prepare_message to: form.widget_email_recipients, from: ErpTechSvcs::Config.email_notifications_from, subject: subject, :content_type => "multipart/mixed"
+
+    message.alternative_content_types_with_attachment(
+      :text => render_to_string(:template => "dynamic_form_mailer/widget_email_with_attachments.text"),
+      :html => render_to_string(:template => "dynamic_form_mailer/widget_email_with_attachments.html")
+    ) do |inline_attachments|
+      files.each do |f|
+        attachments.inline[f.original_filename] = f.tempfile.read
+      end
+    end
+
+    message
+  end
+
+end
+

data/app/models/dynamic_datum.rb

@@ -1,4 +1,6 @@
 class DynamicDatum < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
   DYNAMIC_ATTRIBUTE_PREFIX = 'dyn_'
   
   has_dynamic_attributes :dynamic_attribute_prefix => DYNAMIC_ATTRIBUTE_PREFIX, :destroy_dynamic_attribute_for_nil => false
@@ -20,11 +22,19 @@ class DynamicDatum < ActiveRecord::Base
 
   def dynamic_attributes_with_related_data(related_fields=[], use_label=false)
     key = (use_label ? :fieldLabel : :name)
-    data = sorted_dynamic_attributes(false, use_label)
+    data = sorted_dynamic_attributes(:use_label => use_label)
     related_fields.each do |r|
       data.each do |k,v|
         if k == r[key]
-          data[k] = r[:extraParams]['model'].camelize.constantize.find(v).send(r[:displayField]) rescue nil
+          if r[:xtype] == 'related_combobox'
+            d = r[:displayField]
+            t = nil
+          else
+            #related_searchbox
+            d = r[:display_fields].split(',')
+            t = r[:display_template]
+          end
+          data[k] = DynamicDatum.related_data_value(r[:extraParams]['model'], v, d, t)
         end
       end
     end
@@ -32,44 +42,109 @@ class DynamicDatum < ActiveRecord::Base
     data
   end
 
+  #column can be a string or array of strings
+  def self.related_data_value(model, id, column, template=nil)
+    if column.is_a?(String)
+      return model.camelize.constantize.find(id).send(column) rescue nil
+    else
+      final_display = template
+      column.each do |c|
+        value = model.camelize.constantize.find(id).send(c) rescue nil
+        final_display = final_display.gsub(c, value)
+      end
+      return final_display.gsub('{','').gsub('}','')
+    end
+  end
+
   # we cannot assume that dynamic attributes are stored in order in the database as this is often not the case
   # this method will sort them according to the order of the fields in the form definition
   # method returns an ordered hash
-  # if with_prefix is false, you may choose to use the fieldLabel as the hash key, this is useful displaying data on a view screen
-  def sorted_dynamic_attributes(with_prefix=false, use_label=false)    
-    form = self.updated_with_form if form.nil? and !self.updated_with_form.nil?
+  # options = {:with_prefix => false, :use_label => false, :all => false}
+  # :with_prefix = false will remove the dyn_ from the attribute key
+  # if :with_prefix is false, you may choose to use the fieldLabel as the hash key by setting :use_label = true 
+  # :use_label is useful displaying data on a view screen or formatting an email
+  # :all = false will only return attributes that are in the form definition
+  # :all = true will return all attributes with those not in the form definition last
+  # you can set :all = true and :use_label = true, but attributes not in definition will use key.titleize
+  # if for some reason a form cannot be found, sorting will not be attempted
+  def sorted_dynamic_attributes(options={})
+    options[:with_prefix] = false if options[:with_prefix].nil?
+    options[:use_label] = false if options[:use_label].nil?
+    options[:all] = true if options[:all].nil?
+
+    form = self.updated_with_form !self.updated_with_form.nil?
     form = self.created_with_form if form.nil? and !self.created_with_form.nil?
     form = DynamicForm.get_form(self.reference_type) if form.nil?
     
     unless form.nil?
-      if with_prefix
-        keys = form.definition_object.collect{|f| DYNAMIC_ATTRIBUTE_PREFIX + f[:name]}
+      fields = form.definition_object
+
+      fields_and_values = {}
+      if options[:with_prefix]
+        fields.each do |f|
+          k = DYNAMIC_ATTRIBUTE_PREFIX + f[:name]
+          next if k == DYNAMIC_ATTRIBUTE_PREFIX + 'file' # we dont want to show file upload fields
+          fields_and_values[k] = {}
+          fields_and_values[k][:value] = self.dynamic_attributes[k]
+          fields_and_values[k][:xtype] = f[:xtype]
+        end
       else        
-        labels = form.definition_object.collect{|f| f[:fieldLabel]} if use_label
-        keys = form.definition_object.collect{|f| f[:name]}
+        fields.each do |f|
+          k = f[:name]
+          next if k == 'file' # we dont want to show file upload fields
+          fields_and_values[k] = {}
+          fields_and_values[k][:value] = self.dynamic_attributes_without_prefix[k]
+          fields_and_values[k][:xtype] = f[:xtype]
+          fields_and_values[k][:fieldLabel] = f[:fieldLabel] if options[:use_label]
+        end
       end
 
+      # although we try and save integers as integers, we ensure here they are integers so that combobox value is selected
+      related_fields = form.related_fields
+      if related_fields.length > 0
+        related_fields.collect{|f| f[:name]}.each do |k|
+          k = DYNAMIC_ATTRIBUTE_PREFIX+k if options[:with_prefix]
+          fields_and_values[k][:value] = fields_and_values[k][:value].to_i 
+        end
+      end
+      
       sorted = {}
       i=0
-      keys.each do |key|
-        if with_prefix
-          sorted[key] = self.dynamic_attributes[key]
+      fields_and_values.each do |key, field|        
+        if options[:with_prefix]
+          sorted[key] = field[:value]
         else
-          index = (use_label ? labels[i] : key)
-          sorted[index] = self.dynamic_attributes_without_prefix[key]
-        end        
-
+          index = (options[:use_label] ? field[:fieldLabel] : key)
+          sorted[index] = field[:value]
+        end
         i += 1
       end
       
+      if options[:all]
+        # append attributes not in definition
+        attrs = (options[:with_prefix] ? self.dynamic_attributes : self.dynamic_attributes_without_prefix)
+        keys = fields_and_values.collect{|k,v| k}
+
+        i=0
+        sorted.each do |k,v|
+          index = (options[:use_label] ? keys[i] : k)
+          attrs.delete(index)
+          i += 1
+        end
+
+        attrs.each do |k,v|
+          if options[:with_prefix]
+            sorted[k] = self.dynamic_attributes[k]
+          else
+            index = (options[:use_label] ? k.titleize : k)
+            sorted[index] = self.dynamic_attributes_without_prefix[k]
+          end
+        end
+      end
+
       return sorted
     else
-      if with_prefix
-        return self.dynamic_attributes
-      else
-        return self.dynamic_attributes_without_prefix
-      end
+      return (options[:with_prefix] ? self.dynamic_attributes : self.dynamic_attributes_without_prefix)
     end
   end
-  
 end

data/app/models/dynamic_form.rb

@@ -1,5 +1,15 @@
 class DynamicForm < ActiveRecord::Base
+  attr_protected :created_at, :updated_at
+
   belongs_to :dynamic_form_model
+  belongs_to :created_by, :class_name => "User"
+  belongs_to :updated_by, :class_name => "User"
+
+  extend FriendlyId
+  friendly_id :description, :use => [:slugged], :slug_column => :internal_identifier
+  def should_generate_new_friendly_id?
+    new_record?
+  end
 
   validates_uniqueness_of :internal_identifier, :scope => :model_name, :case_sensitive => false
   
@@ -7,7 +17,7 @@ class DynamicForm < ActiveRecord::Base
   	result = nil
   	begin
   	  klass = Module.const_get(class_name)
-        result = klass.is_a?(Class) ? ((klass.superclass == ActiveRecord::Base or klass.superclass == DynamicModel) ? true : nil) : nil
+      result = (klass.is_a?(Class) ? ((klass.superclass == ActiveRecord::Base or klass.superclass == DynamicModel) ? true : nil) : nil)
   	rescue NameError
   	  result = nil
   	end
@@ -15,12 +25,9 @@ class DynamicForm < ActiveRecord::Base
   end
   
   def self.get_form(klass_name, internal_identifier='')
-    result = nil
-  	unless internal_identifier.blank?
-  	  result = DynamicForm.find_by_model_name_and_internal_identifier(klass_name, internal_identifier)
-  	else
-  	  result = DynamicForm.find_by_model_name_and_default(klass_name, true)
-  	end
+    result = nil  	
+	  result = DynamicForm.find_by_model_name_and_internal_identifier(klass_name, internal_identifier) unless internal_identifier.blank?
+	  result = DynamicForm.find_by_model_name_and_default(klass_name, true) if result.nil?
   	result
   end
   
@@ -38,22 +45,30 @@ class DynamicForm < ActiveRecord::Base
   end
   
   def add_validation(def_object)
-    def_object.each do |item|      
-      if item[:validator_function] and item[:validator_function] != ""
-        item[:validator] = NonEscapeJsonString.new("function(v){ regex = this.initialConfig.validation_regex; return #{item[:validator_function]}; }")
-      elsif item[:validation_regex] and item[:validation_regex] != ""
-        item[:validator] = NonEscapeJsonString.new("function(v){ return validate_regex(v, this.initialConfig.validation_regex); }")
+    def_object.each do |item|
+      if !item[:validation_regex].blank?
+        item[:regex] = NonEscapeJsonString.new(item[:validation_regex].match('^\/') ? item[:validation_regex] : '/'+item[:validation_regex]+'/')
+      elsif !item[:validator_function].blank?
+        item[:validator] = NonEscapeJsonString.new("function(v){ return #{item[:validator_function]}; }")
       end
     end
     
     def_object
   end
+
+  def add_help_qtip(def_object)
+    def_object.each do |item|
+      item[:plugins] = NonEscapeJsonString.new('[new helpQtip("'+item[:help_qtip].gsub(/\"/,'\"')+'")]') unless item[:help_qtip].blank?
+    end
+    
+    def_object
+  end
   
   # will return an array of field names that are of xtype 'related_combobox'
   def related_fields
     related_fields = []
     definition_object.each do |f|
-      related_fields << f if f[:xtype] == 'related_combobox'
+      related_fields << f if ['related_combobox','related_searchbox'].include?(f[:xtype])
     end
 
     related_fields
@@ -74,53 +89,98 @@ class DynamicForm < ActiveRecord::Base
     array_of_fields.to_json
   end
   
-  def to_extjs_formpanel(options={})    
+  def focus_first_field_js
+    if self.focus_first_field
+      return "form.getComponent(0).focus(true, 200);"
+    else
+      return ''
+    end
+  end
+
+  def submit_empty_text_js
+    if self.submit_empty_text
+      return "submitEmptyText: true,"
+    else
+      return ''
+    end
+  end
+
+  def to_extjs_formpanel(options={})   
     form_hash = {
-      :xtype => 'form',
-      :id => "dynamic_form_panel_#{model_name}",
+      :xtype => 'dynamic_form_panel',
       :url => options[:url],
       :title => self.description,
       :frame => true,
-      :bodyStyle => 'padding: 5px 5px 0;'
+      :bodyStyle => 'padding: 5px 5px 0;',
+      :baseParams => {
+        :dynamic_form_id => self.id,
+        :dynamic_form_model_id => self.dynamic_form_model_id,
+        :model_name => self.model_name
+      },
+      :defaults => {},
+      :items => add_help_qtip(definition_with_validation)
     }
-    
+    form_hash[:defaults][:msgTarget] = self.msg_target unless self.msg_target.blank?
     form_hash[:width] = options[:width] if options[:width]
-    form_hash[:baseParams] = {}
     form_hash[:baseParams][:id] = options[:record_id] if options[:record_id]
-    form_hash[:baseParams][:dynamic_form_id] = self.id
-    form_hash[:baseParams][:dynamic_form_model_id] = self.dynamic_form_model_id
-    form_hash[:baseParams][:model_name] = self.model_name
     form_hash[:listeners] = {
-      :afterrender => NonEscapeJsonString.new("function(form) {Ext.getCmp('dynamic_form_panel_#{model_name}').getComponent(0).focus(false);}")
+      :afterrender => NonEscapeJsonString.new("function(form) { #{focus_first_field_js} }")
     }
-    form_hash[:items] = definition_with_validation
     form_hash[:buttons] = []
-    form_hash[:buttons][0] = {
-      :text => 'Submit',
+    form_hash[:buttons] << {
+      :text => self.submit_button_label,
       :listeners => NonEscapeJsonString.new("{
-          \"click\":function(button){
-              var formPanel = Ext.getCmp('dynamic_form_panel_#{model_name}');
-              formPanel.getForm().submit({
-                  reset:true,
-                  success:function(form, action){
-                      Ext.getCmp('dynamic_form_panel_#{model_name}').findParentByType('window').close();
-
-                      if (Ext.getCmp('#{model_name}')){
-                          Ext.getCmp('#{model_name}').query('shared_dynamiceditablegrid')[0].store.load();                                                                      
-                      }
-                  },
-                  failure:function(form, action){
-                    Ext.Msg.alert(action.response.responseText);                                
-                  }
+          click:function(button){
+              var form = button.findParentByType('form').getForm();
+              //jsonSubmit option only works when there is no filefield so we have to do it ourselves
+              //JSON is important to preserve data types (ie. we want integers to save as integers not strings)
+              var form_data = {};
+              Ext.each(form.getFields().items, function(field) {
+                if (Ext.Array.indexOf(['filefield','fileuploadfield'], field.xtype) < 0){
+                  form_data[field.name] = field.getValue();
+                } 
               });
+              if (form.isValid()){
+                form.submit({
+                    #{submit_empty_text_js}
+                    reset:false,
+                    params:{
+                      form_data_json: Ext.encode(form_data)
+                    },
+                    success:function(form, action){
+                        var obj = Ext.decode(action.response.responseText);
+                        if(obj.success){
+                          if (form.getRecord()){
+                            form.owner.fireEvent('afterupdate');
+                          }else{
+                            form.owner.fireEvent('aftercreate', {
+                              record: obj
+                            });
+                          }
+                        }else{
+                          Ext.Msg.alert('Error', obj.message);
+                        }
+                    },
+                    failure:function(form, action){
+                      Ext.Msg.alert('Error', action.response.responseText);
+                    }
+                });
+              }else{
+                Ext.Msg.alert('Error','Please complete form.');
+              }
           }
       }")
     }
-    form_hash[:buttons][1] = {
-      :text => 'Cancel',
+    form_hash[:buttons] << {
+      :text => self.cancel_button_label,
       :listeners => NonEscapeJsonString.new("{
           \"click\":function(button){
-              Ext.getCmp('dynamic_form_panel_#{model_name}').findParentByType('window').close();
+            var form = button.findParentByType('form');
+            if (form.close_selector){
+              form.up(form.close_selector).close();
+            }else{
+              form.up('window').close();
+            }
           }
       }")
     }
@@ -136,62 +196,76 @@ class DynamicForm < ActiveRecord::Base
   # :widget_result_id => 
   # :width =>
   def to_extjs_widget(options={})
-    options[:width] = "'auto'" if options[:width].nil?
-
-    #NOTE: The random nbsp; forces IE to eval this javascript!
-    javascript = "Ext.QuickTips.init();
-
-          Ext.create('Ext.form.Panel',{
-              id: 'dynamic_form_panel_#{model_name}',
-              url:'#{options[:url]}',
-              title: '#{self.description}',"
-
-    javascript += "\"width\": #{options[:width]}," if options[:width]
-
-    javascript += "frame: true,
-              bodyStyle:'padding: 5px 5px 0;',
-              renderTo: 'dynamic_form_target',
-              baseParams: {
-                dynamic_form_id: #{self.id},
-                dynamic_form_model_id: #{self.dynamic_form_model_id},
-                model_name: '#{self.model_name}'
-              },
-              items: #{definition_with_validation.to_json},
-              listeners: {
-                  afterrender: function(form) {
-                      Ext.getCmp('dynamic_form_panel_#{model_name}').getComponent(0).focus(false);
-                  }
-              },
-              buttons: [{
-                  text: 'Submit',
-                  listeners:{
-                      'click':function(button){
-                          var formPanel = Ext.getCmp('dynamic_form_panel_#{model_name}');
-                          formPanel.getForm().submit({
-                              reset:true,
-                              success:function(form, action){
-                                  json_hash = Ext.decode(action.response.responseText);
-                                  Ext.get('#{options[:widget_result_id]}').dom.innerHTML = json_hash.response;
-                                  var scriptTags = Ext.get('#{options[:widget_result_id]}').dom.getElementsByTagName('script');
-                                  Ext.each(scriptTags, function(scriptTag){
-                                        eval(scriptTag.text);
-                                  });
-                              },
-                              failure:function(form, action){
-                                if (action.response){
-                                  json_hash = Ext.decode(action.response.responseText);
-                                  Ext.get('#{options[:widget_result_id]}').dom.innerHTML = json_hash.response;
-                                }
-                              }
-                          });
-                      }
+    javascript = "Ext.QuickTips.init(); Ext.create('Ext.form.Panel',"
+    
+    config_hash = {
+      :url => "#{options[:url]}",
+      :title => "#{self.description}",
+      :frame => true,
+      :bodyStyle => 'padding: 5px 5px 0;',
+      :renderTo => 'dynamic_form_target',
+      :baseParams => {
+        :dynamic_form_id => self.id,
+        :dynamic_form_model_id => self.dynamic_form_model_id,
+        :model_name => self.model_name
+      },
+      :items => add_help_qtip(definition_with_validation),
+      :defaults => {},
+      :listeners => {
+        :afterrender => NonEscapeJsonString.new("function(form) { #{focus_first_field_js} }")
+      }
+    }
+    config_hash[:defaults][:msgTarget] = self.msg_target unless self.msg_target.blank?
+    config_hash[:width] = options[:width] if options[:width]
+    config_hash[:buttons] = []
+    config_hash[:buttons] << {
+      :text => self.submit_button_label,
+      :listeners => NonEscapeJsonString.new("{
+          \"click\":function(button){
+              var form = button.findParentByType('form').getForm();
+              //jsonSubmit option only works when there is no filefield so we have to do it ourselves
+              //JSON is important to preserve data types (ie. we want integers to save as integers not strings)
+              var form_data = {};
+              Ext.each(form.getFields().items, function(field) {
+                if (Ext.Array.indexOf(['filefield','fileuploadfield'], field.xtype) < 0){
+                  form_data[field.name] = field.getValue();
+                } 
+              });
+              form.submit({
+                  #{submit_empty_text_js}
+                  reset:true,
+                  params:{
+                    form_data_json: Ext.encode(form_data)
+                  },
+                  success:function(form, action){
+                      json_hash = Ext.decode(action.response.responseText);
+                      Ext.get('#{options[:widget_result_id]}').dom.innerHTML = json_hash.response;
+                      var scriptTags = Ext.get('#{options[:widget_result_id]}').dom.getElementsByTagName('script');
+                      Ext.each(scriptTags, function(scriptTag){
+                            eval(scriptTag.text);
+                      });
+                  },
+                  failure:function(form, action){
+                    if (action.response){
+                      json_hash = Ext.decode(action.response.responseText);
+                      Ext.get('#{options[:widget_result_id]}').dom.innerHTML = json_hash.response;
+                    }
                   }
-                  
-              },{
-                  text: 'Cancel'
-              }]
-          });"
-      #logger.info javascript
+              });
+          }
+      }")
+    }
+    config_hash[:buttons] << {
+      :text => 'Reset',
+      :listeners => NonEscapeJsonString.new("{
+          \"click\":function(button){
+              button.findParentByType('form').getForm().reset();
+          }
+      }")
+    }
+
+    javascript += "#{config_hash.to_json});"
+    #logger.info javascript
     javascript
   end