formbuilder-rb 0.0.4 → 0.2.0

data/app/models/formbuilder/form.rb

@@ -4,6 +4,8 @@ module Formbuilder
     has_many :response_fields, dependent: :destroy
     belongs_to :formable, polymorphic: true
 
+    attr_accessor :show_blind, :show_admin_only
+
     def input_fields
       response_fields.reject { |rf| !rf.input_field }
     end
@@ -12,5 +14,56 @@ module Formbuilder
       self.response_fields.to_json(methods: [:field_type, :cid])
     end
 
+    def copy_response_fields!(other_form)
+      other_form.response_fields.each_with_index do |response_field, i|
+        self.response_fields.create(
+          label: response_field.label,
+          type: response_field.type,
+          field_options: response_field.field_options,
+          sort_order: response_field.sort_order,
+          required: response_field.required,
+          blind: response_field.blind,
+          admin_only: response_field.admin_only
+        )
+      end
+    end
+
+    def multi_page?
+      num_pages > 1
+    end
+
+    def num_pages
+      response_fields_by_page.length
+    end
+
+    def filtered_response_fields
+      query = response_fields
+      query = query.reject { |rf| rf.blind? } unless show_blind
+      query = query.reject { |rf| rf.admin_only? } unless show_admin_only
+      query
+    end
+
+    def response_fields_by_page
+      [].tap do |a|
+        a.push []
+
+        page_index = 0
+        filtered_response_fields.each do |response_field|
+          if response_field.field_type == 'page_break'
+            a << []
+          else
+            a.last << response_field
+          end
+        end
+
+        a.delete_if { |page| page.empty? }
+        a.push([]) if a.empty?
+      end
+    end
+
+    def response_fields_for_page(x)
+      response_fields_by_page[x - 1] # 0-indexed
+    end
+
   end
 end

data/app/models/formbuilder/response_field.rb

@@ -22,6 +22,9 @@ module Formbuilder
     # Underscored name of this field
     attr_accessor :field_type
 
+    # Search type for this field
+    attr_accessor :search_type
+
     after_initialize -> {
       @input_field = true
     }
@@ -59,14 +62,6 @@ module Formbuilder
       return_hash.select { |k, v| v.present? }
     end
 
-    def render_entry_for_table(value, opts = {})
-      """
-        <td data-column-id='#{self.id}'>
-          #{render_entry(value, opts)}
-        </td>
-      """
-    end
-
     def render_input(value, opts = {})
       raise 'Not implemented'
     end
@@ -75,10 +70,28 @@ module Formbuilder
       value
     end
 
-    def audit_response(value, all_responses)
+    def render_entry_text(value, opts = {})
+      render_entry(value, opts)
+    end
+
+    def audit_response(value, all_responses); end;
+
+    def normalize_response(value, all_responses); end;
+
+    def validate_response(value); end;
+
+    def before_response_destroyed(entry); end;
+
+    def transform_raw_value(raw_value, entry, opts = {})
+      raw_value
+    end
+
+    def options_array
+      Array(self.field_options['options']).map { |o| o['label'] }
     end
 
-    def validate_response(value)
+    def sortable_value(value)
+      value[0..10] # do we really need to sort more than the first 10 characters of a string?
     end
 
   end

data/app/models/formbuilder/response_field_address.rb

@@ -4,6 +4,7 @@ module Formbuilder
     after_initialize -> {
       @serialized = true
       @field_type = 'address'
+      @search_type = 'address'
     }
 
     def render_input(value, opts = {})
@@ -12,7 +13,7 @@ module Formbuilder
       """
         <div class='input-line'>
           <span class='street'>
-            <input type'text' name='response_fields[#{self[:id]}][street]' value='#{value['street']}' />
+            <input type'text' name='response_fields[#{self[:id]}][street]' id='response_fields_#{self[:id]}' value='#{value['street']}' />
             <label>Address</label>
           </span>
         </div>
@@ -53,6 +54,12 @@ module Formbuilder
       """
     end
 
+    def render_entry_text(value, opts = {})
+      "#{value['street']}\n" +
+      "#{value['city']} #{value['state']} #{value['zipcode']}\n" +
+      "#{value['country']}"
+    end
+
     def audit_response(value, all_responses)
       begin
         coords = Geocoder.coordinates("#{value['street']} #{value['city']} " +
@@ -66,6 +73,10 @@ module Formbuilder
       end
     end
 
+    def sortable_value(value)
+      "#{value['street']} #{value['city']} #{value['state']} #{value['zipcode']} #{value['country']}"
+    end
+
     private
     def country_options(selected_country)
       all_countries.map do |k, v|

data/app/models/formbuilder/response_field_checkboxes.rb

@@ -5,6 +5,7 @@ module Formbuilder
       @serialized = true
       @options_field = true
       @field_type = 'checkboxes'
+      @search_type = 'multiple_options'
     }
 
     def render_input(value, opts = {})
@@ -64,5 +65,42 @@ module Formbuilder
       """
     end
 
+    def render_entry_text(value, opts = {})
+      (value || {}).map do |k, v|
+        "#{k}: #{v ? (k == 'Other' ? v : 'y') : 'n'}"
+      end.join("\n")
+    end
+
+    def sortable_value(value)
+      nil # see :normalize_response for override
+    end
+
+    def normalize_response(value, all_responses)
+      options_array.each do |option_label|
+        all_responses["#{self.id}_sortable_values_#{option_label}"] = value[option_label]
+      end
+    end
+
+    def transform_raw_value(raw_value, entry, opts = {})
+      raw_value ||= {}
+
+      {}.tap do |h|
+        options_array.each_with_index do |label, index|
+          h[label] = raw_value[index.to_s] == "on"
+        end
+
+        if raw_value['other_checkbox'] == 'on'
+          entry.get_responses["#{self.id}_other"] = true
+          h['Other'] = raw_value['other']
+        end
+
+        if h.find { |_, v| v }.present?
+          entry.get_responses["#{self.id}_present"] = true
+        else
+          entry.get_responses.delete("#{self.id}_present")
+        end
+      end
+    end
+
   end
 end

data/app/models/formbuilder/response_field_date.rb

@@ -5,13 +5,14 @@ module Formbuilder
       @serialized = true
       @sort_as_numeric = true
       @field_type = 'date'
+      @search_type = 'date'
     }
 
     def render_input(value, opts = {})
       """
         <div class='input-line'>
           <span class='month'>
-            <input type='text' name='response_fields[#{self[:id]}][month]' value='#{value['month']}' maxlength='2' />
+            <input type='text' name='response_fields[#{self[:id]}][month]' value='#{value['month']}' id='response_fields_#{self[:id]}' maxlength='2' />
             <label>MM</label>
           </span>
 
@@ -42,5 +43,10 @@ module Formbuilder
       end
     end
 
+    def sortable_value(value)
+      ['year', 'month', 'day'].each { |x| return 0 unless value[x].try(:present?) }
+      DateTime.new(value['year'].to_i, value['month'].to_i, value['day'].to_i).to_i rescue 0
+    end
+
   end
 end

data/app/models/formbuilder/response_field_dropdown.rb

@@ -4,6 +4,7 @@ module Formbuilder
     after_initialize -> {
       @options_field = true
       @field_type = 'dropdown'
+      @search_type = 'one_option'
     }
 
     def render_input(value, opts = {})
@@ -16,7 +17,7 @@ module Formbuilder
       end
 
       """
-        <select name='response_fields[#{self[:id]}]'>
+        <select name='response_fields[#{self[:id]}]' id='response_fields_#{self[:id]}'>
           #{options}
         </select>
       """

data/app/models/formbuilder/response_field_email.rb

@@ -5,17 +5,29 @@ module Formbuilder
 
     after_initialize -> {
       @field_type = 'email'
+      @search_type = 'text'
     }
 
     def render_input(value, opts = {})
-      tag(:input, type: 'text', name: "response_fields[#{self.id}]", class: "rf-size-#{self[:field_options]['size']}",
-          data: self.length_validations, value: value)
+      tag(
+        :input,
+        type: 'text',
+        name: "response_fields[#{self.id}]",
+        id: "response_fields_#{self[:id]}",
+        class: "rf-size-#{self[:field_options]['size']}",
+        data: self.length_validations,
+        value: value
+      )
     end
 
     def render_entry(value, opts = {})
       "<a href='mailto:#{value}'>#{value}</a>"
     end
 
+    def render_entry_text(value, opts = {})
+      value
+    end
+
     def validate_response(value)
       unless value =~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
         "isn't a valid email address."

data/app/models/formbuilder/response_field_file.rb

@@ -1,43 +1,98 @@
 module Formbuilder
   class ResponseFieldFile < ResponseField
 
+    # Notes:
+    #   I'm modifying this class to accept multiple attachments,
+    #   even though the frontend will only accept one (for now).
+
     after_initialize -> {
       @field_type = 'file'
+      @search_type = 'file'
     }
 
-    # @todo dropzone?
-    def render_input(value, opts = {})
-      attachment = value && EntryAttachment.find(value)
+    def get_attachments(value)
+      if value.blank?
+        []
+      else
+        EntryAttachment.where('id IN (?)', value.split(','))
+      end
+    end
 
+    def render_input(value, opts = {})
       """
-        <span class='existing-filename'>#{attachment.try(:upload).try(:file).try(:filename).try(:gsub, /\?.*$/, '')}</span>
-        <input type='file' name='response_fields[#{self[:id]}]' />
+        <span class='existing-filename'>#{get_attachments(value).first.try(:upload).try(:raw_filename)}</span>
+        <input type='file' name='response_fields[#{self[:id]}][]' id='response_fields_#{self[:id]}' />
       """
     end
 
     def render_entry(value, opts = {})
-      attachment = value && EntryAttachment.where(id: value).first
+      return_str = ""
 
-      return unless attachment
+      return_str << get_attachments(value).map do |attachment|
+        String.new.tap do |str|
+          str << """
+            <a href='#{attachment.upload.url}' target='_blank'>
+          """
 
-      str = ""
+          if attachment.upload.send(:active_versions).include?(:thumb)
+            str << """
+              <img src='#{attachment.upload.thumb.url}' /><br />
+            """
+          end
 
-      str += """
-        <a href='#{attachment.upload.url}' target='_blank'>
-      """
+          str << """
+              #{attachment.upload.try(:raw_filename)}
+            </a>
+          """
+        end
+      end.join('<br /><br />').squish
 
-      if attachment.upload.send(:active_versions).include?(:thumb)
-        str += """
-          <img src='#{attachment.upload.thumb.url}' /><br />
-        """
+      return_str
+    end
+
+    def render_entry_text(value, opts = {})
+      get_attachments(value).map { |attachment|
+        attachment.upload.url
+      }.join(', ')
+    end
+
+    def audit_response(value, all_responses)
+      return unless value
+      all_responses["#{self.id}_filename"] = get_attachments(value).try(:first).try(:upload).try(:raw_filename)
+    end
+
+    def sortable_value(value)
+      value.present? ? 1 : 0
+    end
+
+    def before_response_destroyed(entry)
+      remove_entry_attachments(entry.get_responses[self.id.to_s])
+    end
+
+    def transform_raw_value(raw_value, entry, opts = {})
+      raw_value = [raw_value] unless raw_value.is_a?(Array)
+      raw_value = raw_value.reject { |x| x.blank? }
+
+      # if the file is already uploaded and we're not uploading another, be sure to keep it
+      # @todo currently no way of removing a file
+      if raw_value.empty?
+        entry.responses_column_was.try(:[], self.id.to_s)
+      else
+        remove_entry_attachments(entry.get_responses.try(:[], self.id.to_s)) # remove old attachments
+        remove_entry_attachments(entry.responses_column_was.try(:[], self.id.to_s)) # remove old attachments
+
+        raw_value.map do |file|
+          EntryAttachment.create(upload: file).id
+        end.join(',')
       end
+    end
 
-      str +="""
-          #{attachment.upload.try(:file).try(:filename).try(:gsub, /\?.*$/, '')}
-        </a>
-      """
+    def remove_entry_attachments(entry_attachment_ids)
+      return unless entry_attachment_ids.present?
 
-      str
+      entry_attachment_ids.to_s.split(',').each do |x|
+        EntryAttachment.find_by(id: x).try(:destroy)
+      end
     end
 
   end

data/app/models/formbuilder/response_field_number.rb

@@ -6,11 +6,18 @@ module Formbuilder
     after_initialize -> {
       @sort_as_numeric = true
       @field_type = 'number'
+      @search_type = 'number'
     }
 
     def render_input(value, opts = {})
-      str = tag(:input, type: 'text', name: "response_fields[#{self.id}]",
-                class: "rf-size-#{self[:field_options]['size']}", value: value)
+      str = tag(
+        :input,
+        type: 'text',
+        name: "response_fields[#{self.id}]",
+        id: "response_fields_#{self.id}",
+        class: "rf-size-#{self[:field_options]['size']}",
+        value: value
+      )
 
       if (units = self[:field_options]['units'].presence)
         str += "<span class='units'>#{units}</span>".html_safe

data/app/models/formbuilder/response_field_page_break.rb

@@ -0,0 +1,13 @@
+module Formbuilder
+  class ResponseFieldPageBreak < ResponseField
+
+    after_initialize -> {
+      @input_field = false
+      @field_type = 'page_break'
+    }
+
+    def render_input(value, opts = {})
+    end
+
+  end
+end

data/app/models/formbuilder/response_field_paragraph.rb

@@ -1,3 +1,5 @@
+require 'rinku'
+
 module Formbuilder
   class ResponseFieldParagraph < ResponseField
 
@@ -6,15 +8,29 @@ module Formbuilder
 
     after_initialize -> {
       @field_type = 'paragraph'
+      @search_type = 'text'
     }
 
     def render_input(value, opts = {})
-      content_tag(:textarea, name: "response_fields[#{self.id}]", class: "rf-size-#{self[:field_options]['size']}",
-                  data: self.length_validations) { value }
+      content_tag(
+        :textarea,
+        name: "response_fields[#{self.id}]",
+        id: "response_fields_#{self.id}",
+        class: "rf-size-#{self[:field_options]['size']}",
+        data: self.length_validations
+      ) { value }
     end
 
     def render_entry(value, opts = {})
-      ActionController::Base.helpers.simple_format(value)
+      if value.present?
+        ActionController::Base.helpers.simple_format(Rinku.auto_link(value))
+      else
+        ''
+      end
+    end
+
+    def render_entry_text(value, opts = {})
+      value
     end
 
   end