scinote-web/app/utilities/first_time_data_generator.rb

module FirstTimeDataGenerator
  # Create data for tutorial for new users
  def seed_demo_data(user)
    @user = user

    # First team that this user created
    # should contain the "intro" project
    if cookies[:repeat_tutorial_org_id] || cookies[:repeat_tutorial_team_id]
      team = Team.find_by_id(cookies[:repeat_tutorial_org_id])
      team ||= Team.find_by_id(cookies[:repeat_tutorial_team_id])
      %w(repeat_tutorial_team_id repeat_tutorial_org_id)
        .each do |repeat_tutorial|
        cookies.delete repeat_tutorial.to_sym if cookies[repeat_tutorial.to_sym]
      end
    else
      team = user
             .teams
             .where(created_by: user)
             .order(created_at: :asc)
             .first
    end

    # If private private team does not exist,
    # there was something wrong with user creation.
    # Do nothing
    return unless team

    # Create sample types
    SampleType.create(
      name: 'Potato leaves',
      team: team
    )

    SampleType.create(
      name: 'Tea leaves',
      team: team
    )

    SampleType.create(
      name: 'Potato bug',
      team: team
    )

    SampleGroup.create(
      name: 'Fodder',
      team: team,
      color: Constants::TAG_COLORS[1]
    )

    SampleGroup.create(
      name: 'Nutrient',
      team: team,
      color: Constants::TAG_COLORS[0]
    )

    SampleGroup.create(
      name: 'Seed',
      team: team,
      color: Constants::TAG_COLORS[2]
    )

    samples = []
    # Generate random sample names start
    # and put it on the beginning of 5 samples
    sample_name = (0...3).map{65.+(rand(26)).chr}.join << '/'
    for i in 1..5
      samples << Sample.create(
        name: sample_name + i.to_s,
        team: team,
        user: user,
        sample_type: rand < 0.8 ? pluck_random(team.sample_types) : nil,
        sample_group: rand < 0.8 ? pluck_random(team.sample_groups) : nil
      )
    end

    sample_name = (0...3).map{65.+(rand(26)).chr}.join << '/'
    for i in 1..5
      samples << Sample.create(
        name: sample_name + i.to_s,
        team: team,
        user: user,
        sample_type: rand < 0.8 ? pluck_random(team.sample_types) : nil,
        sample_group: rand < 0.8 ? pluck_random(team.sample_groups) : nil
      )
    end

    name = 'Demo project - qPCR'
    exp_name = 'My first experiment'
    # If there is an existing demo project, archive and rename it
    if team.projects.where(name: name).present?
      # TODO: check if we still need this code
      # old = team.projects.where(name: 'Demo project - qPCR')[0]
      # old.archive! user
      i = 1
      while team.projects.where(
        name: name = "Demo project - qPCR (#{i})"
      ).present?
        i += 1
      end
    end

    project = Project.create(
      visibility: 0,
      name: name,
      due_date: nil,
      team: team,
      created_by: user,
      created_at: generate_random_time(1.week.ago),
      last_modified_by: user,
      archived: false
    )

    experiment = Experiment.create(
      name: exp_name,
      description: 'This is my very first experiment',
      project: project,
      created_by: user,
      created_at: project.created_at + 5.minutes,
      last_modified_by: user
    )

    # Automatically assign project author onto project
    UserProject.create(
      user: user,
      project: project,
      role: 0,
      created_at: generate_random_time(1.week.ago)
    )

    # Activity for creating project
    Activity.new(
      type_of: :create_project,
      user: user,
      project: project,
      message: I18n.t(
        'activities.create_project',
        user: user.full_name,
        project: project.name
      ),
      created_at: project.created_at
    ).sneaky_save

    # Add a comment
    generate_project_comment(
      project,
      user,
      'I\'ve created a demo project'
    )

    # Create a module group
    my_module_group = MyModuleGroup.create(
      name: 'Potato qPCR workflow',
      experiment: experiment
    )

    # Create project modules
    my_modules = []
    my_module_names = [
      'Experiment design',
      'Sampling biological material',
      'RNA isolation',
      'RNA quality & quantity - BIOANALYSER',
      'Reverse transcription',
      'qPCR',
      'Data quality control',
      'Data analysis - ddCq'
    ]

    qpcr_module_description = 'PCR is a method where an enzyme
      (thermostable DNA polymerase, originally isolated in 1960s
      from bacterium Thermus aquaticus, growing in hot lakes of
      Yellowstone park, USA) amplifies a short specific part of
      the template DNA (amplicon) in cycles. In every cycle the
      number of short specific sections of DNA is doubled, leading
      to an exponential amplification of targets. More on how
      conventional PCR works can be found here.'

    my_module_names.each_with_index do |name, i|
      my_module = MyModule.create(
        name: name,
        created_by: user,
        created_at: generate_random_time(6.days.ago),
        due_date: Time.now + (2 * i + 1).weeks,
        description: i == 5 ? qpcr_module_description : nil,
        x: (i < 4 ? i % 4 : 7 - i) * 32,
        y: (i / 4) * 16,
        experiment: experiment,
        workflow_order: i,
        my_module_group: my_module_group
      )

      my_modules << my_module

      # Add connections between current and previous module
      if i > 0
        Connection.create(
          input_id: my_module.id,
          output_id: my_modules[i - 1].id
        )
      end

      # Create module activity
      Activity.new(
        type_of: :create_module,
        user: user,
        project: project,
        my_module: my_module,
        message: I18n.t(
          'activities.create_module',
          user: user.full_name,
          module: my_module.name
        ),
        created_at: my_module.created_at
      ).sneaky_save

      UserMyModule.create(
        user: user,
        my_module: my_module,
        assigned_by: user,
        created_at: generate_random_time(my_module.created_at, 2.minutes)
      )
      Activity.new(
        type_of: :assign_user_to_module,
        user: user,
        project: project,
        my_module: my_module,
        message: I18n.t(
          'activities.assign_user_to_module',
          assigned_user: user.full_name,
          module: my_module.name,
            assigned_by_user: user.full_name
        ),
        created_at: generate_random_time(my_module.created_at, 2.minutes)
      ).sneaky_save
    end

    # Create an archived module
    archived_module = MyModule.create(
      name: 'Data analysis - Pfaffl method',
      created_by: user,
      created_at: generate_random_time(6.days.ago),
      due_date: Time.now + 1.week,
      description: nil,
      x: -1,
      y: -1,
      experiment: experiment,
      workflow_order: -1,
      my_module_group: nil,
      archived: true,
      archived_on: generate_random_time(3.days.ago),
      archived_by: user
    )

    # Activity for creating archived module
    Activity.new(
      type_of: :create_module,
      user: user,
      project: project,
      my_module: archived_module,
      message: I18n.t(
        'activities.create_module',
        user: user.full_name,
        module: archived_module.name
      ),
      created_at: archived_module.created_at
    ).sneaky_save

    # Activity for archiving archived module
    Activity.new(
      type_of: :archive_module,
      user: user,
      project: project,
      my_module: archived_module,
      message: I18n.t(
        'activities.archive_module',
        user: user.full_name,
        module: archived_module.name
      ),
      created_at: archived_module.archived_on
    ).sneaky_save

    # Assign new user to archived module
    UserMyModule.create(
      user: user,
      my_module: archived_module,
      assigned_by: user,
      created_at: generate_random_time(archived_module.created_at, 2.minutes)
    )
    Activity.new(
      type_of: :assign_user_to_module,
      user: user,
      project: project,
      my_module: archived_module,
      message: I18n.t(
        'activities.assign_user_to_module',
        assigned_user: user.full_name,
        module: archived_module.name,
          assigned_by_user: user.full_name
      ),
      created_at: generate_random_time(archived_module.created_at, 2.minutes)
    ).sneaky_save

    # Assign 4 samples to modules
    samples_to_assign = []
    taken_sample_ids = []
    for _ in 1..4
      begin
        sample = samples.sample
      end while sample.id.in? taken_sample_ids
      taken_sample_ids << sample.id
      samples_to_assign << sample
    end

    my_modules[1].get_downstream_modules.each do |mm|
      samples_to_assign.each do |s|
        SampleMyModule.create(
          sample: s,
          my_module: mm
        )
      end
    end

    # Add comments to modules
    generate_module_comment(
      my_modules[0],
      user,
      'We should have a meeting to discuss sampling parametrs soon.'
    )
    generate_module_comment(
      my_modules[0],
      user,
      'I agree.'
    )

    generate_module_comment(
      my_modules[1],
      user,
      'The samples have arrived.'
    )

    generate_module_comment(
      my_modules[2],
      user,
      'Due date has been postponed for a day.'
    )

    generate_module_comment(
      my_modules[4],
      user,
      'Please show Steve the RT procedure.'
    )

    generate_module_comment(
      my_modules[5],
      user,
      'The results must be very definitive.'
    )

    generate_module_comment(
      my_modules[7],
      user,
      'The due date here is flexible.'
    )

    # Create tags and add them to module
    drylab_tag = Tag.create(
      name: 'Drylab',
      color: Constants::TAG_COLORS[8],
      project: project,
      created_by: user,
      last_modified_by: user
    )
    wetlab_tag = Tag.create(
      name: 'Wetlab',
      color: Constants::TAG_COLORS[14],
      project: project,
      created_by: user,
      last_modified_by: user
    )
    decide_tag = Tag.create(
      name: 'Decide',
      color: Constants::TAG_COLORS[5],
      project: project,
      created_by: user,
      last_modified_by: user
    )

    # Add tags to module
    my_modules[0].tags << drylab_tag

    my_modules[1].tags << wetlab_tag
    my_modules[2].tags << wetlab_tag
    my_modules[3].tags << wetlab_tag
    my_modules[4].tags << wetlab_tag

    my_modules[5].tags << drylab_tag
    my_modules[6].tags << drylab_tag

    my_modules[7].tags << drylab_tag
    my_modules[7].tags << decide_tag
    my_modules[7].save

    # Load table contents yaml file
    tab_content = YAML.load_file(
      "#{Rails.root}/app/assets/tutorial_files/tables_content.yaml"
    )

    # Create module content
    # ----------------- Module 1 ------------------
    module_step_names = [
      'Gene expression'
    ]
    module_step_descriptions = [
      'Compare response of PVYNTN, cab4 and PR1 genes in mock/virus ' \
      'inoculated potatoes & in time'
    ]
    generate_module_steps(my_modules[0],
                          module_step_names,
                          module_step_descriptions)

    # Results
    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[0],
      current_user: user,
      current_team: team,
      result_name: 'sF',
      created_at: generate_random_time(my_modules[0].created_at, 2.days),
      file_name: 'samples.txt'
    )

    temp_result = Result.new(
      name: 'Experimental design',
      my_module: my_modules[0],
      created_at: generate_random_time(my_modules[0].created_at, 1.days),
      user: user
    )
    generate_result_comment(
      temp_result,
      user,
      'The table shows proposed number of biological replicates.'
    )
    temp_result.table = Table.new(
      created_by: user,
      team: team,
      contents: tab_content['module1']['experimental_design']
    )
    temp_result.save

    # ----------------- Module 2 ------------------
    module_step_names = [
      'Inoculation of potatoes',
      'Collection of potatoes',
      'Store samples'
    ]
    module_step_descriptions = [
      '50% of samples should be mock inoculated while other 50% with ' \
      'PVY NTN virus.',
      '50% of PVYNTN inoculated potatos and 50% of Mock inoculated potatos ' \
      'collect 1 day post inocullation while other halph of samples collect ' \
      '6 days post inoculation.',
      'Collect samples in 2ml tubes and put them in liquid nitrogen '\
      'and store at 80°C.'
    ]
    generate_module_steps(my_modules[1],
                          module_step_names,
                          module_step_descriptions)

    # Add file to existig step
    DelayedUploaderTutorial.delay(queue: :tutorial).add_step_asset(
      step: my_modules[1].protocol.steps.where('position = 0').take,
      current_user: user,
      current_team: team,
      file_name: 'sample-potatoe.txt'
    )

    # Results
    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[1],
      current_user: user,
      current_team: team,
      result_name: 'PVY-inoculated plant, symptoms',
      created_at: generate_random_time(my_modules[1].created_at, 1.days),
      file_name: 'DSCN0660.JPG'
    )

    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[1],
      current_user: user,
      current_team: team,
      result_name: 'mock-inoculated plant',
      created_at: generate_random_time(my_modules[1].created_at, 2.days),
      file_name: 'DSCN0354.JPG'
    )

    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[1],
      current_user: user,
      current_team: team,
      result_name: 'Height of plants at 6dpi',
      created_at: generate_random_time(my_modules[1].created_at, 3.days),
      file_name: '6dpi_height.JPG'
    )

    # Add a text result
    temp_result = Result.new(
      name: 'Number of samples',
      my_module: my_modules[1],
      user: user,
      created_at: generate_random_time(my_modules[1].created_at, 4.days)
    )
    temp_text = "There are many biological replicates we harvested " \
                "for each type of sample (code-names):\n\n"
    samples_to_assign.each do |s|
      temp_text << "* #{s.name}\n\n"
    end
    temp_result.result_text = ResultText.new(
      text: temp_text
    )

    temp_result.save

    # Create result activity
    Activity.new(
      type_of: :add_result,
      project: project,
      my_module: my_modules[1],
      user: user,
      created_at: temp_result.created_at,
      message: I18n.t(
        'activities.add_text_result',
        user: user.full_name,
        result: temp_result.name
      )
    ).sneaky_save
    # ----------------- Module 3 ------------------
    module_step_names = [
      'Homogenization of the material',
      'Isolation of RNA with RNeasy plant mini kit'
    ]
    module_step_descriptions = [
      ' Use tissue lyser: 1 min on step 3.',
      nil
    ]
    generate_module_steps(my_modules[2], module_step_names, module_step_descriptions)

    # Add file to existig step
    DelayedUploaderTutorial.delay(queue: :tutorial).add_step_asset(
      step: my_modules[2].protocol.steps.where('position = 1').take,
      current_user: user,
      current_team: team,
      file_name: 'RNeasy-Plant-Mini-Kit-EN.pdf'
    )

    # Results
    temp_result = Result.new(
      name: 'Nanodrop results',
      my_module: my_modules[2],
      created_at: generate_random_time(my_modules[2].created_at, 1.days),
      user: user
    )
    generate_result_comment(
      temp_result,
      user,
      'PVY NTN 6dpi isolation seems to have failed, ' \
      'please repeat nanodrop measurement.'
    )
    temp_result.table = Table.new(
      created_by: user,
      team: team,
      contents: tab_content['module3']['nanodrop']
    )
    temp_result.save

    # Create result activity
    Activity.new(
      type_of: :add_result,
      project: project,
      my_module: my_modules[2],
      user: user,
      created_at: temp_result.created_at,
      message: I18n.t(
        'activities.add_text_result',
        user: user.full_name,
        result: temp_result.name
      )
    ).sneaky_save

    # Second result
    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[2],
      current_user: user,
      current_team: team,
      result_name: 'Agarose gel electrophoresis of totRNA samples',
      created_at: generate_random_time(my_modules[2].created_at, 3.days),
      file_name: 'totRNA_gel.jpg'
    )

    # ----------------- Module 4 ------------------
    module_step_names = [
      'Use Nano chip for testing RNA integrity'
    ]
    module_step_descriptions = [
      nil
    ]
    generate_module_steps(my_modules[3], module_step_names, module_step_descriptions)

    # Add file to existig step
    DelayedUploaderTutorial.delay(queue: :tutorial).add_step_asset(
      step: my_modules[3].protocol.steps.where('position = 0').take,
      current_user: user,
      current_team: team,
      file_name: 'G2938-90034_KitRNA6000Nano_ebook.pdf'
    )

    # Results
    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[3],
      current_user: user,
      current_team: team,
      result_name: 'Result of RNA integrity',
      created_at: generate_random_time(my_modules[3].created_at, 2.days),
      file_name: 'Bioanalyser_result.JPG'
    )

    # ----------------- Module 5 ------------------
    module_step_names = [
      'RNA denaturation',
      'Prepare mastermix for RT',
      'RT reaction'
    ]
    module_step_descriptions = [
      '1 ug of RNA denature at 80°C for 5 min --> ice',
      'High Capacity cDNA Reverse Transcription Kit (Applied Biosystems)',
      '25°C for 10 min 37°C for 2 h'
    ]
    generate_module_steps(my_modules[4],
                          module_step_names,
                          module_step_descriptions)

    module_checklist_items = [
      'RT buffer',
      'dNTP mix',
      'Random Primers',
      'RNase inhibitor',
      'Reverse transcriptase',
      'Optional: Luciferase mRNA (denatured)',
      'H2O to 12.5 ul'
    ]

    # Add checklist to step
    step = my_modules[4].protocol.steps.where('position = 1').take
    checklist = Checklist.new(
      name: 'Mastermix',
      step: step
    )

    module_checklist_items.each do |item|
      checklist.checklist_items << ChecklistItem.new(
        text: item
      )
    end
    checklist.save

    # ----------------- Module 6 ------------------
    module_step_names = [
      'Sample preparation',
      'Reaction setup',
      'Use Applied Biosystem 7300 instrument for qPCR',
      'Setup of the 96 plate'
    ]
    module_step_descriptions = [
      nil,
      nil,
      'Use following cycling condtions:',
      'Template of the 96-well plate'
    ]
    generate_module_steps(my_modules[5],
                          module_step_names,
                          module_step_descriptions)

    # Add file to existig steps
    DelayedUploaderTutorial.delay(queue: :tutorial).add_step_asset(
      step: my_modules[5].protocol.steps.where('position = 0').take,
      current_user: user,
      current_team: team,
      file_name: 'sample_preparation.JPG'
    )

    DelayedUploaderTutorial.delay(queue: :tutorial).add_step_asset(
      step: my_modules[5].protocol.steps.where('position = 1').take,
      current_user: user,
      current_team: team,
      file_name: 'reaction_setup.JPG'
    )

    DelayedUploaderTutorial.delay(queue: :tutorial).add_step_asset(
      step: my_modules[5].protocol.steps.where('position = 2').take,
      current_user: user,
      current_team: team,
      file_name: 'cycling_conditions.JPG'
    )

    DelayedUploaderTutorial.delay(queue: :tutorial).add_step_asset(
      step: my_modules[5].protocol.steps.where('position = 3').take,
      current_user: user,
      current_team: team,
      file_name: '96plate.doc'
    )

    # Results
    # Add a hard-coded table result
    temp_result = Result.new(
      name: 'Sample distribution on the plate',
      my_module: my_modules[5],
      user: user,
      created_at: generate_random_time(my_modules[5].created_at, 1.days)
    )
    temp_result.table = Table.new(
      created_by: user,
      team: team,
      contents: tab_content['module6']['distribution'] % {
        sample0: samples_to_assign[0].name,
        sample1: samples_to_assign[1].name,
        sample2: samples_to_assign[2].name,
        sample3: samples_to_assign[3].name
      }
    )
    temp_result.save

    # Create result activity
    Activity.new(
      type_of: :add_result,
      project: project,
      my_module: my_modules[5],
      user: user,
      created_at: temp_result.created_at,
      message: I18n.t(
        'activities.add_table_result',
        user: user.full_name,
        result: temp_result.name
      )
    ).sneaky_save

    # Results
    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[5],
      current_user: user,
      current_team: team,
      result_name: 'Mixtures and plate setup',
      created_at: generate_random_time(my_modules[5].created_at, 2.days),
      file_name: 'Mixes_Templats.xls'
    )

    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[5],
      current_user: user,
      current_team: team,
      result_name: 'Raw data from ABI 7300',
      created_at: generate_random_time(my_modules[5].created_at, 3.days),
      file_name: 'BootCamp-Experiment-results-20122.sds'
    )

    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[5],
      current_user: user,
      current_team: team,
      result_name: 'All results - curves',
      created_at: generate_random_time(my_modules[5].created_at, 4.days),
      file_name: 'curves.JPG'
    )

    # ----------------- Module 7 ------------------
    module_step_names = [
      'Check negative controls NTC',
      'Eliminate results that have positive NTCs'
    ]
    module_step_descriptions = [
      'They have to be negative when using TaqMan assays. If they are ' \
      'positive when using SYBR assays check also melitng curve where signal ' \
      'comes from. - if it is primer dimer result is negative - If it is ' \
      'specific signal it is positive',
      'And repeat procedure'
    ]
    generate_module_steps(my_modules[6],
                          module_step_names,
                          module_step_descriptions)

    # Add comment to step
    step = my_modules[6].protocol.steps.where('position = 1').take
    step.save
    generate_step_comment(
      step,
      user,
      'What is the Cq that should be considered as positive result?'
    )

    # ----------------- Module 8 ------------------
    module_step_names = [
      'Template for ddCq analysis'
    ]
    module_step_descriptions = [
      nil
    ]

    generate_module_steps(my_modules[7],
                          module_step_names,
                          module_step_descriptions)

    # Add file to existig step
    DelayedUploaderTutorial.delay(queue: :tutorial).add_step_asset(
      step: my_modules[7].protocol.steps.where('position = 0').take,
      current_user: user,
      current_team: team,
      file_name: 'ddCq-quantification_diagnostics-template.xls'
    )

    # Add result
    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[7],
      current_user: user,
      current_team: team,
      result_name: 'Results of ddCq method',
      created_at: generate_random_time(my_modules[7].created_at, 1.days),
      file_name: 'ddCq-quantification_diagnostics-results.xls'
    )

    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[7],
      current_user: user,
      current_team: team,
      result_name: 'Dilution curve and efficiency',
      created_at: generate_random_time(my_modules[7].created_at, 2.days),
      file_name: 'dilution_curve-efficiency.JPG'
    )

    DelayedUploaderTutorial.delay(queue: :tutorial).generate_result_asset(
      my_module: my_modules[7],
      current_user: user,
      current_team: team,
      result_name: 'Relative quantification results',
      created_at: generate_random_time(my_modules[7].created_at, 3.days),
      file_name: 'result-ddCq.JPG'
    )

    # Add a text result
    temp_result = Result.new(
      name: 'Markdown remarks',
      my_module: my_modules[7],
      user: user,
      created_at: generate_random_time(my_modules[7].created_at, 4.days)
    )
    temp_text = "__Bolded text__\n\ndouble Enter " \
                "to go to new line\n\n- bulletpoint"
    temp_result.result_text = ResultText.new(
      text: temp_text
    )
    temp_result.save

    # Create result activity
    Activity.new(
      type_of: :add_result,
      project: project,
      my_module: my_modules[7],
      user: user,
      created_at: temp_result.created_at,
      message: I18n.t(
        'activities.add_text_result',
        user: user.full_name,
        result: temp_result.name
      )
    ).sneaky_save

    # create thumbnail
    experiment.generate_workflow_img

    # Lastly, create cookie with according ids
    # so tutorial steps can be properly positioned
    JSON.generate([team: team.id,
                   project: project.id,
                   qpcr_module: my_modules[5].id])
  end

  # WARNING: This only works on PostgreSQL
  def pluck_random(scope)
    scope.order('RANDOM()').first
  end

  def generate_random_time(*args)
    early = args[0]
    if args.size == 1
      rand(early..Time.now)
    else
      late = early + args[1]
      late = Time.now if late > Time.now
      rand(early..late)
    end
  end

  # Create steps for given module
  def generate_module_steps(my_module, step_names, step_descriptions)
    step_names.each_with_index do |name, i|
      created_at = generate_random_time(my_module.created_at, 5.hours)
      completed = rand <= 0.3
      completed_on = nil
      completed_on = generate_random_time(created_at, 10.hours) if completed

      step = Step.create(
        created_at: created_at,
        name: name,
        description: step_descriptions[i],
        position: i,
        completed: completed,
        user: @user,
        protocol: my_module.protocol,
        completed_on: completed_on
      )

      # Create activity
      Activity.new(
        type_of: :create_step,
        project: my_module.experiment.project,
        my_module: my_module,
        user: step.user,
        created_at: created_at,
        message: I18n.t(
          'activities.create_step',
          user: step.user.full_name,
          step: i,
          step_name: step.name
        )
      ).sneaky_save
      if completed
        Activity.new(
          type_of: :complete_step,
          project: my_module.experiment.project,
          my_module: my_module,
          user: step.user,
          created_at: completed_on,
          message: I18n.t(
            'activities.complete_step',
            user: step.user.full_name,
            step: i + 1,
            step_name: step.name,
            completed: my_module.protocol.completed_steps.count,
            all: i + 1
          )
        ).sneaky_save

        # Also add random comments to completed steps
        if rand < 0.3
          polite_comment = 'This looks well.'
        elsif rand < 0.4
          polite_comment = 'Seems satisfactory.'
        elsif rand < 0.4
          polite_comment = 'Try a bit harder next time.'
        end
        if polite_comment
          commented_on = generate_random_time(completed_on)
          generate_step_comment(
            step,
            @user,
            polite_comment,
            commented_on
          )
        end
      end
    end
  end

  def generate_project_comment(project, user, message, created_at = nil)
    created_at ||= generate_random_time(project.created_at, 1.week)
    ProjectComment.create(
      user: user,
      message: message,
      created_at: created_at,
      project: project
    )
    Activity.new(
      type_of: :add_comment_to_project,
      user: user,
      project: project,
      created_at: created_at,
      message: t('activities.add_comment_to_project',
                 user: user.full_name,
                 project: project.name)
    ).sneaky_save
  end

  def generate_module_comment(my_module, user, message, created_at = nil)
    created_at ||= generate_random_time(my_module.created_at, 1.day)
    TaskComment.create(
      user: user,
      message: message,
      created_at: created_at,
      my_module: my_module
    )
    Activity.new(
      type_of: :add_comment_to_module,
      user: user,
      project: my_module.experiment.project,
      my_module: my_module,
      created_at: created_at,
      message: t('activities.add_comment_to_module',
                 user: user.full_name,
                 module: my_module.name)
    ).sneaky_save
  end

  def generate_result_comment(result, user, message, created_at = nil)
    created_at ||= generate_random_time(result.created_at, 1.days)
    ResultComment.new(
      user: user,
      message: message,
      created_at: created_at,
      result: result
    )
    Activity.new(
      type_of: :add_comment_to_result,
      user: user,
      project: result.my_module.experiment.project,
      my_module: result.my_module,
      created_at: created_at,
      message: t('activities.add_comment_to_result',
                 user: user.full_name,
                 result: result.name)
    ).sneaky_save
  end

  def generate_step_comment(step, user, message, created_at = nil)
    created_at ||= generate_random_time(step.created_at, 2.hours)
    StepComment.new(
      user: user,
      message: message,
      created_at: created_at,
      step: step
    )
    Activity.new(
      type_of: :add_comment_to_step,
      user: user,
      project: step.protocol.my_module.experiment.project,
      my_module: step.protocol.my_module,
      created_at: created_at,
      message: t('activities.add_comment_to_step',
                 user: user.full_name,
                 step: step.position + 1,
                 step_name: step.name)
    ).sneaky_save
  end
end