class Patient::ProgrammeStatus

Schema Information

Table name: patient_programme_statuses

id                      :bigint           not null, primary key
academic_year           :integer          not null
consent_status          :integer          default("no_response"), not null
consent_vaccine_methods :integer          default([]), not null, is an Array
date                    :date
disease_types           :enum             is an Array
dose_sequence           :integer
programme_type          :enum             not null
status                  :integer          default("not_eligible"), not null
vaccine_methods         :integer          is an Array
without_gelatine        :boolean
location_id             :bigint
patient_id              :bigint           not null

Indexes

idx_on_academic_year_patient_id_3d5bf8d2c8                 (academic_year,patient_id)
idx_on_patient_id_academic_year_programme_type_75e0e0c471  (patient_id,academic_year,programme_type) UNIQUE
index_patient_programme_statuses_on_location_id            (location_id)
index_patient_programme_statuses_on_patient_id             (patient_id)
index_patient_programme_statuses_on_status                 (status)

Foreign Keys

fk_rails_...  (patient_id => patients.id) ON DELETE => cascade

Constants

CANNOT_VACCINATE_STATUSES
DUE_STATUSES
GROUPS
HAS_REFUSAL_STATUSES
NEEDS_CONSENT_STATUSES
NEEDS_TRIAGE_STATUSES
NOT_ELIGIBLE_STATUSES
VACCINATED_STATUSES

Public Instance Methods

assign ()

Source

# File app/models/patient/programme_status.rb, line 184
def assign
  self.consent_status = generator.consent_status
  self.consent_vaccine_methods = generator.consent_vaccine_methods
  self.date = generator.date
  self.disease_types = generator.disease_types
  self.dose_sequence = generator.dose_sequence
  self.location_id = generator.location_id
  self.status = generator.status
  self.vaccine_methods = generator.vaccine_methods
  self.without_gelatine = generator.without_gelatine
end

cannot_vaccinate? (= status.in?(CANNOT_VACCINATE_STATUSES.keys))

Source

# File app/models/patient/programme_status.rb, line 174
def cannot_vaccinate? = status.in?(CANNOT_VACCINATE_STATUSES.keys)

def needs_triage? = status.in?(NEEDS_TRIAGE_STATUSES.keys)

def due? = status.in?(DUE_STATUSES.keys)

def vaccinated? = status.in?(VACCINATED_STATUSES.keys)

def group = GROUPS.find { status.starts_with?(it) }

def assign
  self.consent_status = generator.consent_status
  self.consent_vaccine_methods = generator.consent_vaccine_methods
  self.date = generator.date
  self.disease_types = generator.disease_types
  self.dose_sequence = generator.dose_sequence
  self.location_id = generator.location_id
  self.status = generator.status
  self.vaccine_methods = generator.vaccine_methods
  self.without_gelatine = generator.without_gelatine
end

def vaccine_criteria = VaccineCriteria.from_programme_status(self)

def needs_more_doses?
  dose_sequence.present? &&
    dose_sequence <= Programme.find(programme_type).maximum_dose_sequence
end

def on_last_dose?
  dose_sequence == Programme.find(programme_type).maximum_dose_sequence
end

def next_dose_eligible_date
  interval = Programme.find(programme_type).minimum_dose_interval
  return unless interval

  if cannot_vaccinate_delay_vaccination?
    date
  elsif date
    (date + interval).to_date
  end
end

private

def generator
  @generator ||=
    StatusGenerator::Programme.new(
      programme_type:,
      academic_year:,
      patient:,
      patient_locations:,
      consents:,
      triages:,
      attendance_record:,
      vaccination_records:,
      parents:,

due? (= status.in?(DUE_STATUSES.keys))

Source

# File app/models/patient/programme_status.rb, line 178
def due? = status.in?(DUE_STATUSES.keys)

def vaccinated? = status.in?(VACCINATED_STATUSES.keys)

def group = GROUPS.find { status.starts_with?(it) }

def assign
  self.consent_status = generator.consent_status
  self.consent_vaccine_methods = generator.consent_vaccine_methods
  self.date = generator.date
  self.disease_types = generator.disease_types
  self.dose_sequence = generator.dose_sequence
  self.location_id = generator.location_id
  self.status = generator.status
  self.vaccine_methods = generator.vaccine_methods
  self.without_gelatine = generator.without_gelatine
end

def vaccine_criteria = VaccineCriteria.from_programme_status(self)

def needs_more_doses?
  dose_sequence.present? &&
    dose_sequence <= Programme.find(programme_type).maximum_dose_sequence
end

def on_last_dose?
  dose_sequence == Programme.find(programme_type).maximum_dose_sequence
end

def next_dose_eligible_date
  interval = Programme.find(programme_type).minimum_dose_interval
  return unless interval

  if cannot_vaccinate_delay_vaccination?
    date
  elsif date
    (date + interval).to_date
  end
end

private

def generator
  @generator ||=
    StatusGenerator::Programme.new(
      programme_type:,
      academic_year:,
      patient:,
      patient_locations:,
      consents:,
      triages:,
      attendance_record:,
      vaccination_records:,
      parents:,
      consent_notifications:

generator ()

Source

# File app/models/patient/programme_status.rb, line 220
def generator
  @generator ||=
    StatusGenerator::Programme.new(
      programme_type:,
      academic_year:,
      patient:,
      patient_locations:,
      consents:,
      triages:,
      attendance_record:,
      vaccination_records:,
      parents:,
      consent_notifications:
    )
end

group (= GROUPS.find { status.starts_with?(it) })

Source

# File app/models/patient/programme_status.rb, line 182
def group = GROUPS.find { status.starts_with?(it) }

def assign
  self.consent_status = generator.consent_status
  self.consent_vaccine_methods = generator.consent_vaccine_methods
  self.date = generator.date
  self.disease_types = generator.disease_types
  self.dose_sequence = generator.dose_sequence
  self.location_id = generator.location_id
  self.status = generator.status
  self.vaccine_methods = generator.vaccine_methods
  self.without_gelatine = generator.without_gelatine
end

def vaccine_criteria = VaccineCriteria.from_programme_status(self)

def needs_more_doses?
  dose_sequence.present? &&
    dose_sequence <= Programme.find(programme_type).maximum_dose_sequence
end

def on_last_dose?
  dose_sequence == Programme.find(programme_type).maximum_dose_sequence
end

def next_dose_eligible_date
  interval = Programme.find(programme_type).minimum_dose_interval
  return unless interval

  if cannot_vaccinate_delay_vaccination?
    date
  elsif date
    (date + interval).to_date
  end
end

private

def generator
  @generator ||=
    StatusGenerator::Programme.new(
      programme_type:,
      academic_year:,
      patient:,
      patient_locations:,
      consents:,
      triages:,
      attendance_record:,
      vaccination_records:,
      parents:,
      consent_notifications:
    )
end

has_refusal? (= status.in?(HAS_REFUSAL_STATUSES.keys))

Source

# File app/models/patient/programme_status.rb, line 172
def has_refusal? = status.in?(HAS_REFUSAL_STATUSES.keys)

def cannot_vaccinate? = status.in?(CANNOT_VACCINATE_STATUSES.keys)

def needs_triage? = status.in?(NEEDS_TRIAGE_STATUSES.keys)

def due? = status.in?(DUE_STATUSES.keys)

def vaccinated? = status.in?(VACCINATED_STATUSES.keys)

def group = GROUPS.find { status.starts_with?(it) }

def assign
  self.consent_status = generator.consent_status
  self.consent_vaccine_methods = generator.consent_vaccine_methods
  self.date = generator.date
  self.disease_types = generator.disease_types
  self.dose_sequence = generator.dose_sequence
  self.location_id = generator.location_id
  self.status = generator.status
  self.vaccine_methods = generator.vaccine_methods
  self.without_gelatine = generator.without_gelatine
end

def vaccine_criteria = VaccineCriteria.from_programme_status(self)

def needs_more_doses?
  dose_sequence.present? &&
    dose_sequence <= Programme.find(programme_type).maximum_dose_sequence
end

def on_last_dose?
  dose_sequence == Programme.find(programme_type).maximum_dose_sequence
end

def next_dose_eligible_date
  interval = Programme.find(programme_type).minimum_dose_interval
  return unless interval

  if cannot_vaccinate_delay_vaccination?
    date
  elsif date
    (date + interval).to_date
  end
end

private

def generator
  @generator ||=
    StatusGenerator::Programme.new(
      programme_type:,
      academic_year:,
      patient:,
      patient_locations:,
      consents:,
      triages:,
      attendance_record:,
      vaccination_records:,
      parents:

needs_consent? (= status.in?(NEEDS_CONSENT_STATUSES.keys))

Source

# File app/models/patient/programme_status.rb, line 170
def needs_consent? = status.in?(NEEDS_CONSENT_STATUSES.keys)

def has_refusal? = status.in?(HAS_REFUSAL_STATUSES.keys)

def cannot_vaccinate? = status.in?(CANNOT_VACCINATE_STATUSES.keys)

def needs_triage? = status.in?(NEEDS_TRIAGE_STATUSES.keys)

def due? = status.in?(DUE_STATUSES.keys)

def vaccinated? = status.in?(VACCINATED_STATUSES.keys)

def group = GROUPS.find { status.starts_with?(it) }

def assign
  self.consent_status = generator.consent_status
  self.consent_vaccine_methods = generator.consent_vaccine_methods
  self.date = generator.date
  self.disease_types = generator.disease_types
  self.dose_sequence = generator.dose_sequence
  self.location_id = generator.location_id
  self.status = generator.status
  self.vaccine_methods = generator.vaccine_methods
  self.without_gelatine = generator.without_gelatine
end

def vaccine_criteria = VaccineCriteria.from_programme_status(self)

def needs_more_doses?
  dose_sequence.present? &&
    dose_sequence <= Programme.find(programme_type).maximum_dose_sequence
end

def on_last_dose?
  dose_sequence == Programme.find(programme_type).maximum_dose_sequence
end

def next_dose_eligible_date
  interval = Programme.find(programme_type).minimum_dose_interval
  return unless interval

  if cannot_vaccinate_delay_vaccination?
    date
  elsif date
    (date + interval).to_date
  end
end

private

def generator
  @generator ||=
    StatusGenerator::Programme.new(
      programme_type:,
      academic_year:,
      patient:,
      patient_locations:,
      consents:,
      triages:,
      attendance_record:,
      vaccination_records:,

needs_more_doses? ()

Source

# File app/models/patient/programme_status.rb, line 198
def needs_more_doses?
  dose_sequence.present? &&
    dose_sequence <= Programme.find(programme_type).maximum_dose_sequence
end

needs_triage? (= status.in?(NEEDS_TRIAGE_STATUSES.keys))

Source

# File app/models/patient/programme_status.rb, line 176
def needs_triage? = status.in?(NEEDS_TRIAGE_STATUSES.keys)

def due? = status.in?(DUE_STATUSES.keys)

def vaccinated? = status.in?(VACCINATED_STATUSES.keys)

def group = GROUPS.find { status.starts_with?(it) }

def assign
  self.consent_status = generator.consent_status
  self.consent_vaccine_methods = generator.consent_vaccine_methods
  self.date = generator.date
  self.disease_types = generator.disease_types
  self.dose_sequence = generator.dose_sequence
  self.location_id = generator.location_id
  self.status = generator.status
  self.vaccine_methods = generator.vaccine_methods
  self.without_gelatine = generator.without_gelatine
end

def vaccine_criteria = VaccineCriteria.from_programme_status(self)

def needs_more_doses?
  dose_sequence.present? &&
    dose_sequence <= Programme.find(programme_type).maximum_dose_sequence
end

def on_last_dose?
  dose_sequence == Programme.find(programme_type).maximum_dose_sequence
end

def next_dose_eligible_date
  interval = Programme.find(programme_type).minimum_dose_interval
  return unless interval

  if cannot_vaccinate_delay_vaccination?
    date
  elsif date
    (date + interval).to_date
  end
end

private

def generator
  @generator ||=
    StatusGenerator::Programme.new(
      programme_type:,
      academic_year:,
      patient:,
      patient_locations:,
      consents:,
      triages:,
      attendance_record:,
      vaccination_records:,
      parents:,
      consent_notifications:

next_dose_eligible_date ()

Source

# File app/models/patient/programme_status.rb, line 207
def next_dose_eligible_date
  interval = Programme.find(programme_type).minimum_dose_interval
  return unless interval

  if cannot_vaccinate_delay_vaccination?
    date
  elsif date
    (date + interval).to_date
  end
end

on_last_dose? ()

Source

# File app/models/patient/programme_status.rb, line 203
def on_last_dose?
  dose_sequence == Programme.find(programme_type).maximum_dose_sequence
end

vaccinated? (= status.in?(VACCINATED_STATUSES.keys))

Source

# File app/models/patient/programme_status.rb, line 180
def vaccinated? = status.in?(VACCINATED_STATUSES.keys)

def group = GROUPS.find { status.starts_with?(it) }

def assign
  self.consent_status = generator.consent_status
  self.consent_vaccine_methods = generator.consent_vaccine_methods
  self.date = generator.date
  self.disease_types = generator.disease_types
  self.dose_sequence = generator.dose_sequence
  self.location_id = generator.location_id
  self.status = generator.status
  self.vaccine_methods = generator.vaccine_methods
  self.without_gelatine = generator.without_gelatine
end

def vaccine_criteria = VaccineCriteria.from_programme_status(self)

def needs_more_doses?
  dose_sequence.present? &&
    dose_sequence <= Programme.find(programme_type).maximum_dose_sequence
end

def on_last_dose?
  dose_sequence == Programme.find(programme_type).maximum_dose_sequence
end

def next_dose_eligible_date
  interval = Programme.find(programme_type).minimum_dose_interval
  return unless interval

  if cannot_vaccinate_delay_vaccination?
    date
  elsif date
    (date + interval).to_date
  end
end

private

def generator
  @generator ||=
    StatusGenerator::Programme.new(
      programme_type:,
      academic_year:,
      patient:,
      patient_locations:,
      consents:,
      triages:,
      attendance_record:,
      vaccination_records:,
      parents:,
      consent_notifications:
    )

vaccine_criteria (= VaccineCriteria.from_programme_status(self))

Source

# File app/models/patient/programme_status.rb, line 196
  def vaccine_criteria = VaccineCriteria.from_programme_status(self)

  def needs_more_doses?
    dose_sequence.present? &&
      dose_sequence <= Programme.find(programme_type).maximum_dose_sequence
  end

  def on_last_dose?
    dose_sequence == Programme.find(programme_type).maximum_dose_sequence
  end

  def next_dose_eligible_date
    interval = Programme.find(programme_type).minimum_dose_interval
    return unless interval

    if cannot_vaccinate_delay_vaccination?
      date
    elsif date
      (date + interval).to_date
    end
  end

  private

  def generator
    @generator ||=
      StatusGenerator::Programme.new(
        programme_type:,
        academic_year:,
        patient:,
        patient_locations:,
        consents:,
        triages:,
        attendance_record:,
        vaccination_records:,
        parents:,
        consent_notifications:
      )
  end
end