@@ -218,7 +218,8 @@ class Plan < ActiveRecord::Base
 
         if self.save!
           # Send an email confirmation to the owners and co-owners
-          deliver_if(recipients: self.owner_and_coowners, key: 'users.feedback_requested') do |r|
+          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_requested') do |r|
             UserMailer.feedback_confirmation(r, self, user).deliver_now
           end
           # Send an email to all of the org admins as well as the Org's administrator email
class Plan < ActiveRecord::Base
  include ConditionalUserMailer
  include ExportablePlan
  before_validation :set_creation_defaults

  ##
  # Associations
  belongs_to :template
  has_many :phases, through: :template
  has_many :sections, through: :phases
  has_many :questions, through: :sections
  has_many :themes, through: :questions
  has_many :answers, dependent: :destroy
  has_many :notes, through: :answers
  has_many :roles, dependent: :destroy
  has_many :users, through: :roles
  has_and_belongs_to_many :guidance_groups, join_table: :plans_guidance_groups

  accepts_nested_attributes_for :template
  has_many :exported_plans

  has_many :roles

# COMMENTED OUT THE DIRECT CONNECTION HERE TO Users to prevent assignment of users without an access_level specified (currently defaults to creator)
#  has_many :users, through: :roles


  ##
  # Possibly needed for active_admin
  #   -relies on protected_attributes gem as syntax depricated in rails 4.2
  attr_accessible :locked, :project_id, :version_id, :version, :plan_sections,
                  :exported_plans, :project, :title, :template, :grant_number,
                  :identifier, :principal_investigator, :principal_investigator_identifier,
                  :description, :data_contact, :funder_name, :visibility, :exported_plans,
                  :roles, :users, :org, :data_contact_email, :data_contact_phone, :feedback_requested,
                  :principal_investigator_email, :as => [:default, :admin]
  accepts_nested_attributes_for :roles

  # public is a Ruby keyword so using publicly
  enum visibility: [:organisationally_visible, :publicly_visible, :is_test, :privately_visible]

  #TODO: work out why this messes up plan creation :
  #   briley: Removed reliance on :users, its really on :roles (shouldn't have a plan without at least a creator right?) It should be ok like this though now
#  validates :template, :title, presence: true

  ##
  # Constants
  A4_PAGE_HEIGHT = 297 #(in mm)
  A4_PAGE_WIDTH = 210 #(in mm)
  ROUNDING = 5 #round estimate up to nearest 5%
  FONT_HEIGHT_CONVERSION_FACTOR = 0.35278 #convert font point size to mm
  FONT_WIDTH_HEIGHT_RATIO = 0.4 #Assume glyph width averages 2/5 the height

  # 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 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 :search, -> (term) {
    search_pattern = "%#{term}%"
    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)
  }
  ##
  # 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


  ##
  # 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.dmptemplate.settings(key)
    self.template.settings(key) unless self.template.nil?
  end

  ##
  # returns the template for this plan, or generates an empty template and returns that
  #
  # @return [Dmptemplate] the template associated with this plan
  def dmptemplate
    #self.project.try(:dmptemplate) || Dmptemplate.new
    self.template
  end



  def base_template
    base = nil
    t = self.template
    if t.customization_of.present?
      base = Template.where("dmptemplate_id = ? and created_at < ?", t.customization_of, self.created_at).order(version: :desc).first
    end
    return base
  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 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 confirmation to the owners and co-owners
          deliver_if(recipients: self.owner_and_coowners, key: 'users.feedback_requested') do |r|
            UserMailer.feedback_confirmation(r, self, user).deliver_now
          end
          # Send an email to all of the org admins as well as the Org's administrator email
          if user.org.contact_email.present? && !admins.collect{ |u| u.email }.include?(user.org.contact_email)
            admins << User.new(email: user.org.contact_email, firstname: user.org.contact_name)
          end
          deliver_if(recipients: admins, key: 'admins.feedback_requested') do |r|
            UserMailer.feedback_notification(r, 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
          deliver_if(recipients: self.owner_and_coowners, key: 'users.feedback_provided') do |r|
            UserMailer.feedback_notification(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 (?) AND orgs.id != ?", 
                                                       true, guidance_groups_ids, self.template.org.id)

    # 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 = self.owner_and_coowners.collect(&:org)
    
    # Super Admins can view plans read-only, Org Admins can view their Org's plans 
    # otherwise the user must have the commenter role
    (user.can_super_admin? ||
     user.can_org_admin? && owner_orgs.include?(user.org) ||
     has_role(user.id, :commenter))
  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}}},
                   {customizations: :org}
                  ]},
       {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
  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.first
    return plan, phase
  end

  # deep copy the given plan and all of it's associations
  #
  # @params [Plan] plan to be deep copied
  # @return [Plan] saved copied plan
  def self.deep_copy(plan)
    plan_copy = plan.dup
    plan_copy.title = "Copy of " + plan.title
    plan_copy.save!
    plan.answers.each do |answer|
      answer_copy = Answer.deep_copy(answer)
      answer_copy.plan_id = plan_copy.id
      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
    end
    return 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]
  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
  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
  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)
  end

  # 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)
    num_answers = pre_fetched_answers.reduce(0) do |m, a|
      if a.is_valid? 
        m+=1
      end
      m
    end
    return 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)
    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?
    else
      false
    end
  end

  ##
  # 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_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
  #
  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

    role = Role.new
    role.user_id = user_id
    role.plan_id = id

    # if you get assigned a role you can comment
    role.commenter= true

    # the rest of the roles are inclusing so creator => administrator => editor
    if is_creator
      role.creator =  true
      role.administrator = true
      role.editor = true
    end

    if is_administrator
      role.administrator = true
      role.editor = true
    end

    if is_editor
      role.editor = true
    end

    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 dmptemplate 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
    dmptemplate.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.dmptemplate.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 and dirty flags 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
  end
end

owner_and_coowners class method is still used after the change? If not, please remove it!