class Programme

Source

# File app/models/programme.rb, line 152
def <=>(other) = type <=> other.type

def variant_type = nil

def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

== (other)

Source

# File app/models/programme.rb, line 148
def ==(other) = type == other.type

def eql?(other) = other.is_a?(Programme) && type.eql?(other.type)

def <=>(other) = type <=> other.type

def variant_type = nil

def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding,

all (= TYPES.map { |type| find(type) })

Source

# File app/models/programme.rb, line 103
  def all = TYPES.map { |type| find(type) }

  def find_all(types, disease_types: nil, patient: nil)
    types.map { |type| find(type, patient:, disease_types:) }
  end

  def all_as_variants
    all.flat_map(&:variants)
  end

  def find(type, disease_types: nil, patient: nil)
    validate_type!(type)

    @programmes ||= {}
    programme = (@programmes[type] ||= new(type:))

    programme.variant_for(patient:, disease_types:)
  end

  def find_by_snomed_target_disease_codes(snomed_target_disease_codes)
    all_as_variants.find do |variant|
      variant.snomed_target_disease_codes ==
        snomed_target_disease_codes.to_set
    end
  end

  def exists?(type) = type.in?(TYPES)

  def sample = find(TYPES.sample)

  private

  def validate_type!(type)
    raise InvalidType, type unless exists?(type)
  end
end

def initialize(type:)
  @type = type
end

def to_param = type

def id = type

def ==(other) = type == other.type

def eql?(other) = other.is_a?(Programme) && type.eql?(other.type)

def <=>(other) = type <=> other.type

def variant_type = nil

def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

all_as_variants ()

Source

# File app/models/programme.rb, line 109
def all_as_variants
  all.flat_map(&:variants)
end

available_delivery_methods ()

Source

# File app/models/programme.rb, line 248
def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

available_delivery_sites ()

Source

# File app/models/programme.rb, line 253
def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

can_save_to_todays_batch? (= !mmr?)

Source

# File app/models/programme.rb, line 216
def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

catch_up_only? (= mmr?)

Source

# File app/models/programme.rb, line 212
def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

default_dose_sequence (= hpv? || flu? ? 1 : nil)

Source

# File app/models/programme.rb, line 258
def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

def fhir_mapper
  @fhir_mapper

default_year_groups ()

Source

# File app/models/programme.rb, line 220
def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

disease_types (= DISEASE_TYPES.fetch(type))

Source

# File app/models/programme.rb, line 206
def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak?

doubles? (= menacwy? || td_ipv?)

Source

# File app/models/programme.rb, line 208
def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? =

eql? (other)

Source

# File app/models/programme.rb, line 150
def eql?(other) = other.is_a?(Programme) && type.eql?(other.type)

def <=>(other) = type <=> other.type

def variant_type = nil

def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to:

exists? (type)

Source

# File app/models/programme.rb, line 129
  def exists?(type) = type.in?(TYPES)

  def sample = find(TYPES.sample)

  private

  def validate_type!(type)
    raise InvalidType, type unless exists?(type)
  end
end

def initialize(type:)
  @type = type
end

def to_param = type

def id = type

def ==(other) = type == other.type

def eql?(other) = other.is_a?(Programme) && type.eql?(other.type)

def <=>(other) = type <=> other.type

def variant_type = nil

def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

fhir_mapper ()

Source

# File app/models/programme.rb, line 282
def fhir_mapper
  @fhir_mapper ||= FHIRMapper::Programme.new(self)
end

find (type, disease_types: nil, patient: nil)

Source

# File app/models/programme.rb, line 113
def find(type, disease_types: nil, patient: nil)
  validate_type!(type)

  @programmes ||= {}
  programme = (@programmes[type] ||= new(type:))

  programme.variant_for(patient:, disease_types:)
end

find_all (types, disease_types: nil, patient: nil)

Source

# File app/models/programme.rb, line 105
def find_all(types, disease_types: nil, patient: nil)
  types.map { |type| find(type, patient:, disease_types:) }
end

find_by_snomed_target_disease_codes (snomed_target_disease_codes)

Source

# File app/models/programme.rb, line 122
def find_by_snomed_target_disease_codes(snomed_target_disease_codes)
  all_as_variants.find do |variant|
    variant.snomed_target_disease_codes ==
      snomed_target_disease_codes.to_set
  end
end

has_multiple_vaccine_methods? (= vaccine_methods.length > 1)

Source

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

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

def fhir_mapper

id (= type)

Source

# File app/models/programme.rb, line 146
def id = type

def ==(other) = type == other.type

def eql?(other) = other.is_a?(Programme) && type.eql?(other.type)

def <=>(other) = type <=> other.type

def variant_type = nil

def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding

import_names (= IMPORT_NAMES.fetch(type))

Source

# File app/models/programme.rb, line 268
def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

def fhir_mapper
  @fhir_mapper ||= FHIRMapper::Programme.new

initialize (type:)

Source

# File app/models/programme.rb, line 140
def initialize(type:)
  @type = type
end

is_catch_up? (year_group:)

Source

# File app/models/programme.rb, line 228
def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

maximum_dose_sequence (= MAXIMUM_DOSE_SEQUENCES.fetch(type))

Source

# File app/models/programme.rb, line 260
def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

def fhir_mapper
  @fhir_mapper ||=

method_missing (type, *_args)

Source

# File app/models/programme.rb, line 99
  def method_missing(type, *_args) = find(type.to_s)

  def respond_to_missing?(type, *_args) = exists?(type.to_s)

  def all = TYPES.map { |type| find(type) }

  def find_all(types, disease_types: nil, patient: nil)
    types.map { |type| find(type, patient:, disease_types:) }
  end

  def all_as_variants
    all.flat_map(&:variants)
  end

  def find(type, disease_types: nil, patient: nil)
    validate_type!(type)

    @programmes ||= {}
    programme = (@programmes[type] ||= new(type:))

    programme.variant_for(patient:, disease_types:)
  end

  def find_by_snomed_target_disease_codes(snomed_target_disease_codes)
    all_as_variants.find do |variant|
      variant.snomed_target_disease_codes ==
        snomed_target_disease_codes.to_set
    end
  end

  def exists?(type) = type.in?(TYPES)

  def sample = find(TYPES.sample)

  private

  def validate_type!(type)
    raise InvalidType, type unless exists?(type)
  end
end

def initialize(type:)
  @type = type
end

def to_param = type

def id = type

def ==(other) = type == other.type

def eql?(other) = other.is_a?(Programme) && type.eql?(other.type)

def <=>(other) = type <=> other.type

def variant_type = nil

def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.

minimum_dose_interval (= MINIMUM_DOSE_INTERVALS.fetch(type))

Source

# File app/models/programme.rb, line 262
def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

def fhir_mapper
  @fhir_mapper ||= FHIRMapper

multi_dose? (= minimum_dose_interval.present?)

Source

# File app/models/programme.rb, line 266
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

def fhir_mapper
  @fhir_mapper ||= FHIRMapper::Programme

TODO: Make this more explicit when other programmes start administering multiple doses (e.g. immunocompromised schedules).

name ()

Source

# File app/models/programme.rb, line 162
def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

name_in_sentence ()

Source

# File app/models/programme.rb, line 171
def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

name_on_nhs_uk ()

Source

# File app/models/programme.rb, line 166
def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

respond_to_missing? (type, *_args)

Source

# File app/models/programme.rb, line 101
  def respond_to_missing?(type, *_args) = exists?(type.to_s)

  def all = TYPES.map { |type| find(type) }

  def find_all(types, disease_types: nil, patient: nil)
    types.map { |type| find(type, patient:, disease_types:) }
  end

  def all_as_variants
    all.flat_map(&:variants)
  end

  def find(type, disease_types: nil, patient: nil)
    validate_type!(type)

    @programmes ||= {}
    programme = (@programmes[type] ||= new(type:))

    programme.variant_for(patient:, disease_types:)
  end

  def find_by_snomed_target_disease_codes(snomed_target_disease_codes)
    all_as_variants.find do |variant|
      variant.snomed_target_disease_codes ==
        snomed_target_disease_codes.to_set
    end
  end

  def exists?(type) = type.in?(TYPES)

  def sample = find(TYPES.sample)

  private

  def validate_type!(type)
    raise InvalidType, type unless exists?(type)
  end
end

def initialize(type:)
  @type = type
end

def to_param = type

def id = type

def ==(other) = type == other.type

def eql?(other) = other.is_a?(Programme) && type.eql?(other.type)

def <=>(other) = type <=> other.type

def variant_type = nil

def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(

sample (= find(TYPES.sample))

Source

# File app/models/programme.rb, line 131
  def sample = find(TYPES.sample)

  private

  def validate_type!(type)
    raise InvalidType, type unless exists?(type)
  end
end

seasonal? (= flu?)

Source

# File app/models/programme.rb, line 210
def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

snomed_target_disease_codes (= SNOMED_TARGET_DISEASE_CODES.fetch(type))

Source

# File app/models/programme.rb, line 270
def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

def fhir_mapper
  @fhir_mapper ||= FHIRMapper::Programme.new(self

snomed_target_disease_name (= SNOMED_TARGET_DISEASE_NAMES.fetch(type))

Source

# File app/models/programme.rb, line 274
def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

def fhir_mapper
  @fhir_mapper ||= FHIRMapper::Programme.new(self)
end

snomed_target_disease_terms (= SNOMED_TARGET_DISEASE_TERMS.fetch(type))

Source

# File app/models/programme.rb, line 272
def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

def fhir_mapper
  @fhir_mapper ||= FHIRMapper::Programme.new(self)

supports_delegation? (= flu?)

Source

# File app/models/programme.rb, line 214
def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

supports_outbreak? (= mmr?)

Source

# File app/models/programme.rb, line 278
  def supports_outbreak? = mmr?

  private

  def fhir_mapper
    @fhir_mapper ||= FHIRMapper::Programme.new(self)
  end
end

to_param (= type)

Source

# File app/models/programme.rb, line 144
def to_param = type

def id = type

def ==(other) = type == other.type

def eql?(other) = other.is_a?(Programme) && type.eql?(other.type)

def <=>(other) = type <=> other.type

def variant_type = nil

def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate

translation_key (= mmr? ? "mmr_and_mmrv" : type)

Source

# File app/models/programme.rb, line 156
def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def

triage_on_vaccination_history? (= menacwy? || td_ipv?)

Source

# File app/models/programme.rb, line 218
def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

def supports_outbreak? = mmr?

private

def

vaccine_methods ()

Source

# File app/models/programme.rb, line 242
def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

vaccines ()

Source

# File app/models/programme.rb, line 238
def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

validate_type! (type)

Source

# File app/models/programme.rb, line 135
def validate_type!(type)
  raise InvalidType, type unless exists?(type)
end

variant_for (disease_types: nil, patient: nil)

Source

# File app/models/programme.rb, line 175
def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

variant_type (= nil)

Source

# File app/models/programme.rb, line 154
def variant_type = nil

def translation_key = mmr? ? "mmr_and_mmrv" : type

TYPES.each do |programme_type|
  define_method("#{programme_type}?") { type == programme_type }
end

def name
  @name ||= I18n.t(translation_key, scope: :programme_types)
end

def name_on_nhs_uk
  @name_on_nhs_uk ||=
    I18n.t(type, scope: :programme_names_on_nhs_uk, default: nil)
end

def name_in_sentence
  @name_in_sentence = flu? ? name.downcase : name
end

def variant_for(disease_types: nil, patient: nil)
  return self unless mmr?

  # We don't use both `patient` and `disease_types` because the patient
  #  might be eligible for a particular programme variant, but the disease
  #  types indicate a different variant was used.

  eligible_for_mmrv =
    if disease_types.present?
      disease_types.include?("varicella")
    elsif disease_types.nil? && patient
      patient.eligible_for_mmrv?
    end

  return self if eligible_for_mmrv.nil?

  variant_type = eligible_for_mmrv ? "mmrv" : "mmr"

  Programme::Variant.new(self, variant_type:)
end

def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

def disease_types = DISEASE_TYPES.fetch(type)

def doubles? = menacwy? || td_ipv?

def seasonal? = flu?

def catch_up_only? = mmr?

def supports_delegation? = flu?

def can_save_to_todays_batch? = !mmr?

def triage_on_vaccination_history? = menacwy? || td_ipv?

def default_year_groups
  if Flipper.enabled?(:vaccinating_16_plus_year_olds)
    DEFAULT_YEAR_GROUPS_WITH_OVER_16S_BY_TYPE.fetch(type)
  else
    DEFAULT_YEAR_GROUPS_BY_TYPE.fetch(type)
  end
end

def is_catch_up?(year_group:)
  return nil if seasonal?
  return true if catch_up_only?

  # NOTE: This logic only works if no teams administer programmes to year
  # groups earlier than the first default year group for that programme.
  # We only know of teams administering beyond the default year groups.
  default_year_groups.first != year_group
end

def vaccines
  @vaccines ||= Vaccine.for_programme(self)
end

def vaccine_methods
  @vaccine_methods ||= vaccines.map(&:method).uniq
end

def has_multiple_vaccine_methods? = vaccine_methods.length > 1

def available_delivery_methods
  @available_delivery_methods ||=
    vaccines.flat_map(&:available_delivery_methods).uniq
end

def available_delivery_sites
  @available_delivery_sites ||=
    vaccines.flat_map(&:available_delivery_sites).uniq
end

def default_dose_sequence = hpv? || flu? ? 1 : nil

def maximum_dose_sequence = MAXIMUM_DOSE_SEQUENCES.fetch(type)

def minimum_dose_interval = MINIMUM_DOSE_INTERVALS.fetch(type)

# TODO: Make this more explicit when other programmes start
# administering multiple doses (e.g. immunocompromised schedules).
def multi_dose? = minimum_dose_interval.present?

def import_names = IMPORT_NAMES.fetch(type)

def snomed_target_disease_codes = SNOMED_TARGET_DISEASE_CODES.fetch(type)

def snomed_target_disease_terms = SNOMED_TARGET_DISEASE_TERMS.fetch(type)

def snomed_target_disease_name = SNOMED_TARGET_DISEASE_NAMES.fetch(type)

delegate :fhir_target_disease_coding, to: :fhir_mapper

variants ()

Source

# File app/models/programme.rb, line 196
def variants
  if mmr?
    %w[mmr mmrv].map do |variant_type|
      Programme::Variant.new(self, variant_type:)
    end
  else
    [self]
  end
end

Constants

Attributes

Public Class Methods