fe 1.0.0 → 2.0.0

data/app/models/concerns/fe/answer_sheet_concern.rb

@@ -0,0 +1,125 @@
+module Fe
+  module AnswerSheetConcern
+    extend ActiveSupport::Concern
+
+    begin
+      included do
+        has_many :answer_sheet_question_sheets, foreign_key: 'answer_sheet_id', class_name: '::Fe::AnswerSheetQuestionSheet'
+        has_many :question_sheets, through: :answer_sheet_question_sheets, class_name: 'Fe::QuestionSheet'
+        has_many :answers, ->(answer_sheet) {
+          question_sheet_ids = answer_sheet.question_sheet_ids
+
+          if question_sheet_ids.any?
+            element_ids = Fe::Page.joins(:question_sheet).where(question_sheet_id: question_sheet_ids).pluck(:all_element_ids).compact
+            element_ids = element_ids.collect{ |e| e.split(',') }.flatten
+          end
+
+          unless question_sheet_ids.any? && element_ids.any?
+            # an answer sheet not assigned to a question sheet, or assigned to
+            # a question sheet with no elements should not return any answers
+            return where('false')
+          end
+
+          where('question_id' => element_ids)
+
+        }, foreign_key: 'answer_sheet_id', class_name: '::Fe::Answer'
+        has_many :reference_sheets, foreign_key: 'applicant_answer_sheet_id', class_name: 'Fe::ReferenceSheet'
+        has_many :payments, foreign_key: 'application_id', class_name: 'Fe::Payment'
+      end
+    rescue ActiveSupport::Concern::MultipleIncludedBlocks
+    end
+
+    def languages
+      return [] unless question_sheets.first
+
+      unless @languages
+        @languages = question_sheets.first.languages
+        question_sheets[1..-1].each { |qs| @languages &= qs.languages.select(&:present?) }
+      end
+      @languages
+    end
+
+    def complete?
+      !completed_at.nil?
+    end
+
+    # answers for this sheet, grouped by question id
+    def answers_by_question
+      @answers_by_question ||= answers.group_by { |answer| answer.question_id }
+    end
+
+    # Convenience method if there is only one question sheet in your system
+    def question_sheet
+      question_sheets.first
+    end
+
+    def pages
+      Page.where(question_sheet_id: question_sheets.collect(&:id)).visible.order('number')
+    end
+
+    def completely_filled_out?
+      pages.all? {|p| p.complete?(self)}
+    end
+
+    def has_answer_for?(question_id)
+      !answers_by_question[question_id].nil?
+    end
+
+    def reference?
+      false
+    end
+
+    def percent_complete(required_only = true, restrict_to_pages = [])
+      # build an element to page lookup using page's cached all_element_ids
+      # this will make the hidden? calls on element faster because we can pass the page
+      # (the page builds a list of hidden elements for quick lookup)
+      elements_to_pages = {}
+      pages = question_sheets.collect(&:pages).flatten
+      pages = pages & restrict_to_pages if restrict_to_pages.present?
+      pages.each do |p|
+        p.all_element_ids_arr.each do |e_id|
+          elements_to_pages[e_id] = p
+        end
+      end
+
+      # determine which questions should count towards the questions total in the percent calculation
+      countable_questions = question_sheets.collect{ |qs| qs.all_elements.questions }.flatten
+      countable_questions.select!{ |e| elements_to_pages[e.id] } if restrict_to_pages.present?
+      countable_questions.reject!{ |e| e.hidden?(self, elements_to_pages[e.id]) }
+      countable_questions.select!{ |e| e.required } if required_only
+
+      # no progress if there are no questions
+      num_questions = countable_questions.length
+      return 0 if num_questions == 0
+
+      # count questions with answers in Fe::Answer
+      answers = self.answers.where("(question_id IN (?) AND value IS NOT NULL) AND (value != '')", countable_questions.collect(&:id))
+      answered_question_ids = answers.pluck(Arel.sql('distinct(question_id)'))
+
+      # need to look for answers for the remaining questions using has_response?
+      # so that questions with object_name/attribute_name set are counted
+      other_answered_questions = countable_questions.reject{ |e| answered_question_ids.include?(e.id) }
+      other_answered_questions.select!{ |e| e.has_response?(self) }
+
+      # count total
+      num_answers = answered_question_ids.count + other_answered_questions.count
+      [ [ (num_answers.to_f / num_questions.to_f * 100.0).to_i, 100 ].min, 0 ].max
+    end
+
+    def collat_title() "" end
+
+    def question_sheet_ids
+      question_sheets.collect(&:id)
+    end
+
+    def question_sheets_all_reference_elements
+      # forms are generally not changed often so caching on the last updated elementd
+      # will provide a good balance of speed and cache invalidation
+      element_ids = Rails.cache.fetch(question_sheets + ['answer_sheet#answer_sheet_all_reference_elements', Fe::Element.order('updated_at desc, id desc').first]) do
+        question_sheets.compact.collect { |q| q.all_elements.reference_kinds.pluck(:id) }.flatten
+      end
+
+      Fe::Element.find(element_ids)
+    end
+  end
+end

data/app/models/{fe/concerns → concerns/fe}/choice_field_concern.rb

@@ -13,11 +13,32 @@ module Fe
 
     begin
       included do
-        has_many :elements, :class_name => "Element", :foreign_key => "choice_field_id", :dependent => :nullify#, :order => :position
+        has_many :elements, class_name: "Element", foreign_key: "choice_field_id", dependent: :nullify#, order: :position
+        serialize :rating_before_label_translations, Hash
+        serialize :rating_after_label_translations, Hash
+        serialize :rating_na_label_translations, Hash
       end
     rescue ActiveSupport::Concern::MultipleIncludedBlocks
     end
 
+    def rating_before_label(locale = nil)
+      rating_before_label_translations &&
+        rating_before_label_translations[locale].present? ?
+        rating_before_label_translations[locale] : self[:rating_before_label]
+    end
+
+    def rating_after_label(locale = nil)
+      rating_after_label_translations && 
+        rating_after_label_translations[locale].present? ?
+        rating_after_label_translations[locale] : self[:rating_after_label]
+    end
+
+    def rating_na_label(locale = nil)
+      rating_na_label_translations && 
+        rating_na_label_translations[locale].present? ?
+        rating_na_label_translations[locale] : self[:rating_na_label]
+    end
+
     # Returns choices stored one per line in content field
     def choices(locale = nil)
       retVal = Array.new
@@ -34,7 +55,7 @@ module Fe
           retVal = [ doc.elements.collect(text_xpath){|c|c.text}, doc.elements.collect(value_xpath){|c|c.text} ].transpose
         end
       elsif content.present?
-        choices = content_translations[locale] || content
+        choices = content(locale)
         choices.split("\n").each do |opt|
           pair = opt.strip.split(";").reverse!
           pair[1] ||= pair[0]
@@ -44,19 +65,19 @@ module Fe
       return retVal
     end
 
-    def has_answer?(choice, app)
-      responses(app).each do |r|   # loop through Answers
-                                   # legacy field type choices may be int or tinyint
-                                   # raise r.inspect + ' - ' + choice.inspect if id == 1137 && r != 1
-                                   # r = r.to_s
-        return true if  case true
-                          when is_true(r) then is_true(choice)
-                          when is_false(r) then is_false(choice)
-                          else
-                            r.to_s == choice.to_s
-                        end
+    # choices can be an array, in which case any match returns true
+    def has_answer?(choice, answer_sheet)
+      if choice.is_a?(Array)
+        return choice.any? { |c| 
+          has_answer?(c, answer_sheet)
+        }
       end
-      false
+
+      responses(answer_sheet).any? { |r|
+        is_true(r) && is_true(choice) ||
+        is_false(r) && is_false(choice) ||
+        r.to_s.strip == choice.to_s.strip
+      }
     end
 
     # which view to render this element?
@@ -89,8 +110,8 @@ module Fe
     end
 
     # css class names for javascript-based validation
-    def validation_class(answer_sheet)
-      if self.required?(answer_sheet)
+    def validation_class(answer_sheet, page = nil)
+      if self.required?(answer_sheet, page)
         if self.style == 'drop-down'
           'validate-selection required'
         elsif self.style == 'rating'
@@ -105,9 +126,8 @@ module Fe
       end
     end
 
-    def display_response(app=nil)
+    def display_response(app = nil)
       r = responses(app)
-      r.reject! {|a| a.class == Answer && a.value.blank?}
       if r.blank?
         ""
       elsif self.style == 'yes-no'
@@ -120,15 +140,13 @@ module Fe
       elsif self.style == 'acceptance'
         "Accepted"  # if not blank, it's accepted
       else
-        r.compact.join(", ")
+        r.compact.join(', ')
       end
     end
 
     def conditional_match(answer_sheet)
-      displayed_response = display_response(answer_sheet)
-      (is_true(displayed_response) && is_true(conditional_answer)) ||
-        (is_response_false(answer_sheet) && is_false(conditional_answer)) ||
-        (displayed_response == conditional_answer)
+      has_answer?(conditional_answers, answer_sheet) || 
+        (responses(answer_sheet).empty? && conditional_answers.empty?)
     end
 
     def is_response_false(answer_sheet)

data/app/models/fe/address.rb

@@ -1,3 +1,3 @@
-class Fe::Address < ActiveRecord::Base
-  belongs_to :person
+class Fe::Address < ApplicationRecord
+  belongs_to :person, optional: true
 end

data/app/models/fe/answer.rb

@@ -7,7 +7,7 @@
 # may want special handling for ChoiceFields to store both id/slug and text representations
 
 module Fe
-  class Answer < ActiveRecord::Base
+  class Answer < ApplicationRecord
     include Fe::AnswerConcern
   end
 end

data/app/models/fe/answer_sheet.rb

@@ -1,5 +1,5 @@
 module Fe
-  class AnswerSheet < ActiveRecord::Base
+  class AnswerSheet < ApplicationRecord
     self.abstract_class = true
 
 =begin

data/app/models/fe/answer_sheet_question_sheet.rb

@@ -1,7 +1,7 @@
 module Fe
-  class AnswerSheetQuestionSheet < ActiveRecord::Base
+  class AnswerSheetQuestionSheet < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
     belongs_to :answer_sheet, class_name: Fe.answer_sheet_class
-    belongs_to :question_sheet, class_name: 'Fe::QuestionSheet'
+    belongs_to :question_sheet, optional: true, class_name: 'Fe::QuestionSheet'
   end
 end

data/app/models/fe/application.rb

@@ -5,12 +5,16 @@ class Fe::Application < Fe::AnswerSheet
 
   self.table_name = "#{Fe.table_name_prefix}applications"
 
-  belongs_to :applicant, foreign_key: 'person_id', class_name: "Person"
-  has_many :references, :class_name => 'ReferenceSheet', :foreign_key => :applicant_answer_sheet_id, :dependent => :destroy
-  has_one :answer_sheet_question_sheet, :foreign_key => "answer_sheet_id"
-  has_many :answer_sheet_question_sheets, :foreign_key => 'answer_sheet_id'
-  has_many :question_sheets, :through => :answer_sheet_question_sheets
-  
+  belongs_to :applicant, optional: true, foreign_key: 'person_id', class_name: "Person"
+  has_many :references, class_name: 'ReferenceSheet', foreign_key: :applicant_answer_sheet_id, dependent: :destroy
+  has_one :answer_sheet_question_sheet, foreign_key: "answer_sheet_id"
+  has_many :answer_sheet_question_sheets, foreign_key: 'answer_sheet_id'
+  has_many :question_sheets, through: :answer_sheet_question_sheets
+
+  has_paper_trail on: [], ignore: [:updated_at]
+
+  alias_method :all_references, :references
+
   # This will be overridden by the state machine defined in the enclosing app
   def completed?
     raise "completed? should be implemented by the extending class"
@@ -35,7 +39,7 @@ class Fe::Application < Fe::AnswerSheet
     end
     return Fe::ReferenceSheet.new()
   end
-  
+
   def answer_sheets
     a_sheets = [self]
     references.each do |r|
@@ -43,7 +47,7 @@ class Fe::Application < Fe::AnswerSheet
     end
     a_sheets
   end
-  
+
   def reference_answer_sheets
     r_sheets = Array.new()
     references.each do |r|
@@ -51,9 +55,9 @@ class Fe::Application < Fe::AnswerSheet
     end
     r_sheets
   end
-  
+
   def has_references?
     self.references.size > 0
   end
-  
+
 end

data/app/models/fe/condition.rb

@@ -3,17 +3,17 @@
 #                   i.e. "answer == 'yes'"
 # a question can have more than one answer (choose many) in which case ANY answer will do (find)
 module Fe
-  class Condition < ActiveRecord::Base
+  class Condition < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
 
     belongs_to :question_sheet
 
     belongs_to :trigger,
-               :class_name => "Question",
-               :foreign_key => "trigger_id"
+               class_name: "Question",
+               foreign_key: "trigger_id"
 
     validates_presence_of :expression
-    validates_length_of :expression, :maximum => 255, :allow_nil => true
+    validates_length_of :expression, maximum: 255, allow_nil: true
 
     # evaluate triggering element against expression and return match|nil
     def evaluate?

data/app/models/fe/date_field.rb

@@ -3,7 +3,7 @@
 module Fe
   class DateField < Question
 
-    def validation_class(answer_sheet = nil)
+    def validation_class(answer_sheet = nil, page = nil)
       if self.style == 'mmyy'
         'validate-selection ' + super
       else

data/app/models/fe/element.rb

@@ -1,42 +1,47 @@
 # Element represents a section, question or content element on the question sheet
 module Fe
-  class Element < ActiveRecord::Base
+  class Element < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
 
+    attr_accessor :old_id
+
     belongs_to :question_grid,
-               class_name: "Fe::QuestionGrid"
+               optional: true, class_name: "Fe::QuestionGrid"
 
     belongs_to :question_grid_with_total,
-               class_name: "Fe::QuestionGridWithTotal",
+               optional: true, class_name: "Fe::QuestionGridWithTotal",
                foreign_key: "question_grid_id"
 
     belongs_to :choice_field,
-               class_name: "Fe::ChoiceField"
+               optional: true, class_name: "Fe::ChoiceField"
 
     has_many :choice_field_children, foreign_key: 'choice_field_id',
       class_name: 'Fe::Element'
 
-    belongs_to :question_sheet, :foreign_key => "related_question_sheet_id"
+    belongs_to :question_sheet, optional: true, foreign_key: "related_question_sheet_id"
 
-    belongs_to :conditional, polymorphic: true
+    belongs_to :conditional, optional: true, polymorphic: true
 
     self.inheritance_column = :kind
 
     has_many :page_elements, dependent: :destroy
     has_many :pages, through: :page_elements
 
-    scope :active, -> { select("distinct(#{Fe::Element.table_name}.id), #{Fe::Element.table_name}.*").where(Fe::QuestionSheet.table_name + '.archived' => false).joins({:pages => :question_sheet}) }
+    scope :active, -> { select("distinct(#{Fe::Element.table_name}.id), #{Fe::Element.table_name}.*").where(Fe::QuestionSheet.table_name + '.archived' => false).joins({pages: :question_sheet}) }
     scope :questions, -> { where("kind NOT IN('Fe::Paragraph', 'Fe::Section', 'Fe::QuestionGrid', 'Fe::QuestionGridWithTotal')") }
+    scope :shared, -> { where(share: true) }
+    scope :grid_kinds, -> { where(kind: ['Fe::QuestionGrid', 'Fe::QuestionGridWithTotal']) }
+    scope :reference_kinds, -> { where(kind: 'Fe::ReferenceQuestion') }
 
     validates_presence_of :kind
     validates_presence_of :style
-    # validates_presence_of :label, :style, :on => :update
+    # validates_presence_of :label, :style, on: :update
 
-    validates_length_of :kind, :maximum => 40, :allow_nil => true
-    validates_length_of :style, :maximum => 40, :allow_nil => true
-    # validates_length_of :label, :maximum => 255, :allow_nil => true
+    validates_length_of :kind, maximum: 40, allow_nil: true
+    validates_length_of :style, maximum: 40, allow_nil: true
+    # validates_length_of :label, maximum: 255, allow_nil: true
 
-    before_validation :set_defaults, :on => :create
+    before_validation :set_defaults, on: :create
     before_save :set_conditional_element
     after_save :update_page_all_element_ids
     after_save :update_any_previous_conditional_elements
@@ -46,22 +51,22 @@ module Fe
     serialize :content_translations, Hash
 
     # HUMANIZED_ATTRIBUTES = {
-    #   :slug => "Variable"
+    #   slug: "Variable"
     # }changed.include?('address1')
     #
     # def self.human_attrib_name(attr)
     #   HUMANIZED_ATTRIBUTES[attr.to_sym] || super
     # end
     def label(locale = nil)
-      label_translations[locale] || self[:label]
+      label_translations[locale].present? ? label_translations[locale] : self[:label]
     end
 
     def content(locale = nil)
-      content_translations[locale] || self[:content]
+      content_translations[locale].present? ? content_translations[locale] : self[:content]
     end
 
     def tooltip(locale = nil)
-      tip_translations[locale] || self[:tooltip]
+      tip_translations[locale].present? ? tip_translations[locale] : self[:tooltip]
     end
 
     # returns all pages this element is on, whether that be directly, through a grid, or as a choice field conditional option
@@ -89,12 +94,10 @@ module Fe
     end
 
     # assume each element is on a question sheet only once to make things simpler. if not, just take the first one
+    # NOTE: getting the previous_element isn't an expensive operation any more because of the all_elements_id cache
     def previous_element(question_sheet, page = nil)
-      unless page
-        page_element = page_elements.joins(page: :question_sheet).where("#{Fe::QuestionSheet.table_name}.id" => question_sheet.id).first
-        return unless page_element
-        page = page_element.page
-      end
+      return false unless question_sheet
+      page ||= pages_on.detect{ |p| p.question_sheet == question_sheet }
 
       index = page.all_element_ids_arr.index(self.id)
       unless index
@@ -105,13 +108,46 @@ module Fe
         index = page.all_element_ids_arr.index(self.id)
       end
       if index && index > 0 && prev_el_id = page.all_element_ids_arr[index-1]
-        return Fe::Element.find(prev_el_id)
+        # occasionally the all_elements_ids_arr can get out of sync here, resulting in no element found
+        el = Fe::Element.find_by(id: prev_el_id)
+        unless el
+          page.rebuild_all_element_ids
+          index = page.all_element_ids_arr.index(self.id)
+          prev_el_id = page.all_element_ids_arr[index-1]
+          el = Fe::Element.find(prev_el_id) # give an error at this point if it's not found
+        end
+
+        return el
+      end
+    end
+
+    # return an array of all elements whose answers or visibility might affect
+    # the visibility of this element
+    def visibility_affecting_element_ids
+      return @visibility_affecting_element_ids if @visibility_affecting_element_ids
+
+      # the form doesn't change much so caching on the last updated element will
+      # provide a good balance of speed and cache invalidation
+      Rails.cache.fetch([self, 'element#visibility_affecting_element_ids', Fe::Element.order('updated_at desc, id desc').first]) do
+        elements = []
+
+        elements << question_grid if question_grid
+        elements << choice_field if choice_field
+        elements += Fe::Element.where(conditional_type: 'Fe::Element', conditional_id: id)
+        element_ids = elements.collect(&:id) +
+          elements.collect { |e| e.visibility_affecting_element_ids }.flatten
+        element_ids.uniq
       end
     end
 
-    def hidden_by_conditional?(answer_sheet, page, prev_el)
-      (prev_el ||= previous_element(answer_sheet.question_sheet, page)) &&
-        prev_el.is_a?(Fe::Question) &&
+    def visibility_affecting_questions
+      Fe::Question.where(id: visibility_affecting_element_ids)
+    end
+
+    def hidden_by_conditional?(answer_sheet, page)
+      return false unless answer_sheet.question_sheets.include?(page.question_sheet)
+      prev_el = previous_element(page.question_sheet, page)
+      prev_el.is_a?(Fe::Question) &&
         prev_el.conditional == self &&
         !prev_el.conditional_match(answer_sheet)
     end
@@ -122,21 +158,21 @@ module Fe
         choice_field.is_response_false(answer_sheet)
     end
 
-    # use prev_el directly if it's passed in; otherwise, pass page to previous_element to find the prev_el faster
-    def visible?(answer_sheet = nil, page = nil, prev_el = nil)
-      !hidden?(answer_sheet, page, prev_el)
+    # use page if it's passed in, otherwise it will revert to the first page in answer_sheet
+    def visible?(answer_sheet = nil, page = nil)
+      !hidden?(answer_sheet, page)
     end
 
-    # use prev_el directly if it's passed in; otherwise, pass page to previous_element to find the prev_el faster
-    def hidden?(answer_sheet = nil, page = nil, prev_el = nil)
-      @hidden ||= answer_sheet &&
-        (hidden_by_choice_field?(answer_sheet) ||
-         hidden_by_conditional?(answer_sheet, page, prev_el))
+    # use page if it's passed in, otherwise it will revert to the first page in answer_sheet
+    def hidden?(answer_sheet = nil, page = nil)
+      page ||= pages_on.detect{ |p| answer_sheet.question_sheets.include?(p.question_sheet) }
+      return true if !page || page.hidden?(answer_sheet)
+      return page.all_hidden_elements(answer_sheet).include?(self)
     end
 
-    # use prev_el directly if it's passed in; otherwise, pass page to previous_element to find the prev_el faster
-    def required?(answer_sheet = nil, page = nil, prev_el = nil)
-      if hidden?(answer_sheet, page, prev_el)
+    # use page if it's passed in, otherwise it will revert to the first page in answer_sheet
+    def required?(answer_sheet = nil, page = nil)
+      if answer_sheet && hidden?(answer_sheet, page)
         return false
       else
         required == true
@@ -145,7 +181,7 @@ module Fe
 
     def position(page = nil)
       if page
-        page_elements.where(:page_id => page.id).first.try(:position)
+        page_elements.where(page_id: page.id).first.try(:position)
       else
         self[:position]
       end
@@ -153,7 +189,7 @@ module Fe
 
     def set_position(position, page = nil)
       if page
-        pe = page_elements.where(:page_id => page.id).first
+        pe = page_elements.where(page_id: page.id).first
         pe.update_attribute(:position, position) if pe
       else
         self[:position] = position
@@ -189,8 +225,8 @@ module Fe
           new_element.choice_field_id = parent.id
       end
       new_element.position = parent.elements.maximum(:position).to_i + 1 if parent
-      new_element.save!(:validate => false)
-      Fe::PageElement.create(:element => new_element, :page => page) unless parent
+      new_element.save!(validate: false)
+      Fe::PageElement.create(element: new_element, page: page) unless parent
 
       # duplicate children
       if respond_to?(:elements) && elements.present?
@@ -204,7 +240,10 @@ module Fe
     def all_elements
       if respond_to?(:elements)
         elements.reload
-        (elements + elements.collect(&:all_elements)).flatten
+        #(elements + elements.collect(&:all_elements)).flatten
+        elements.collect{ |el|
+          [el, el.all_elements]
+        }.flatten
       else
         []
       end
@@ -215,10 +254,14 @@ module Fe
       (self.is_a?(Fe::Question) || self.is_a?(Fe::QuestionGrid) || self.is_a?(Fe::QuestionGridWithTotal))
     end
 
+    def conditional_answers
+      conditional_answer.split(';').collect(&:strip)
+    end
+
     def conditional_match(answer_sheet)
       displayed_response = display_response(answer_sheet)
       return false unless displayed_response && conditional_answer
-      (displayed_response.split(',') & conditional_answer.split(',')).length > 0
+      conditional_answers.include?(displayed_response)
     end
 
     def self.max_label_length
@@ -232,7 +275,7 @@ module Fe
 
           if index = page.all_element_ids_arr.index(self.id)
             self.conditional_id = page.all_element_ids_arr[index+1]
-          else 
+          else
             self.conditional_id = nil
           end
         end
@@ -255,13 +298,52 @@ module Fe
     end
 
     def update_page_all_element_ids
-      [question_grid, question_grid_with_total].compact.each do |field|
+      [question_grid, question_grid_with_total, choice_field].compact.each do |field|
         field.update_page_all_element_ids
       end
 
       pages.reload.each do |p| p.rebuild_all_element_ids end
     end
 
+    # matches in an AND method; if requested we can add a second filter method later
+    # to match on an OR basis
+    def matches_filter(filter)
+      filter.all? { |method| self.send(method) }
+    end
+
+    def css_classes
+      css_class.to_s.split(' ').collect(&:strip)
+    end
+
+    def self.create_from_import(element_data, page, question_sheet)
+      element_data[:old_id] = element_data.delete('id')
+      children = element_data.delete(:children)
+      element = element_data['kind'].constantize.create!(element_data)
+      question_sheet.element_id_mappings[element.old_id] = element.id
+      children.each do |child|
+        byebug unless child.class == Hash
+        child_element = create_from_import(child, page, question_sheet)
+        if child['choice_field_id'].present?
+          child_element.choice_field_id = element.id
+        end
+        byebug if child_element.label == 'Your Name:'
+        if child['question_grid_id'].present?
+          child_element.question_grid_id = element.id
+        end
+        child_element.save!
+      end
+      element
+    end
+
+    def export_hash
+      children = choice_field_children.collect(&:export_hash)
+      self.attributes.to_hash.merge(children: children)
+    end
+
+    def export_to_yaml
+      export_hash.to_yaml
+    end
+
     protected
 
     def set_defaults