diff --git a/app/controllers/answers_controller.rb b/app/controllers/answers_controller.rb
index 28b3fe3..fd991ff 100644
--- a/app/controllers/answers_controller.rb
+++ b/app/controllers/answers_controller.rb
@@ -56,7 +56,7 @@
         }
       }).find(p_params[:plan_id])
       @question = @answer.question
-      @section = @plan.get_section(@question.section_id)
+      @section = @plan.sections.find_by(id: @question.section_id)
       template = @section.phase.template
 
       render json: {
diff --git a/app/controllers/application_controller.rb b/app/controllers/application_controller.rb
index d8e5aad..adaa154 100644
--- a/app/controllers/application_controller.rb
+++ b/app/controllers/application_controller.rb
@@ -96,64 +96,53 @@
     "#{_('Successfully %{action} your %{object}.') % {object: obj_name, action: action}}"
   end
 
-  # Check whether the string is a valid array of JSON objects
-  def is_json_array_of_objects?(string)
-    if string.present?
-      begin
-        json = JSON.parse(string)
-        return (json.is_a?(Array) && json.all?{ |o| o.is_a?(Hash) })
-      rescue JSON::ParserError
-        return false
+  private
+
+  # Override rails default render action to look for a branded version of a
+  # template instead of using the default one. If no override exists, the
+  # default version in ./app/views/[:controller]/[:action] will be used
+  #
+  # The path in the app/views/branded/ directory must match the the file it is
+  # replacing. For example:
+  #  app/views/branded/layouts/_header.html.erb -> app/views/layouts/_header.html.erb
+  def prepend_view_paths
+    prepend_view_path "app/views/branded"
+  end
+
+  def errors_to_s(obj)
+    if obj.errors.count > 0
+      msg = "<br />"
+      obj.errors.each do |e,m|
+        if m.include?('empty') || m.include?('blank')
+          msg += "#{_(e)} - #{_(m)}<br />"
+        else
+          msg += "'#{obj[e]}' - #{_(m)}<br />"
+        end
       end
+      msg
     end
   end
 
-  private
-    # Override rails default render action to look for a branded version of a
-    # template instead of using the default one. If no override exists, the
-    # default version in ./app/views/[:controller]/[:action] will be used
-    #
-    # The path in the app/views/branded/ directory must match the the file it is
-    # replacing. For example:
-    #  app/views/branded/layouts/_header.html.erb -> app/views/layouts/_header.html.erb
-    def prepend_view_paths
-      prepend_view_path "app/views/branded"
+  ##
+  # Sign out of Shibboleth SP local session too.
+  # -------------------------------------------------------------
+  def after_sign_out_path_for(resource_or_scope)
+    if Rails.application.config.shibboleth_enabled
+      return Rails.application.config.shibboleth_logout_url + root_url
+      super
+    else
+      super
     end
+  end
+  # -------------------------------------------------------------
 
-    def errors_to_s(obj)
-      if obj.errors.count > 0
-        msg = "<br />"
-        obj.errors.each do |e,m|
-          if m.include?('empty') || m.include?('blank')
-            msg += "#{_(e)} - #{_(m)}<br />"
-          else
-            msg += "'#{obj[e]}' - #{_(m)}<br />"
-          end
-        end
-        msg
-      end
+  def from_external_domain?
+    if request.referer.present?
+      referer = URI.parse(request.referer)
+      home = URI.parse(root_url)
+      referer.host != home.host
+    else
+      false
     end
-
-    ##
-    # Sign out of Shibboleth SP local session too.
-    # -------------------------------------------------------------
-    def after_sign_out_path_for(resource_or_scope)
-      if Rails.application.config.shibboleth_enabled
-        return Rails.application.config.shibboleth_logout_url + root_url
-        super
-      else
-        super
-      end
-    end
-    # -------------------------------------------------------------
-
-    def from_external_domain?
-      if request.referer.present?
-        referer = URI.parse(request.referer)
-        home = URI.parse(root_url)
-        referer.host != home.host
-      else
-        false
-      end
-    end
+  end
 end
diff --git a/app/controllers/concerns/conditional_user_mailer.rb b/app/controllers/concerns/conditional_user_mailer.rb
index aa7622b..d8bc509 100644
--- a/app/controllers/concerns/conditional_user_mailer.rb
+++ b/app/controllers/concerns/conditional_user_mailer.rb
@@ -1,35 +1,27 @@
-module ConditionalUserMailer
-  extend ActiveSupport::Concern
+# frozen_string_literal: true
 
-  # Adds following methods as class methods for the class that include this module
-  included do
-    # Executes a given block passed if the recipient user has the preference email key enabled
-    # @param recipients {User | Enumerable } User object or any object that includes Enumerable class
-    # @param key {String} - A key (dot notation) whose value is true/false and belongs to prefences.email (see config/branding.yml)
-    def deliver_if(recipients: [], key:)
-      raise(ArgumentError, 'key must be String') unless key.is_a?(String)
-      if block_given?
-        split_key = key.split('.')
-        if !recipients.respond_to?(:each)
-          recipients = Array(recipients)
-        end
-        recipients.each do |r|
-          if r.respond_to?(:get_preferences)
-            email_hash = r.get_preferences('email')
-            should_deliver = split_key.reduce(email_hash) do |m,o|
-              if m.is_a?(Hash)
-                m[o.to_sym]
-              else
-                break
-              end
-            end
-            yield r if should_deliver.is_a?(TrueClass)
-          end
-        end
-        true
-      else  # Block not given
-        false
-      end
+module ConditionalUserMailer
+
+  # Executes a given block passed if the recipient user has the preference
+  # email key enabled
+  #
+  # @param recipients {User | Enumerable } User object or any object that
+  # includes Enumerable class
+  #
+  # @param key {String} - A key (dot notation) whose value is true/false and
+  # belongs to prefences.email (see config/branding.yml)
+  #
+  # Returns true or false
+  def deliver_if(recipients: [], key:, &block)
+    return false unless block_given?
+
+    Array(recipients).each do |recipient|
+      email_hash = recipient.get_preferences('email').with_indifferent_access
+      preference_value = !!email_hash.dig(*key.to_s.split('.'))
+      block.call(recipient) if preference_value
     end
+
+    true
   end
-end
\ No newline at end of file
+
+end
diff --git a/app/controllers/concerns/versionable.rb b/app/controllers/concerns/versionable.rb
index 676d4d2..aa633d7 100644
--- a/app/controllers/concerns/versionable.rb
+++ b/app/controllers/concerns/versionable.rb
@@ -1,106 +1,123 @@
 module Versionable
-  extend ActiveSupport::Concern
 
-  included do
-    ##
-    # Takes in a Template, phase, Section, Question, or Annotaion
-    # IF the template is published, generates a new template
-    # finds the passed object in the new template
-    # @param obj - Template, Phase, Section, Question, Annotation
-    # @return type_of(obj)
-    def get_modifiable(obj)
-      if obj.respond_to?(:template)
-        template = obj.template
-      elsif obj.is_a?(Template)
-        template = obj
-      else
-        raise ArgumentError, _('obj should be a Template, Phase, Section, Question, or Annotation')
-      end
-      
-      new_template = Template.find_or_generate_version!(template) # raises RuntimeError if template is not latest
-
-      if new_template != template
-        if obj.is_a?(Template)
-          obj = new_template
-        else
-          obj = find_in_space(obj,new_template.phases)
-        end
-      end
-      return obj
-    end
-    ##
-    # Takes in a phase, Section, Question, or Annotation which is newly
-    # generated and returns a modifiable version of that object
-    # NOTE: the obj passed is still not saved however it should belongs to a parent already
-    def get_new(obj)
-      raise ArgumentError, _('obj should be a Phase, Section, Question, or Annotation') unless obj.respond_to?(:template)
-
+  ##
+  # Takes in a Template, phase, Section, Question, or Annotaion
+  # IF the template is published, generates a new template
+  # finds the passed object in the new template
+  # @param obj - Template, Phase, Section, Question, Annotation
+  # @return type_of(obj)
+  def get_modifiable(obj)
+    if obj.respond_to?(:template)
       template = obj.template
-      new_template = Template.find_or_generate_version!(template) # raises RuntimeError if template is not latest
-
-      if new_template != template # Copied version
-        case obj
-          when Phase
-            belongs = :template
-          when Section
-            belongs = :phase
-          when Question
-            belongs = :section
-          when Annotation
-            belongs = :question
-          else
-            raise ArgumentError,  _('obj should be a Phase, Section, Question, or Annotation')
-        end
-
-        if belongs == :template
-          obj = obj.send(:deep_copy)
-          obj.template = new_template
-        else
-          found = find_in_space(obj.send(belongs), new_template.phases)
-          obj = obj.send(:deep_copy)
-          obj.send("#{belongs}=", found)
-        end
-      end
-      return obj
+    elsif obj.is_a?(Template)
+      template = obj
+    else
+      raise ArgumentError,
+        _('obj should be a Template, Phase, Section, Question, or Annotation')
     end
+
+    # raises RuntimeError if template is not latest
+    new_template = Template.find_or_generate_version!(template)
+
+    if new_template != template
+      if obj.is_a?(Template)
+        obj = new_template
+      else
+        obj = find_in_space(obj,new_template.phases)
+      end
+    end
+    return obj
+  end
+
+  ##
+  # Takes in a phase, Section, Question, or Annotation which is newly
+  # generated and returns a modifiable version of that object
+  # NOTE: the obj passed is still not saved however it should belongs to a
+  # parent already
+  def get_new(obj)
+    unless obj.respond_to?(:template)
+      raise ArgumentError,
+        _('obj should be a Phase, Section, Question, or Annotation')
+    end
+
+    template = obj.template
+    # raises RuntimeError if template is not latest
+    new_template = Template.find_or_generate_version!(template)
+
+    if new_template != template # Copied version
+      case obj
+      when Phase
+        belongs = :template
+      when Section
+        belongs = :phase
+      when Question
+        belongs = :section
+      when Annotation
+        belongs = :question
+      else
+        raise ArgumentError,
+          _('obj should be a Phase, Section, Question, or Annotation')
+      end
+
+      if belongs == :template
+        obj = obj.send(:deep_copy)
+        obj.template = new_template
+      else
+        found = find_in_space(obj.send(belongs), new_template.phases)
+        obj = obj.send(:deep_copy)
+        obj.send("#{belongs}=", found)
+      end
+    end
+    return obj
   end
 
   private
-    # Locates an object (e.g. phase, section, question, annotation) in a search_space
-    # (e.g. phases/sections/questions/annotations) by comparing either the number method or
-    # the org_id and text for annotations
-    def find_in_space(obj, search_space)
-      raise ArgumentError, _('The search_space does not respond to each') unless search_space.respond_to?(:each)
-      raise ArgumentError, _('The search space does not have elements associated') unless search_space.length > 0
 
-      if obj.is_a?(search_space.first.class)
-        if obj.respond_to?(:number) # object is an instance of Phase, Section or Question
-          return search_space.find{ |search| search.number == obj.number }
-        elsif obj.respond_to?(:org_id) && obj.respond_to?(:text)  # object is an instance of Annotation
-          return search_space.find{ |annotation| annotation.org_id == obj.org_id && annotation.text == obj.text }
+  # Locates an object (e.g. phase, section, question, annotation) in a
+  # search_space
+  # (e.g. phases/sections/questions/annotations) by comparing either the number
+  # method or the org_id and text for annotations
+  def find_in_space(obj, search_space)
+    unless search_space.respond_to?(:each)
+      raise ArgumentError, _('The search_space does not respond to each')
+    end
+    unless search_space.length > 0
+      raise ArgumentError,
+        _('The search space does not have elements associated')
+    end
+
+    if obj.is_a?(search_space.first.class)
+      # object is an instance of Phase, Section or Question
+      if obj.respond_to?(:number)
+        return search_space.find{ |search| search.number == obj.number }
+      # object is an instance of Annotation
+      elsif obj.respond_to?(:org_id) && obj.respond_to?(:text)
+        return search_space.find do |annotation|
+          annotation.org_id == obj.org_id && annotation.text == obj.text
         end
-        return nil
-      end
-
-      case search_space.first
-        when Phase
-          number = obj.phase.number
-          relation = :sections
-        when Section
-          number = obj.section.number
-          relation = :questions
-        when Question
-          number = obj.question.number
-          relation = :annotations
-        else
-          return nil
-      end
-
-      search_space = search_space.find{ |search| search.number == number }
-
-      if search_space.present?
-        return find_in_space(obj, search_space.send(relation))
       end
       return nil
     end
+
+    case search_space.first
+    when Phase
+      number = obj.phase.number
+      relation = :sections
+    when Section
+      number = obj.section.number
+      relation = :questions
+    when Question
+      number = obj.question.number
+      relation = :annotations
+    else
+      return nil
+    end
+
+    search_space = search_space.find{ |search| search.number == number }
+
+    if search_space.present?
+      return find_in_space(obj, search_space.send(relation))
+    end
+    return nil
+  end
 end
diff --git a/app/controllers/org_admin/plans_controller.rb b/app/controllers/org_admin/plans_controller.rb
index b8bd89d..6d1e9a6 100644
--- a/app/controllers/org_admin/plans_controller.rb
+++ b/app/controllers/org_admin/plans_controller.rb
@@ -4,31 +4,31 @@
     def index
       # Test auth directly and throw Pundit error sincePundit is unaware of namespacing
       raise Pundit::NotAuthorizedError unless current_user.present? && current_user.can_org_admin?
-      
+
       vals = Role.access_values_for(:reviewer)
       @feedback_plans = Plan.joins(:roles).where('roles.user_id = ? and roles.access IN (?)', current_user.id, vals)
       @plans = current_user.org.plans
     end
-    
+
     # GET org_admin/plans/:id/feedback_complete
     def feedback_complete
       plan = Plan.find(params[:id])
       # Test auth directly and throw Pundit error sincePundit is unaware of namespacing
       raise Pundit::NotAuthorizedError unless current_user.present? && current_user.can_org_admin?
       raise Pundit::NotAuthorizedError unless plan.reviewable_by?(current_user.id)
-      
+
       if plan.complete_feedback(current_user)
         redirect_to org_admin_plans_path, notice: _('%{plan_owner} has been notified that you have finished providing feedback') % { plan_owner: plan.owner.name(false) }
       else
         redirect_to org_admin_plans_path, alert: _('Unable to notify user that you have finished providing feedback.')
       end
     end
-    
+
     # GET /org_admin/download_plans
     def download_plans
       # Test auth directly and throw Pundit error sincePundit is unaware of namespacing
       raise Pundit::NotAuthorizedError unless current_user.present? && current_user.can_org_admin?
-      
+
       org = current_user.org
       file_name = org.name.gsub(/ /, "_")
       header_cols = [
@@ -40,20 +40,20 @@
         "#{_('Updated')}",
         "#{_('Visibility')}"
       ]
-      
+
       plans = CSV.generate do |csv|
         csv << header_cols
         org.plans.includes(template: :org).order(updated_at: :desc).each do |plan|
           owner = plan.owner
           csv << [
-            "#{plan.title}", 
-            "#{plan.template.title}", 
-            "#{plan.owner.org.present? ? plan.owner.org.name : ''}", 
+            "#{plan.title}",
+            "#{plan.template.title}",
+            "#{plan.owner.org.present? ? plan.owner.org.name : ''}",
             "#{plan.owner.name(false)}",
             "#{plan.owner.email}",
             "#{l(plan.latest_update.to_date, formats: :short)}",
-            "#{Plan.visibility_message(plan.visibility.to_sym).capitalize}"
-          ] 
+            "#{Plan::VISIBILITY_MESSAGE[plan.visibility.to_sym].capitalize}"
+          ]
         end
       end
 
diff --git a/app/controllers/plans_controller.rb b/app/controllers/plans_controller.rb
index 9b1a535..fde81df 100644
--- a/app/controllers/plans_controller.rb
+++ b/app/controllers/plans_controller.rb
@@ -168,7 +168,6 @@
     render('/phases/edit', locals: {
       base_template_org: phase.template.base_org,
       plan: plan, phase: phase, readonly: readonly,
-      question_guidance: plan.guidance_by_question_as_hash,
       guidance_groups: guidance_groups,
       answers: answers,
       guidance_service: GuidanceService.new(plan) })
@@ -237,9 +236,6 @@
   def status
     @plan = Plan.find(params[:id])
     authorize @plan
-    respond_to do |format|
-      format.json { render json: @plan.status }
-    end
   end
 
   def answer
@@ -405,25 +401,6 @@
     groups.values
   end
 
-
-  def fixup_hash(plan)
-    rollup(plan, "notes", "answer_id", "answers")
-    rollup(plan, "answers", "question_id", "questions")
-    rollup(plan, "questions", "section_id", "sections")
-    rollup(plan, "sections", "phase_id", "phases")
-
-    plan["template"]["phases"] = plan.delete("phases")
-
-    ghash = {}
-    plan["guidance_groups"].map{|g| ghash[g["id"]] = g}
-    plan["plans_guidance_groups"].each do |pgg|
-      pgg["guidance_group"] = ghash[ pgg["guidance_group_id"] ]
-    end
-
-    plan["template"]["org"] = Org.find(plan["template"]["org_id"]).serializable_hash()
-  end
-
-
   # find all object under src_plan_key
   # merge them into the items under obj_plan_key using
   # super_id = id
diff --git a/app/controllers/roles_controller.rb b/app/controllers/roles_controller.rb
index 913bc2a..6752ef5 100644
--- a/app/controllers/roles_controller.rb
+++ b/app/controllers/roles_controller.rb
@@ -9,7 +9,7 @@
     authorize @role
 
     access_level = params[:role][:access_level].to_i
-    @role.set_access_level(access_level)
+    @role.access_level = access_level
     message = ''
     if params[:user].present?
       if @role.plan.owner.present? && @role.plan.owner.email == params[:user]
@@ -51,7 +51,7 @@
     @role = Role.find(params[:id])
     authorize @role
     access_level = params[:role][:access_level].to_i
-    @role.set_access_level(access_level)
+    @role.access_level = access_level
     if @role.update_attributes(role_params)
       deliver_if(recipients: @role.user, key: 'users.added_as_coowner') do |r|
         UserMailer.permissions_change_notification(@role, current_user).deliver_now
diff --git a/app/helpers/application_helper.rb b/app/helpers/application_helper.rb
index a2a6012..ea0077a 100644
--- a/app/helpers/application_helper.rb
+++ b/app/helpers/application_helper.rb
@@ -1,5 +1,5 @@
 module ApplicationHelper
-  
+
   def resource_name
     :user
   end
@@ -13,11 +13,6 @@
   def devise_mapping
     @devise_mapping ||= Devise.mappings[:user]
   end
-  
-  # ---------------------------------------------------------------------------
-  def hash_to_js_json_variable(obj_name, hash)
-    "<script type=\"text/javascript\">var #{obj_name} = #{hash.to_json};</script>".html_safe
-  end
 
   # Determines whether or not the URL path passed matches with the full path (including params) of the last URL requested.
   # see http://api.rubyonrails.org/classes/ActionDispatch/Request.html#method-i-fullpath for details
@@ -30,10 +25,6 @@
     end
   end
 
-  def is_integer?(string)
-    return string.present? && string.match(/^(\d)+$/)
-  end
-
   def fingerprinted_asset(name)
     Rails.env.production? ? "#{name}-#{ASSET_FINGERPRINT}" : name
   end
diff --git a/app/helpers/plans_helper.rb b/app/helpers/plans_helper.rb
index 1b9cb6d..b726508 100644
--- a/app/helpers/plans_helper.rb
+++ b/app/helpers/plans_helper.rb
@@ -1,27 +1,10 @@
 module PlansHelper
-  # Shows whether the user has default, template-default or custom settings
-  # for the given plan.
-  # --------------------------------------------------------
-  def plan_settings_indicator(plan)
-    plan_settings     = plan.super_settings(:export)
-    template_settings = plan.template.try(:settings, :export)
-
-    key = if plan_settings.try(:value?)
-      plan_settings.formatting == template_settings.formatting ? "template_formatting" : "custom_formatting"
-    elsif template_settings.try(:value?)
-      "template_formatting"
-    else
-      "default_formatting"
-    end
-
-    content_tag(:small, t("helpers.settings.plans.#{key}"))
-  end
 
   # display the role of the user for a given plan
   def display_role(role)
     if role.creator?
       access = _('Owner')
-      
+
     else
       case role.access_level
         when 3
@@ -48,7 +31,7 @@
       return "<span>#{_('Private')}</span>" # Test Plans
     end
   end
-  
+
   def visibility_tooltip(val)
     case val
     when 'organisationally_visible'
diff --git a/app/models/annotation.rb b/app/models/annotation.rb
index b8a6968..5dc5b9d 100644
--- a/app/models/annotation.rb
+++ b/app/models/annotation.rb
@@ -53,6 +53,7 @@
                    uniqueness: { message: UNIQUENESS_MESSAGE,
                                  scope: [:question_id, :org_id] }
 
+
   # =================
   # = Class Methods =
   # =================
diff --git a/app/models/answer.rb b/app/models/answer.rb
index 46d9aa8..22b9a09 100644
--- a/app/models/answer.rb
+++ b/app/models/answer.rb
@@ -72,8 +72,7 @@
     answer.question_options.each do |opt|
       answer_copy.question_options << opt
     end
-    answer_copy.save!
-    return answer_copy
+    answer_copy
   end
 
   # This method helps to decide if an answer option (:radiobuttons, :checkbox, etc ) in form views should be checked or not
diff --git a/app/models/concerns/exportable_plan.rb b/app/models/concerns/exportable_plan.rb
index f4cec41..37af160 100644
--- a/app/models/concerns/exportable_plan.rb
+++ b/app/models/concerns/exportable_plan.rb
@@ -1,122 +1,120 @@
 module ExportablePlan
-  extend ActiveSupport::Concern
 
-  included do
-
-    def as_pdf(coversheet = false)
-      prepare(coversheet)
-    end
-
-    def as_csv(headings = true, unanswered = true)
-      hash = prepare(false)
-
-      CSV.generate do |csv|
-        hdrs = (hash[:phases].length > 1 ? [_('Phase')] : [])
-        if headings
-          hdrs << [_('Section'),_('Question'),_('Answer')]
-        else
-          hdrs << [_('Answer')]
-        end
-
-        csv << hdrs.flatten
-        hash[:phases].each do |phase|
-          phase[:sections].each do |section|
-            section[:questions].each do |question|
-              answer = self.answer(question[:id], false)
-              answer_text = answer.present? ? answer.text : (unanswered ? _('Not Answered') : '')
-              flds = (hash[:phases].length > 1 ? [phase[:title]] : [])
-              if headings
-                if question[:text].is_a? String
-                  question_text = question[:text]
-                else
-                  question_text = (question[:text].length > 1 ? question[:text].join(', ') : question[:text][0])
-                end
-                flds << [ section[:title], sanitize_text(question_text), sanitize_text(answer_text) ]
-              else
-                flds << [ sanitize_text(answer_text) ]
-              end
-
-              csv << flds.flatten
-            end
-          end
-        end
-      end
-    end
-
-    private
-      def prepare(coversheet = false)
-        hash = coversheet ? prepare_coversheet : {}
-        template = Template.includes(phases: { sections: {questions: :question_format } }).
-                            joins(phases: { sections: { questions: :question_format } }).
-                            where(id: self.template_id).order('sections.number', 'questions.number').first
-
-        hash[:title] = self.title
-        hash[:answers] = self.answers
-
-        # add the relevant questions/answers
-        phases = []
-        template.phases.each do |phase|
-          phs = { title: phase.title, number: phase.number, sections: [] }
-          phase.sections.each do |section|
-            sctn = { title: section.title, number: section.number, questions: [] }
-            section.questions.each do |question|
-              txt = question.text
-              sctn[:questions] << { id: question.id, text: txt, format: question.question_format }
-            end
-            phs[:sections] << sctn
-          end
-          phases << phs
-        end
-        hash[:phases] = phases
-
-        record_plan_export(:pdf)
-
-        hash
-      end
-
-      def prepare_coversheet
-        hash = {}
-        # name of owner and any co-owners
-        attribution = self.owner.present? ? [self.owner.name(false)] : []
-        self.roles.administrator.not_creator.each do |role|
-          attribution << role.user.name(false)
-        end
-        hash[:attribution] = attribution
-
-        # Org name of plan owner's org
-        hash[:affiliation] = self.owner.present? ? self.owner.org.name : ''
-
-        # set the funder name
-        hash[:funder] = self.funder_name.present? ? self.funder_name : (self.template.org.present? ? self.template.org.name : '')
-
-        # set the template name and customizer name if applicable
-        hash[:template] = self.template.title
-        customizer = ""
-        cust_questions = self.questions.where(modifiable: true).pluck(:id)
-        # if the template is customized, and has custom answered questions
-        if self.template.customization_of.present? && Answer.where(plan_id: self.id, question_id: cust_questions).present?
-          customizer = _(" Customised By: ") + self.template.org.name
-        end
-        hash[:customizer] = customizer
-        hash
-      end
-
-      def record_plan_export(format)
-        exported_plan = ExportedPlan.new.tap do |ep|
-          ep.plan = self
-          ep.phase_id = self.phases.first.id
-          ep.format = format
-          plan_settings = self.settings(:export)
-
-          Settings::Template::DEFAULT_SETTINGS.each do |key, value|
-            ep.settings(:export).send("#{key}=", plan_settings.send(key))
-          end
-        end
-        exported_plan.save
-      end
-
-      def sanitize_text(text)
-        if (!text.nil?) then ActionView::Base.full_sanitizer.sanitize(text.gsub(/&nbsp;/i,"")) end
-      end
+  def as_pdf(coversheet = false)
+    prepare(coversheet)
   end
+
+  def as_csv(headings = true, unanswered = true)
+    hash = prepare(false)
+
+    CSV.generate do |csv|
+      hdrs = (hash[:phases].length > 1 ? [_('Phase')] : [])
+      if headings
+        hdrs << [_('Section'),_('Question'),_('Answer')]
+      else
+        hdrs << [_('Answer')]
+      end
+
+      csv << hdrs.flatten
+      hash[:phases].each do |phase|
+        phase[:sections].each do |section|
+          section[:questions].each do |question|
+            answer = self.answer(question[:id], false)
+            answer_text = answer.present? ? answer.text : (unanswered ? _('Not Answered') : '')
+            flds = (hash[:phases].length > 1 ? [phase[:title]] : [])
+            if headings
+              if question[:text].is_a? String
+                question_text = question[:text]
+              else
+                question_text = (question[:text].length > 1 ? question[:text].join(', ') : question[:text][0])
+              end
+              flds << [ section[:title], sanitize_text(question_text), sanitize_text(answer_text) ]
+            else
+              flds << [ sanitize_text(answer_text) ]
+            end
+
+            csv << flds.flatten
+          end
+        end
+      end
+    end
+  end
+
+  private
+
+  def prepare(coversheet = false)
+    hash = coversheet ? prepare_coversheet : {}
+    template = Template.includes(phases: { sections: {questions: :question_format } }).
+    joins(phases: { sections: { questions: :question_format } }).
+    where(id: self.template_id).order('sections.number', 'questions.number').first
+
+    hash[:title] = self.title
+    hash[:answers] = self.answers
+
+    # add the relevant questions/answers
+    phases = []
+    template.phases.each do |phase|
+      phs = { title: phase.title, number: phase.number, sections: [] }
+      phase.sections.each do |section|
+        sctn = { title: section.title, number: section.number, questions: [] }
+        section.questions.each do |question|
+          txt = question.text
+          sctn[:questions] << { id: question.id, text: txt, format: question.question_format }
+        end
+        phs[:sections] << sctn
+      end
+      phases << phs
+    end
+    hash[:phases] = phases
+
+    record_plan_export(:pdf)
+
+    hash
+  end
+
+  def prepare_coversheet
+    hash = {}
+    # name of owner and any co-owners
+    attribution = self.owner.present? ? [self.owner.name(false)] : []
+    self.roles.administrator.not_creator.each do |role|
+      attribution << role.user.name(false)
+    end
+    hash[:attribution] = attribution
+
+    # Org name of plan owner's org
+    hash[:affiliation] = self.owner.present? ? self.owner.org.name : ''
+
+    # set the funder name
+    hash[:funder] = self.funder_name.present? ? self.funder_name : (self.template.org.present? ? self.template.org.name : '')
+
+    # set the template name and customizer name if applicable
+    hash[:template] = self.template.title
+    customizer = ""
+    cust_questions = self.questions.where(modifiable: true).pluck(:id)
+    # if the template is customized, and has custom answered questions
+    if self.template.customization_of.present? && Answer.where(plan_id: self.id, question_id: cust_questions).present?
+      customizer = _(" Customised By: ") + self.template.org.name
+    end
+    hash[:customizer] = customizer
+    hash
+  end
+
+  def record_plan_export(format)
+    exported_plan = ExportedPlan.new.tap do |ep|
+      ep.plan = self
+      ep.phase_id = self.phases.first.id
+      ep.format = format
+      plan_settings = self.settings(:export)
+
+      Settings::Template::DEFAULT_SETTINGS.each do |key, value|
+        ep.settings(:export).send("#{key}=", plan_settings.send(key))
+      end
+    end
+    exported_plan.save
+  end
+
+  def sanitize_text(text)
+    ActionView::Base.full_sanitizer.sanitize(text.to_s.gsub(/&nbsp;/i,""))
+  end
+
 end
diff --git a/app/models/concerns/json_link_validator.rb b/app/models/concerns/json_link_validator.rb
index 8315a7d..739174c 100644
--- a/app/models/concerns/json_link_validator.rb
+++ b/app/models/concerns/json_link_validator.rb
@@ -1,32 +1,15 @@
 module JSONLinkValidator
-  extend ActiveSupport::Concern
 
-  included do
-    # Parses a stringified JSON according to validate_links (e.g. [{ link: String, text: String}, ...])
-    # param {String} the stringified JSON value
-    # Returns an Array of hashes after decoding/validating the stringified JSON passed, otherwise nil
-    def parse_links(value)
-      return nil unless value.is_a?(String)
-      begin
-        parsed_value = JSON.parse(value)
-        return valid_links?(parsed_value) ? parsed_value : nil
-      rescue JSON::ParserError
-        nil
+  # Validates whether or not the value passed is conforming to
+  # [{ link: String, text: String}, ...]
+  def valid_links?(value)
+    if value.is_a?(Array)
+      r = value.all? do |o|
+        o.is_a?(Hash) && o.key?('link') && o.key?('text') &&
+        o['link'].is_a?(String) && o['text'].is_a?(String)
       end
+      return r
     end
-    # Validates whether or not the value passed is conforming to [{ link: String, text: String}, ...]
-    def valid_links?(value)
-      if value.is_a?(Array)
-        r = value.all? do |o| 
-          o.is_a?(Hash) &&
-          o.has_key?('link') &&
-          o.has_key?('text') &&
-          o['link'].is_a?(String) &&
-          o['text'].is_a?(String)
-        end
-        return r
-      end
-      false
-    end
+    false
   end
 end
\ No newline at end of file
diff --git a/app/models/guidance.rb b/app/models/guidance.rb
index 5ad8950..4258326 100644
--- a/app/models/guidance.rb
+++ b/app/models/guidance.rb
@@ -1,3 +1,7 @@
+# Guidance provides information from organisations to Users, helping them when
+# answering questions. (e.g. "Here's how to think about your data
+# protection responsibilities...")
+#
 # == Schema Information
 #
 # Table name: guidances
@@ -26,8 +30,6 @@
 # [+Created:+] 07/07/2014
 # [+Copyright:+] Digital Curation Centre and California Digital Library
 
-
-
 class Guidance < ActiveRecord::Base
   include GlobalHelpers
   include ValidationMessages
@@ -36,12 +38,10 @@
   # ================
   # = Associations =
   # ================
-  belongs_to :guidance_group
-  has_and_belongs_to_many :themes, join_table: "themes_in_guidance"
 
-  # EVALUATE CLASS AND INSTANCE METHODS BELOW
-  #
-  # What do they do? do they do it efficiently, and do we need them?
+  belongs_to :guidance_group
+
+  has_and_belongs_to_many :themes, join_table: "themes_in_guidance"
 
 
   # ===============
@@ -62,37 +62,15 @@
 
   scope :search, -> (term) {
     search_pattern = "%#{term}%"
-    joins(:guidance_group).where("guidances.text LIKE ? OR guidance_groups.name LIKE ?", search_pattern, search_pattern)
+    joins(:guidance_group)
+      .where("guidances.text LIKE ? OR guidance_groups.name LIKE ?",
+             search_pattern,
+             search_pattern)
   }
-  ##
-  # Determine if a guidance is in a group which belongs to a specified organisation
-  #
-  # @param org_id [Integer] the integer id for an organisation
-  # @return [Boolean] true if this guidance is in a group belonging to the specified organisation, false otherwise
-	def in_group_belonging_to?(org_id)
-    unless guidance_group.nil?
-  		if guidance_group.org.id == org_id
-  			return true
-  		end
-    end
-		return false
-	end
 
-  ##
-  # returns all templates belgonging to a specified guidance group
-  #
-  # @param guidance_group [Integer] the integer id for an guidance_group
-  # @return [Array<Templates>] list of templates
-	def get_guidance_group_templates? (guidance_group)
-    # DISCUSS - here we have yet another way of finding a specific or group of
-    # an object.  Would it make sense to standardise the project by only using
-    # either finders or where, or alteast the same syntax within the where statement.
-    # Also why is this a ? method... it dosent return a boolean
-    # Additionally, shouldnt this be a function of guidance group, not guidance?
-    # and finally, it should be a self.method, as it dosent care about the guidance it's acting on
-			templates = guidancegroups.where("guidance_group_id (?)", guidance_group.id).template
-			return templates
-	end
+  # =================
+  # = Class methods =
+  # =================
 
   ##
   # Returns whether or not a given user can view a given guidance
@@ -103,7 +81,8 @@
   #
   # @param id [Integer] the integer id for a guidance
   # @param user [User] a user object
-  # @return [Boolean] true if the specified user can view the specified guidance, false otherwise
+  # @return [Boolean] true if the specified user can view the specified
+  # guidance, false otherwise
   def self.can_view?(user, id)
     guidance = Guidance.find_by(id: id)
     viewable = false
@@ -114,7 +93,8 @@
         if guidance.guidance_group.org == user.org
           viewable = true
         end
-        # guidance groups are viewable if they are owned by the Managing Curation Center
+        # guidance groups are viewable if they are owned by the Managing
+        # Curation Center
         if Org.managing_orgs.include?(guidance.guidance_group.org)
           viewable = true
         end
@@ -139,16 +119,38 @@
   # @param user [User] a user object
   # @return [Array<Guidance>] a list of all "viewable" guidances to a user
   def self.all_viewable(user)
-    managing_groups = Org.includes(guidance_groups: :guidances).managing_orgs.collect{|o| o.guidance_groups}
+    managing_groups = Org.includes(guidance_groups: :guidances)
+                         .managing_orgs.collect{|o| o.guidance_groups}
     # find all groups owned by a Funder organisation
-    funder_groups = Org.includes(guidance_groups: :guidances).funder.collect{|org| org.guidance_groups}
+    funder_groups = Org.includes(guidance_groups: :guidances)
+                       .funder.collect{|org| org.guidance_groups}
     # find all groups owned by any of the user's organisations
     organisation_groups = user.org.guidance_groups
 
     # find all guidances belonging to any of the viewable groups
-    all_viewable_groups = (managing_groups + funder_groups + organisation_groups).flatten
-    all_viewable_guidances = all_viewable_groups.collect{|group| group.guidances}
+    all_viewable_groups = (managing_groups +
+                            funder_groups +
+                            organisation_groups).flatten
+    all_viewable_guidances = all_viewable_groups.collect do |group|
+      group.guidances
+    end
     # pass the list of viewable guidances to the view
     return all_viewable_guidances.flatten
   end
+
+  ##
+  # Determine if a guidance is in a group which belongs to a specified
+  # organisation
+  #
+  # @param org_id [Integer] the integer id for an organisation
+  # @return [Boolean] true if this guidance is in a group belonging to the
+  # specified organisation, false otherwise
+  def in_group_belonging_to?(org_id)
+    unless guidance_group.nil?
+      if guidance_group.org.id == org_id
+        return true
+      end
+    end
+    return false
+  end
 end
diff --git a/app/models/guidance_group.rb b/app/models/guidance_group.rb
index f9520a2..db9888a 100644
--- a/app/models/guidance_group.rb
+++ b/app/models/guidance_group.rb
@@ -1,3 +1,6 @@
+# Set of Guidances that pertain to a certain category of Users (e.g. Maths
+# department, vs Biology department)
+#
 # == Schema Information
 #
 # Table name: guidance_groups
@@ -18,20 +21,20 @@
 #
 #  fk_rails_...  (org_id => orgs.id)
 #
-
 class GuidanceGroup < ActiveRecord::Base
   include GlobalHelpers
   include ValidationValues
   include ValidationMessages
 
-  ##
-  # Associations
-  belongs_to :org
-  has_many :guidances, dependent: :destroy
-  has_and_belongs_to_many :plans, join_table: :plans_guidance_groups
-  # depricated but needed for migration "single_group_for_guidance"
-  # has_and_belongs_to_many :guidances, join_table: "guidance_in_group"
+  # ================
+  # = Associations =
+  # ================
 
+  belongs_to :org
+
+  has_many :guidances, dependent: :destroy
+
+  has_and_belongs_to_many :plans, join_table: :plans_guidance_groups
 
   # ===============
   # = Validations =
@@ -54,48 +57,18 @@
   # What do they do? do they do it efficiently, and do we need them?
 
   # Retrieves every guidance group associated to an org
-  scope :by_org, -> (org) {
-    where(org_id: org.id)
-  }
-  scope :search, -> (term) {
+  scope :by_org, ->(org) { where(org_id: org.id) }
+
+  scope :search, lambda { |term|
     search_pattern = "%#{term}%"
     where("name LIKE ?", search_pattern)
   }
 
-  ##
-  # Converts the current guidance group to a string containing the display name.
-  # If it's organisation has no other guidance groups, then the name is simply
-  # the name of the parent organisation, otherwise it returns the name of the
-  # organisation followed by the name of the guidance group.
-  #
-  # @return [String] the display name for the guidance group
-	def display_name
-		if org.guidance_groups.count > 1
-			return "#{org.name}: #{name}"
-		else
-			return org.name
-		end
-	end
+  scope :published, -> { where(published: true) }
 
-  ##
-  # Returns the list of all guidance groups not coming from the given organisations
-  #
-  # @param excluded_orgs [Array<Organisation>] a list of organisations to exclude in the result
-  # @return [Array<GuidanceGroup>] a list of guidance groups
-  def self.guidance_groups_excluding(excluded_orgs)
-    excluded_org_ids = Array.new
-
-    if excluded_orgs.is_a?(Array)
-      excluded_orgs.each do |org|
-        excluded_org_ids << org.id
-      end
-    else
-      excluded_org_ids << excluded_orgs
-    end
-
-    return_orgs =  GuidanceGroup.where("org_id NOT IN (?)", excluded_org_ids)
-    return return_orgs
-  end
+  # =================
+  # = Class methods =
+  # =================
 
   ##
   # Returns whether or not a given user can view a given guidance group
@@ -106,48 +79,50 @@
   #
   # @param id [Integer] the integer id for a guidance group
   # @param user [User] a user object
-  # @return [Boolean] true if the specified user can view the specified guidance group, false otherwise
+  # @return [Boolean] true if the specified user can view the specified
+  # guidance group, false otherwise
   def self.can_view?(user, guidance_group)
     viewable = false
     # groups are viewable if they are owned by any of the user's organisations
-    if guidance_group.org == user.org
-      viewable = true
-    end
+    viewable = true if guidance_group.org == user.org
     # groups are viewable if they are owned by the managing curation center
     Org.managing_orgs.each do |managing_group|
-      if guidance_group.org.id == managing_group.id
-        viewable = true
-      end
+      viewable = true if guidance_group.org.id == managing_group.id
     end
     # groups are viewable if they are owned by a funder
-    if guidance_group.org.funder?
-      viewable = true
-    end
+    viewable = true if guidance_group.org.funder?
 
-    return viewable
+    viewable
   end
 
-    ##
-    # Returns a list of all guidance groups which a specified user can view
-    # we define guidance groups viewable to a user by those owned by:
-    #   the Managing Curation Center
-    #   a funder organisation
-    #   an organisation, of which the user is a member
-    #
-    # @param user [User] a user object
-    # @return [Array<GuidanceGroup>] a list of all "viewable" guidance groups to a user
+  ##
+  # Returns a list of all guidance groups which a specified user can view
+  # we define guidance groups viewable to a user by those owned by:
+  #   the Managing Curation Center
+  #   a funder organisation
+  #   an organisation, of which the user is a member
+  #
+  # @param user [User] a user object
+  # @return [Array<GuidanceGroup>] a list of all "viewable" guidance groups to
+  # a user
   def self.all_viewable(user)
     # first find all groups owned by the Managing Curation Center
-    managing_org_groups = Org.includes(guidance_groups: [guidances: :themes]).managing_orgs.collect{|org| org.guidance_groups}
+    managing_org_groups = Org.includes(guidance_groups: [guidances: :themes])
+                             .managing_orgs.collect(&:guidance_groups)
 
     # find all groups owned by  a Funder organisation
-    funder_groups = Org.includes(:guidance_groups).funder.collect{|org| org.guidance_groups}
+    funder_groups = Org.includes(:guidance_groups)
+                       .funder
+                       .collect(&:guidance_groups)
 
     organisation_groups = [user.org.guidance_groups]
 
-    # pass this organisation guidance groups to the view with respond_with @all_viewable_groups
-    all_viewable_groups = managing_org_groups + funder_groups + organisation_groups
+    # pass this organisation guidance groups to the view with respond_with
+    # @all_viewable_groups
+    all_viewable_groups = managing_org_groups +
+                          funder_groups +
+                          organisation_groups
     all_viewable_groups = all_viewable_groups.flatten.uniq
-    return all_viewable_groups
+    all_viewable_groups
   end
 end
diff --git a/app/models/notification.rb b/app/models/notification.rb
index cfbe0cb..b5a6962 100644
--- a/app/models/notification.rb
+++ b/app/models/notification.rb
@@ -71,19 +71,6 @@
   # If no user is given, currently logged in user (if any) is the default
   # @return [Boolean] is the Notification acknowledged ?
   def acknowledged?(user)
-    users.include?(user) if user.present? && dismissable?
-  end
-
-  private
-
-  # Validate Notification dates
-  def valid_dates
-    return false if starts_at.blank? || expires_at.blank?
-    errors.add(:starts_at, _('Should be today or later')) if starts_at < Date.today
-    errors.add(:expires_at, _('Should be tomorrow or later')) if expires_at < Date.tomorrow
-    if starts_at > expires_at
-      errors.add(:starts_at, _('Should be before expiration date'))
-      errors.add(:expires_at, _('Should be after start date'))
-    end
+    dismissable? && user.present? && users.include?(user)
   end
 end
diff --git a/app/models/org.rb b/app/models/org.rb
index 443c0e3..36e2bd0 100644
--- a/app/models/org.rb
+++ b/app/models/org.rb
@@ -122,7 +122,9 @@
             column: 'org_type'
 
   # Predefined queries for retrieving the managain organisation and funders
-  scope :managing_orgs, -> { where(abbreviation: Rails.configuration.branding[:organisation][:abbreviation]) }
+  scope :managing_orgs, -> do
+    where(abbreviation: Branding.fetch(:organisation, :abbreviation))
+  end
 
   scope :search, -> (term) {
     search_pattern = "%#{term}%"
@@ -194,17 +196,8 @@
   # returns all published templates belonging to the organisation
   #
   # @return [Array<Template>] published templates
-	def published_templates
-		return templates.where("published = ?", true)
-	end
-
-  def check_api_credentials
-    if token_permission_types.count == 0
-      users.each do |user|
-        user.api_token = ""
-        user.save!
-      end
-    end
+  def published_templates
+    return templates.where("published = ?", true)
   end
 
   def org_admins
diff --git a/app/models/perm.rb b/app/models/perm.rb
index 4dfde8c..a2fdced 100644
--- a/app/models/perm.rb
+++ b/app/models/perm.rb
@@ -24,23 +24,40 @@
   validates :name, presence: { message: PRESENCE_MESSAGE },
                    uniqueness: { message: UNIQUENESS_MESSAGE }
 
-  # ==========
-  # = Scopes =
-  # ==========
 
-  scope :add_orgs, -> { Perm.find_by(name: 'add_organisations') }
+  # =================
+  # = Class methods =
+  # =================
 
-  scope :change_affiliation, -> { Perm.find_by(name: 'change_org_affiliation') }
+  def self.add_orgs
+    Perm.find_by(name: 'add_organisations')
+  end
 
-  scope :grant_permissions, -> { Perm.find_by(name: 'grant_permissions') }
+  def self.change_affiliation
+    Perm.find_by(name: 'change_org_affiliation')
+  end
 
-  scope :modify_templates, -> { Perm.find_by(name: 'modify_templates') }
+  def self.grant_permissions
+    Perm.find_by(name: 'grant_permissions')
+  end
 
-  scope :modify_guidance, -> { Perm.find_by(name: 'modify_guidance') }
+  def self.modify_templates
+    Perm.find_by(name: 'modify_templates')
+  end
 
-  scope :use_api, -> { Perm.find_by(name: 'use_api') }
+  def self.modify_guidance
+    Perm.find_by(name: 'modify_guidance')
+  end
 
-  scope :change_org_details, -> { Perm.find_by(name: 'change_org_details') }
+  def self.use_api
+    Perm.find_by(name: 'use_api')
+  end
 
-  scope :grant_api, -> { Perm.find_by(name: 'grant_api_to_orgs') }
+  def self.change_org_details
+    Perm.find_by(name: 'change_org_details')
+  end
+
+  def self.grant_api
+    Perm.find_by(name: 'grant_api_to_orgs')
+  end
 end
diff --git a/app/models/phase.rb b/app/models/phase.rb
index 42312b4..41a985b 100644
--- a/app/models/phase.rb
+++ b/app/models/phase.rb
@@ -38,7 +38,9 @@
   # ================
   # = Associations =
   # ================
-  belongs_to :template
+  belongs_to :template, touch: true
+
+  belongs_to :plan
 
   has_one :prefix_section, -> (phase) {
     modifiable.where("number < ?",
@@ -84,13 +86,6 @@
     Phase.where(template_id: template_id).select(:id, :title)
   }
 
-  # TODO: Remove after implementing new template versioning logic
-  # Callbacks
-  after_save do |phase|
-    # Updates the template.updated_at attribute whenever a phase has been created/updated
-    phase.template.touch if template.present?
-  end
-
   def deep_copy(**options)
     copy = self.dup
     copy.modifiable = options.fetch(:modifiable, self.modifiable)
@@ -105,9 +100,7 @@
   # Returns the number of answered question for the phase.
   def num_answered_questions(plan)
     return 0 if plan.nil?
-    return sections.reduce(0) do |m, s|
-      m + s.num_answered_questions(plan)
-    end
+    sections.to_a.sum { |s| s.num_answered_questions(plan) }
   end
 
   # Returns the number of questions for a phase. Note, this method becomes useful
diff --git a/app/models/plan.rb b/app/models/plan.rb
index 7609c70..8c6c5e2 100644
--- a/app/models/plan.rb
+++ b/app/models/plan.rb
@@ -1,3 +1,8 @@
+# frozen_string_literal: true
+
+# The central model object within this domain. Represents a Data Management
+# Plan for a research project.
+#
 # == Schema Information
 #
 # Table name: plans
@@ -31,7 +36,6 @@
 #
 #  fk_rails_...  (template_id => templates.id)
 #
-
 class Plan < ActiveRecord::Base
   include ConditionalUserMailer
   include ExportablePlan
@@ -42,29 +46,27 @@
   # = Constants =
   # =============
 
-  ##
-  # (in mm)
-  A4_PAGE_HEIGHT = 297
 
-  ##
-  # (in mm)
-  A4_PAGE_WIDTH = 210
+  # Returns visibility message given a Symbol type visibility passed, otherwise
+  # nil
+  VISIBILITY_MESSAGE = {
+    organisationally_visible: _('organisational'),
+    publicly_visible: _('public'),
+    is_test: _('test'),
+    privately_visible: _('private')
+  }
 
-  ##
-  # Round estimate up to nearest 5%
-  ROUNDING = 5
-
-  ##
-  # convert font point size to mm
-  FONT_HEIGHT_CONVERSION_FACTOR = 0.35278
-
-  ##
-  # Assume glyph width averages 2/5 the height
-  FONT_WIDTH_HEIGHT_RATIO = 0.4
-
+  # ==============
+  # = Attributes =
+  # ==============
 
   # public is a Ruby keyword so using publicly
-  enum visibility: [:organisationally_visible, :publicly_visible, :is_test, :privately_visible]
+  enum visibility: %i[organisationally_visible publicly_visible
+                      is_test privately_visible]
+
+
+  alias_attribute :name, :title
+
 
   # ================
   # = Associations =
@@ -80,6 +82,13 @@
 
   has_many :themes, through: :questions
 
+  has_many :guidances, through: :themes
+
+  has_many :guidance_group_options, -> { GuidanceGroup.published },
+           through: :guidances,
+           source: :guidance_group,
+           class_name: "GuidanceGroup"
+
   has_many :answers, dependent: :destroy
 
   has_many :notes, through: :answers
@@ -94,14 +103,16 @@
 
   has_many :roles
 
-  # ==============
-  # = Attributes =
-  # ==============
+
+  # =====================
+  # = Nested Attributes =
+  # =====================
 
   accepts_nested_attributes_for :template
 
   accepts_nested_attributes_for :roles
 
+
   # ===============
   # = Validations =
   # ===============
@@ -114,680 +125,83 @@
 
   validates :complete, inclusion: { in: BOOLEAN_VALUES }
 
+
   # =============
   # = Callbacks =
   # =============
+
   before_validation :set_creation_defaults
 
+
   # ==========
   # = Scopes =
   # ==========
 
-  # Scope queries
-  # Note that in ActiveRecord::Enum the mappings are exposed through a class method with the pluralized attribute name (e.g visibilities rather than visibility)
-  scope :publicly_visible, -> { includes(:template).where(:visibility => visibilities[:publicly_visible]) }
 
-  # Retrieves any plan in which the user has an active role and it is not a reviewer
-  scope :active, -> (user) {
-    includes([:template, :roles]).where({ "roles.active": true, "roles.user_id": user.id }).where(Role.not_reviewer_condition)
+  # Retrieves any plan in which the user has an active role and it is not a
+  # reviewer
+  scope :active, lambda { |user|
+    includes(%i[template roles])
+      .where("roles.active": true, "roles.user_id": user.id)
+      .where(Role.not_reviewer_condition)
   }
 
   # Retrieves any plan organisationally or publicly visible for a given org id
-  scope :organisationally_or_publicly_visible, -> (user) {
-    includes(:template, {roles: :user})
-      .where({
-        visibility: [visibilities[:organisationally_visible], visibilities[:publicly_visible]],
-        "roles.access": Role.access_values_for(:creator, :administrator, :editor, :commenter).min,
-        "users.org_id": user.org_id})
-      .where(['NOT EXISTS (SELECT 1 FROM roles WHERE plan_id = plans.id AND user_id = ?)', user.id])
+  scope :organisationally_or_publicly_visible, lambda { |user|
+    access = Role.access_values_for(:creator, :administrator,
+                                    :editor, :commenter).min
+
+    visibilities = [Plan.visibilities[:organisationally_visible],
+                    Plan.visibilities[:publicly_visible]]
+
+    includes(:template, roles: :user)
+      .where(
+        visibility: visibilities,
+        roles: { access: access },
+        users: { org_id: user.org_id }
+      )
+      .where(<<~SQL, user_id: user.id)
+        NOT EXISTS (SELECT 1 FROM roles
+                             WHERE plan_id = plans.id AND user_id = :user_id)
+      SQL
   }
 
-  scope :search, -> (term) {
+  scope :search, lambda { |term|
     search_pattern = "%#{term}%"
-    joins(:template).where("plans.title LIKE ? OR templates.title LIKE ?", search_pattern, search_pattern)
+    joins(:template)
+      .where("plans.title LIKE ? OR templates.title LIKE ?",
+             search_pattern, search_pattern)
   }
 
   # Retrieves plan, template, org, phases, sections and questions
-  scope :overview, -> (id) {
-    Plan.includes(:phases, :sections, :questions, template: [ :org ]).find(id)
+  scope :overview, lambda { |id|
+    includes(:phases, :sections, :questions, template: [:org]).find(id)
   }
+
   ##
   # Settings for the template
   has_settings :export, class_name: 'Settings::Template' do |s|
     s.key :export, defaults: Settings::Template::DEFAULT_SETTINGS
   end
-  alias_method :super_settings, :settings
+  alias super_settings settings
 
 
-  ##
-  # Proxy through to the template settings (or defaults if this plan doesn't have
-  # an associated template) if there are no settings stored for this plan.
-  # `key` is required by rails-settings, so it's required here, too.
-  #
-  # @param key [Key] a key required by rails
-  # @return [Settings] settings for this plan's template
-  def settings(key)
-    self_settings = self.super_settings(key)
-    return self_settings if self_settings.value?
-    self.template.settings(key) unless self.template.nil?
-  end
+  # =================
+  # = Class methods =
+  # =================
 
-  ##
-  # returns the most recent answer to the given question id
-  # optionally can create an answer if none exists
-  #
-  # @param qid [Integer] the id for the question to find the answer for
-  # @param create_if_missing [Boolean] if true, will genereate a default answer to the question
-  # @return [Answer,nil] the most recent answer to the question, or a new question with default value, or nil
-  def answer(qid, create_if_missing = true)
-    answer = answers.where(:question_id => qid).order("created_at DESC").first
-    question = Question.find(qid)
-    if answer.nil? && create_if_missing then
-      answer = Answer.new
-      answer.plan_id = id
-      answer.question_id = qid
-      answer.text = question.default_value
-      default_options = Array.new
-      question.question_options.each do |option|
-        if option.is_default
-          default_options << option
-        end
-      end
-      answer.question_options = default_options
-    end
-    return answer
-  end
-
-# TODO: This just retrieves all of the guidance associated with the themes within the template
-#       so why are we transferring it here to the plan?
-  ##
-  # returns all of the sections for this version of the plan, and for the project's organisation
-  #
-  # @return [Array<Section>,nil] either a list of sections, or nil if none were found
-  def set_possible_guidance_groups
-    # find all the themes in this plan
-    # and get the guidance groups they belong to
-    ggroups = []
-    self.template.phases.each do |phase|
-      phase.sections.each do |section|
-        section.questions.each do |question|
-          question.themes.each do |theme|
-            theme.guidances.each do |guidance|
-              ggroups << guidance.guidance_group if guidance.guidance_group.published
-              # only show published guidance groups
-            end
-          end
-        end
-      end
-    end
-
-    self.guidance_groups = ggroups.uniq
-  end
-
-  ##
-  # returns all of the possible guidance groups for the plan (all options to
-  # be selected by the user to display)
-  #
-  # @return Array<Guidance>
-  def get_guidance_group_options
-    # find all the themes in this plan
-    # and get the guidance groups they belong to
-    ggroups = []
-    Template.includes(phases: [sections: [questions: [themes: [guidances: [guidance_group: :org]]]]]).find(self.template_id).phases.each do |phase|
-      phase.sections.each do |section|
-        section.questions.each do |question|
-          question.themes.each do |theme|
-            theme.guidances.each do |guidance|
-              ggroups << guidance.guidance_group if guidance.guidance_group.published
-              # only show published guidance groups
-            end
-          end
-        end
-      end
-    end
-    return ggroups.uniq
-  end
-
-  ##
-  # Sets up the plan for feedback:
-  #  emails confirmation messages to owners
-  #  emails org admins and org contact
-  #  adds org admins to plan with the 'reviewer' Role
-  def request_feedback(user)
-    Plan.transaction do
-      begin
-        val = Role.access_values_for(:reviewer, :commenter).min
-        self.feedback_requested = true
-
-        # Share the plan with each org admin as the reviewer role
-        admins = user.org.org_admins
-        admins.each do |admin|
-          self.roles << Role.new(user: admin, access: val)
-        end
-
-        if self.save!
-          # Send an email to the org-admin contact
-          if user.org.contact_email.present?
-            contact = User.new(email: user.org.contact_email, firstname: user.org.contact_name)
-            UserMailer.feedback_notification(contact, self, user).deliver_now
-          end
-          true
-        else
-          false
-        end
-      rescue Exception => e
-        Rails.logger.error e
-        false
-      end
-    end
-  end
-
-  ##
-  # Finalizes the feedback for the plan:
-  #  emails confirmation messages to owners
-  #  sets flag on plans.feedback_requested to false
-  #  removes org admins from the 'reviewer' Role for the Plan
-  def complete_feedback(org_admin)
-    Plan.transaction do
-      begin
-        self.feedback_requested = false
-
-        # Remove the org admins reviewer role from the plan
-        vals = Role.access_values_for(:reviewer)
-        self.roles.delete(Role.where(plan: self, access: vals))
-
-        if self.save!
-          # Send an email confirmation to the owners and co-owners
-          owners = User.joins(:roles).where('roles.plan_id =? AND roles.access IN (?)', self.id, Role.access_values_for(:administrator))
-          deliver_if(recipients: owners, key: 'users.feedback_provided') do |r|
-            UserMailer.feedback_complete(r, self, org_admin).deliver_now
-          end
-          true
-        else
-          false
-        end
-      rescue Exception => e
-        Rails.logger.error e
-        false
-      end
-    end
-  end
-
-  # Returns all of the plan's available guidance by question as a hash for use on the write plan page
-  # {
-  #   QUESTION: {
-  #     GUIDANCE_GROUP: {
-  #       THEME: [GUIDANCE, GUIDANCE],
-  #       THEME: [GUIDANCE]
-  #     }
-  #   }
-  # }
-  def guidance_by_question_as_hash
-    # Get all of the selected guidance groups for the plan
-    guidance_groups_ids = self.guidance_groups.collect(&:id)
-    guidance_groups =  GuidanceGroup.joins(:org).where("guidance_groups.published = ? AND guidance_groups.id IN (?)",
-                                                       true, guidance_groups_ids)
-
-    # Gather all of the Themes used in the plan as a hash
-    # {
-    #  QUESTION: [THEME, THEME],
-    #  QUESTION: [THEME]
-    # }
-    question_themes = {}
-    themes_used = []
-    self.questions.joins(:themes).pluck('questions.id', 'themes.title').each do |qt|
-      themes_used << qt[1] unless themes_used.include?(qt[1])
-      question_themes[qt[0]] = [] unless question_themes[qt[0]].present?
-      question_themes[qt[0]] << qt[1] unless question_themes[qt[0]].include?(qt[1])
-    end
-
-    # Gather all of the Guidance available for the themes used in the plan as a hash
-    # {
-    #  THEME: {
-    #    GUIDANCE_GROUP: [GUIDANCE, GUIDANCE],
-    #    GUIDANCE_GROUP: [GUIDANCE]
-    #  }
-    # }
-    theme_guidance = {}
-    GuidanceGroup.includes(guidances: :themes).joins(:guidances).
-          where('guidance_groups.published = ? AND guidances.published = ? AND themes.title IN (?) AND guidance_groups.id IN (?)', true, true, themes_used, guidance_groups.collect(&:id)).
-          pluck('guidance_groups.name', 'themes.title', 'guidances.text').each do |tg|
-
-      theme_guidance[tg[1]] = {} unless theme_guidance[tg[1]].present?
-      theme_guidance[tg[1]][tg[0]] = [] unless theme_guidance[tg[1]][tg[0]].present?
-      theme_guidance[tg[1]][tg[0]] << tg[2] unless theme_guidance[tg[1]][tg[0]].include?(tg[2])
-    end
-
-    # Generate a hash for the view that contains all of a question guidance
-    # {
-    #   QUESTION: {
-    #     GUIDANCE_GROUP: {
-    #       THEME: [GUIDANCE, GUIDANCE],
-    #       THEME: [GUIDANCE]
-    #     }
-    #   }
-    # }
-    question_guidance = {}
-    question_themes.keys.each do |question|
-      ggs = {}
-      # Gather all of the guidance groups applicable to the themes assigned to the question
-      groups = []
-      question_themes[question].each do |theme|
-        groups << theme_guidance[theme].keys if theme_guidance[theme].present?
-      end
-
-      # Loop through all of the applicable guidance groups and collect their themed guidance
-      groups.flatten.uniq.each do |guidance_group|
-        guidances_by_theme = {}
-
-        # Collect all of the guidances for each theme used by the question
-        question_themes[question].each do |theme|
-          if theme_guidance[theme].present? && theme_guidance[theme][guidance_group].present?
-            guidances_by_theme[theme] = [] unless guidances_by_theme[theme].present?
-            guidances_by_theme[theme] = theme_guidance[theme][guidance_group]
-          end
-        end
-
-        ggs[guidance_group] = guidances_by_theme unless ggs[guidance_group]
-      end
-
-      question_guidance[question] = ggs
-    end
-
-    question_guidance
-  end
-
-  ##
-  # determines if the plan is editable by the specified user
-  #
-  # @param user_id [Integer] the id for a user
-  # @return [Boolean] true if user can edit the plan
-  def editable_by?(user_id)
-    user_id = user_id.id if user_id.is_a?(User)
-    has_role(user_id, :editor)
-  end
-
-  ##
-  # determines if the plan is readable by the specified user
-  #
-  # @param user_id [Integer] the id for a user
-  # @return [Boolean] true if the user can read the plan
-  def readable_by?(user_id)
-    user           = user_id.is_a?(User) ? user_id : User.find(user_id)
-    owner_orgs     = owner_and_coowners.collect(&:org)
-    sys_permission = Branding.fetch(:service_configuration, :plans,
-                                    :org_admins_read_all)
-
-    # Super Admins can view plans read-only
-    if user.can_super_admin?
-      return true
-    # Org Admins can view their Org's plans if system permission allows
-    elsif user.can_org_admin? && owner_orgs.include?(user.org) && sys_permission
-      return true
-    # ...otherwise the user must have the commenter role.
-    elsif has_role(user.id, :commenter)
-      return true
-    else
-      return false
-    end
-  end
-
-  ##
-  # determines if the plan is readable by the specified user
-  #
-  # @param user_id [Integer] the id for a user
-  # @return [Boolean] true if the user can read the plan
-  def commentable_by?(user_id)
-    user_id = user_id.id if user_id.is_a?(User)
-    has_role(user_id, :commenter)
-  end
-
-  ##
-  # determines if the plan is administerable by the specified user
-  #
-  # @param user_id [Integer] the id for the user
-  # @return [Boolean] true if the user can administer the plan
-  def administerable_by?(user_id)
-    user_id = user_id.id if user_id.is_a?(User)
-    has_role(user_id, :administrator)
-  end
-
-  ##
-  # determines if the plan is owned by the specified user
-  #
-  # @param user_id [Integer] the id for the user
-  # @return [Boolean] true if the user can administer the plan
-  def owned_by?(user_id)
-    user_id = user_id.id if user_id.is_a?(User)
-    has_role(user_id, :creator)
-  end
-
-  ##
-  # determines if the plan is reviewable by the specified user
-  #
-  # @param user_id [Integer] the id for the user
-  # @return [Boolean] true if the user can administer the plan
-  def reviewable_by?(user_id)
-    user_id = user_id.id if user_id.is_a?(User)
-    has_role(user_id, :reviewer)
-  end
-
-  ##
-  # determines whether or not the specified user has any rol on the plan
-  #
-  # @param user_id [Integer] the id for the user
-  # @return [Boolean] true if the user has any rol
-  def any_role?(user)
-    user_id = user.id if user.is_a?(User)
-    !self.roles.index{ |rol| rol.user_id == user_id }.nil?
-  end
-
-  ##
-  # defines and returns the status of the plan
-  # status consists of a hash of the num_questions, num_answers, sections, questions, and spaced used.
-  # For each section, it contains the id's of each of the questions
-  # for each question, it contains the answer_id, answer_created_by, answer_text, answer_options_id, aand answered_by
-  #
-  # @return [Status]
-
-  def status
-    status = {
-      "num_questions" => 0,
-      "num_answers" => 0,
-      "sections" => {},
-      "questions" => {},
-      "space_used" => 0 # percentage of available space in pdf used
-    }
-
-    space_used = height_of_text(self.title, 2, 2)
-
-    section_ids = sections.map {|s| s.id}
-
-    # we retrieve this is 2 joins:
-    #   1. sections and questions
-    #   2. questions and answers
-    # why? because Rails 4 doesn't have any sensible left outer join.
-    # when we change to RAILS 5 it is meant to have so this can be fixed then
-
-    records = Section.joins(questions: :question_format)
-                     .select('sections.id as sectionid,
-                              sections.title as stitle,
-                              questions.id as questionid,
-                              questions.text as questiontext,
-                              question_formats.title as qformat')
-                     .where("sections.id in (?) ", section_ids)
-                     .to_a
-
-    # extract question ids to get answers
-    question_ids = records.map {|r| r.questionid}.uniq
-    status["num_questions"] = question_ids.count
-
-    arecords = Question.joins(answers: :user)
-                       .select('questions.id as questionid,
-                                answers.id as answerid,
-                                answers.plan_id as plan_id,
-                                answers.text as answertext,
-                                answers.updated_at as updated,
-                                users.email as username')
-                       .where("questions.id in (?) and answers.plan_id = ?",question_ids, self.id)
-                       .to_a
-
-    # we want answerids to extract options later
-    answer_ids = arecords.map {|r| r.answerid}.uniq
-    status["num_answers"] = answer_ids.count
-
-    # create map from questionid to answer structure
-    qa_map = {}
-    arecords.each do |rec|
-      qa_map[rec.questionid] = {
-        plan: rec.plan_id,
-        id: rec.answerid,
-        text: rec.answertext,
-        updated: rec.updated,
-        user: rec.username
-      }
-    end
-
-
-    # build main status structure
-    records.each do |rec|
-      sid = rec.sectionid
-      stitle = rec.stitle
-      qid = rec.questionid
-      qtext = rec.questiontext
-      format = rec.qformat
-
-      answer = nil
-      if qa_map.has_key?(qid)
-        answer = qa_map[qid]
-      end
-
-      aid = answer.nil? ? nil : answer[:id]
-      atext = answer.nil? ? nil : answer[:text]
-      updated = answer.nil? ? nil : answer[:updated]
-      uname = answer.nil? ? nil : answer[:user]
-
-      space_used += height_of_text(stitle, 1, 1)
-
-      shash = status["sections"]
-      if !shash.has_key?(sid)
-        shash[sid] = {}
-        shash[sid]["num_questions"] = 0
-        shash[sid]["num_answers"] = 0
-        shash[sid]["questions"] = Array.new
-      end
-
-      shash[sid]["questions"] << qid
-      shash[sid]["num_questions"] += 1
-
-      space_used += height_of_text(qtext) unless qtext == stitle
-      if atext.present?
-        space_used += height_of_text(atext)
-      else
-        space_used += height_of_text(_('Question not answered.'))
-      end
-
-      if answer.present? then
-        shash[sid]["num_answers"] += 1
-      end
-
-      status["questions"][qid] = {
-        "format" => format,
-        "answer_id" => aid,
-        "answer_updated_at" => updated.to_i,
-        "answer_text" => atext,
-        "answered_by" => uname
-      }
-
-    end
-
-    records = Answer.joins(:question_options).select('answers.id as answerid, question_options.id as optid').where(id: answer_ids).to_a
-    opt_hash = {}
-    records.each do |rec|
-      aid = rec.answerid
-      optid = rec.optid
-      if !opt_hash.has_key?(aid)
-        opt_hash[aid] = Array.new
-      end
-      opt_hash[aid] << optid
-    end
-
-    status["questions"].each_key do |questionid|
-      answerid = status["questions"][questionid]["answer_id"]
-      status["questions"][questionid]["answer_option_ids"] = opt_hash[answerid]
-    end
-
-    status['space_used'] = estimate_space_used(space_used)
-
-    return status
-  end
-
-
-  ##
-  # assigns the passed user_id to the creater_role for the project
-  # gives the user rights to read, edit, administrate, and defines them as creator
-  #
-  # @param user_id [Integer] the user to be given priveleges' id
-  def assign_creator(user_id)
-    user_id = user_id.id if user_id.is_a?(User)
-    add_user(user_id, true, true, true)
-  end
-
-  ##
-  # returns the funder id for the plan
-  #
-  # @return [Integer, nil] the id for the funder
-  def funder_id
-    if self.template.nil? then
-      return nil
-    end
-    return self.template.org
-  end
-
-  ##
-  # returns the funder organisation for the project or nil if none is specified
-  #
-  # @return [Organisation, nil] the funder for project, or nil if none exists
-  def funder
-    template = self.template
-    if template.nil? then
-      return nil
-    end
-
-    if template.customization_of
-      return template.customization_of.org
-    else
-      return template.org
-    end
-  end
-
-  ##
-  # assigns the passed user_id as an editor for the project
-  # gives the user rights to read and edit
-  #
-  # @param user_id [Integer] the user to be given priveleges' id
-  def assign_editor(user_id)
-    add_user(user_id, true)
-  end
-
-  ##
-  # assigns the passed user_id as a reader for the project
-  # gives the user rights to read
-  #
-  # @param user_id [Integer] the user to be given priveleges' id
-  def assign_reader(user_id)
-    add_user(user_id)
-  end
-
-  ##
-  # assigns the passed user_id as an administrator for the project
-  # gives the user rights to read, adit, and administrate the project
-  #
-  # @param user_id [Integer] the user to be given priveleges' id
-  def assign_administrator(user_id)
-    add_user(user_id, true, true)
-  end
-
-  ##
-  # the datetime for the latest update of this plan
-  #
-  # @return [DateTime] the time of latest update
-  def latest_update
-    latest_update = updated_at
-    phases.each do |phase|
-      if phase.updated_at > latest_update then
-        latest_update = phase.updated_at
-      end
-    end
-    return latest_update
-  end
-
-  # Getters to match 'My plans' columns
-
-  ##
-  # the title of the project
-  #
-  # @return [String] the title of the project
-  def name
-    self.title
-  end
-
-  ##
-  # the owner of the project
-  #
-  # @return [User] the creater of the project
-  def owner
-    vals = Role.access_values_for(:creator)
-    User.joins(:roles).where('roles.plan_id = ? AND roles.access IN (?)', self.id, vals).first
-  end
-
-  ##
-  # returns the shared roles of a plan, excluding the creator
-  def shared
-    role_values = Role.where(plan: self).where(Role.not_creator_condition).any?
-  end
-
-  ##
-  # the owner and co-owners of the project
-  #
-  # @return [Users]
-  def owner_and_coowners
-    vals = Role.access_values_for(:creator).concat(Role.access_values_for(:administrator))
-    User.joins(:roles).where("roles.plan_id = ? AND roles.access IN (?)", self.id, vals)
-  end
-
-  ##
-  # the time the project was last updated, formatted as a date
-  #
-  # @return [Date] last update as a date
-  def last_edited
-    self.latest_update.to_date
-  end
-
-  # Returns the number of answered questions from the entire plan
-  def num_answered_questions
-    return Answer.where(id: answers.map(&:id)).includes({ question: :question_format }, :question_options).reduce(0) do |m, a|
-      if a.is_valid?
-        m+=1
-      end
-      m
-    end
-  end
-
-  # Returns a section given its id or nil if does not exist for the current plan
-  def get_section(section_id)
-    self.sections.find { |s| s.id == section_id }
-  end
-
-  # Returns the number of questions for a plan.
-  def num_questions
-    return sections.includes(:questions).joins(:questions).reduce(0){ |m, s| m + s.questions.length }
-  end
-  # the following two methods are for eager loading. One gets used for the plan/show
-  # page and the oter for the plan/edit. The difference is just that one pulls in more than
-  # the other.
-  # TODO: revisit this and work out for sure that maintaining the difference is worthwhile.
-  # it may not be. Also make sure nether is doing more thanit needs to.
-  #
-  def self.eager_load(id)
-    Plan.includes(
-      [{template: [
-                   {phases: {sections: {questions: :answers}}}
-                  ]},
-       {plans_guidance_groups: {guidance_group: :guidances}}
-      ]).find(id)
-  end
-
-  # Pre-fetched a plan phase together with its sections and questions associated. It also pre-fetches the answers and notes associated to the plan
+  # Pre-fetched a plan phase together with its sections and questions
+  # associated. It also pre-fetches the answers and notes associated to the plan
   def self.load_for_phase(id, phase_id)
-    plan = Plan
-      .joins(template: { phases: { sections: :questions }})
-      .preload(template: { phases: { sections: :questions }}) # Preserves the default order defined in the model relationships
-      .where("plans.id = :id AND phases.id = :phase_id", { id: id, phase_id: phase_id })
-      .merge(Plan.includes(answers: :notes))[0]
-    phase = plan.template.phases.find {|p| p.id==phase_id.to_i }
+    # Preserves the default order defined in the model relationships
+    plan = Plan.joins(template: { phases: { sections: :questions } })
+               .preload(template: { phases: { sections: :questions } })
+               .where(plans: { id: id }, phases: { id: phase_id })
+               .merge(Plan.includes(answers: :notes)).first
 
-    return plan, phase
+    phase = plan.template.phases.find { |p| p.id == phase_id.to_i }
+
+    [plan, phase]
   end
 
   # deep copy the given plan and all of it's associations
@@ -804,192 +218,357 @@
       answer_copy.save!
     end
     plan.guidance_groups.each do |guidance_group|
-      if guidance_group.present?
-        plan_copy.guidance_groups << GuidanceGroup.where(id: guidance_group.id).first
-      end
+      plan_copy.guidance_groups << guidance_group if guidance_group.present?
     end
-    return plan_copy
+    plan_copy
   end
 
-  # Returns visibility message given a Symbol type visibility passed, otherwise nil
-  def self.visibility_message(type)
-    message = {
-      :organisationally_visible => _('organisational'),
-      :publicly_visible => _('public'),
-      :is_test => _('test'),
-      :privately_visible => _('private')
-    }
-    message[type]
+  # ===========================
+  # = Public instance methods =
+  # ===========================
+
+  ##
+  # Proxy through to the template settings (or defaults if this plan doesn't
+  # have an associated template) if there are no settings stored for this plan.
+  #
+  # TODO: Update this comment below. AFAIK `key` has nothing to do with Rails.
+  # key - Is required by rails-settings, so it's required here, too.
+  #
+  # Returns Hash
+  def settings(key)
+    self_settings = super_settings(key)
+    return self_settings if self_settings.value?
+    template&.settings(key)
+  end
+
+  ##
+  # returns the most recent answer to the given question id
+  # optionally can create an answer if none exists
+  #
+  # @param qid [Integer] the id for the question to find the answer for
+  # @param create_if_missing [Boolean] if true, will genereate a default answer
+  # to the question.
+  # @return [Answer,nil] the most recent answer to the question, or a new
+  # question with default value, or nil.
+  def answer(qid, create_if_missing = true)
+    answer = answers.where(question_id: qid).order("created_at DESC").first
+    question = Question.find(qid)
+    if answer.nil? && create_if_missing
+      answer             = Answer.new
+      answer.plan_id     = id
+      answer.question_id = qid
+      answer.text        = question.default_value
+      default_options    = []
+      question.question_options.each do |option|
+        default_options << option if option.is_default
+      end
+      answer.question_options = default_options
+    end
+    answer
+  end
+
+  alias get_guidance_group_options guidance_group_options
+
+  deprecate :get_guidance_group_options,
+            deprecator: Cleanup::Deprecators::GetDeprecator.new
+
+  ##
+  # Sets up the plan for feedback:
+  #  emails confirmation messages to owners
+  #  emails org admins and org contact
+  #  adds org admins to plan with the 'reviewer' Role
+  def request_feedback(user)
+    Plan.transaction do
+      begin
+        val = Role.access_values_for(:reviewer, :commenter).min
+        self.feedback_requested = true
+        # Share the plan with each org admin as the reviewer role
+        admins = user.org.org_admins
+        admins.each do |admin|
+          roles << Role.new(user: admin, access: val)
+        end
+        if save!
+          # Send an email to the org-admin contact
+          if user.org.contact_email.present?
+            contact = User.new(email: user.org.contact_email,
+                               firstname: user.org.contact_name)
+            UserMailer.feedback_notification(contact, self, user).deliver_now
+          end
+          true
+        else
+          puts "save was false"
+
+          false
+        end
+      rescue Exception => e
+        Rails.logger.error e
+        false
+      end
+    end
+  end
+
+  ##
+  # Finalizes the feedback for the plan: Emails confirmation messages to owners
+  # sets flag on plans.feedback_requested to false removes org admins from the
+  # 'reviewer' Role for the Plan.
+  def complete_feedback(org_admin)
+    Plan.transaction do
+      begin
+        self.feedback_requested = false
+
+        # Remove the org admins reviewer role from the plan
+        vals = Role.access_values_for(:reviewer)
+        roles.delete(Role.where(plan: self, access: vals))
+
+        if save!
+          # Send an email confirmation to the owners and co-owners
+          owners = User.joins(:roles)
+                       .where('roles.plan_id =? AND roles.access IN (?)',
+                              id, Role.access_values_for(:administrator))
+
+          deliver_if(recipients: owners, key: 'users.feedback_provided') do |r|
+            UserMailer.feedback_complete(r, self, org_admin).deliver_now
+          end
+          true
+        else
+          false
+        end
+      rescue ArgumentError => e
+        Rails.logger.error e
+        false
+      end
+    end
+  end
+
+  ##
+  # determines if the plan is editable by the specified user
+  #
+  # @param user_id [Integer] the id for a user
+  # @return [Boolean] true if user can edit the plan
+  def editable_by?(user_id)
+    user_id = user_id.id if user_id.is_a?(User)
+    role?(user_id, :editor)
+  end
+
+  ##
+  # determines if the plan is readable by the specified user
+  #
+  # @param user_id [Integer] the id for a user
+  # @return [Boolean] true if the user can read the plan
+  def readable_by?(user_id)
+    user           = user_id.is_a?(User) ? user_id : User.find(user_id)
+    owner_orgs     = owner_and_coowners.collect(&:org)
+    sys_permission = Branding.fetch(:service_configuration, :plans,
+                                    :org_admins_read_all)
+
+    # Super Admins can view plans read-only
+    return true if user.can_super_admin?
+
+    # Org Admins can view their Org's plans if system permission allows
+    return true if user.can_org_admin? && owner_orgs.include?(user.org) &&
+                                          sys_permission
+
+    # ...otherwise the user must have the commenter role.
+    return true if role?(user.id, :commenter)
+
+    # Else
+    false
+  end
+
+  ##
+  # determines if the plan is readable by the specified user
+  #
+  # @param user_id [Integer] the id for a user
+  # @return [Boolean] true if the user can read the plan
+  def commentable_by?(user_id)
+    user_id = user_id.id if user_id.is_a?(User)
+    role?(user_id, :commenter)
+  end
+
+  ##
+  # determines if the plan is administerable by the specified user
+  #
+  # @param user_id [Integer] the id for the user
+  # @return [Boolean] true if the user can administer the plan
+  def administerable_by?(user_id)
+    user_id = user_id.id if user_id.is_a?(User)
+    role?(user_id, :administrator)
+  end
+
+  ##
+  # determines if the plan is reviewable by the specified user
+  #
+  # @param user_id [Integer] the id for the user
+  # @return [Boolean] true if the user can administer the plan
+  def reviewable_by?(user_id)
+    user_id = user_id.id if user_id.is_a?(User)
+    role?(user_id, :reviewer)
+  end
+
+  ##
+  # Assigns the passed user_id to the creater_role for the project gives the
+  # user rights to read, edit, administrate, and defines them as creator
+  #
+  # @param user_id [Integer] the user to be given priveleges' id
+  def assign_creator(user_id)
+    user_id = user_id.id if user_id.is_a?(User)
+    add_user(user_id, true, true, true)
+  end
+
+  ##
+  # the datetime for the latest update of this plan
+  #
+  # @return [DateTime] the time of latest update
+  def latest_update
+    (phases.pluck(:updated_at) + [updated_at]).max
+  end
+
+  ##
+  # the owner of the project
+  #
+  # @return [User] the creater of the project
+  def owner
+    vals = Role.access_values_for(:creator)
+    User.joins(:roles)
+        .where('roles.plan_id = ? AND roles.access IN (?)', id, vals).first
+  end
+
+  ##
+  # TODO: Rewrite this description
+  #
+  # returns the shared roles of a plan, excluding the creator
+  def shared?
+    roles.where(Role.not_creator_condition).any?
+  end
+
+  alias shared shared?
+
+  deprecate :shared, deprecator: Cleanup::Deprecators::PredicateDeprecator.new
+
+  ##
+  # the owner and co-owners of the project
+  #
+  # @return [Users]
+  def owner_and_coowners
+    vals = Role.access_values_for(:creator)
+               .concat(Role.access_values_for(:administrator))
+    User.joins(:roles)
+        .where(roles: { plan_id: id, access: vals })
+  end
+
+  # Returns the number of answered questions from the entire plan
+  def num_answered_questions
+    Answer.where(id: answers.map(&:id))
+          .includes(:question_options, { question: :question_format })
+          .reduce(0) do |m, a|
+
+      if a.is_valid?
+        m += 1
+        m
+      end
+    end
+  end
+
+  # Returns the number of questions for a plan.
+  def num_questions
+    questions.count
   end
 
   # Determines whether or not visibility changes are permitted according to the
-  # percentage of the plan answered in respect to a threshold defined at application.config
+  # percentage of the plan answered in respect to a threshold defined at
+  # application.config
   def visibility_allowed?
-    value=(self.num_answered_questions().to_f/self.num_questions()*100).round(2)
-    !self.is_test? && value >= Rails.application.config.default_plan_percentage_answered
+    value=(num_answered_questions.to_f/num_questions*100).round(2)
+    !is_test? && value >= Rails.application
+                               .config
+                               .default_plan_percentage_answered
   end
 
   # Determines whether or not a question (given its id) exists for the self plan
   def question_exists?(question_id)
-    Plan.joins(:questions).exists?(id: self.id, "questions.id": question_id)
+    Plan.joins(:questions).exists?(id: id, "questions.id": question_id)
   end
 
-  # Checks whether or not the number of questions matches the number of valid answers
+  # Checks whether or not the number of questions matches the number of valid
+  # answers
   def no_questions_matches_no_answers?
     num_questions = question_ids.length
-    pre_fetched_answers = Answer
-      .includes({ question: :question_format }, :question_options)
-      .where(id: answer_ids)
+    pre_fetched_answers = Answer.includes(:question_options,
+                                          question: :question_format)
+                                .where(id: answer_ids)
     num_answers = pre_fetched_answers.reduce(0) do |m, a|
-      if a.is_valid?
-        m+=1
-      end
+      m+=1 if a.is_valid?
       m
     end
-    return num_questions == num_answers
+    num_questions == num_answers
   end
 
   private
 
   # Returns whether or not the user has the specified role for the plan
-  def has_role(user_id, role_as_sym)
+  def role?(user_id, role_as_sym)
     if user_id.is_a?(Integer) && role_as_sym.is_a?(Symbol)
       vals = Role.access_values_for(role_as_sym)
-      self.roles.where(user_id: user_id, access: vals, active: true).first.present?
+      roles.where(user_id: user_id, access: vals, active: true).any?
     else
       false
     end
   end
 
+  alias has_role role?
+
+  deprecate :has_role, deprecator: Cleanup::Deprecators::PredicateDeprecator.new
+
   ##
   # adds a user to the project
   # if no flags are specified, the user is given read privleges
   #
   # @param user_id [Integer] the user to be given privleges
   # @param is_editor [Boolean] whether or not the user can edit the project
-  # @param is_administrator [Boolean] whether or not the user can administrate the project
+  # @param is_administrator [Boolean] whether or not the user can administrate
+  # the project
   # @param is_creator [Boolean] wheter or not the user created the project
   # @return [Array<ProjectGroup>]
   #
-  # TODO: change this to specifying uniqueness of user/plan association and handle
-  # that way
+  # TODO: change this to specifying uniqueness of user/plan association and
+  # handle that way
   #
-  def add_user(user_id, is_editor = false, is_administrator = false, is_creator = false)
-    Role.where(plan_id: self.id, user_id: user_id).each do |r|
-      r.destroy
-    end
+  def add_user(user_id, is_editor = false,
+                        is_administrator = false,
+                        is_creator = false)
 
-    role = Role.new
+    Role.where(plan_id: id, user_id: user_id).find_each(&:destroy)
+
+    role         = Role.new
     role.user_id = user_id
     role.plan_id = id
 
     # if you get assigned a role you can comment
-    role.commenter= true
+    role.commenter = true
 
     # the rest of the roles are inclusing so creator => administrator => editor
     if is_creator
-      role.creator =  true
+      role.creator       = true
       role.administrator = true
-      role.editor = true
+      role.editor        = true
     end
 
     if is_administrator
       role.administrator = true
-      role.editor = true
+      role.editor        = true
     end
 
-    if is_editor
-      role.editor = true
-    end
+    role.editor = true if is_editor
 
     role.save
-
-    # This is necessary because we're creating the associated record but not assigning it
-    # to roles. Auto-saving like this may be confusing when coding upstream in a controller,
-    # view or api. Should probably change this to:
-    #    self.roles << role
-    # and then let the save be called manually via:
-    #    plan.save!
-    #self.reload
-  end
-
-  ##
-  # creates a plan for each phase in the template associated with this project
-  # unless the phase is unpublished, it creates a new plan, and a new version of the plan and adds them to the project's plans
-  #
-  # @return [Array<Plan>]
-  def create_plans
-    self.template.phases.each do |phase|
-      latest_published_version = phase.latest_published_version
-      unless latest_published_version.nil?
-        new_plan = Plan.new
-        new_plan.version = latest_published_version
-        plans << new_plan
-      end
-    end
-  end
-
-
-
-  ##
-  # Based on the height of the text gathered so far and the available vertical
-  # space of the pdf, estimate a percentage of how much space has been used.
-  # This is highly dependent on the layout in the pdf. A more accurate approach
-  # would be to render the pdf and check how much space had been used, but that
-  # could be very slow.
-  # NOTE: This is only an estimate, rounded up to the nearest 5%; it is intended
-  # for guidance when editing plan data, not to be 100% accurate.
-  #
-  # @param used_height [Integer] an estimate of the height used so far
-  # @return [Integer] the estimate of space used of an A4 portrain
-  def estimate_space_used(used_height)
-    @formatting ||= self.settings(:export).formatting
-
-    return 0 unless @formatting[:font_size] > 0
-
-    margin_height    = @formatting[:margin][:top].to_i + @formatting[:margin][:bottom].to_i
-    page_height      = A4_PAGE_HEIGHT - margin_height # 297mm for A4 portrait
-    available_height = page_height * self.template.settings(:export).max_pages
-
-    percentage = (used_height / available_height) * 100
-    (percentage / ROUNDING).ceil * ROUNDING # round up to nearest five
-  end
-
-  ##
-  # Take a guess at the vertical height (in mm) of the given text based on the
-  # font-size and left/right margins stored in the plan's settings.
-  # This assumes a fixed-width for each glyph, which is obviously
-  # incorrect for the font-face choices available; the idea is that
-  # they'll hopefully average out to that in the long-run.
-  # Allows for hinting different font sizes (offset from base via font_size_inc)
-  # and vertical margins (i.e. for heading text)
-  #
-  # @param text [String] the text to estimate size of
-  # @param font_size_inc [Integer] the size of the font of the text, defaults to 0
-  # @param vertical_margin [Integer] the top margin above the text, defaults to 0
-  def height_of_text(text, font_size_inc = 0, vertical_margin = 0)
-    @formatting     ||= self.settings(:export).formatting
-    @margin_width   ||= @formatting[:margin][:left].to_i + @formatting[:margin][:right].to_i
-    @base_font_size ||= @formatting[:font_size]
-
-    return 0 unless @base_font_size > 0
-
-    font_height = FONT_HEIGHT_CONVERSION_FACTOR * (@base_font_size + font_size_inc)
-    font_width  = font_height * FONT_WIDTH_HEIGHT_RATIO # Assume glyph width averages at 2/5s the height
-    leading     = font_height / 2
-
-    chars_in_line = (A4_PAGE_WIDTH - @margin_width) / font_width # 210mm for A4 portrait
-    num_lines = (text.length / chars_in_line).ceil
-
-    (num_lines * font_height) + vertical_margin + leading
   end
 
   # Initialize the title for new templates
   # --------------------------------------------------------
   def set_creation_defaults
-    # Only run this before_validation because rails fires this before save/create
-    if self.id.nil?
-      self.title = "My plan (#{self.template.title})" if self.title.nil? && !self.template.nil?
-    end
+    # Only run this before_validation because rails fires this before
+    # save/create
+    return if id?
+    self.title = "My plan (#{template.title})" if title.nil? && !template.nil?
   end
 end
diff --git a/app/models/pref.rb b/app/models/pref.rb
index e0e553e..22d8bfc 100644
--- a/app/models/pref.rb
+++ b/app/models/pref.rb
@@ -33,7 +33,7 @@
   #
   # @return [JSON] preferences hash
   def self.default_settings
-    return Rails.configuration.branding[:preferences]
+    Branding.fetch(:preferences)
   end
 
 end
diff --git a/app/models/question.rb b/app/models/question.rb
index 180b675..2a1027d 100644
--- a/app/models/question.rb
+++ b/app/models/question.rb
@@ -27,6 +27,12 @@
   include ValidationMessages
   include ActsAsSortable
 
+  # ==============
+  # = Attributes =
+  # ==============
+
+  alias_attribute :to_s, :text
+
   # include
   ##
   # Sort order: Number ASC
@@ -83,23 +89,17 @@
   accepts_nested_attributes_for :annotations, allow_destroy: true
 
 
+  # =====================
+  # = Delegated methods =
+  # =====================
+
+  delegate :option_based?, to: :question_format
+
+
   # ===========================
   # = Public instance methods =
   # ===========================
 
-  ##
-  # returns the text from the question
-  #
-  # @return [String] question's text
-  def to_s
-    "#{text}"
-  end
-
-  def option_based?
-    format = self.question_format
-    return format.option_based
-  end
-
   def deep_copy(**options)
     copy = self.dup
     copy.modifiable = options.fetch(:modifiable, self.modifiable)
@@ -112,20 +112,19 @@
     return copy
   end
 
-# TODO: consider moving this to a view helper instead and use the built in scopes for guidance. May need to add
-#       a new one for 'thematic_guidance'. This method doesn't even make reference to this class and its returning
-#       a hash that is specific to a view
-  ##
-  # guidance for org
+  # TODO: consider moving this to a view helper instead and use the built in
+  # scopes for guidance. May need to add a new one for 'thematic_guidance'.
+  # This method doesn't even make reference to this class and its returning
+  # a hash that is specific to a view guidance for org
   #
   # @param org [Org] the org to find guidance for
   # @return [Hash{String => String}]
   def guidance_for_org(org)
     # pulls together guidance from various sources for question
     guidances = {}
-    theme_ids = themes.collect{|t| t.id}
-    if theme_ids.present?
-      GuidanceGroup.includes(guidances: :themes).where(org_id: org.id).each do |group|
+    if theme_ids.any?
+      GuidanceGroup.includes(guidances: :themes)
+                   .where(org_id: org.id).each do |group|
         group.guidances.each do |g|
           g.themes.each do |theme|
             if theme_ids.include? theme.id
@@ -144,27 +143,38 @@
   #
   # @param org_ids [Array<Integer>] the ids for the organisations
   # @return [Array<Annotation>] the example answers for this question for the specified orgs
-   def get_example_answers(org_ids)
-    org_ids = [org_ids] unless org_ids.is_a?(Array)
-    self.annotations.where(org_id: org_ids, type: Annotation.types[:example_answer]).order(:created_at)
+   def example_answers(org_ids)
+    annotations.where(org_id: Array(org_ids),
+                      type: Annotation.types[:example_answer])
+               .order(:created_at)
    end
 
+   alias get_example_answers example_answers
+
+   deprecate :get_example_answers,
+               deprecator: Cleanup::Deprecators::GetDeprecator.new
+
   ##
   # get guidance belonging to the current user's org for this question(need org
   # to distinguish customizations)
   #
   # @param org_id [Integer] the id for the organisation
-  # @return [String] the annotation guidance for this question for the specified org
-  def get_guidance_annotation(org_id)
-    guidance = self.annotations.where(org_id: org_id).where(type: Annotation.types[:guidance])
-    return guidance.first
+  # @return [String] the annotation guidance for this question for the
+  # specified org
+  def guidance_annotation(org_id)
+    annotations.where(org_id: org_id, type: Annotation.types[:guidance]).first
   end
 
+  alias get_guidance_annotation guidance_annotation
+
+  deprecate :get_guidance_annotation,
+              deprecator: Cleanup::Deprecators::GetDeprecator.new
+
   def annotations_per_org(org_id)
     example_answer = annotations.find_by(org_id: org_id, type: Annotation.types[:example_answer])
-    guidance = annotations.find_by(org_id: org_id, type: Annotation.types[:guidance])
+    guidance       = annotations.find_by(org_id: org_id, type: Annotation.types[:guidance])
     example_answer = annotations.build({ type: :example_answer, text: '', org_id: org_id }) unless example_answer.present?
-    guidance = annotations.build({ type: :guidance, text: '', org_id: org_id }) unless guidance.present?
+    guidance       = annotations.build({ type: :guidance, text: '', org_id: org_id }) unless guidance.present?
     return [example_answer, guidance]
   end
 end
diff --git a/app/models/question_format.rb b/app/models/question_format.rb
index a911ce0..45056dc 100644
--- a/app/models/question_format.rb
+++ b/app/models/question_format.rb
@@ -19,35 +19,43 @@
   #
   FORMAT_TYPES = %i[textarea textfield radiobuttons checkbox dropdown
                     multiselectbox date rda_metadata]
-  ##
-  # Associations
-  has_many :questions
+
+
+  # ==============
+  # = Attributes =
+  # ==============
 
   enum formattype: FORMAT_TYPES
 
+  alias_attribute :to_s, :title
+
+  alias_attribute :option_based?, :option_based
+
+  # ================
+  # = Associations =
+  # ================
+
+  has_many :questions
+
+
+  # ===============
+  # = Validations =
+  # ===============
+
   validates :title, presence: { message: PRESENCE_MESSAGE },
                     uniqueness: { message: UNIQUENESS_MESSAGE }
 
+  validates :description, presence: { message: PRESENCE_MESSAGE }
+
   validates :option_based, inclusion: { in: BOOLEAN_VALUES }
 
+
+  # =================
+  # = Class methods =
+  # =================
+
   # Retrieves the id for a given formattype passed
-  scope :id_for, -> (formattype) { where(formattype: formattype).pluck(:id).first }
-
-  ##
-  # Define Bit Field Values so we can test a format without doing string comps
-  # Column type
-
-  # EVALUATE CLASS AND INSTANCE METHODS BELOW
-  #
-  # What do they do? do they do it efficiently, and do we need them?
-
-
-  ##
-  # gives the title of the question_format
-  #
-  # @return [String] title of the question_format
-  def to_s
-    "#{title}"
+  def self.id_for(formattype)
+    where(formattype: formattype).pluck(:id).first
   end
-
 end
diff --git a/app/models/question_option.rb b/app/models/question_option.rb
index eb02e20..5b9fc1e 100644
--- a/app/models/question_option.rb
+++ b/app/models/question_option.rb
@@ -51,20 +51,6 @@
 
   scope :by_number, -> { order(:number) }
 
-  # =================
-  # = Class methods =
-  # =================
-
-  ##
-  # deep copy the given question_option and all it's associations
-  #
-  # @params [QuestionOption] question_option to be deep copied
-  # @return [QuestionOption] the saved, copied question_option
-  def self.deep_copy(question_option)
-    question_option_copy = question_option.dup
-    question_option_copy.save!
-    return question_option_copy
-  end
 
   # ===========================
   # = Public instance methods =
diff --git a/app/models/role.rb b/app/models/role.rb
index 8726a29..db4ad6e 100644
--- a/app/models/role.rb
+++ b/app/models/role.rb
@@ -27,10 +27,44 @@
   include ValidationMessages
   include ValidationValues
 
-  ##
-  # Associationsrequire "role"
+  # =============
+  # = Constants =
+  # =============
+
+  # Returns a hash of hashes where each key represents an access level
+  # (e.g. see access_level method to understand the integers)
+  #
+  # This method becomes useful for generating template messages (e.g.
+  # permissions change notification mailer)
+  ACCESS_LEVEL_MESSAGES = {
+    5 => {
+      type: _('reviewer'),
+      placeholder1: _('read the plan and provide feedback.'),
+      placeholder2: nil
+    },
+    3 => {
+      type: _('co-owner'),
+      placeholder1: _('write and edit the plan in a collaborative manner.'),
+      placeholder2: _('You can also grant rights to other collaborators.')
+    },
+    2 => {
+      type: _('editor'),
+      placeholder1: _('write and edit the plan in a collaborative manner.'),
+      placeholder2: nil,
+    },
+    1 => {
+      type: _('read-only'),
+      placeholder1: _('read the plan and leave comments.'),
+      placeholder2: nil,
+    }
+  }
+
+  # ================
+  # = Associations =
+  # ================
 
   belongs_to :user
+
   belongs_to :plan
 
   ##
@@ -80,6 +114,10 @@
     where(access: access_values)
   }
 
+  # ===========================
+  # = Public instance methods =
+  # ===========================
+
   ##
   # return the access level for the current project group
   # 5 if the user is a reviewer
@@ -101,52 +139,17 @@
     end
   end
 
-  # Sets access_level according to bit fields defined in the column access
-  # TODO refactor according to the hash defined above (e.g. 1 key is :creator, 2 key is :administrator, etc)
-  def set_access_level(access_level)
-    if access_level >= 1
-      self.commenter = true
-    else
-      self.commenter = false
-    end
-    if access_level >= 2
-      self.editor = true
-    else
-      self.editor = false
-    end
-    if access_level >= 3
-      self.administrator = true
-    else
-      self.administrator = false
-    end
+  def access_level=(value)
+    self.commenter     = value.to_i >= 1
+    self.editor        = value.to_i >= 2
+    self.administrator = value.to_i >= 3
   end
 
-  # Returns a hash of hashes where each key represents an access level (e.g. see access_level method to understand the integers)
-  # This method becomes useful for generating template messages (e.g. permissions change notification mailer)
-  def self.access_level_messages
-    {
-      5 => {
-        :type => _('reviewer'),
-        :placeholder1 => _('read the plan and provide feedback.'),
-        :placeholder2 => nil
-        },
-      3 => {
-        :type => _('co-owner'),
-        :placeholder1 => _('write and edit the plan in a collaborative manner.'),
-        :placeholder2 => _('You can also grant rights to other collaborators.')
-        },
-      2 => {
-        :type => _('editor'),
-        :placeholder1 => _('write and edit the plan in a collaborative manner.'),
-        :placeholder2 => nil,
-        },
-      1 => {
-        :type => _('read-only'),
-        :placeholder1 => _('read the plan and leave comments.'),
-        :placeholder2 => nil,
-      }
-    }
-  end
+  alias :set_access_level :access_level=
+
+  deprecate :set_access_level,
+              deprecator: Cleanup::Deprecators::SetDeprecator.new
+
 
   def set_defaults
     self.active = true if self.new_record?
diff --git a/app/models/section.rb b/app/models/section.rb
index fe812b6..6db0398 100644
--- a/app/models/section.rb
+++ b/app/models/section.rb
@@ -101,13 +101,10 @@
   # Returns the number of answered questions for a given plan
   def num_answered_questions(plan)
     return 0 if plan.nil?
-    questions_hash = questions.reduce({}) { |m, q| m[q.id] = q; m }
-    plan.answers.includes({ question: :question_format }, :question_options).reduce(0) do |m, a|
-      if questions_hash[a.question_id].present? && a.is_valid?
-        m+= 1
-      end
-      m
-    end
+    plan.answers.includes({ question: :question_format }, :question_options)
+                .where(question_id: question_ids)
+                .to_a
+                .count(&:is_valid?)
   end
 
   def deep_copy(**options)
diff --git a/app/models/splash_log.rb b/app/models/splash_log.rb
index 7b9cc0e..ea57796 100644
--- a/app/models/splash_log.rb
+++ b/app/models/splash_log.rb
@@ -8,5 +8,5 @@
 #  updated_at  :datetime         not null
 #
 
-class SplashLog < ActiveRecord::Base
-end
+class SplashLog < ActiveRecord::Base
+end
diff --git a/app/models/template.rb b/app/models/template.rb
index ef69476..4816af1 100644
--- a/app/models/template.rb
+++ b/app/models/template.rb
@@ -39,8 +39,12 @@
   validates_with TemplateLinksValidator
 
 
-  # Stores links as an JSON object: { funder: [{"link":"www.example.com","text":"foo"}, ...], sample_plan: [{"link":"www.example.com","text":"foo"}, ...]}
-  # The links is validated against custom validator allocated at validators/template_links_validator.rb
+  # Stores links as an JSON object:
+  # {funder: [{"link":"www.example.com","text":"foo"}, ...],
+  #  sample_plan: [{"link":"www.example.com","text":"foo"}, ...]}
+  #
+  # The links is validated against custom validator allocated at
+  # validators/template_links_validator.rb
   serialize :links, JSON
 
   # ================
@@ -81,6 +85,7 @@
   # =============
   # = Callbacks =
   # =============
+
   before_validation :set_defaults
 
   after_update :reconcile_published, if: -> (template) { template.published? }
@@ -94,9 +99,7 @@
 
   scope :unarchived, -> { where(archived: false) }
 
-  scope :default, -> { where(is_default: true, published: true).last }
-
-  scope :published, -> (family_id = nil) {
+  scope :published, ->(family_id = nil) {
     if family_id.present?
       unarchived.where(published: true, family_id: family_id)
     else
@@ -105,42 +108,19 @@
   }
 
   # Retrieves the latest templates, i.e. those with maximum version associated.
-  # It can be filtered down if family_id is passed. NOTE, the template objects
-  # instantiated only contain version and family attributes populated. See
-  # Template::latest_version scope method for an adequate instantiation of
-  # template instances.
-  scope :latest_version_per_family, -> (family_id = nil) {
-    chained_scope = unarchived.select("MAX(version) AS version", :family_id)
-    if family_id.present?
-      chained_scope = chained_scope.where(family_id: family_id)
-    end
-    chained_scope.group(:family_id)
-  }
-
-  scope :latest_customized_version_per_customised_of, -> (customization_of=nil,
-                                                          org_id = nil) {
-    chained_scope = select("MAX(version) AS version", :customization_of)
-    chained_scope = chained_scope.where(customization_of: customization_of)
-    if org_id.present?
-      chained_scope = chained_scope.where(org_id: org_id)
-    end
-    chained_scope.group(:customization_of)
-  }
-
-  # Retrieves the latest templates, i.e. those with maximum version associated.
   # It can be filtered down if family_id is passed
-  scope :latest_version, -> (family_id = nil) {
+  scope :latest_version, ->(family_id = nil) {
     unarchived.from(latest_version_per_family(family_id), :current)
-      .joins(<<~SQL)
-        INNER JOIN templates ON current.version = templates.version
-          AND current.family_id = templates.family_id
-        INNER JOIN orgs ON orgs.id = templates.org_id
-      SQL
+              .joins(<<~SQL)
+                INNER JOIN templates ON current.version = templates.version
+                  AND current.family_id = templates.family_id
+                INNER JOIN orgs ON orgs.id = templates.org_id
+              SQL
   }
 
   # Retrieves the latest customized versions, i.e. those with maximum version
   # associated for a set of family_id and an org
-  scope :latest_customized_version, -> (family_id = nil, org_id = nil) {
+  scope :latest_customized_version, ->(family_id = nil, org_id = nil) {
     unarchived
       .from(latest_customized_version_per_customised_of(family_id, org_id),
             :current)
@@ -154,24 +134,24 @@
 
   # Retrieves the latest templates, i.e. those with maximum version associated
   # for a set of org_id passed
-  scope :latest_version_per_org, -> (org_id = nil) {
-    if org_id.respond_to?(:each)
-      family_ids = families(org_id).pluck(:family_id)
-    else
-      family_ids = families([org_id]).pluck(:family_id)
-    end
+  scope :latest_version_per_org, ->(org_id = nil) {
+    family_ids = if org_id.respond_to?(:each)
+                   families(org_id).pluck(:family_id)
+                 else
+                   families([org_id]).pluck(:family_id)
+                 end
     latest_version(family_ids)
   }
 
   # Retrieve all of the latest customizations for the specified org
-  scope :latest_customized_version_per_org, -> (org_id=nil) {
+  scope :latest_customized_version_per_org, lambda { |org_id = nil|
     family_ids = families(org_id).pluck(:family_id)
     latest_customized_version(family_ids, org_id)
   }
 
   # Retrieves templates with distinct family_id. It can be filtered down if
   # org_id is passed
-  scope :families, -> (org_id=nil) {
+  scope :families, lambda { |org_id = nil|
     if org_id.respond_to?(:each)
       unarchived.where(org_id: org_id, customization_of: nil).distinct
     else
@@ -181,126 +161,179 @@
 
   # Retrieves the latest version of each customizable funder template (and the
   # default template)
-  scope :latest_customizable, -> {
-    family_ids = families(Org.funder.collect(&:id)).distinct.pluck(:family_id) << default.family_id
-    published(family_ids.flatten).where('visibility = ? OR is_default = ?', visibilities[:publicly_visible], true)
+  scope :latest_customizable, lambda {
+    funder_ids = Org.funder.pluck(:id)
+    family_ids = families(funder_ids).distinct
+                                     .pluck(:family_id) + [default.family_id]
+
+    published(family_ids.flatten)
+      .where('visibility = :visibility OR is_default = :is_default',
+             visibility: visibilities[:publicly_visible], is_default: true)
   }
 
   # Retrieves unarchived templates with public visibility
-  scope :publicly_visible, -> {
+  scope :publicly_visible, lambda {
     unarchived.where(visibility: visibilities[:publicly_visible])
   }
 
   # Retrieves unarchived templates with organisational visibility
-  scope :organisationally_visible, -> {
+  scope :organisationally_visible, lambda {
     unarchived.where(visibility: visibilities[:organisationally_visible])
   }
 
   # Retrieves unarchived templates whose title or org.name includes the term
   # passed
-  scope :search, -> (term) {
+  scope :search, lambda { |term|
     unarchived.where("templates.title LIKE :term OR orgs.name LIKE :term",
-                       { term: "%#{term}%" })
+                     term: "%#{term}%")
   }
 
-  # A standard template should be organisationally visible. Funder templates that are
-  # meant for external use will be publicly visible. This allows a funder to create 'funder' as
-  # well as organisational templates. The default template should also always be publicly_visible
-  enum visibility: [:organisationally_visible, :publicly_visible]
+  # A standard template should be organisationally visible. Funder templates
+  # that are meant for external use will be publicly visible. This allows a
+  # funder to create 'funder' as well as organisational templates. The default
+  # template should also always be publicly_visible.
+  enum visibility: %i[organisationally_visible publicly_visible]
 
   # defines the export setting for a template object
   has_settings :export, class_name: 'Settings::Template' do |s|
     s.key :export, defaults: Settings::Template::DEFAULT_SETTINGS
   end
 
-  validates :org, :title, presence: {message: _("can't be blank")}
+  validates :org, :title, presence: { message: _("can't be blank") }
 
-  # Class methods gets defined within this
-  class << self
+  # =================
+  # = Class Methods =
+  # =================
 
-    def current(family_id)
-      unarchived.where(family_id: family_id).order(version: :desc).first
-    end
+  def self.default
+    where(is_default: true, published: true).last
+  end
 
-    def live(family_id)
-      if family_id.respond_to?(:each)
-        unarchived.where(family_id: family_id, published: true)
-      else
-        unarchived.where(family_id: family_id, published: true).first
-      end
-    end
+  def self.current(family_id)
+    unarchived.where(family_id: family_id).order(version: :desc).first
+  end
 
-    def find_or_generate_version!(template)
-      if template.latest? && template.generate_version?
-        template.generate_version!
-      elsif template.latest? && !template.generate_version?
-        template
-      else
-        raise _('A historical template cannot be retrieved for being modified')
-      end
+  def self.live(family_id)
+    if family_id.respond_to?(:each)
+      unarchived.where(family_id: family_id, published: true)
+    else
+      unarchived.where(family_id: family_id, published: true).first
     end
   end
 
+  def self.find_or_generate_version!(template)
+    if template.latest? && template.generate_version?
+      template.generate_version!
+    elsif template.latest? && !template.generate_version?
+      template
+    else
+      raise _('A historical template cannot be retrieved for being modified')
+    end
+  end
+
+  # Retrieves the latest templates, i.e. those with maximum version associated.
+  # It can be filtered down if family_id is passed. NOTE, the template objects
+  # instantiated only contain version and family attributes populated. See
+  # Template::latest_version scope method for an adequate instantiation of
+  # template instances.
+  def self.latest_version_per_family(family_id = nil)
+    chained_scope = unarchived.select("MAX(version) AS version", :family_id)
+    if family_id.present?
+      chained_scope = chained_scope.where(family_id: family_id)
+    end
+    chained_scope.group(:family_id)
+  end
+
+  private_class_method :latest_version_per_family
+
+  def self.latest_customized_version_per_customised_of(customization_of = nil,
+                                                       org_id = nil)
+    chained_scope = select("MAX(version) AS version", :customization_of)
+    chained_scope = chained_scope.where(customization_of: customization_of)
+    chained_scope = chained_scope.where(org_id: org_id) if org_id.present?
+    chained_scope.group(:customization_of)
+  end
+
+  private_class_method :latest_customized_version_per_customised_of
+
+
+  # ===========================
+  # = Public instance methods =
+  # ===========================
+
   # Creates a copy of the current template
-  # raises ActiveRecord::RecordInvalid when save option is true and validations fails
+  # raises ActiveRecord::RecordInvalid when save option is true and validations
+  # fails.
   def deep_copy(attributes: {}, **options)
-    copy = self.dup
+    copy = dup
     if attributes.respond_to?(:each_pair)
-      attributes.each_pair{ |attribute, value| copy.send("#{attribute}=".to_sym, value) if copy.respond_to?("#{attribute}=".to_sym) }
+      attributes.each_pair do |attribute, value|
+        if copy.respond_to?("#{attribute}=".to_sym)
+          copy.send("#{attribute}=".to_sym, value)
+        end
+      end
     end
     copy.save! if options.fetch(:save, false)
     options[:template_id] = copy.id
-    self.phases.each{ |phase| copy.phases << phase.deep_copy(options) }
-    return copy
+    phases.each { |phase| copy.phases << phase.deep_copy(options) }
+    copy
   end
 
   # Retrieves the template's org or the org of the template this one is derived
   # from of it is a customization
   def base_org
-    if self.customization_of.present?
-      return Template.where(family_id: self.customization_of).first.org
+    if customization_of.present?
+      Template.where(family_id: customization_of).first.org
     else
-      return self.org
+      org
     end
   end
 
-  # Returns whether or not this is the latest version of the current template's family
+  # Returns whether or not this is the latest version of the current template's
+  # family
   def latest?
-    return (self.id == Template.latest_version(self.family_id).pluck(:id).first)
+    id == Template.latest_version(family_id).pluck(:id).first
   end
+
   # Determines whether or not a new version should be generated
   def generate_version?
-    return self.published
-  end
-  # Determines whether or not a customization for the customizing_org passed should be generated
-  def customize?(customizing_org)
-    if customizing_org.is_a?(Org) && (self.org.funder_only? || self.is_default)
-      return !Template.unarchived.where(customization_of: self.family_id, org: customizing_org).exists?
-    end
-    return false
-  end
-  # Determines whether or not a customized template should be upgraded
-  def upgrade_customization?
-    if self.customization_of.present?
-      funder_template = Template.published(self.customization_of).select(:created_at).first
-      if funder_template.present?
-        return funder_template.created_at > self.created_at
-      end
-    end
-    return false
+    published
   end
 
-  # Checks to see if the template family has a published version and if its not the current template
+  # Determines whether or not a customization for the customizing_org passed
+  # should be generated
+  def customize?(customizing_org)
+    if customizing_org.is_a?(Org) && (org.funder_only? || is_default)
+      return !Template.unarchived.where(customization_of: family_id,
+                                        org: customizing_org).exists?
+    end
+    false
+  end
+
+  # Determines whether or not a customized template should be upgraded
+  def upgrade_customization?
+    if customization_of.present?
+      funder_template = Template.published(customization_of)
+                                .select(:created_at).first
+
+      return funder_template.created_at > created_at if funder_template.present?
+    end
+    false
+  end
+
+  # Checks to see if the template family has a published version and if its not
+  # the current template
   def draft?
-    return !self.published && Template.published(self.family_id).length > 0
+    !published && !Template.published(family_id).empty?
   end
 
   def removable?
-    versions = Template.includes(:plans).where(family_id: self.family_id)
-    return versions.select{|version| version.plans.length > 0 }.empty?
+    versions = Template.includes(:plans).where(family_id: family_id)
+    versions.reject { |version| version.plans.empty? }.empty?
   end
 
-  # Returns a new unpublished copy of self with a new family_id, version = zero for the specified org
+  # Returns a new unpublished copy of self with a new family_id, version = zero
+  # for the specified org
   def generate_copy!(org)
     raise _('generate_copy! requires an organisation target') unless org.is_a?(Org) # Assume customizing_org is persisted
     template = deep_copy(
@@ -310,9 +343,10 @@
         family_id: new_family_id,
         org: org,
         is_default: false,
-        title: _('Copy of %{template}') % { template: self.title }
-      }, modifiable: true, save: true)
-    return template
+        title: format(_('Copy of %{template}'), template: title)
+      }, modifiable: true, save: true
+    )
+    template
   end
 
   # Generates a new copy of self with an incremented version number
@@ -320,37 +354,57 @@
     raise _('generate_version! requires a published template') unless published
     template = deep_copy(
       attributes: {
-        version: self.version+1,
+        version: version + 1,
         published: false,
-        org: self.org
-      }, save: true)
-    return template
+        org: org
+      }, save: true
+    )
+    template
   end
 
   # Generates a new copy of self for the specified customizing_org
   def customize!(customizing_org)
-    raise _('customize! requires an organisation target') unless customizing_org.is_a?(Org) # Assume customizing_org is persisted
-    raise _('customize! requires a template from a funder') if !self.org.funder_only? && !self.is_default # Assume self has org associated
+    # Assume customizing_org is persisted
+    unless customizing_org.is_a?(Org)
+      raise _('customize! requires an organisation target')
+    end
+
+    # Assume self has org associated
+    if !org.funder_only? && !is_default
+      raise _('customize! requires a template from a funder')
+    end
+
     customization = deep_copy(
       attributes: {
         version: 0,
         published: false,
         family_id: new_family_id,
-        customization_of: self.family_id,
+        customization_of: family_id,
         org: customizing_org,
         visibility: Template.visibilities[:organisationally_visible],
         is_default: false
-      }, modifiable: false, save: true)
-    return customization
+      }, modifiable: false, save: true
+    )
+    customization
   end
 
-  # Generates a new copy of self including latest changes from the funder this template is customized_of
+  # Generates a new copy of self including latest changes from the funder this
+  # template is customized_of
   def upgrade_customization!
-    raise _('upgrade_customization! requires a customised template') unless customization_of.present?
-    funder_template = Template.published(self.customization_of).first
-    raise _('upgrade_customization! cannot be carried out since there is no published template of its current funder') unless funder_template.present?
-    source = deep_copy(attributes: { version: self.version+1, published: false }) # preserves modifiable flags from the self template copied
-    # Creates a new customisation for the published template whose family_id is self.customization_of
+    if customization_of.blank?
+      raise _('upgrade_customization! requires a customised template')
+    end
+    funder_template = Template.published(customization_of).first
+
+    if funder_template.blank?
+      raise _("upgrade_customization! cannot be carried out since there is no published template of its current funder")
+    end
+
+    # preserves modifiable flags from the self template copied
+    source = deep_copy(attributes: { version: version + 1, published: false })
+
+    # Creates a new customisation for the published template whose family_id is
+    # self.customization_of
     customization = funder_template.deep_copy(
       attributes: {
         version: source.version,
@@ -360,73 +414,100 @@
         org: source.org,
         visibility: Template.visibilities[:organisationally_visible],
         is_default: false
-      }, modifiable: false, save: true)
+      }, modifiable: false, save: true
+    )
+
     # Sorts the phases from the source template, i.e. self
-    sorted_phases = source.phases.sort{ |phase1,phase2| phase1.number <=> phase2.number }
-    # Merges modifiable sections or questions from source into customization template object
+    sorted_phases = source.phases.sort_by(&:number)
+
+    # Merges modifiable sections or questions from source into customization
+    # template object
     customization.phases.each do |customization_phase|
-      # Search for the phase in the source template whose number matches the customization_phase
-      candidate_phase = sorted_phases.bsearch{ |phase| customization_phase.number <=> phase.number }
-      if candidate_phase.present? # The funder could have added this new phase after the customisation took place
-        # Selects modifiable sections from the candidate_phase
-        modifiable_sections = candidate_phase.sections.select{ |section| section.modifiable }
-        # Attaches modifiable sections into the customization_phase
-        modifiable_sections.each{ |modifiable_section| customization_phase.sections << modifiable_section }
-        # Sorts the sections for the customization_phase
-        sorted_sections = customization_phase.sections.sort{ |section1, section2| section1.number <=> section2.number }
-        # Selects unmodifiable sections from the candidate_phase
-        unmodifiable_sections = candidate_phase.sections.select{ |section| !section.modifiable }
-        unmodifiable_sections.each do |unmodifiable_section|
-          # Search for modifiable questions within the unmodifiable_section from candidate_phase
-          modifiable_questions = unmodifiable_section.questions.select{ |question| question.modifiable }
-          customization_section = sorted_sections.bsearch{ |section| unmodifiable_section.number <=> section.number }
-          if customization_section.present? # The funder could have deleted the section
-            modifiable_questions.each{ |modifiable_question| customization_section.questions << modifiable_question; }
-          end
-          # Search for unmodifiable questions within the unmodifiable_section in case source template added annotations
-          unmodifiable_questions = unmodifiable_section.questions.select{ |question| !question.modifiable }
-          sorted_questions = customization_section.questions.sort{ |question1, question2| question1.number <=> question2.number }
-          unmodifiable_questions.each do |unmodifiable_question|
-            customization_question = sorted_questions.bsearch{ |question| unmodifiable_question.number <=> question.number }
-            if customization_question.present?  # The funder could have deleted the question
-              annotations_added_by_customiser = unmodifiable_question.annotations.select{ |annotation| annotation.org_id == source.org_id }
-              annotations_added_by_customiser.each{ |annotation| customization_question.annotations << annotation }
-            end
+      # Search for the phase in the source template whose number matches the
+      # customization_phase
+
+      candidate_phase = sorted_phases.bsearch do |phase|
+        customization_phase.number <=> phase.number
+      end
+
+      # The funder could have added this new phase after the customisation took
+      # place
+      next if candidate_phase.blank?
+      # Selects modifiable sections from the candidate_phase
+      modifiable_sections = candidate_phase.sections.select(&:modifiable)
+
+      # Attaches modifiable sections into the customization_phase
+      modifiable_sections.each { |modifiable_section| customization_phase.sections << modifiable_section }
+
+      # Sorts the sections for the customization_phase
+      sorted_sections = customization_phase.sections.sort_by(&:number)
+
+      # Selects unmodifiable sections from the candidate_phase
+      unmodifiable_sections = candidate_phase.sections.reject(&:modifiable)
+
+      unmodifiable_sections.each do |unmodifiable_section|
+        # Search for modifiable questions within the unmodifiable_section
+        # from candidate_phase
+        modifiable_questions  = unmodifiable_section.questions.select(&:modifiable)
+        customization_section = sorted_sections.bsearch { |section| unmodifiable_section.number <=> section.number }
+        # The funder could have deleted the section
+        if customization_section.present?
+          modifiable_questions.each { |modifiable_question| customization_section.questions << modifiable_question; }
+        end
+        # Search for unmodifiable questions within the unmodifiable_section in case source template added annotations
+        unmodifiable_questions = unmodifiable_section.questions.reject(&:modifiable)
+        sorted_questions = customization_section.questions.sort_by(&:number)
+        unmodifiable_questions.each do |unmodifiable_question|
+          customization_question = sorted_questions.bsearch { |question| unmodifiable_question.number <=> question.number }
+          if customization_question.present?  # The funder could have deleted the question
+            annotations_added_by_customiser = unmodifiable_question.annotations.select { |annotation| annotation.org_id == source.org_id }
+            annotations_added_by_customiser.each { |annotation| customization_question.annotations << annotation }
           end
         end
       end
     end
     # Appends the modifiable phases from source
-    source.phases.select{ |phase| phase.modifiable }.each{ |modifiable_phase| customization.phases << modifiable_phase }
-    return customization
+    source.phases.select(&:modifiable).each do |modifiable_phase|
+      customization.phases << modifiable_phase
+    end
+    customization
   end
 
   private
-    # Generate a new random family identifier
-    def new_family_id
-      family_id = loop do
-        random = rand 2147483647
-        break random unless Template.exists?(family_id: random)
-      end
-      family_id
-    end
 
-    # Default values to set before running any validation
-    def set_defaults
-      self.published ||= false
-      self.archived ||= false
-      self.is_default ||= false
-      self.version ||= 0
-      self.visibility = ((self.org.present? && self.org.funder_only?) || self.is_default?) ? Template.visibilities[:publicly_visible] : Template.visibilities[:organisationally_visible] unless self.id.present?
-      self.customization_of ||= nil
-      self.family_id ||= new_family_id
-      self.archived ||= false
-      self.links ||= { funder: [], sample_plan: [] }
-    end
+  # ============================
+  # = Private instance methods =
+  # ============================
 
-    # Only one version of a template should be published at a time, so if this one was published make sure other versions are not
-    def reconcile_published
-      # Unpublish all other versions of this template family
-      Template.where('family_id = ? AND published = ? AND id != ?', self.family_id, true, self.id).update_all(published: false)
+  # Generate a new random family identifier
+  def new_family_id
+    family_id = loop do
+      random = rand 2_147_483_647
+      break random unless Template.exists?(family_id: random)
     end
+    family_id
+  end
+
+  # Default values to set before running any validation
+  def set_defaults
+    self.published ||= false
+    self.archived ||= false
+    self.is_default ||= false
+    self.version ||= 0
+    self.visibility = (org.present? && org.funder_only?) || is_default? ? Template.visibilities[:publicly_visible] : Template.visibilities[:organisationally_visible] if id.blank?
+    self.customization_of ||= nil
+    self.family_id ||= new_family_id
+    self.archived ||= false
+    self.links ||= { funder: [], sample_plan: [] }
+  end
+
+  # Only one version of a template should be published at a time, so if this
+  # one was published make sure other versions are not
+  def reconcile_published
+    # Unpublish all other versions of this template family
+    Template.published
+            .where(family_id: family_id)
+            .where.not(id: id)
+            .update_all(published: false)
+  end
 end
diff --git a/app/models/user.rb b/app/models/user.rb
index 4c01e36..3185d32 100644
--- a/app/models/user.rb
+++ b/app/models/user.rb
@@ -87,27 +87,14 @@
 
   has_many :roles, dependent: :destroy
 
-  has_many :plans, through: :roles do
-    def filter(query)
-      return self unless query.present?
-      t = self.arel_table
-      q = "%#{query}%"
-      conditions = t[:title].matches(q)
-      columns = %i(
-        grant_number identifier description principal_investigator data_contact
-      )
-      columns = ['grant_number', 'identifier', 'description', 'principal_investigator', 'data_contact']
-      columns.each {|col| conditions = conditions.or(t[col].matches(q)) }
-      self.where(conditions)
-    end
-  end
-
+  has_many :plans, through: :roles
 
   has_many :user_identifiers
 
   has_many :identifier_schemes, through: :user_identifiers
 
-  has_and_belongs_to_many :notifications, dependent: :destroy, join_table: 'notification_acknowledgements'
+  has_and_belongs_to_many :notifications, dependent: :destroy,
+                          join_table: 'notification_acknowledgements'
 
 
   # ===============
@@ -132,8 +119,9 @@
 
   scope :search, -> (term) {
     search_pattern = "%#{term}%"
-    # MySQL does not support standard string concatenation and since concat_ws or concat functions do
-    # not exist for sqlite, we have to come up with this conditional
+    # MySQL does not support standard string concatenation and since concat_ws
+    # or concat functions do not exist for sqlite, we have to come up with this
+    # conditional
     if ActiveRecord::Base.connection.adapter_name == "Mysql2"
       where("concat_ws(' ', firstname, surname) LIKE ? OR email LIKE ?", search_pattern, search_pattern)
     else
@@ -188,14 +176,6 @@
   end
 
   ##
-  # returns all active plans for a user
-  #
-  # @return [Plans]
-  def active_plans
-    self.plans.includes(:template).where("roles.active": true).where(Role.not_reviewer_condition)
-  end
-
-  ##
   # Returns the user's identifier for the specified scheme name
   #
   # @param the identifier scheme name (e.g. ORCID)
@@ -205,14 +185,6 @@
   end
 
   ##
-  # sets a new organisation for the user
-  #
-  # @param new_organisation [Organisation] the new organisation for the user
-  def organisation=(new_org)
-    org_id = new_org.id unless new_org.nil?
-  end
-
-  ##
   # checks if the user is a super admin
   # if the user has any privelege which requires them to see the super admin page
   # then they are a super admin
diff --git a/app/views/org_admin/phases/preview.html.erb b/app/views/org_admin/phases/preview.html.erb
index 19acbfd..312c7e9 100644
--- a/app/views/org_admin/phases/preview.html.erb
+++ b/app/views/org_admin/phases/preview.html.erb
@@ -36,7 +36,6 @@
                     plan: nil,
                     phase: phase,
                     readonly: true,
-                    question_guidance: {},
                     edit: false,
                     guidance_groups: [],
                     base_template_org: template.base_org,
diff --git a/app/views/phases/_edit_plan_answers.html.erb b/app/views/phases/_edit_plan_answers.html.erb
index e01758b..205fd5c 100644
--- a/app/views/phases/_edit_plan_answers.html.erb
+++ b/app/views/phases/_edit_plan_answers.html.erb
@@ -1,4 +1,3 @@
-<%# locals: { plan, phase, readonly, question_guidance, guidance_groups } %>
 <div class="tab-panels" role="tabpanel">
   <div id="phase-#<%= phase.id %>-panel" class="tab-panel active" aria-hidden="false" aria-labelledby="phase-#<%= phase.id %>-tab">
     <div class="row">
@@ -28,14 +27,14 @@
       <% sectionid = section.id %>
       <div class="panel panel-default">
         <div class="heading-button" role="button" data-toggle="collapse"
-             data-parent="sections-accordion" 
+             data-parent="sections-accordion"
              href="#collapse-<%= sectionid %>"
-             aria-expanded="false" 
+             aria-expanded="false"
              aria-controls="collapse-<%= sectionid %>">
 
           <div class="panel-heading" role="tab" id="heading-<%= sectionid %>">
             <div class="panel-title pull-left">
-              <%= section.title %> 
+              <%= section.title %>
               <% if plan.present? %>
                   <span class="section-progress-<%= sectionid %>">
                     <%= render :partial => "/org_admin/sections/progress", locals: { section: section, plan: plan } %>
@@ -62,7 +61,7 @@
                     <!-- Answer Section -->
                     <div class="question-form">
                       <div id="<%= "answer-locking-#{question.id}" %>" class="answer-locking"></div>
-                      <div id="<%= "answer-form-#{question.id}" %>" class="answer-form"> 
+                      <div id="<%= "answer-form-#{question.id}" %>" class="answer-form">
                         <%= render(partial: '/answers/new_edit', locals: { template: phase.template, question: question, answer: answer, readonly: readonly, locking: false, base_template_org: base_template_org }) %>
                       </div>
                       <div id="<%= "answer-status-#{question.id}" %>" class="mt-10">
diff --git a/app/views/phases/edit.html.erb b/app/views/phases/edit.html.erb
index 046de4a..f6decf0 100644
--- a/app/views/phases/edit.html.erb
+++ b/app/views/phases/edit.html.erb
@@ -1,8 +1,7 @@
-<%# locals: { plan, phase, readonly, question_guidance } %>
 <% title "#{plan.title} - Write plan" %>
 <div class="row">
   <div class="col-md-12">
-    <h1><%= plan.title %></h1> 
+    <h1><%= plan.title %></h1>
   </div>
 </div>
 
diff --git a/app/views/user_mailer/permissions_change_notification.html.erb b/app/views/user_mailer/permissions_change_notification.html.erb
index d9553fe..db036b4 100644
--- a/app/views/user_mailer/permissions_change_notification.html.erb
+++ b/app/views/user_mailer/permissions_change_notification.html.erb
@@ -4,14 +4,18 @@
   plan_title = @role.plan.title
   access = nil
   access_level = @role.access_level()
-  access_level_messages = Role.access_level_messages
 %>
 <% FastGettext.with_locale FastGettext.default_locale do %>
   <p>
     <%= _('Hello %{username}') %{ :username => username } %>
   </p>
   <p>
-    <%= _('Your permissions relating to %{plan_title} have changed. You now have %{type} access. This means you can %{placeholder1} %{placeholder2}') %{ :plan_title => plan_title, :type => access_level_messages[access_level][:type], :placeholder1 => access_level_messages[access_level][:placeholder1], :placeholder2 => access_level_messages[access_level][:placeholder2] } %>
+    <%= _('Your permissions relating to %{plan_title} have changed. You now have %{type} access. This means you can %{placeholder1} %{placeholder2}') % {
+       plan_title: plan_title,
+       type: Role::ACCESS_LEVEL_MESSAGES[access_level][:type],
+       placeholder1: Role::ACCESS_LEVEL_MESSAGES[access_level][:placeholder1],
+       placeholder2: Role::ACCESS_LEVEL_MESSAGES[access_level][:placeholder2]
+      } %>
   </p>
   <%= render partial: 'email_signature' %>
 <% end %>
diff --git a/app/views/user_mailer/plan_visibility.html.erb b/app/views/user_mailer/plan_visibility.html.erb
index 7c63eb1..8d0ac01 100644
--- a/app/views/user_mailer/plan_visibility.html.erb
+++ b/app/views/user_mailer/plan_visibility.html.erb
@@ -2,7 +2,7 @@
   tool_name = Rails.configuration.branding[:application][:name]
   username = @user.name
   plan_title = @plan.title
-  plan_visibility = Plan.visibility_message(@plan.visibility.to_sym)
+  plan_visibility = Plan::VISIBILITY_MESSAGE[@plan.visibility.to_sym]
 %>
 <% FastGettext.with_locale FastGettext.default_locale do %>
   <p>
diff --git a/lib/cleanup.rb b/lib/cleanup.rb
new file mode 100644
index 0000000..5b71994
--- /dev/null
+++ b/lib/cleanup.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+# Private: Utility module providing tools to clean up the codebase over time.
+module Cleanup
+end
diff --git a/lib/cleanup/deprecators.rb b/lib/cleanup/deprecators.rb
new file mode 100644
index 0000000..fd59e57
--- /dev/null
+++ b/lib/cleanup/deprecators.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Cleanup
+  # Private: Custom deprecator classes to use while we refactor the code for
+  # better readability.
+  module Deprecators
+  end
+end
diff --git a/lib/cleanup/deprecators/get_deprecator.rb b/lib/cleanup/deprecators/get_deprecator.rb
new file mode 100644
index 0000000..cde5b4a
--- /dev/null
+++ b/lib/cleanup/deprecators/get_deprecator.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Cleanup
+  module Deprecators
+
+    # Used to deprecate methods with non-idiomatic getter names.
+    #
+    # There are methods in the code with non-idiomatic method names. Typically,
+    # Ruby getters are named as nouns for the attribute they are returning.
+    # Prefer User#status over User#get_status.
+    #
+    class GetDeprecator
+
+      ##
+      # Default message to display to developer when deprecated method called.
+      MESSAGE = "%<deprecated_method>s is deprecated. "\
+                  "Instead, you should use: %<new_method>s. "\
+                  "Read #{__FILE__} for more information."
+
+      # Message printed to STDOUT when a deprecated method is called.
+      def deprecation_warning(deprecated_method, _message, _backtrace = nil)
+        new_method = deprecated_method.to_s.gsub(/^get\_/, '')
+        message = format(MESSAGE,
+                         deprecated_method: deprecated_method,
+                         new_method: new_method)
+        Kernel.warn(message)
+      end
+
+    end
+  end
+end
diff --git a/lib/cleanup/deprecators/predicate_deprecator.rb b/lib/cleanup/deprecators/predicate_deprecator.rb
new file mode 100644
index 0000000..19ca2a5
--- /dev/null
+++ b/lib/cleanup/deprecators/predicate_deprecator.rb
@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Cleanup
+  module Deprecators
+
+    # Used to deprecate methods that are predicate methods without question mks
+    #
+    # There are methods in the code with non-idiomatic method names. Typically,
+    # Ruby predicates are named as verbs in the infinitive with a question mark.
+    #
+    class PredicateDeprecator
+
+      ##
+      # Default message to display to developer when deprecated method called.
+      MESSAGE = "%<deprecated_method>s is deprecated. "\
+                  "Instead, you should use: %<new_method>s. "\
+                  "Read #{__FILE__} for more information."
+
+      # Message printed to STDOUT when a deprecated method is called.
+      def deprecation_warning(deprecated_method, _message, _backtrace = nil)
+        new_method = "#{deprecated_method.to_s}?"
+        message = format(MESSAGE,
+                         deprecated_method: deprecated_method,
+                         new_method: new_method)
+        Kernel.warn(message)
+      end
+
+    end
+  end
+end
diff --git a/lib/cleanup/deprecators/set_deprecator.rb b/lib/cleanup/deprecators/set_deprecator.rb
new file mode 100644
index 0000000..cd5a4aa
--- /dev/null
+++ b/lib/cleanup/deprecators/set_deprecator.rb
@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Cleanup
+  module Deprecators
+
+    # Used to deprecate methods with non-idiomatic setter names.
+    #
+    # There are methods in the code with non-idiomatic method names. Typically,
+    # Ruby getters are named as nouns for the attribute they are returning.
+    # Prefer User#status= over User#set_status.
+    #
+    class SetDeprecator
+
+      ##
+      # Default message to display to developer when deprecated method called.
+      MESSAGE = "%<deprecated_method>s is deprecated. "\
+                  "Instead, you should use: %<new_method>s. "\
+                  "Read #{__FILE__} for more information."
+
+      # Message printed to STDOUT when a deprecated method is called.
+      def deprecation_warning(deprecated_method, _message, _backtrace = nil)
+        new_method = deprecated_method.to_s.gsub(/^set\_/, '').gsub(/\Z/, '=')
+        message = format(MESSAGE,
+                         deprecated_method: deprecated_method,
+                         new_method: new_method)
+        Kernel.warn(message)
+      end
+
+    end
+  end
+end