class Session

Source

# File app/models/session.rb, line 198
def birth_academic_years(programme: nil)
  if programme
    session_programme_year_groups.where(
      programme_type: programme.type
    ).pluck_birth_academic_years
  else
    session_programme_year_groups.pluck_birth_academic_years
  end
end

completed? ()

Source

# File app/models/session.rb, line 221
def completed?
  return false if dates.empty?
  Date.current > dates.max
end

future_dates (= dates.select(&:future?))

Source

# File app/models/session.rb, line 253
  def future_dates = dates.select(&:future?)

  def next_date(include_today:)
    (include_today ? today_or_future_dates : future_dates).first
  end

  def has_been_attended?(date:)
    gillick_assessments.any? { it.date == date } ||
      pre_screenings.any? { it.date == date } ||
      attendance_records.any? { it.date == date }
  end

  def patients_with_no_consent_response_count
    patients.has_programme_status(
      "needs_consent_no_response",
      programme: programmes,
      academic_year:
    ).count
  end

  def sync_location_programme_year_groups!(programme_types:)
    location_programme_year_groups =
      Location::ProgrammeYearGroup
        .joins(:location_year_group)
        .where(
          location_year_group: {
            location_id:,
            academic_year:
          },
          programme_type: programme_types
        )
        .pluck(:programme_type, :"location_year_group.value")

    rows =
      location_programme_year_groups.map do |programme_type, year_group|
        [id, programme_type, year_group]
      end

    ActiveRecord::Base.transaction do
      Session::ProgrammeYearGroup.where(session_id: id).delete_all
      Session::ProgrammeYearGroup.import!(
        %i[session_id programme_type year_group],
        rows,
        on_duplicate_key_ignore: true
      )
    end
  end

  private

  def set_slug
    self.slug = SecureRandom.alphanumeric(10) if slug.nil?
  end
end

has_been_attended? (date:)

Source

# File app/models/session.rb, line 259
def has_been_attended?(date:)
  gillick_assessments.any? { it.date == date } ||
    pre_screenings.any? { it.date == date } ||
    attendance_records.any? { it.date == date }
end

has_multiple_vaccine_methods? (= vaccine_methods.length > 1)

Source

# File app/models/session.rb, line 237
def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

def today_or_future_dates
  dates.select { it.today? || it.future? }
end

def future_dates = dates.select(&:future?)

def next_date(include_today:)
  (include_today ? today_or_future_dates : future_dates).first
end

def has_been_attended?(date:)
  gillick_assessments.any? { it.date == date } ||
    pre_screenings.any? { it.date == date } ||
    attendance_records.any? { it.date == date }
end

def patients_with_no_consent_response_count
  patients.has_programme_status(
    "needs_consent_no_response",
    programme: programmes,
    academic_year:
  ).count
end

def sync_location_programme_year_groups!(programme_types:)
  location_programme_year_groups =
    Location::ProgrammeYearGroup
      .joins(:location_year_group)
      .where(
        location_year_group: {
          location_id:,
          academic_year:
        },
        programme_type: programme_types
      )
      .pluck(:programme_type, :"location_year_group.value")

  rows =
    location_programme_year_groups.map do |programme_type, year_group|
      [id, programme_type, year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

private

def set_slug
  self.slug = SecureRandom.alphanumeric(10) if slug.nil?
end

has_programme_type? (programme_type)

Source

# File app/models/session.rb, line 170
def has_programme_type?(programme_type)
  session_programme_year_groups.exists?(programme_type:)
end

next_date (include_today:)

Source

# File app/models/session.rb, line 255
def next_date(include_today:)
  (include_today ? today_or_future_dates : future_dates).first
end

patients ()

Source

# File app/models/session.rb, line 208
def patients
  Patient
    .joins_sessions
    .where(sessions: { id: })
    .where(birth_academic_year: birth_academic_years)
    .not_deceased
    .eligible_for_any_programmes_of(programmes, session: self)
end

patients_with_no_consent_response_count ()

Source

# File app/models/session.rb, line 265
def patients_with_no_consent_response_count
  patients.has_programme_status(
    "needs_consent_no_response",
    programme: programmes,
    academic_year:
  ).count
end

programme_types ()

Source

# File app/models/session.rb, line 163
def programme_types
  @programme_types ||=
    session_programme_year_groups.map(&:programme_type).sort.uniq
end

programmes (= Programme.find_all(programme_types))

Source

# File app/models/session.rb, line 168
def programmes = Programme.find_all(programme_types)

def has_programme_type?(programme_type)
  session_programme_year_groups.exists?(programme_type:)
end

def vaccines
  @vaccines ||= Vaccine.where(programme_type: programme_types)
end

def year_groups(programme: nil)
  if session_programme_year_groups.loaded?
    if programme
      session_programme_year_groups
        .select { it.programme_type == programme.type }
        .map(&:year_group)
        .sort
        .uniq
    else
      session_programme_year_groups.map(&:year_group).sort.uniq
    end
  elsif programme
    session_programme_year_groups.where(
      programme_type: programme.type
    ).pluck_year_groups
  else
    session_programme_year_groups.pluck_year_groups
  end
end

def birth_academic_years(programme: nil)
  if programme
    session_programme_year_groups.where(
      programme_type: programme.type
    ).pluck_birth_academic_years
  else
    session_programme_year_groups.pluck_birth_academic_years
  end
end

def patients
  Patient
    .joins_sessions
    .where(sessions: { id: })
    .where(birth_academic_year: birth_academic_years)
    .not_deceased
    .eligible_for_any_programmes_of(programmes, session: self)
end

def today? = dates.any?(&:today?)

def unscheduled? = dates.empty?

def completed?
  return false if dates.empty?
  Date.current > dates.max
end

def scheduled? = !unscheduled? && !completed?

def started?
  return false if dates.empty?
  Date.current >= dates.min
end

def vaccine_methods
  @vaccine_methods ||= programmes.flat_map(&:vaccine_methods).uniq.sort
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

def today_or_future_dates
  dates.select { it.today? || it.future? }
end

def future_dates = dates.select(&:future?)

def next_date(include_today:)
  (include_today ? today_or_future_dates : future_dates).first
end

def has_been_attended?(date:)
  gillick_assessments.any? { it.date == date } ||
    pre_screenings.any? { it.date == date } ||
    attendance_records.any? { it.date == date }
end

def patients_with_no_consent_response_count
  patients.has_programme_status(
    "needs_consent_no_response",
    programme: programmes,
    academic_year:
  ).count
end

def sync_location_programme_year_groups!(programme_types:)
  location_programme_year_groups =
    Location::ProgrammeYearGroup
      .joins(:location_year_group)
      .where(
        location_year_group: {
          location_id:,
          academic_year:
        },
        programme_type: programme_types
      )
      .pluck(:programme_type, :"location_year_group.value")

  rows =
    location_programme_year_groups.map do |programme_type, year_group|
      [id, programme_type, year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

private

def set_slug
  self.slug = SecureRandom.alphanumeric(10)

programmes_for (year_group: nil, patient: nil)

Source

# File app/models/session.rb, line 239
def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

scheduled? (= !unscheduled? && !completed?)

Source

# File app/models/session.rb, line 226
def scheduled? = !unscheduled? && !completed?

def started?
  return false if dates.empty?
  Date.current >= dates.min
end

def vaccine_methods
  @vaccine_methods ||= programmes.flat_map(&:vaccine_methods).uniq.sort
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

def today_or_future_dates
  dates.select { it.today? || it.future? }
end

def future_dates = dates.select(&:future?)

def next_date(include_today:)
  (include_today ? today_or_future_dates : future_dates).first
end

def has_been_attended?(date:)
  gillick_assessments.any? { it.date == date } ||
    pre_screenings.any? { it.date == date } ||
    attendance_records.any? { it.date == date }
end

def patients_with_no_consent_response_count
  patients.has_programme_status(
    "needs_consent_no_response",
    programme: programmes,
    academic_year:
  ).count
end

def sync_location_programme_year_groups!(programme_types:)
  location_programme_year_groups =
    Location::ProgrammeYearGroup
      .joins(:location_year_group)
      .where(
        location_year_group: {
          location_id:,
          academic_year:
        },
        programme_type: programme_types
      )
      .pluck(:programme_type, :"location_year_group.value")

  rows =
    location_programme_year_groups.map do |programme_type, year_group|
      [id, programme_type, year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

private

def set_slug
  self.slug = SecureRandom.alphanumeric(10) if slug.nil?

set_slug ()

Source

# File app/models/session.rb, line 303
def set_slug
  self.slug = SecureRandom.alphanumeric(10) if slug.nil?
end

started? ()

Source

# File app/models/session.rb, line 228
def started?
  return false if dates.empty?
  Date.current >= dates.min
end

sync_location_programme_year_groups! (programme_types:)

Source

# File app/models/session.rb, line 273
def sync_location_programme_year_groups!(programme_types:)
  location_programme_year_groups =
    Location::ProgrammeYearGroup
      .joins(:location_year_group)
      .where(
        location_year_group: {
          location_id:,
          academic_year:
        },
        programme_type: programme_types
      )
      .pluck(:programme_type, :"location_year_group.value")

  rows =
    location_programme_year_groups.map do |programme_type, year_group|
      [id, programme_type, year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

to_param (= slug)

Source

# File app/models/session.rb, line 159
def to_param = slug

delegate :type, to: :location, prefix: true

def programme_types
  @programme_types ||=
    session_programme_year_groups.map(&:programme_type).sort.uniq
end

def programmes = Programme.find_all(programme_types)

def has_programme_type?(programme_type)
  session_programme_year_groups.exists?(programme_type:)
end

def vaccines
  @vaccines ||= Vaccine.where(programme_type: programme_types)
end

def year_groups(programme: nil)
  if session_programme_year_groups.loaded?
    if programme
      session_programme_year_groups
        .select { it.programme_type == programme.type }
        .map(&:year_group)
        .sort
        .uniq
    else
      session_programme_year_groups.map(&:year_group).sort.uniq
    end
  elsif programme
    session_programme_year_groups.where(
      programme_type: programme.type
    ).pluck_year_groups
  else
    session_programme_year_groups.pluck_year_groups
  end
end

def birth_academic_years(programme: nil)
  if programme
    session_programme_year_groups.where(
      programme_type: programme.type
    ).pluck_birth_academic_years
  else
    session_programme_year_groups.pluck_birth_academic_years
  end
end

def patients
  Patient
    .joins_sessions
    .where(sessions: { id: })
    .where(birth_academic_year: birth_academic_years)
    .not_deceased
    .eligible_for_any_programmes_of(programmes, session: self)
end

def today? = dates.any?(&:today?)

def unscheduled? = dates.empty?

def completed?
  return false if dates.empty?
  Date.current > dates.max
end

def scheduled? = !unscheduled? && !completed?

def started?
  return false if dates.empty?
  Date.current >= dates.min
end

def vaccine_methods
  @vaccine_methods ||= programmes.flat_map(&:vaccine_methods).uniq.sort
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

def today_or_future_dates
  dates.select { it.today? || it.future? }
end

def future_dates = dates.select(&:future?)

def next_date(include_today:)
  (include_today ? today_or_future_dates : future_dates).first
end

def has_been_attended?(date:)
  gillick_assessments.any? { it.date == date } ||
    pre_screenings.any? { it.date == date } ||
    attendance_records.any? { it.date == date }
end

def patients_with_no_consent_response_count
  patients.has_programme_status(
    "needs_consent_no_response",
    programme: programmes,
    academic_year:
  ).count
end

def sync_location_programme_year_groups!(programme_types:)
  location_programme_year_groups =
    Location::ProgrammeYearGroup
      .joins(:location_year_group)
      .where(
        location_year_group: {
          location_id:,
          academic_year:
        },
        programme_type: programme_types
      )
      .pluck(:programme_type, :"location_year_group.value")

  rows =
    location_programme_year_groups.map do |programme_type, year_group|
      [id, programme_type, year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

private

def set_slug
  self.slug = SecureRandom.alphanumeric(10

today? (= dates.any?(&:today?))

Source

# File app/models/session.rb, line 217
def today? = dates.any?(&:today?)

def unscheduled? = dates.empty?

def completed?
  return false if dates.empty?
  Date.current > dates.max
end

def scheduled? = !unscheduled? && !completed?

def started?
  return false if dates.empty?
  Date.current >= dates.min
end

def vaccine_methods
  @vaccine_methods ||= programmes.flat_map(&:vaccine_methods).uniq.sort
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

def today_or_future_dates
  dates.select { it.today? || it.future? }
end

def future_dates = dates.select(&:future?)

def next_date(include_today:)
  (include_today ? today_or_future_dates : future_dates).first
end

def has_been_attended?(date:)
  gillick_assessments.any? { it.date == date } ||
    pre_screenings.any? { it.date == date } ||
    attendance_records.any? { it.date == date }
end

def patients_with_no_consent_response_count
  patients.has_programme_status(
    "needs_consent_no_response",
    programme: programmes,
    academic_year:
  ).count
end

def sync_location_programme_year_groups!(programme_types:)
  location_programme_year_groups =
    Location::ProgrammeYearGroup
      .joins(:location_year_group)
      .where(
        location_year_group: {
          location_id:,
          academic_year:
        },
        programme_type: programme_types
      )
      .pluck(:programme_type, :"location_year_group.value")

  rows =
    location_programme_year_groups.map do |programme_type, year_group|
      [id, programme_type, year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

private

def set_slug
  self.slug = SecureRandom.alphanumeric(10) if

today_or_future_dates ()

Source

# File app/models/session.rb, line 249
def today_or_future_dates
  dates.select { it.today? || it.future? }
end

unscheduled? (= dates.empty?)

Source

# File app/models/session.rb, line 219
def unscheduled? = dates.empty?

def completed?
  return false if dates.empty?
  Date.current > dates.max
end

def scheduled? = !unscheduled? && !completed?

def started?
  return false if dates.empty?
  Date.current >= dates.min
end

def vaccine_methods
  @vaccine_methods ||= programmes.flat_map(&:vaccine_methods).uniq.sort
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def programmes_for(year_group: nil, patient: nil)
  year_group ||= patient.year_group(academic_year:)

  programmes.select do |programme|
    session_programme_year_groups.any? do
      it.programme_type == programme.type && it.year_group == year_group
    end
  end
end

def today_or_future_dates
  dates.select { it.today? || it.future? }
end

def future_dates = dates.select(&:future?)

def next_date(include_today:)
  (include_today ? today_or_future_dates : future_dates).first
end

def has_been_attended?(date:)
  gillick_assessments.any? { it.date == date } ||
    pre_screenings.any? { it.date == date } ||
    attendance_records.any? { it.date == date }
end

def patients_with_no_consent_response_count
  patients.has_programme_status(
    "needs_consent_no_response",
    programme: programmes,
    academic_year:
  ).count
end

def sync_location_programme_year_groups!(programme_types:)
  location_programme_year_groups =
    Location::ProgrammeYearGroup
      .joins(:location_year_group)
      .where(
        location_year_group: {
          location_id:,
          academic_year:
        },
        programme_type: programme_types
      )
      .pluck(:programme_type, :"location_year_group.value")

  rows =
    location_programme_year_groups.map do |programme_type, year_group|
      [id, programme_type, year_group]
    end

  ActiveRecord::Base.transaction do
    Session::ProgrammeYearGroup.where(session_id: id).delete_all
    Session::ProgrammeYearGroup.import!(
      %i[session_id programme_type year_group],
      rows,
      on_duplicate_key_ignore: true
    )
  end
end

private

def set_slug
  self.slug = SecureRandom.alphanumeric(10) if slug.

vaccine_methods ()

Source

# File app/models/session.rb, line 233
def vaccine_methods
  @vaccine_methods ||= programmes.flat_map(&:vaccine_methods).uniq.sort
end

vaccines ()

Source

# File app/models/session.rb, line 174
def vaccines
  @vaccines ||= Vaccine.where(programme_type: programme_types)
end

year_groups (programme: nil)

Source

# File app/models/session.rb, line 178
def year_groups(programme: nil)
  if session_programme_year_groups.loaded?
    if programme
      session_programme_year_groups
        .select { it.programme_type == programme.type }
        .map(&:year_group)
        .sort
        .uniq
    else
      session_programme_year_groups.map(&:year_group).sort.uniq
    end
  elsif programme
    session_programme_year_groups.where(
      programme_type: programme.type
    ).pluck_year_groups
  else
    session_programme_year_groups.pluck_year_groups
  end
end

Schema Information

Public Instance Methods