fe 0.0.4 → 2.0.0

data/app/models/fe/question_set.rb

@@ -3,30 +3,24 @@
 module Fe
   class QuestionSet
 
-    attr_reader :elements
+    attr_reader :elements, :questions
 
     # associate answers from database with a set of elements
     def initialize(elements, answer_sheet)
       @elements = elements
       @answer_sheet = answer_sheet
-
       @questions = elements.select { |e| e.question? }
-
-      # answers = @answer_sheet.answers_by_question
-
-      @questions.each do |question|
-        question.answers = question.responses(answer_sheet) #answers[question.id]
-      end
-      @questions
     end
 
     # update with responses from form
     def post(params, answer_sheet)
-      questions_indexed = @questions.index_by {|q| q.id}
+      questions_indexed = @questions.index_by(&:id)
 
       # loop over form values
       params ||= {}
-      params.each do |question_id, response|
+      # we only assign answers to questions from this set, so it's fine to use to_unsafe_h here.  If we don't,
+      # the kind_of?(Hash) checks will fail as per rails 5
+      params.to_unsafe_h.each do |question_id, response|
         next if questions_indexed[question_id.to_i].nil? # the rare case where a question was removed after the app was opened.
         # update each question with the posted response
         questions_indexed[question_id.to_i].set_response(posted_values(response), answer_sheet)
@@ -53,6 +47,51 @@ module Fe
       end
     end
 
+    # options should contain:
+    # 
+    # :filter - Array of symbols, ex [ :confidential ]
+    #
+    #           These will be called on each element to determine if they match the filter
+    #           An element matches the filter using an AND condition, ie. if all the methods
+    #           in the array return true
+    # 
+    # :filter_default - Either :show or :hide
+    #
+    #           If show, all elements are shown by default and hidden if they match the filter.
+    #           If hide, all elements are hidden by default and shown if they match the filter.
+    #
+    def set_filter(options = {})
+      return if options.nil? || options.empty?
+
+      filter = options.delete(:filter)
+      unless filter && filter.is_a?(Array)
+        raise("expect options[:filter] to be an array")
+      end
+      filter_default = options.delete(:filter_default)
+      unless filter_default && [:show, :hide].include?(filter_default)
+        raise("expect options[:filter_default] to be either :show or :hide")
+      end
+
+      @filter = filter
+      @filter_default = filter_default
+
+      matching_ids = []
+      @elements.each do |e|
+        if e.matches_filter(@filter) && !matching_ids.include?(e.id)
+          matching_ids << e.id
+          matching_ids += e.all_elements.collect(&:id)
+        end
+      end
+
+      case filter_default
+      when :show
+        @elements = @elements.to_a.reject{ |e| matching_ids.include?(e.id) }
+      when :hide
+        @elements = @elements.to_a.select{ |e| matching_ids.include?(e.id) }
+      end
+
+      initialize(@elements, @answer_sheet)
+    end
 
     private
 
@@ -65,11 +104,13 @@ module Fe
         if month.blank? or year.blank?
           values = ''
         else
-          values = [Date.new(year.to_i, month.to_i, 1).strftime('%m/%d/%Y')]  # for mm/yy drop downs
+          values = [Date.new(year.to_i, month.to_i, 1).strftime('%Y-%m-%d')]  # for mm/yy drop downs
         end
       elsif param.kind_of?(Hash)
         # from Hash with multiple answers per question
-        values = param.values.map {|v| CGI.unescape(v)}
+        # If value is also a hash, use the value hash without escaping or anything,
+        # so that custom elements can be implemented by handling set_response.
+        values = param.values.map {|v| v.is_a?(Hash) ? v : CGI.unescape(v)}
       elsif param.kind_of?(String)
         values = [CGI.unescape(param)]
       end
@@ -77,6 +118,5 @@ module Fe
       # Hash may contain empty string to force post for no checkboxes
   #    values = values.reject {|r| r == ''}
     end
-
   end
 end

data/app/models/fe/question_sheet.rb

@@ -1,61 +1,96 @@
 # QuestionSheet represents a particular form
 module Fe
-  class QuestionSheet < ActiveRecord::Base
+  class QuestionSheet < ApplicationRecord
     self.table_name = self.table_name.sub('fe_', Fe.table_name_prefix)
 
-    has_many :pages, -> { order('number') },
-             :dependent => :destroy
+    attr_accessor :old_id
+    attr_accessor :element_id_mappings
 
-    # has_many :elements
-    # has_many :questions
+    has_many :pages, -> { order('number') },
+             dependent: :destroy
 
     has_many :answer_sheet_question_sheets
 
     has_many :answer_sheets,
-             :through => :answer_sheet_question_sheets
+             through: :answer_sheet_question_sheets
+    has_many :question_sheets,
+             through: :answer_sheet_question_sheets
 
-    scope :active, -> { where(:archived => false) }
-    scope :archived, -> { where(:archived => true) }
+    scope :active, -> { where(archived: false) }
+    scope :archived, -> { where(archived: true) }
 
     validates_presence_of :label
-    #  validates_length_of :label, :maximum => 60, :allow_nil => true
-    validates_uniqueness_of :label
+
+    serialize :languages, Array
 
     before_destroy :check_for_answers
 
     # create a new form with a page already attached
     def self.new_with_page
-      question_sheet = self.new(:label => next_label)
-      question_sheet.pages.build(:label => 'Page 1', :number => 1)
+      question_sheet = self.new(label: next_label)
+      question_sheet.pages.build(label: 'Page 1', number: 1)
       question_sheet
     end
 
     def questions
-      pages.collect(&:questions).flatten
+      all_elements.questions
     end
 
     def elements
       pages.collect(&:elements).flatten
     end
 
+    def all_elements
+      element_ids = pages.pluck(:all_element_ids).compact.join(',').split(',').find_all(&:present?)
+      element_ids.present? ? Element.where(id: element_ids).order(Arel.sql(element_ids.collect{ |id| "id=#{id} DESC" }.join(', '))) : Element.where("1 = 0")
+    end
+
     # Pages get duplicated
     # Question elements get associated
     # non-question elements get cloned
     def duplicate
       new_sheet = QuestionSheet.new(self.attributes.merge(id: nil))
       new_sheet.label = self.label + ' - COPY'
-      new_sheet.save(:validate => false)
+      new_sheet.save(validate: false)
       self.pages.each do |page|
         page.copy_to(new_sheet)
       end
       new_sheet
     end
 
-    # pages hidden by a conditional element
-    def hidden_pages(answer_sheet)
-      elements.find_all{ |e| 
-        e.conditional.is_a?(Fe::Page) && !e.conditional_match(answer_sheet)
-      }.collect(&:conditional)
+    def export_to_yaml
+      atts = attributes.to_hash
+      atts[:pages] = pages.collect(&:export_hash)
+      atts.to_yaml
+    end
+
+    def self.create_from_yaml(filename)
+      # NOTE: yaml will break if some classes aren't loaded before YAML::load, strange
+      Fe::Element.distinct.where.not(kind: 'Fe::Style').pluck(:kind).each(&:constantize)
+
+      sheet_data = YAML::load(File.read(filename))
+      sheet_data[:old_id] = sheet_data.delete("id")
+      pages = sheet_data.delete(:pages)
+      puts("Create import by data #{sheet_data}")
+      question_sheet = Fe::QuestionSheet.create!(sheet_data)
+      question_sheet.element_id_mappings = []
+      pages.each do |page_atts|
+        page = Page.create_from_import(page_atts, question_sheet)
+        question_sheet.pages << page
+      end
+      # set page conditional_id values to new ids based on old_id
+      question_sheet.all_elements.each do |el|
+        if el.conditional_type != "Fe::Page" && el.conditional_id.present?
+          # noop
+        end
+
+        # note that conditional elements are already translated to new ids in the element import so no need to do it here
+        if el.conditional_type == "Fe::Page" && el.conditional_id
+          el.update(conditional_id: question_sheet.pages.detect{ |el2| el2.old_id == el.conditional_id }&.id)
+        end
+      end
+
+      question_sheet
     end
 
     private

data/app/models/fe/reference_question.rb

@@ -2,22 +2,15 @@
 # - a question that provides a fields to specify a reference
 module Fe
   class ReferenceQuestion < Question
+    has_many :reference_sheets, foreign_key: :question_id
+
+    after_save :update_references_question_sheet_ids
 
     def response(app=nil)
       return unless app
       # A reference is the same if the related_question_sheet corresponding to the question is the same
       reference = Fe::ReferenceSheet.find_by_applicant_answer_sheet_id_and_question_id(app.id, id)
-      # if references.present?
-      #   reference = references.detect {|r| r.question_id == id }
-      #   # If they have another reference that matches this question id, don't go fishing for another one
-      #   unless reference
-      #     # If the question_id doesn't match, but the reference question is based on the same reference template (question sheet)
-      #     # update the reference with the new question_id
-      #     reference = references.detect {|r| r.question.related_question_sheet_id == related_question_sheet_id}
-      #     reference.update_attribute(:question_id, id) if reference
-      #   end
-      # end
-      reference || Fe::ReferenceSheet.create(:applicant_answer_sheet_id => app.id, :question_id => id)
+      reference || Fe::ReferenceSheet.create(applicant_answer_sheet_id: app.id, question_id: id)
     end
 
     def has_response?(app = nil)
@@ -25,11 +18,11 @@ module Fe
         reference = response(app)
         reference && reference.valid?
       else
-        Fe::ReferenceSheet.where(:question_id => id).count > 0
+        Fe::ReferenceSheet.where(question_id: id).count > 0
       end
     end
 
-    def display_response(app=nil)
+    def display_response(app = nil, humanize = false)
       response(app).to_s
     end
 
@@ -38,5 +31,8 @@ module Fe
       "fe/reference_#{style}"
     end
 
+    def update_references_question_sheet_ids
+      reference_sheets.where(status: :created).update_all(question_sheet_id: related_question_sheet_id, updated_at: Time.now)
+    end
   end
 end

data/app/models/fe/reference_sheet.rb

@@ -1,38 +1,49 @@
 require 'validates_email_format_of'
 require 'aasm'
 module Fe
-  class ReferenceSheet < ActiveRecord::Base
+  class ReferenceSheet < ApplicationRecord
     include Fe::AnswerSheetConcern
     include Rails.application.routes.url_helpers
     include AASM
+    include AccessKeyGenerator
+
+    attr_accessor :allow_quiet_reference_email_changes
+
     self.table_name = "#{Fe.table_name_prefix}references"
     self.inheritance_column = 'fake'
 
+    scope :visible, -> { where(visible: true) }
+
     belongs_to :question,
-               :class_name => 'Element',
-               :foreign_key => 'question_id'
+               class_name: 'Fe::ReferenceQuestion',
+               foreign_key: 'question_id'
 
     belongs_to :applicant_answer_sheet,
-               :class_name => Fe.answer_sheet_class,
-               :foreign_key => "applicant_answer_sheet_id"
+               class_name: "::#{Fe.answer_sheet_class}",
+               foreign_key: "applicant_answer_sheet_id"
 
-    validates_presence_of :first_name, :last_name, :phone, :email, :relationship, :on => :update, :message => "can't be blank"
-    validates :email, :email_format => { :message => "doesn't look right." }
+    # using belongs_to :question_sheet doesn't work, it uses the Fe::AnswerSheetConcern#question_sheet implementation
+    belongs_to :question_sheet_ref, optional: true, class_name: 'Fe::QuestionSheet', foreign_key: :question_sheet_id
 
-    delegate :style, :to => :question
+    validates_presence_of :first_name, :last_name, :phone, :email, :relationship, on: :update, message: "can't be blank"
+    validates :email, email_format: { on: :update, message: "doesn't look right." }
 
-    before_save :check_email_change
+    delegate :style, to: :question
 
+    before_save :reset_reference, if: :new_reference_requested?
+    after_save :notify_old_reference_not_needed, if: :new_reference_requested?
+    before_create :set_question_sheet
     after_destroy :notify_reference_of_deletion
+    after_create :update_visible
 
-    aasm :initial => :created, :column => :status do
+    aasm column: :status do
 
-      state :started, :enter => Proc.new {|ref|
-        ref.started_at = Time.now
+      state :started, enter: Proc.new {
+        update(started_at: Time.now)
       }
-      state :created
-      state :completed, :enter => Proc.new {|ref|
-        ref.submitted_at = Time.now
+      state :created, initial: true
+      state :completed, enter: Proc.new {
+        update(submitted_at: Time.now)
         # SpReferenceMailer.deliver_completed(ref)
 =begin
         Fe::Notifier.notification(ref.email, # RECIPIENTS
@@ -57,26 +68,44 @@ module Fe
                                    'password' => person.user.password_plain}).deliver
 =end
 
-        ref.applicant_answer_sheet.complete(ref)
+        applicant_answer_sheet.complete(self)
       }
 
       event :start do
-        transitions :to => :started, :from => :created
+        transitions to: :started, from: :created
       end
 
       event :submit do
-        transitions :to => :completed, :from => :started
-        transitions :to => :completed, :from => :created
+        transitions to: :completed, from: :started
+        transitions to: :completed, from: :created
       end
 
       event :unsubmit do
-        transitions :to => :started, :from => :completed
+        transitions to: :started, from: :completed
       end
     end
 
-    alias_method :applicant, :applicant_answer_sheet
-    def generate_access_key
-      self.access_key = Digest::MD5.hexdigest(email + Time.now.to_s)
+    alias_method :application, :applicant_answer_sheet
+    delegate :applicant, to: :application
+
+    def computed_visibility_cache_key
+      return @computed_visibility_cache_key if @computed_visibility_cache_key
+      return nil unless question # keep from crashing for tests
+      answers = Fe::Answer.where(question_id: question.visibility_affecting_element_ids,
+                                 answer_sheet_id: applicant_answer_sheet)
+      answers.collect(&:cache_key_with_version).join('/')
+    end
+
+    def update_visible(page = nil)
+      if visibility_cache_key == computed_visibility_cache_key
+        visible
+      else
+        self.visible = question.visible?(applicant_answer_sheet, page)
+        self.visibility_cache_key = computed_visibility_cache_key
+        # save only these columns and don't check validations, but do record updated_at
+        # as it is significant enough of an event that we probably want that to set updated_at
+        Fe::ReferenceSheet.where(id: id).update_all(visibility_cache_key: self.computed_visibility_cache_key, visible: self.visible, updated_at: Time.now)
+      end
     end
 
     def frozen?
@@ -86,7 +115,7 @@ module Fe
     def email_sent?() !self.email_sent_at.nil? end
 
     # send email invite
-    def send_invite
+    def send_invite(host)
       return if self.email.blank?
 
       application = self.applicant_answer_sheet
@@ -95,21 +124,21 @@ module Fe
                             Fe.from_email,
                             "Reference Invite",
                             {'reference_full_name' => self.name,
-                             'applicant_full_name' => application.name,
-                             'applicant_email' => application.email,
-                             'applicant_home_phone' => application.phone,
-                             'reference_url' => edit_fe_reference_sheet_url(self, :a => self.access_key, :host => ActionMailer::Base.default_url_options[:host])}).deliver
+                             'applicant_full_name' => application.applicant.name,
+                             'applicant_email' => application.applicant.email,
+                             'applicant_home_phone' => application.applicant.phone,
+                             'reference_url' => edit_fe_reference_sheet_url(self, a: self.access_key, host: host)}).deliver_now
       # Send notification to applicant
-      Notifier.notification(applicant_answer_sheet.email, # RECIPIENTS
+      Notifier.notification(applicant_answer_sheet.applicant.email, # RECIPIENTS
                             Fe.from_email, # FROM
                             "Reference Notification to Applicant", # LIQUID TEMPLATE NAME
-                            {'applicant_full_name' => applicant_answer_sheet.name,
+                            {'applicant_full_name' => applicant_answer_sheet.applicant.name,
                              'reference_full_name' => self.name,
                              'reference_email' => self.email,
-                             'application_url' => edit_fe_answer_sheet_url(applicant_answer_sheet, :host => ActionMailer::Base.default_url_options[:host])}).deliver
+                             'application_url' => edit_fe_answer_sheet_url(applicant_answer_sheet, host: host)}).deliver_now
 
       self.email_sent_at = Time.now
-      self.save(:validate => false)
+      self.save(validate: false)
 
       true
     end
@@ -126,48 +155,78 @@ module Fe
       name
     end
 
-    def required?
-      question.required?(applicant_answer_sheet)
-    end
-
     def reference?
       true
     end
 
     # Can't rely on answer_sheet's implementation for old reference's that might have id's that may match an application id
     def question_sheet
-      QuestionSheet.find(question.related_question_sheet_id) if question && question.related_question_sheet_id
+      question_sheet_ref
     end
 
-    # Can't rely on answer_sheet's implementation for old reference's that might have id's that may match an application id
     def question_sheets
-      [question_sheet]
+      [question_sheet_ref]
+    end
+
+    def question_sheet_ids
+      [question_sheet_id].compact
     end
 
     def display_type
       question.label.split(/:| \(/).first
     end
 
+    def optional?
+      question.try(:hidden?, applicant_answer_sheet)
+    end
+
+    def required?
+      question.required?(applicant_answer_sheet) && !optional?
+    end
+
+    def all_affecting_questions_answered
+      return false unless question
+      question.visibility_affecting_questions.all? { |q| q.has_response?(applicant_answer_sheet) }
+    end
+
     protected
+
+    def set_question_sheet
+      self.question_sheet_id = question.try(:related_question_sheet_id)
+    end
+
     # if the email address has changed, we have to trash the old reference answers
-    def check_email_change
-      if changed.include?('email')
-        answers.destroy_all
-        # Every time the email address changes, generate a new access_key
-        generate_access_key
-        self.email_sent_at = nil
-        self.status = 'created'
-      end
+    def reset_reference
+      answers.destroy_all
+      # Every time the email address changes, generate a new access_key
+      generate_access_key
+      self.email_sent_at = nil
+      self.status = 'created'
+    end
+
+    def notify_old_reference_not_needed
+      return unless email_sent_at_was.present? && email_was.present?
+      notify_reference_not_needed(self, email_was, first_name_was, last_name_was)
     end
 
     def notify_reference_of_deletion
-      if email.present?
-        Notifier.notification(email,
-                              Fe.from_email,
-                              "Reference Deleted",
-                              {'reference_full_name' => self.name,
-                               'applicant_full_name' => applicant_answer_sheet.name}).deliver
-      end
+      return unless email_sent_at.present? && email.present?
+      notify_reference_not_needed(self, email, first_name, last_name)
+    end
+
+    def notify_reference_not_needed(ref, ref_email, ref_first_name, ref_last_name)
+      # inform referrer that they no longer need to fill out reference
+      Fe::Notifier.notification(
+        ref_email, # RECIPIENTS
+        Fe.from_email, # FROM
+        'Reference Deleted',
+        { 'reference_full_name' => "#{ref_first_name} #{ref_last_name}",
+          'applicant_full_name' => applicant_answer_sheet.applicant.name }
+       ).deliver_now
+    end
+
+    def new_reference_requested?
+      !allow_quiet_reference_email_changes && !new_record? && !completed? && email_changed?
     end
   end
 end

data/app/models/fe/state_chooser.rb

@@ -3,8 +3,8 @@ require 'carmen'
 # - drop down of states
 module Fe
   class StateChooser < Question
-    def choices(country = 'US')
-      @states = Carmen.states(country)
+    def choices(locale = nil, country = 'US')
+      @states = _(Carmen.states(country))
     end
   end
 end

data/app/models/fe/text_field.rb

@@ -14,9 +14,9 @@ module Fe
     end
 
     # css class names for javascript-based validation
-    def validation_class(answer_sheet)
+    def validation_class(answer_sheet, page = nil)
       validation = ''
-      validation += ' required' if self.required?(answer_sheet)
+      validation += ' required' if self.required?(answer_sheet, page)
       # validate-number, etc.
       validate_style = ['number', 'currency-dollar', 'email', 'url', 'phone'].find {|v| v == self.style }
       if validate_style

data/app/models/fe/user.rb

@@ -1,3 +1,3 @@
-class Fe::User < ActiveRecord::Base
+class Fe::User < ApplicationRecord
   belongs_to :user
 end

data/app/models/staff.rb

@@ -1,10 +1,12 @@
-class Staff < ActiveRecord::Base
+class Staff < ApplicationRecord
   self.table_name = "ministry_staff"
   belongs_to :person
   
-  belongs_to :primary_address, :class_name => "StaffAddress", :foreign_key => :fk_primaryAddress
-  belongs_to :secondary_address, :class_name => "StaffAddress", :foreign_key => :fk_secondaryAddress
+  belongs_to :primary_address, class_name: "StaffAddress", foreign_key: :fk_primaryAddress
+  belongs_to :secondary_address, class_name: "StaffAddress", foreign_key: :fk_secondaryAddress
   
+  alias_attribute :preferred_name, :preferredName
+
   def self.get_staff(ssm_id)
     if ssm_id.nil? then raise "nil ssm_id!" end
     ssm_user = User.find_by(userID: ssm_id)
@@ -70,13 +72,13 @@ class Staff < ActiveRecord::Base
     ]
   end
   
-  scope :specialty_roles, -> { where(:jobStatus => "Staff Full Time").where(:ministry => "Campus Ministry").
-      where(:removedFromPeopleSoft => "N").where("jobTitle NOT IN (?)", field_roles).order(:jobTitle).order(:lastName) }
+  scope :specialty_roles, -> { where(jobStatus: "Staff Full Time").where(ministry: "Campus Ministry").
+      where(removedFromPeopleSoft: "N").where("jobTitle NOT IN (?)", field_roles).order(:jobTitle).order(:lastName) }
 
   def self.get_roles(region)
     result = {}
     Staff.strategy_order.each do |strategy|
-      result[strategy] = specialty_roles.where(:strategy => strategy).where(:region => region)
+      result[strategy] = specialty_roles.where(strategy: strategy).where(region: region)
     end
     result
   end

data/app/validators/email_validator.rb

@@ -0,0 +1,11 @@
+require 'mail'
+
+class EmailValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    begin
+      parsed = Mail::Address.new(value)
+    rescue Mail::Field::ParseError => e
+    end
+    record.errors.add attribute, "is not valid" unless !parsed.nil? && parsed.address == value && parsed.local != value #cannot be a local address
+  end
+end

data/app/views/fe/admin/elements/create.js.erb

@@ -1,11 +1,12 @@
 <% if @page_element %>
   $('#question_modal').dialog('close');
-  $('#page-preview').html('<%= escape_javascript(render('fe/admin/question_pages/question_page')) %>');
+  $('#page-preview').html('<%= escape_javascript(render("fe/admin/question_pages/question_page")) %>');
   $('#element_<%= dom_id(@element) %>').hide();
-  $('#element_form_<%= dom_id(@element) %>').html('<%= escape_javascript(render('fe/admin/panels/prop_element',:element => @element)) %>');
+  $('#element_form_<%= dom_id(@element) %>').html('<%= escape_javascript(render("fe/admin/panels/prop_element", element: @element)) %>');
   $('#element_form_<%= dom_id(@element) %>').show();
   selectElement("#element_<%= @element.id %>");
-  $.scrollTo("#element_<%= @element.id %>");
+  scrollTo("#element_<%= @element.id %>");
+  setUpSortables();
 <% else %>
   alert('That question already exists on this question sheet')
 <% end %>

data/app/views/fe/admin/elements/destroy.js.erb

@@ -1,4 +1,4 @@
 $('#element_<%= @element.id %>').remove()
-$('#panel').html('<%= escape_javascript(render('fe/admin/panels/insert')) %>')
+$('#panel').html('<%= escape_javascript(render("fe/admin/panels/insert")) %>')
 activeElement = ''
 switchTab('insert')

data/app/views/fe/admin/elements/drop.js.erb

@@ -1,2 +1,3 @@
-$('#page-preview').html('<%= escape_javascript(render('fe/admin/question_pages/question_page', :page => @page)) %>')
+$('#page-preview').html('<%= escape_javascript(render("fe/admin/question_pages/question_page", page: @page)) %>')
 $('#list-pages li').removeClass('active')
+setUpJsHelpers();

data/app/views/fe/admin/elements/duplicate.js.erb

@@ -1,2 +1,3 @@
-$('#page-preview').html('<%= escape_javascript(render('fe/admin/question_pages/question_page')) %>')
+$('#page-preview').html('<%= escape_javascript(render("fe/admin/question_pages/question_page")) %>')
 selectElement("#element_<%= @element.id %>")
+setUpSortables();

data/app/views/fe/admin/elements/edit.js.erb

@@ -1,4 +1,4 @@
 $('#element_<%= dom_id(@element) %>').hide()
-$('#element_form_<%= dom_id(@element) %>').html('<%= escape_javascript(render('fe/admin/panels/prop_element',:element => @element)) %>')
+$('#element_form_<%= dom_id(@element) %>').html('<%= escape_javascript(render("fe/admin/panels/prop_element", element: @element)) %>')
 $('#element_form_<%= dom_id(@element) %>').show();
 selectElement("#element_<%= @element.id %>")

data/app/views/fe/admin/elements/error.js.erb

@@ -1,4 +1,4 @@
-$('#errors').html('<%= escape_javascript(render('errors', :element => @element)) %>')
+$('#errors').html('<%= escape_javascript(render("errors", element: @element)) %>')
 <% @element.errors.each do |attr_name, message| %> 
   addError('element_<%= attr_name %>')
 <% end %>