class Quby::Compiler::Outputs::RoquaSerializer

Attributes

questionnaire[R]

Public Class Methods

new(questionnaire) click to toggle source
# File lib/quby/compiler/outputs/roqua_serializer.rb, line 7
def initialize(questionnaire)
  @questionnaire = questionnaire
end

Public Instance Methods

as_json(options = {}) click to toggle source
# File lib/quby/compiler/outputs/roqua_serializer.rb, line 11
def as_json(options = {})
  {
    key: questionnaire.key,
    versions: versions,
    keys: questionnaire.roqua_keys,
    roqua_keys: questionnaire.roqua_keys,
    sbg_key: questionnaire.sbg_key,
    sbg_domains: questionnaire.sbg_domains,
    outcome_regeneration_requested_at: questionnaire.outcome_regeneration_requested_at,
    deactivate_answers_requested_at: questionnaire.deactivate_answers_requested_at,
    respondent_types: questionnaire.respondent_types,
    tags: questionnaire.tags.to_h.keys,
    charts: charts,
    outcome_tables_schema: outcome_tables_schema,
  }
end
charts() click to toggle source
# File lib/quby/compiler/outputs/roqua_serializer.rb, line 39
def charts
  {
    overview: questionnaire.charts.overview && {
      subscore: questionnaire.charts.overview.subscore,
      y_max: questionnaire.charts.overview.y_max,
    },
    others: questionnaire.charts.map do |chart|
      case chart
      when Quby::Compiler::Entities::Charting::LineChart
        {
          y_label: chart.y_label,
          tonality: chart.tonality,
          baseline: YAML.dump(chart.baseline),
          clinically_relevant_change: chart.clinically_relevant_change,
        }
      when Quby::Compiler::Entities::Charting::OverviewChart
        {
          subscore: chart.subscore,
          y_max: chart.y_max,
        }
      else
        {}
      end.merge(
        key: chart.key,
        type: chart.type,
        title: chart.title,
        plottables: chart.plottables,
        y_categories: chart.y_categories,
        y_range_categories: chart.y_range_categories,
        chart_type: chart.chart_type,
        y_range: chart.y_range,
        tick_interval: chart.tick_interval,
        plotbands: chart.plotbands,
        plotlines: chart.plotlines
      )
    end
  }
end
outcome_tables_from_definition() click to toggle source
# File lib/quby/compiler/outputs/roqua_serializer.rb, line 94
def outcome_tables_from_definition
  # hash of tables, with the score keys (rows) and subscore keys (columns) used for each
  tables = {}
  # hash of `subscore_key: subscore_label` pairs used in tables
  headers = {}

  questionnaire.outcome_tables.each do |table|
    tables[table.key] = {name: table.name,
                         default_collapsed: table.default_collapsed,
                         score_keys: table.score_keys,
                         subscore_keys: table.subscore_keys}.compact

    table.subscore_keys.each do |subscore_key|
      table.score_keys.find do |score_key|
        subschema = questionnaire.score_schemas[score_key].subscore_schemas.find do |subschema|
          subschema.key == subscore_key
        end
        headers[subscore_key] = subschema&.label
      end
    end
  end

  {
    headers: headers,
    tables: tables,
  }
end
outcome_tables_from_score_schemas() click to toggle source
# File lib/quby/compiler/outputs/roqua_serializer.rb, line 122
def outcome_tables_from_score_schemas
  # hash of tables, with the score keys (rows) and subscore keys (columns) used for each
  tables = Hash.new{ |hash, key| hash[key] = {score_keys: Set.new, subscore_keys: Set.new } }
  # hash of `subscore_key: subscore_label` pairs used in tables
  headers = {}

  questionnaire.score_schemas.values.each do |schema|
    schema.subscore_schemas.each do |subschema|
      next if subschema.outcome_table.blank?
      tables[subschema.outcome_table][:subscore_keys] << subschema.key
      tables[subschema.outcome_table][:score_keys] << schema.key
      headers[subschema.key] = subschema.label
    end
  end

  {
    headers: headers,
    tables: tables,
  }
end
outcome_tables_schema() click to toggle source

configuration for outcome tables. tables:

<outcome_table_name:Symbol>: # each entry is a table.
  score_keys: Set[<schema.key:Symbol>] # rows in the table
  subscore_keys: Set[<subschema.key:Symbol>] # columns  in the table

headers:

<subscore_key:Symbol>: <subscore.label:String> # headers for each subscore key for all tables.
# File lib/quby/compiler/outputs/roqua_serializer.rb, line 86
def outcome_tables_schema
  if questionnaire.outcome_tables.present?
    outcome_tables_from_definition
  else
    outcome_tables_from_score_schemas
  end
end
versions() click to toggle source
# File lib/quby/compiler/outputs/roqua_serializer.rb, line 28
def versions
  questionnaire.versions.map do |version|
    {
      number: version.number,
      release_notes: version.release_notes,
      regenerate_outcome: version.regenerate_outcome,
      deactivate_answers: version.deactivate_answers
    }
  end
end