class Quby::Compiler::Outputs::QubyFrontendV1Serializer

Attributes

questionnaire[R]

Public Class Methods

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

Public Instance Methods

as_json(options = {}) click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 309
def as_json(options = {})
  {
    key: questionnaire.key,
    title: questionnaire.title,
    description: questionnaire.description,
    outcome_description: questionnaire.outcome_description,
    short_description: questionnaire.short_description,
    abortable: questionnaire.abortable,
    enable_previous_questionnaire_button: questionnaire.enable_previous_questionnaire_button,
    default_answer_value: questionnaire.default_answer_value,
    leave_page_alert: questionnaire.leave_page_alert,
    allow_hotkeys: questionnaire.allow_hotkeys,
    license: questionnaire.license,
    licensor: questionnaire.licensor,
    language: questionnaire.language,
    renderer_version: questionnaire.renderer_version,
    last_update: questionnaire.last_update,
    last_author: questionnaire.last_author,
    extra_css: questionnaire.extra_css,
    allow_switch_to_bulk: questionnaire.allow_switch_to_bulk,

    panels: panels,
    score_calculations: score_calculations,
    score_schemas: score_schemas,
    flags: flags,
    textvars: textvars,
    lookup_tables: lookup_tables,

    # belong to roqua domain, but for now they're here too:
    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: outcome_tables,
  }
end
charts() click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 224
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: range_as_json(chart.y_range),
        tick_interval: chart.tick_interval,
        plotbands: chart.plotbands,
        plotlines: chart.plotlines
      )
    end
  }
end
flags() click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 263
def flags
  questionnaire.flags.transform_values do |flag|
    {
      key: flag.key,
      description_true: flag.description_true,
      description_false: flag.description_false,
      description: flag.description,
      internal: flag.internal,
      trigger_on: flag.trigger_on,
      shows_questions: flag.shows_questions,
      hides_questions: flag.hides_questions,
      depends_on: flag.depends_on,
      default_in_interface: flag.default_in_interface,
    }
  end
end
item_as_json(item) click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 23
def item_as_json(item)
  case item
  when Quby::Compiler::Entities::Text
    text_as_json(item)
  when Quby::Compiler::Entities::Question
    question_as_json(item)
  when Quby::Compiler::Entities::Table
    table_as_json(item)
  end
end
lookup_tables() click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 291
def lookup_tables
  # TODO: Figure out something better. For now, no interest in walking a tree and converting Range objects to something JSON-able.
  YAML.dump(questionnaire.lookup_tables)
end
option_as_json(option) click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 180
def option_as_json(option)
  {
    key: option.key,
    value: option.value,
    description: option.description,
    context_free_description: option.context_free_description,
    questions: option.questions.map {|question| question_as_json(question)},
    inner_title: option.inner_title,
    hides_questions: option.hides_questions,
    shows_questions: option.shows_questions,
    hidden: option.hidden,
    placeholder: option.placeholder,
  }
end
outcome_tables() click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 296
def outcome_tables
  # TODO DOes not seem to be used in definitions?
  questionnaire.outcome_tables.map do |outcome_table|
    {
      key: outcome_table.key,
      score_keys: outcome_table.score_keys,
      subscore_keys: outcome_table.subscore_keys,
      name: outcome_table.name,
      default_collapsed: outcome_table.default_collapsed,
    }
  end
end
panels() click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 13
def panels
  questionnaire.panels.map do |panel|
    {
      key: panel.key,
      title: panel.title,
      items: panel.items.reject { |item| item.respond_to?(:table) && item.table }.map { |item| item_as_json(item) }
    }
  end
end
question_as_json(question) click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 58
def question_as_json(question)
  base_options = {
    type: 'question',
    question_type: question.type,
    key: question.key,
    title: question.title,
    context_free_title: question.context_free_title,
    description: question.description,
    presentation: question.presentation,
    hidden: question.hidden,
    depends_on: question.depends_on,
    default_position: question.default_position,
    col_span: question.col_span,
    row_span: question.row_span,
    validations: question.validations.map {|validation| validation_as_json(validation) },
    raw_content: question.raw_content,
    switch_cycle: question.switch_cycle,

    sbg_key: question.sbg_key,
    allow_duplicate_option_values: question.allow_duplicate_option_values,
    allow_blank_titles: question.allow_blank_titles,
    as: question.as,
    display_modes: question.display_modes,
    autocomplete: question.autocomplete,
    show_values: question.show_values,
    deselectable: question.deselectable,
    disallow_bulk: question.disallow_bulk,
    score_header: question.score_header,
    sets_textvar: question.sets_textvar,
    default_invisible: question.default_invisible,
    question_group: question.question_group,
    group_minimum_answered: question.group_minimum_answered,
    group_maximum_answered: question.group_maximum_answered,
    value_tooltip: question.input_data[:value_tooltip],

    parent_option_key: question.parent_option_key,
  }

  case question
  when Quby::Compiler::Entities::Questions::CheckboxQuestion
    base_options.merge(
      options: question.options.map { |option| option_as_json(option) },
      check_all_option: question.check_all_option,
      uncheck_all_option: question.uncheck_all_option,
      maximum_checked_allowed: question.maximum_checked_allowed,
      minimum_checked_required: question.minimum_checked_required
    )
  when Quby::Compiler::Entities::Questions::DateQuestion
    base_options.merge(
      components: question.components,
      required_components: question.required_components,
      year_key: question.year_key,
      month_key: question.month_key,
      day_key: question.day_key,
      hour_key: question.hour_key,
      minute_key: question.minute_key,
    )
  when Quby::Compiler::Entities::Questions::DeprecatedQuestion
    base_options.merge(
      options: question.options.map { |option| option_as_json(option) }
    )
  when Quby::Compiler::Entities::Questions::FloatQuestion
    base_options.merge(
      labels: question.labels,
      unit: question.unit,
      size: question.size,
    )
  when Quby::Compiler::Entities::Questions::IntegerQuestion
    base_options.merge(
      labels: question.labels,
      unit: question.unit,
      size: question.size,
    )
  when Quby::Compiler::Entities::Questions::RadioQuestion
    base_options.merge(
      options: question.options.map { |option| option_as_json(option) }
    )
  when Quby::Compiler::Entities::Questions::SelectQuestion
    base_options.merge(
      options: question.options.map { |option| option_as_json(option) }
    )
  when Quby::Compiler::Entities::Questions::StringQuestion
    base_options.merge(
      unit: question.unit,
      size: question.size,
    )
  when Quby::Compiler::Entities::Questions::TextQuestion
    base_options.merge(
      lines: question.lines
    )
  else
    raise "Unknown item type"
  end
end
range_as_json(range) click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 350
def range_as_json(range)
  return unless range

  {
    begin: range.begin,
    end: range.end,
    exclude_end: range.exclude_end?
  }
end
score_calculations() click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 195
def score_calculations
  questionnaire.score_calculations.transform_values do |score_calculation|
    {
      key: score_calculation.key,
      label: score_calculation.label,
      sbg_key: score_calculation.sbg_key,
      options: score_calculation.options,
      sourcecode: score_calculation.sourcecode
    }
  end
end
score_schemas() click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 207
def score_schemas
  questionnaire.score_schemas.transform_values do |schema|
    {
      key: schema.key,
      label: schema.label,
      subscore_schemas: schema.subscore_schemas.map do |subschema|
        {
          key: subschema.key,
          label: subschema.label,
          export_key: subschema.export_key,
          only_for_export: subschema.only_for_export
        }
      end
    }
  end
end
table_as_json(table) click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 47
def table_as_json(table)
  {
    type: 'table',
    columns: table.columns,
    title: table.title,
    description: table.description,
    show_option_desc: table.show_option_desc,
    items: table.items.map { |item| item_as_json(item) }
  }
end
text_as_json(text) click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 34
def text_as_json(text)
  {
    type: 'text',
    str: text.str,
    html_content: text.html_content,
    display_in: text.display_in,
    col_span: text.col_span,
    row_span: text.row_span,
    raw_content: text.raw_content,
    switch_cycle: text.switch_cycle,
  }
end
textvars() click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 280
def textvars
  questionnaire.textvars.transform_values do |textvar|
    {
      key: textvar.key,
      description: textvar.description,
      default: textvar.default,
      depends_on_flag: textvar.depends_on_flag,
    }
  end
end
validation_as_json(validation) click to toggle source
# File lib/quby/compiler/outputs/quby_frontend_v1_serializer.rb, line 153
def validation_as_json(validation)
  case validation[:type]
  when :requires_answer
    validation.slice(:type, :explanation)
  when :answer_group_minimum, :answer_group_maximum
    validation.slice(:type, :explanation, :group, :value)
  when :valid_integer, :valid_float
    validation.slice(:type, :explanation)
  when :valid_date
    validation.slice(:type, :explanation, :subtype).merge(value_type: validation[:value].class.to_s)
  when :minimum, :maximum
    validation.slice(:type, :explanation, :value, :subtype).merge(value_type: validation[:value].class.to_s)
  when :too_many_checked
    validation.slice(:type, :explanation, :uncheck_all_key)
  when :minimum_checked_required
    validation.slice(:type, :explanation, :minimum_checked_value)
  when :maximum_checked_allowed
    validation.slice(:type, :explanation, :maximum_checked_value)
  when :regexp
    validation.slice(:type, :explanation).merge(matcher: validation.fetch(:matcher).source)
  when :not_all_checked
    validation.slice(:type, :explanation, :check_all_key)
  else
    raise "Unknown validation type: #{validation.inspect}"
  end
end