scinote-web/app/utilities/first_time_data_generator.rb

1523 lines
55 KiB
Ruby
Raw Normal View History

2016-02-12 23:52:43 +08:00
module FirstTimeDataGenerator
# Default inventory repository
REPO_SAMPLES_NAME = 'Samples'.freeze
2018-01-09 22:57:06 +08:00
# Create data for demo for new users
def seed_demo_data(user, team, asset_queue = :demo)
2016-02-12 23:52:43 +08:00
@user = user
2017-01-25 17:24:50 +08:00
# If private private team does not exist,
2016-02-12 23:52:43 +08:00
# there was something wrong with user creation.
# Do nothing
2017-01-25 17:24:50 +08:00
return unless team
2016-02-12 23:52:43 +08:00
# Skip this team if user already has a demo project
return if team.projects.where(demo: true).any?
name = '[NEW] Demo project by SciNote'
exp_name = 'Polymerase chain reaction'
# 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 = "#{name} (#{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,
template: false,
demo: true
)
# check if samples repo already exist, then create custom repository samples
repository = Repository.where(team: team).where(name: REPO_SAMPLES_NAME)
repository =
if repository.blank?
if team.repositories.count < Rails.configuration.x.repositories_limit
Repository.create(
name: REPO_SAMPLES_NAME,
team: team,
created_by: user
)
else
# User first repo just as a placeholder, this call will fail anyhow
Repository.create(
name: team.repositories.first.name,
team: team,
created_by: user
)
end
else
repository.first
end
# create list value column for sample types
repo_columns = []
['Sample Types', 'Sample Groups'].each do |repo_name|
repo_column = repository.repository_columns.where(name: repo_name)
repo_columns <<
if repo_column.blank?
RepositoryColumn.create(
repository: repository,
created_by: user,
data_type: :RepositoryListValue,
name: repo_name
)
else
repo_column.first
end
end
# Maintain old names
repository_column_sample_types, repository_column_sample_groups =
repo_columns
# create few list items for sample types
repository_items_sample_types = []
['Potato leaves', 'Tea leaves', 'Potato bug'].each do |name|
item = RepositoryListItem.create(
data: name,
created_by: user,
last_modified_by: user,
repository_column: repository_column_sample_types,
repository: repository
)
# Check if it already exists
if item.persisted?
repository_items_sample_types << item
else
repository_items_sample_types << repository_column_sample_types
.repository_list_items
.where(data: name).first
end
end
# create few list items for sample groups
repository_items_sample_groups = []
%i(Fodder Nutrient Seed).each do |name|
item = RepositoryListItem.create(
data: name,
created_by: user,
last_modified_by: user,
repository_column: repository_column_sample_groups,
repository: repository
)
# Check if it already exists
if item.persisted?
repository_items_sample_groups << item
else
repository_items_sample_groups << repository_column_sample_groups
.repository_list_items
.where(data: name).first
end
end
2018-02-27 17:40:52 +08:00
repository_rows_to_assign = []
# Generate random custom respository sample names and assign sample types
# and groups
2018-04-12 20:38:22 +08:00
2018-02-27 17:40:52 +08:00
repository_sample_name = (0...3).map { 65.+(rand(26)).chr }.join << '/'
2018-02-27 17:43:57 +08:00
(1..5).each do |index|
repository_row = RepositoryRow.create(
repository: repository,
created_by: user,
last_modified_by: user,
2018-02-27 17:40:52 +08:00
name: repository_sample_name + index.to_s
)
RepositoryListValue.create(
created_by: user,
last_modified_by: user,
repository_list_item: repository_items_sample_types[
rand(0..(repository_items_sample_types.length - 1))
],
repository_cell_attributes: {
repository_row: repository_row,
repository_column: repository_column_sample_types
}
)
RepositoryListValue.create(
created_by: user,
last_modified_by: user,
repository_list_item: repository_items_sample_groups[
rand(0..(repository_items_sample_groups.length - 1))
],
repository_cell_attributes: {
repository_row: repository_row,
repository_column: repository_column_sample_groups
}
)
2018-02-27 17:40:52 +08:00
repository_rows_to_assign << repository_row
end
2016-02-12 23:52:43 +08:00
# Create sample types
SampleType.create(
2017-01-25 17:24:50 +08:00
name: 'Potato leaves',
team: team
2016-02-12 23:52:43 +08:00
)
SampleType.create(
2017-01-25 17:24:50 +08:00
name: 'Tea leaves',
team: team
2016-02-12 23:52:43 +08:00
)
SampleType.create(
2017-01-25 17:24:50 +08:00
name: 'Potato bug',
team: team
2016-02-12 23:52:43 +08:00
)
SampleGroup.create(
2017-01-25 17:24:50 +08:00
name: 'Fodder',
team: team,
color: Constants::TAG_COLORS[1]
2016-02-12 23:52:43 +08:00
)
SampleGroup.create(
2017-01-25 17:24:50 +08:00
name: 'Nutrient',
team: team,
color: Constants::TAG_COLORS[0]
2016-02-12 23:52:43 +08:00
)
SampleGroup.create(
2017-01-25 17:24:50 +08:00
name: 'Seed',
team: team,
color: Constants::TAG_COLORS[2]
2016-02-12 23:52:43 +08:00
)
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,
2017-01-25 17:24:50 +08:00
team: team,
2016-02-12 23:52:43 +08:00
user: user,
2017-01-25 17:24:50 +08:00
sample_type: rand < 0.8 ? pluck_random(team.sample_types) : nil,
sample_group: rand < 0.8 ? pluck_random(team.sample_groups) : nil
2016-02-12 23:52:43 +08:00
)
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,
2017-01-25 17:24:50 +08:00
team: team,
2016-02-12 23:52:43 +08:00
user: user,
2017-01-25 17:24:50 +08:00
sample_type: rand < 0.8 ? pluck_random(team.sample_types) : nil,
sample_group: rand < 0.8 ? pluck_random(team.sample_groups) : nil
2016-02-12 23:52:43 +08:00
)
end
2019-02-05 18:15:16 +08:00
experiment_description =
'Polymerase chain reaction (PCR) monitors the amplification of DNA ' \
'in real time (qPCR cyclers constantly scan qPCR plates). It is, in ' \
'contrast to the conventional PCR, quantitative, meaning that it ' \
'enables us to determine the exact concentration (relative or ' \
'absolute) of the amplified DNA in the sample. Conversely, in ' \
'conventional PCR we can see the result of amplification only after ' \
'the PCR is completed (end-point detection).
Apart from DNA, RNA can also be used as a template (e.g. in case of ' \
'gene expression studies or detection of RNA viruses). In this case, ' \
'the RNA needs to be reverse transcribed into DNA (also termed ' \
'complementary DNA or cDNA) before it is amplified with real-time PCR. ' \
'There is a term for this combined method: real-time reverse ' \
'transcription PCR or qRT-PCR (sometimes RT-qPCR) for short.'
experiment = Experiment.create(
name: exp_name,
2019-02-05 18:15:16 +08:00
description: experiment_description,
project: project,
created_by: user,
created_at: project.created_at + 5.minutes,
last_modified_by: user
2016-02-12 23:52:43 +08:00
)
# Automatically assign project author onto project
UserProject.create(
user: user,
project: project,
role: 0,
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(1.week.ago)
2016-02-12 23:52:43 +08:00
)
# Add a comment
generate_project_comment(
project,
user,
2017-01-25 17:24:50 +08:00
'I\'ve created a demo project'
2016-02-12 23:52:43 +08:00
)
# Create a module group
my_module_group = MyModuleGroup.create(
experiment: experiment
2016-02-12 23:52:43 +08:00
)
# Create project modules
my_modules = []
my_module_names = [
2017-01-25 17:24:50 +08:00
'Experiment design',
'Sampling biological material',
'RNA isolation',
'RNA quality & quantity - BIOANALYSER',
'Reverse transcription',
'qPCR',
'Data quality control',
'Data analysis - ddCq'
2016-02-12 23:52:43 +08:00
]
2017-01-25 17:24:50 +08:00
qpcr_module_description = 'PCR is a method where an enzyme
2016-02-12 23:52:43 +08:00
(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
2017-01-25 17:24:50 +08:00
conventional PCR works can be found here.'
2016-02-12 23:52:43 +08:00
my_module_names.each_with_index do |name, i|
my_module = MyModule.create(
name: name,
created_by: user,
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(6.days.ago),
2016-02-12 23:52:43 +08:00
due_date: Time.now + (2 * i + 1).weeks,
description: i == 5 ? qpcr_module_description : nil,
2016-08-11 22:24:44 +08:00
x: (i < 4 ? i % 4 : 7 - i) * 32,
y: (i / 4) * 16,
2016-08-18 14:33:08 +08:00
experiment: experiment,
2016-02-12 23:52:43 +08:00
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,
2017-01-25 17:24:50 +08:00
output_id: my_modules[i - 1].id
2016-02-12 23:52:43 +08:00
)
end
UserMyModule.create(
user: user,
my_module: my_module,
assigned_by: user,
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_module.created_at, 2.minutes)
2016-02-12 23:52:43 +08:00
)
end
# Create an archived module
archived_module = MyModule.create(
2017-01-25 17:24:50 +08:00
name: 'Data analysis - Pfaffl method',
2016-02-12 23:52:43 +08:00
created_by: user,
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(6.days.ago),
2016-02-12 23:52:43 +08:00
due_date: Time.now + 1.week,
description: nil,
x: -1,
y: -1,
experiment: experiment,
2016-02-12 23:52:43 +08:00
workflow_order: -1,
my_module_group: nil,
archived: true,
2016-07-21 19:11:15 +08:00
archived_on: generate_random_time(3.days.ago),
2016-02-12 23:52:43 +08:00
archived_by: user
)
# Assign new user to archived module
UserMyModule.create(
user: user,
my_module: archived_module,
assigned_by: user,
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(archived_module.created_at, 2.minutes)
2016-02-12 23:52:43 +08:00
)
# 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].downstream_modules.each do |mm|
2016-02-12 23:52:43 +08:00
samples_to_assign.each do |s|
SampleMyModule.create(
sample: s,
my_module: mm
)
end
2018-02-27 17:40:52 +08:00
repository_rows_to_assign.each do |repository_row|
MyModuleRepositoryRow.create!(
repository_row: repository_row,
my_module: mm,
assigned_by: user
)
end
2016-02-12 23:52:43 +08:00
end
# Add comments to modules
generate_module_comment(
my_modules[0],
user,
'We should have a meeting to discuss sampling parametrs soon.'
2016-02-12 23:52:43 +08:00
)
generate_module_comment(
my_modules[0],
user,
'I agree.'
2016-02-12 23:52:43 +08:00
)
generate_module_comment(
my_modules[1],
user,
'The samples have arrived.'
2016-02-12 23:52:43 +08:00
)
generate_module_comment(
my_modules[2],
user,
'Due date has been postponed for a day.'
2016-02-12 23:52:43 +08:00
)
generate_module_comment(
my_modules[4],
user,
'Please show Steve the RT procedure.'
2016-02-12 23:52:43 +08:00
)
generate_module_comment(
my_modules[5],
user,
'The results must be very definitive.'
2016-02-12 23:52:43 +08:00
)
generate_module_comment(
my_modules[7],
user,
'The due date here is flexible.'
2016-02-12 23:52:43 +08:00
)
2016-07-21 19:11:15 +08:00
# Create tags and add them to module
drylab_tag = Tag.create(
2019-02-05 18:15:16 +08:00
name: 'Dry lab',
color: Constants::TAG_COLORS[0],
2016-07-21 19:11:15 +08:00
project: project,
created_by: user,
last_modified_by: user
)
wetlab_tag = Tag.create(
2019-02-05 18:15:16 +08:00
name: 'Wet lab',
color: Constants::TAG_COLORS[12],
2016-07-21 19:11:15 +08:00
project: project,
created_by: user,
last_modified_by: user
)
2019-02-05 18:15:16 +08:00
plant_tag = Tag.create(
name: 'Plant',
color: Constants::TAG_COLORS[5],
2016-07-21 19:11:15 +08:00
project: project,
created_by: user,
last_modified_by: user
)
2019-02-05 18:15:16 +08:00
virus_tag = Tag.create(
name: 'Pathogenic virus',
color: Constants::TAG_COLORS[13],
project: project,
created_by: user,
last_modified_by: user
)
infectious_tag = Tag.create(
name: 'Infectious sample',
color: Constants::TAG_COLORS[2],
project: project,
created_by: user,
last_modified_by: user
)
bacteria_tag = Tag.create(
name: 'Bacteria',
color: Constants::TAG_COLORS[14],
project: project,
created_by: user,
last_modified_by: user
)
patent_tag = Tag.create(
name: 'Results for patent',
color: Constants::TAG_COLORS[3],
project: project,
created_by: user,
last_modified_by: user
)
identifires_tag = Tag.create(
name: 'Assign unique identifires',
color: Constants::TAG_COLORS[15],
project: project,
created_by: user,
last_modified_by: user
)
plasmid_tag = Tag.create(
name: 'Plasmid A',
color: Constants::TAG_COLORS[1],
project: project,
created_by: user,
last_modified_by: user
)
2016-02-12 23:52:43 +08:00
2016-07-21 19:11:15 +08:00
# Add tags to module
my_modules[0].tags << drylab_tag
my_modules[1].tags << wetlab_tag
2019-02-05 18:15:16 +08:00
my_modules[1].tags << plant_tag
my_modules[1].tags << virus_tag
my_modules[2].tags << plant_tag
my_modules[2].tags << infectious_tag
2016-07-21 19:11:15 +08:00
my_modules[3].tags << wetlab_tag
2019-02-05 18:15:16 +08:00
2016-07-21 19:11:15 +08:00
my_modules[4].tags << wetlab_tag
2019-02-05 18:15:16 +08:00
my_modules[4].tags << bacteria_tag
my_modules[5].tags << wetlab_tag
my_modules[5].tags << bacteria_tag
my_modules[5].tags << virus_tag
my_modules[5].tags << patent_tag
my_modules[5].tags << identifires_tag
2016-07-21 19:11:15 +08:00
my_modules[6].tags << drylab_tag
2019-02-05 18:15:16 +08:00
my_modules[6].tags << plasmid_tag
2016-07-21 19:11:15 +08:00
my_modules[7].tags << drylab_tag
2019-02-05 18:15:16 +08:00
my_modules[7].tags << plasmid_tag
2016-07-21 19:11:15 +08:00
my_modules[7].save
# Load table contents yaml file
2017-01-25 17:24:50 +08:00
tab_content = YAML.load_file(
2018-01-09 22:57:06 +08:00
"#{Rails.root}/app/assets/demo_files/tables_content.yaml"
2017-01-25 17:24:50 +08:00
)
2016-07-21 19:11:15 +08:00
# Create module content
# ----------------- Module 1 ------------------
2016-02-12 23:52:43 +08:00
module_step_names = [
2017-01-25 17:24:50 +08:00
'Gene expression'
2016-02-12 23:52:43 +08:00
]
module_step_descriptions = [
2017-01-25 17:24:50 +08:00
'Compare response of PVYNTN, cab4 and PR1 genes in mock/virus ' \
'inoculated potatoes & in time'
2016-02-12 23:52:43 +08:00
]
2017-01-25 17:24:50 +08:00
generate_module_steps(my_modules[0],
module_step_names,
module_step_descriptions)
2016-02-12 23:52:43 +08:00
2019-02-05 18:15:16 +08:00
step = my_modules[0].protocol.steps.where('position = 0').take
Table.create(
name: 'Experiment design table',
2016-07-21 19:11:15 +08:00
created_by: user,
2019-02-05 18:15:16 +08:00
step: step,
team: team,
2019-02-05 18:15:16 +08:00
contents: tab_content['module1']['experimental_design_table']
2016-07-21 19:11:15 +08:00
)
# ----------------- Module 2 ------------------
2016-02-12 23:52:43 +08:00
module_step_names = [
2017-01-25 17:24:50 +08:00
'Inoculation of potatoes',
2019-02-05 18:15:16 +08:00
'Store samples',
'Collection of potatoes'
2016-02-12 23:52:43 +08:00
]
2019-02-05 18:15:16 +08:00
second_rep_item = smart_annotate_rep_item(repository_rows_to_assign.second)
third_rep_item = smart_annotate_rep_item(repository_rows_to_assign.third)
fifth_rep_item = smart_annotate_rep_item(repository_rows_to_assign.fifth)
2019-02-13 19:20:14 +08:00
module_step_descriptions = [
2019-02-05 18:15:16 +08:00
'<html>
<body>
<p>50% of samples should be mock inoculated
<span class=\"atwho-inserted\"contenteditable=\"false\"
data-atwho-at-query=\"#\">[#' + third_rep_item + ']</span>
2019-02-05 18:15:16 +08:00
<span class=\"atwho-inserted\" contenteditable=\"false\"
data-atwho-at-query=\"#\">[#' + fifth_rep_item + ']</span>
2019-02-05 18:15:16 +08:00
while other 50% with PVY NTN virus
<span class=\"atwho-inserted\" contenteditable=\"false\"
data-atwho-at-query=\"#\">[#' + third_rep_item + ']</span>
2019-02-05 18:15:16 +08:00
<span class=\"atwho-inserted\" contenteditable=\"false\"
data-atwho-at-query=\"#\">[#' + fifth_rep_item + ']</span>.
2019-02-05 18:15:16 +08:00
</p>
</body>
2019-02-13 19:20:14 +08:00
</html>',
2019-02-05 18:15:16 +08:00
'Collect samples in <strong>2ml tubes</strong> and put them in '\
'<strong>liquid nitrogen</strong> and store at <strong>80°C</strong>.',
2017-01-25 17:24:50 +08:00
'50% of PVYNTN inoculated potatos and 50% of Mock inoculated potatos ' \
'collect 1 day post inocullation while other halph of samples collect ' \
2019-02-05 18:15:16 +08:00
'6 days post inoculation.'
2016-02-12 23:52:43 +08:00
]
2017-01-25 17:24:50 +08:00
generate_module_steps(my_modules[1],
module_step_names,
module_step_descriptions)
2016-02-12 23:52:43 +08:00
# Delete repository items, if we went over the limit
repository_rows_to_assign.map(&:destroy) unless repository.id
2019-02-05 18:15:16 +08:00
# Add table to existig step
step = my_modules[1].protocol.steps.where('position = 0').take
Table.create(
created_by: user,
step: step,
team: team,
contents: tab_content['module2']['samples_table']
)
2016-07-21 19:11:15 +08:00
# Add file to existig step
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2017-01-25 17:24:50 +08:00
step: my_modules[1].protocol.steps.where('position = 0').take,
2016-07-21 19:11:15 +08:00
current_user: user,
current_team: team,
2019-02-05 18:15:16 +08:00
file_name: 'PVY-inoculated_plant_symptoms.JPG'
2016-07-21 19:11:15 +08:00
)
2019-02-05 18:15:16 +08:00
# Add comment to step 1
user_annotation = user.name
2019-02-05 18:15:16 +08:00
generate_step_comment(
step,
user,
"#{user_annotation} I have used different sample [##{second_rep_item}]"
2016-07-21 19:11:15 +08:00
)
2019-02-05 18:15:16 +08:00
# Add comment to step 3
step = my_modules[1].protocol.steps.where('position = 2').take
generate_step_comment(
step,
user,
user_annotation + ' Please complete this by Monday.'
)
# Results
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2016-07-21 19:11:15 +08:00
my_module: my_modules[1],
current_user: user,
current_team: team,
2019-02-05 18:15:16 +08:00
result_name: 'Mock inoculated plant',
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_modules[1].created_at, 2.days),
2019-02-05 18:15:16 +08:00
file_name: 'mock-inoculated-plant.JPG'
2016-07-21 19:11:15 +08:00
)
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2016-07-21 19:11:15 +08:00
my_module: my_modules[1],
current_user: user,
current_team: team,
2019-02-05 18:15:16 +08:00
result_name: 'Plant',
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_modules[1].created_at, 3.days),
2017-01-25 17:24:50 +08:00
file_name: '6dpi_height.JPG'
2016-07-21 19:11:15 +08:00
)
# Add a text result
temp_result = Result.new(
2017-01-25 17:24:50 +08:00
name: 'Number of samples',
2016-07-21 19:11:15 +08:00
my_module: my_modules[1],
user: user,
created_at: generate_random_time(my_modules[1].created_at, 4.days)
)
2017-01-25 17:24:50 +08:00
temp_text = "There are many biological replicates we harvested " \
"for each type of sample (code-names):\n\n"
2016-07-21 19:11:15 +08:00
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
# ----------------- Module 3 ------------------
2016-02-12 23:52:43 +08:00
module_step_names = [
2017-01-25 17:24:50 +08:00
'Homogenization of the material',
2019-02-05 18:15:16 +08:00
'Isolation of RNA with RNeasy plant mini kit',
'Disruption with mortar and pestle',
'Disruption',
'Buffer addition',
'Transfer the lysate to a QIAshredder spin column',
'Addition of ethanol',
'Transfer the sample',
'Add 700 μL Buffer RW1 to the RNeasy spin column.',
'Addition of buffer',
'Place the RNeasy spin column in a new 1.5 ml collection tube',
'If the expected RNA yield is >30 μg'
2016-02-12 23:52:43 +08:00
]
module_step_descriptions = [
2019-02-05 18:15:16 +08:00
'Use tissue lyser: 1 min on step 3.',
'Disrupt a maximum of 100 mg plant material according to step 3 or 4.',
'Immediately place tissue in liquid nitrogen. Grind thoroughly. ' \
'Decant tissue powder and liquid nitrogen into RNase-free, ' \
'liquid-nitrogencooled, 2 mL microcentrifuge tube (not supplied). ' \
'Allow the liquid nitrogen to evaporate, but do not allow the tissue ' \
'to thaw. Proceed immediately to step 5.',
'<html><body><p>Disruption using the TissueLyser II, TissueLyser LT, ' \
'or TissueRuptor.<br><br>For detailed information on disruption of ' \
'plant tissues for purification of RNA, see TissueLyser Handbook, ' \
'TissueLyser LT Handbook, or TissueRuptor Handbook. (The RNeasy Mini ' \
'Handbook will be updated with this option.)</p></body></html>',
'Add 450 μL Buffer RLT or Buffer RLC to a maximum of 100 mg tissue ' \
'powder. Vortex vigorously.',
'Transfer the lysate to a QIAshredder spin column placed in a 2 mL ' \
'collection tube. Centrifuge for 2 min at full speed. Transfer the ' \
'supernatant of the flow-through to a new microcentrifuge tube (not ' \
'supplied) without disturbing the cell-debris pellet.',
'Add 0.5 volume of ethanol (96100%) to the cleared lysate, and mix ' \
'immediately by pipetting. Do not centrifuge.',
'Transfer the sample (usually 650 μl), with any precipitate, to an ' \
'RNeasy Mini spin column (pink) in a 2 mL collection tube (supplied). ' \
'Close the lid, and centrifuge for 15 s at ≥8000 x g (≥10,000 rpm). ' \
'Discard the flowthrough.',
'Close the lid, andcentrifuge for 15 s at ≥8000 x g. Discard the ' \
'flow-through.',
'Add 500 μL Buffer RPE to the RNeasy spin column. Close the lid, and ' \
'centrifuge for 2 min at ≥8000 x g.',
'Add 3050 μL RNase-free water directly to the spin column membrane. ' \
'Close the lid, and centrifuge for 1 min at ≥8000 x g to elute the RNA.',
'<html><body><p>If the expected RNA yield is &gt;30 μg, repeat step 9 ' \
'using another 3050 μL of RNase-free water.<br>Alternatively, use the ' \
'eluate from step 9 (if high RNA concentration is required). Reuse the ' \
'collection tube from step 12.</p></body></html>'
2016-02-12 23:52:43 +08:00
]
generate_module_steps(my_modules[2], module_step_names, module_step_descriptions)
2016-07-21 19:11:15 +08:00
# Results
temp_result = Result.new(
2017-01-25 17:24:50 +08:00
name: 'Nanodrop results',
2016-07-21 19:11:15 +08:00
my_module: my_modules[2],
created_at: generate_random_time(my_modules[2].created_at, 1.days),
user: user
)
2019-02-05 18:15:16 +08:00
qpcr_id = MyModule.where(name: 'qPCR').last.id.base62_encode
DelayedUploaderDemo.generate_result_comment(
temp_result,
user,
2019-02-05 18:15:16 +08:00
user_annotation + ' Please check if results match results in ' \
'[#qPCR~tsk~' + qpcr_id + ']',
generate_random_time(temp_result.created_at, 1.days)
2016-07-21 19:11:15 +08:00
)
temp_result.table = Table.new(
created_by: user,
team: team,
2017-01-25 17:24:50 +08:00
contents: tab_content['module3']['nanodrop']
2016-07-21 19:11:15 +08:00
)
temp_result.save
# Second result
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2016-07-21 19:11:15 +08:00
my_module: my_modules[2],
current_user: user,
current_team: team,
2017-01-25 17:24:50 +08:00
result_name: 'Agarose gel electrophoresis of totRNA samples',
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_modules[2].created_at, 3.days),
file_name: 'totRNA_gel.jpg',
comment: user_annotation + ' Could you check if this is okay?'
2016-07-21 19:11:15 +08:00
)
# ----------------- Module 4 ------------------
2016-02-12 23:52:43 +08:00
module_step_names = [
2019-02-05 18:15:16 +08:00
'Before you start',
'Excise the tissue sample from the animal or remove it from storage.',
'Weigh the piece to be used, and place it into a suitably sized vessel ' \
'for disruption and homogenization.',
'Disrupt the tissue and homogenize the lysate in Buffer RLT',
'Disruption and homogenization using a rotorstator homogenizer',
'Centrifuge the lysate for 3 min at full speed',
'Add 1 volume of 70% ethanol* to the cleared lysate, and mix ' \
'immediately by pipetting',
'Transfer up to 700 µL of the sample',
'Add 700 µL Buffer RW1 to the RNeasy spin column',
'Add 500 µL Buffer RPE to the RNeasy spin column',
'Place the RNeasy spin column in a new 1.5 mL collection tube (supplied)'
2016-02-12 23:52:43 +08:00
]
module_step_descriptions = [
2019-02-05 18:15:16 +08:00
'Follow the guidelines bellow.',
'<html><body><p>Remove RNAlater stabilized tissues from the reagent ' \
'using forceps. Determine the amount of tissue. Do not use more than ' \
'30 mg.<br>Weighing tissue is the most accurate way to determine the ' \
'amount.<br>Note: If the tissues were stored in RNAlater Reagent at ' \
'20°C, be sure to remove any crystals that may have formed.' \
'</p></body></html>',
'<html><body><p>RNA in harvested tissues is not protected until the '\
'tissues are treated with RNAlater RNA Stabilization Reagent, '\
'flash-frozen, or disrupted and homogenized in step 3. Frozen tissues ' \
'should not be allowed to thaw during handling. The relevant ' \
'procedures should be carried out as quickly as possible.<br><br>Note: ' \
'Remaining fresh tissues can be placed into RNAlater RNA Stabilization ' \
'Reagent to stabilize RNA (see protocol on page 34). However, ' \
'previously frozen tissues thaw too slowly in the reagent, preventing ' \
'the reagent from diffusing into the tissues quickly enough to prevent ' \
'RNA degradation.</p></body></html>',
'<html><body><p>See “Disrupting and homogenizing starting material”, ' \
'pages 1821, for more details on disruption and homogenization.' \
'<br><br><strong>Note</strong>: Ensure that β-ME is added to Buffer ' \
'RLT before use (see “Things to do before starting”).<br><br>After ' \
'storage in RNAlater RNA Stabilization Reagent, tissues may become ' \
'slightly harder than fresh or thawed tissues. Disruption and ' \
'homogenization using standard methods is usually not a problem. For ' \
'easier disruption and homogenization, we recommend using 600 µl ' \
'Buffer RLT.<br><br><strong>Note</strong>: Incomplete homogenization ' \
'leads to significantly reduced RNA yields and can cause clogging of ' \
'the RNeasy spin column. Homogenization with the TissueLyser LT, ' \
'TissueLyser II, and rotorstator homogenizers generally results in ' \
'higher RNA yields than with other methods.</p></body></html>',
'Place the weighed (fresh, frozen, or RNAlater stabilized) tissue in a ' \
'suitably sized vessel. Add the appropriate volume of Buffer RLT (see ' \
'Table 8). Immediately disrupt and homogenize the tissue using a ' \
'conventional rotorstator homogenizer until it is uniformly ' \
'homogeneous (usually 2040 s).',
'<html><body><p>Carefully remove the supernatant by pipetting, and ' \
'transfer it to a new microcentrifuge tube (not supplied).<br><br>' \
'Use only this supernatant (lysate) in subsequent steps. In some ' \
'preparations, very small amounts of insoluble material will be ' \
'present after the 3 min centrifugation, making the pellet ' \
'invisible.</p></body></html>',
'<html><body><span style="text-decoration: underline;">Do not ' \
'centrifuge.</span><br><br><strong>Note</strong>: The volume of lysate ' \
'may be less than 350 µL or 600 µL due to loss during homogenization ' \
'and centrifugation in steps 3 and 4.<br><br><strong>Note</strong>: ' \
'Precipitates may be visible after addition of ethanol. This does not ' \
'affect the procedure.</body></html>',
'<html><body><p>Transfer up to 700 µL of the sample, including any ' \
'precipitate that may have formed, to an RNeasy spin column placed in ' \
'a 2 mL collection tube (supplied).<br>Close the lid gently, and ' \
'centrifuge for 15 s at ≥8000 x g (≥10,000 rpm). Discard the ' \
'flow-through. If the sample volume exceeds 700 µL, centrifuge ' \
'successive aliquots in the same RNeasy spin column. Discard the ' \
'flow-through after each centrifugation.</p></body></html>',
'Close the lid gently, and centrifuge for 15 s at ≥8000 x g (≥10,000 ' \
'rpm) to wash the spin column membrane. Discard the flow-through.',
'<html><body><p>Close the lid gently, and centrifuge for 2 min at ' \
'≥8000 x g (≥10,000 rpm) to wash the spin column membrane.<br><br>The ' \
'long centrifugation dries the spin column membrane, ensuring that no ' \
'ethanol is carried over during RNA elution. Residual ethanol may ' \
'interfere with downstream reactions.<br><br><strong>Note</strong>: ' \
'After centrifugation, carefully remove the RNeasy spin column from ' \
'the collection tube so that the column does not contact the flow-' \
'through. Otherwise, carryover of ethanol will occur.</p></body></html>',
'Add 3050 µL RNase-free water directly to the spin column membrane. ' \
'Close the lid gently, and centrifuge for 1 min at ≥8000 x g ' \
'(≥10,000 rpm) to elute the RNA.'
2016-02-12 23:52:43 +08:00
]
generate_module_steps(my_modules[3], module_step_names, module_step_descriptions)
2019-02-05 18:15:16 +08:00
# Add file to existig step 1
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2017-01-25 17:24:50 +08:00
step: my_modules[3].protocol.steps.where('position = 0').take,
2016-07-21 19:11:15 +08:00
current_user: user,
current_team: team,
2019-02-05 18:15:16 +08:00
file_name: 'important_notes.pdf'
)
# Add checklist 1 to step 1
step = my_modules[3].protocol.steps.where('position = 0').take
checklist = Checklist.new(
name: 'If using the RNeasy Kit for the first time, read ' \
2019-02-13 19:20:14 +08:00
'"Important Notes" in the attached file',
2019-02-05 18:15:16 +08:00
step: step
)
module_checklist_items = [
'For optimal results, stabilize harvested tissues immediately in ' \
'RNAlater RNA Stabilization Reagent (see protocol on page 34). Tissues ' \
'can be stored in the reagent for up to 1 day at 37°C, 7 days at ' \
'1525°C, or 4 weeks at 28°C, or archived at 20°C or 80°C.',
'Fresh, frozen, or RNAlater stabilized tissues can be used. Tissues ' \
'can be stored at 70°C for several months. Flash-freeze tissues in ' \
'liquid nitrogen, and immediately transfer to 70°C. Do not allow ' \
'tissues to thaw during weighing or handling prior to disruption in ' \
'Buffer RLT. Homogenized tissue lysates from step 4 can also be stored ' \
'at 70°C for several months. Incubate frozen lysates at 37°C in a ' \
'water bath until completely thawed and salts are dissolved before ' \
'continuing with step 5. Avoid prolonged incubation, which may ' \
'compromise RNA integrity.',
'If desired, more than 30 mg tissue can be disrupted and homogenized ' \
'at the start of the procedure (increase the volume of Buffer RLT ' \
'proportionately). Use a portion of the homogenate corresponding to no ' \
'more than 30 mg tissue for RNA purification, and store the rest at 80°C.',
'Buffer RLT may form a precipitate upon storage. If necessary, ' \
2019-02-05 18:15:16 +08:00
'redissolve by warming, and then place at room temperature (1525°C).',
'Buffer RLT and Buffer RW1 contain a guanidine salt and are therefore ' \
'not compatible with disinfecting reagents containing bleach. See page ' \
'6 for safety information.',
'Perform all steps of the procedure at room temperature. During the ' \
'procedure, work quickly.',
'Perform all centrifugation steps at 2025°C in a standard ' \
'microcentrifuge. Ensure that the centrifuge does not cool below 20°C.'
]
module_checklist_items.each_with_index do |item, ind|
checklist.checklist_items << ChecklistItem.new(text: item, position: ind)
2019-02-05 18:15:16 +08:00
end
checklist.save
# Add checklist 2 to step 1
checklist = Checklist.new(
name: 'Things to do before starting',
step: step
)
module_checklist_items = [
'β-Mercaptoethanol (β-ME) must be added to Buffer RLT before use. Add ' \
'10 µl β-ME per 1 mL Buffer RLT. Dispense in a fume hood and wear ' \
'appropriate protective clothing. Buffer RLT containing β-ME can be ' \
'stored at room temperature (1525°C) for up to 1 month. ' \
'Alternatively, add 20 µL of 2 M dithiothreitol (DTT) per 1 mL Buffer ' \
'RLT. The stock solution of 2 M DTT in water should be prepared fresh ' \
'or frozen in single-use aliquots. Buffer RLT containing DTT can be ' \
'stored at room temperature for up to 1 month.',
'Buffer RPE is supplied as a concentrate. Before using for the first ' \
'time, add 4 volumes of ethanol (96100%) as indicated on the bottle ' \
'to obtain a working solution.',
'If performing optional on-column DNase digestion, prepare DNase I ' \
'stock solution as described in Appendix D (page 67).'
]
module_checklist_items.each_with_index do |item, ind|
checklist.checklist_items << ChecklistItem.new(text: item, position: ind)
2019-02-05 18:15:16 +08:00
end
checklist.save
# Add table to existig step 4
step = my_modules[3].protocol.steps.where('position = 3').take
Table.create(
created_by: user,
step: step,
team: team,
name: 'Volumes of Buffer RLT for tissue disruption and homogenization',
contents: tab_content['module4']['volumes']
2016-07-21 19:11:15 +08:00
)
2019-02-05 18:15:16 +08:00
# Add checklist to step 8
step = my_modules[3].protocol.steps.where('position = 7').take
checklist = Checklist.new(
name: 'Optional',
step: step
)
module_checklist_items = [
'If performing optional on-column DNase digestion (see “Eliminating ' \
'genomic DNA contamination”, page 21), follow steps D1D4 (page 67) ' \
'after performing this step.'
]
module_checklist_items.each_with_index do |item, ind|
checklist.checklist_items << ChecklistItem.new(text: item, position: ind)
2019-02-05 18:15:16 +08:00
end
checklist.save
2016-07-21 19:11:15 +08:00
# Results
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2016-07-21 19:11:15 +08:00
my_module: my_modules[3],
current_user: user,
current_team: team,
2017-01-25 17:24:50 +08:00
result_name: 'Result of RNA integrity',
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_modules[3].created_at, 2.days),
2017-01-25 17:24:50 +08:00
file_name: 'Bioanalyser_result.JPG'
2016-07-21 19:11:15 +08:00
)
2019-02-05 18:15:16 +08:00
temp_result = Result.new(
name: 'DNA q results',
my_module: my_modules[3],
created_at: generate_random_time(my_modules[3].created_at, 1.days),
user: user
)
temp_result.table = Table.new(
created_by: user,
team: team,
contents: tab_content['module4']['dna_q']
)
temp_result.save
2016-07-21 19:11:15 +08:00
# ----------------- Module 5 ------------------
2016-02-12 23:52:43 +08:00
module_step_names = [
2017-01-25 17:24:50 +08:00
'RNA denaturation',
'Prepare mastermix for RT',
'RT reaction'
2016-02-12 23:52:43 +08:00
]
module_step_descriptions = [
2017-01-25 17:24:50 +08:00
'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'
2016-02-12 23:52:43 +08:00
]
2017-01-25 17:24:50 +08:00
generate_module_steps(my_modules[4],
module_step_names,
module_step_descriptions)
2016-02-12 23:52:43 +08:00
2016-07-21 19:11:15 +08:00
module_checklist_items = [
2019-02-05 18:15:16 +08:00
'H2O to 12.5 uL',
2017-01-25 17:24:50 +08:00
'Optional: Luciferase mRNA (denatured)',
2019-02-05 18:15:16 +08:00
'Reverse transcriptase',
'RNase inhibitor',
'Random Primers',
'dNTP mix',
'RT buffer'
2016-07-21 19:11:15 +08:00
]
# Add checklist to step
2017-01-25 17:24:50 +08:00
step = my_modules[4].protocol.steps.where('position = 1').take
2016-07-21 19:11:15 +08:00
checklist = Checklist.new(
2017-01-25 17:24:50 +08:00
name: 'Mastermix',
2016-07-21 19:11:15 +08:00
step: step
)
module_checklist_items.each_with_index do |item, ind|
checklist.checklist_items << ChecklistItem.new(text: item, position: ind)
2016-07-21 19:11:15 +08:00
end
checklist.save
# ----------------- Module 6 ------------------
2016-02-12 23:52:43 +08:00
module_step_names = [
2019-02-05 18:15:16 +08:00
'Master Mix Preparation',
'Setup of the 96-well Plate',
'Reaction setup - NEW TITLE'
2016-02-12 23:52:43 +08:00
]
module_step_descriptions = [
2019-02-05 18:15:16 +08:00
'PCR Master Mix includes Nuclease-Free Water and PCR Master Mix, 2X. ' \
'PCR Master Mix is a premixed, ready-to-use solution containing Taq ' \
'DNA Polymerase, dNTPs, MgCl2 and reaction buffers at optimal ' \
'concentrations for efficient amplification of DNA templates by PCR.',
'<html><body><p>It is recommended to use pre-defined Excel templates ' \
'or PlatR Pietting Assistant to customize pipetting scheme. Make sure ' \
'to always include all necessary controls.&nbsp;Especially the ' \
'negative controls.<br><br>Template of the 96-well plate.' \
'</p></body></html>',
'<html><body><p>The Applied Biosystems 7900HT Fast Real-Time PCR ' \
'System (7900HT Fast System) uses fluorescent-based PCR chemistries to ' \
'provide:</p><ul><li>Quantitative detection of nucleic acid sequences ' \
'using real-time analysis</li><li>Qualitative detection of nucleic ' \
'acid sequences using end-point and dissociation-curve analysis</li>' \
'</ul><p>You can perform several assay types on the 7900HT Fast System ' \
'using reactions plates in the 96-well, 384-well, or TaqMan® Low ' \
'Density Array format. This guide describes the allelic discrimination ' \
'assay.</p></body></html>'
2016-02-12 23:52:43 +08:00
]
2017-01-25 17:24:50 +08:00
generate_module_steps(my_modules[5],
module_step_names,
module_step_descriptions)
2016-02-12 23:52:43 +08:00
2019-02-05 18:15:16 +08:00
# Add table to existig step 1
step = my_modules[5].protocol.steps.where('position = 0').take
Table.create(
created_by: user,
step: step,
team: team,
name: 'Realtime mastermix preparation - gene expression',
contents: tab_content['module6']['mastermix']
)
# Add checklist to step 1
step = my_modules[5].protocol.steps.where('position = 0').take
checklist = Checklist.new(
name: 'QA checklist',
step: step
)
module_checklist_items = [
'Make sure the UV light was on at least for 20 minutes before you ' \
'started to work',
'Write down LOT numbers of reagents used',
'Use tips with filtes for pipetting samples; use tips without filters ' \
'for pipetting reagents',
'Always use designated separate chambers for pipetting samples and ' \
'reagents',
'Change lab coats when switching chambers',
'Clean surfaces with 70% ethanol or RNA remover',
'Turn on the UV light'
]
module_checklist_items.each_with_index do |item, ind|
checklist.checklist_items << ChecklistItem.new(text: item, position: ind)
2019-02-05 18:15:16 +08:00
end
checklist.save
2016-07-21 19:11:15 +08:00
# Add file to existig steps
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2017-01-25 17:24:50 +08:00
step: my_modules[5].protocol.steps.where('position = 0').take,
2016-07-21 19:11:15 +08:00
current_user: user,
current_team: team,
2019-02-05 18:15:16 +08:00
file_name: 'Mixes_Templats.xlsx'
)
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2019-02-05 18:15:16 +08:00
step: my_modules[5].protocol.steps.where('position = 1').take,
current_user: user,
current_team: team,
file_name: 'qPCR_template.jpg'
2016-07-21 19:11:15 +08:00
)
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2017-01-25 17:24:50 +08:00
step: my_modules[5].protocol.steps.where('position = 1').take,
2016-07-21 19:11:15 +08:00
current_user: user,
current_team: team,
2019-02-05 18:15:16 +08:00
file_name: '96plate.docx'
2016-07-21 19:11:15 +08:00
)
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2017-01-25 17:24:50 +08:00
step: my_modules[5].protocol.steps.where('position = 2').take,
2016-07-21 19:11:15 +08:00
current_user: user,
current_team: team,
2017-01-25 17:24:50 +08:00
file_name: 'cycling_conditions.JPG'
2016-07-21 19:11:15 +08:00
)
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2019-02-05 18:15:16 +08:00
step: my_modules[5].protocol.steps.where('position = 2').take,
2016-07-21 19:11:15 +08:00
current_user: user,
current_team: team,
2019-02-05 18:15:16 +08:00
file_name: 'Dual_Labeled_Fluorescent_Probes.jpg'
2016-07-21 19:11:15 +08:00
)
# Results
# Add a hard-coded table result
temp_result = Result.new(
2017-01-25 17:24:50 +08:00
name: 'Sample distribution on the plate',
2016-07-21 19:11:15 +08:00
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,
2017-01-25 17:24:50 +08:00
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
}
2016-07-21 19:11:15 +08:00
)
temp_result.save
# Results
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2016-07-21 19:11:15 +08:00
my_module: my_modules[5],
current_user: user,
current_team: team,
2019-02-05 18:15:16 +08:00
result_name: 'Results',
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_modules[5].created_at, 2.days),
2019-02-05 18:15:16 +08:00
file_name: '1505745387970-1058053257.jpg'
2016-07-21 19:11:15 +08:00
)
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2016-07-21 19:11:15 +08:00
my_module: my_modules[5],
current_user: user,
current_team: team,
2019-02-05 18:15:16 +08:00
result_name: 'Cromatogram',
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_modules[5].created_at, 3.days),
2019-02-05 18:15:16 +08:00
file_name: 'chromatogram.png'
2016-07-21 19:11:15 +08:00
)
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2016-07-21 19:11:15 +08:00
my_module: my_modules[5],
current_user: user,
current_team: team,
2017-01-25 17:24:50 +08:00
result_name: 'All results - curves',
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_modules[5].created_at, 4.days),
2017-01-25 17:24:50 +08:00
file_name: 'curves.JPG'
2016-07-21 19:11:15 +08:00
)
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2019-02-05 18:15:16 +08:00
my_module: my_modules[5],
current_user: user,
current_team: team,
result_name: 'Bacteria plates YPGA',
created_at: generate_random_time(my_modules[5].created_at, 2.days),
file_name: 'Bacterial_colonies.jpg',
comment: user_annotation + ' please check the results again. ' \
'<span class=\"atwho-inserted\" contenteditable=\"false\"' \
'data-atwho-at-query=\"#\">[#' + fifth_rep_item + ']</span>' \
' seems to be acting strange?'
2019-02-05 18:15:16 +08:00
)
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2019-02-05 18:15:16 +08:00
my_module: my_modules[5],
current_user: user,
current_team: team,
result_name: 'Article',
created_at: generate_random_time(my_modules[5].created_at, 4.days),
file_name: 'Recent_attempts_to_detect_Ebola_virus.docx'
)
# Add a text result
temp_result = Result.new(
name: 'Data analysis',
my_module: my_modules[5],
user: user,
created_at: generate_random_time(my_modules[5].created_at, 4.days)
)
temp_result.result_text = ResultText.new(
text: <<~FOO
<html><body><pre class='hljs language-python'>
<code># Read PCR data into a pandas DataFrame. You want a data file where each
# row corresponds to a separate well, with columns for the sample name,
# target name, and Cq value. NTC wells should have the sample name set to
# a value like 'NTC'.
&gt;&gt; df = pd.read_csv('my_data.csv')
# If your Sample, Target, and Cq columns are called other things, they
# should be renamed to Sample, Target, and Cq.
&gt;&gt; df = df.rename(columns={'Gene': 'Target', 'Ct': 'Cq'})
# Drop the wells that are too close to the NTC for that target.
&gt;&gt; censored = eleven.censor_background(df)
# Rank your candidate reference genes.
&gt;&gt; ranked = eleven.rank_targets(censored, ['Gapdh', 'Rn18s', 'Hprt',
'Ubc', 'Actb'], 'Control')
# Normalize your data by your most stable genes and compute normalization
# factors (NFs).
&gt;&gt; nf = eleven.calculate_nf(censored, ranked.ix['Target', 0:3], 'Control')
# Now, normalize all of your expression data.
&gt;&gt; censored['RelExp'] = eleven.expression_nf(censored, nf, 'Control')</code>
</pre></body></html>
FOO
)
temp_result.save
# Add a text result
temp_result = Result.new(
name: 'Immunofluorescence summary',
my_module: my_modules[5],
user: user,
created_at: generate_random_time(my_modules[5].created_at, 4.days)
)
temp_result.result_text = ResultText.new(
text: 'Immunofluorescence is a technique used for light microscopy ' \
'with a fluorescence microscope and is used primarily on ' \
'microbiological samples. This technique uses the specificity of ' \
'antibodies to their antigen to target fluorescent dyes to specific ' \
'biomolecule targets within a cell, and therefore allows visualization ' \
'of the distribution of the target molecule through the sample. The ' \
'specific region an antibody recognizes on an antigen is called an ' \
'epitope. There have been.'
)
temp_result.save
# Add a text result
temp_result = Result.new(
name: 'Discussion',
my_module: my_modules[5],
user: user,
created_at: generate_random_time(my_modules[5].created_at, 4.days)
)
temp_result.result_text = ResultText.new(
text: 'Immunofluorescence is a technique used for light microscopy ' \
'with a fluorescence microscope and is used primarily on ' \
'microbiological samples. this technique uses the specificity of ' \
'antibodies to their antigen to target fluorescent dyes to specific ' \
'biomolecule targets within a cell, and therefore allows visualization ' \
'of the distribution of the target molecule through the sample. the ' \
'specific region an antibody recognizes on an antigen is called an ' \
'epitope. There have been efforts in epitope mapping since many ' \
'antibodies can bind the same epitope and levels of binding between ' \
'antibodies that recognize the same epitope can vary. Additionally, ' \
'the binding of the fluorophore to the antibody itself cannot ' \
'interfere with the immunological specificity of the antibody or the ' \
'binding capacity of its antigen. Immunofluorescence is a widely used ' \
'example of immunostaining (using antibodies to stain proteins) and ' \
'is a specific example of immunohistochemistry(the use of the ' \
'antibody-antigen relationship in tissues). this technique primarily ' \
'makes use of fluorophores to visualise the location of the antibodies.'
)
temp_result.save
# Add table result
temp_result = Result.new(
name: 'qPCR raw data',
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']['qpcr_raw_data']
)
temp_result.save
2016-07-21 19:11:15 +08:00
# ----------------- Module 7 ------------------
2016-02-12 23:52:43 +08:00
module_step_names = [
2019-02-05 18:15:16 +08:00
'Native PAGE protocol',
'QA Checklist',
2017-01-25 17:24:50 +08:00
'Check negative controls NTC',
2019-02-05 18:15:16 +08:00
'Eliminate results that have positive NTCs',
'Native-Page Protocol',
'Excel results'
2016-02-12 23:52:43 +08:00
]
module_step_descriptions = [
2019-02-05 18:15:16 +08:00
'Protein electrophoresis is a method for analysing the proteins in a ' \
'fluid or an extract. The electrophoresis may be performed with a ' \
'small volume of sample in a number of alternative ways with or ' \
'without a supporting medium: SDS polyacrylamide gel electrophoresis ' \
'(in short: gel electrophoresis, PAGE, or SDS-electrophoresis), ' \
'free-flow electrophoresis, electrofocusing, isotachophoresis, ' \
'affinity electrophoresis, immunoelectrophoresis, ' \
'counterelectrophoresis, and capillary electrophoresis. Each method ' \
'has many variations with individual advantages and limitations. Gel ' \
'electrophoresis is often performed in combination with ' \
'electroblotting immunoblotting to give additional information about a ' \
'specific protein. Because of practical limitations, protein ' \
'electrophoresis is generally not suited as a preparative method.',
'Please perform the following checklist before and after you start ' \
'working.',
'<html><body><div class="row">They have to be negative when using ' \
'TaqMan assays.<br><ul><li class="col-xs-12">If they are positive when ' \
'using SYBR assays check also melitng curve where signal comes ' \
'from</li><li class="col-xs-12">If it is primer dimer result is ' \
'negative</li><li class="col-xs-12">If it is specific signal it is ' \
'positive.</li></ul></div></body></html>',
'And repeat procedure.',
'Follow a Nature protocol attached and a PDF.',
'Write results in excel file.'
2016-02-12 23:52:43 +08:00
]
2017-01-25 17:24:50 +08:00
generate_module_steps(my_modules[6],
module_step_names,
module_step_descriptions)
2016-02-12 23:52:43 +08:00
2019-02-05 18:15:16 +08:00
# Add file to existig steps
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2019-02-05 18:15:16 +08:00
step: my_modules[6].protocol.steps.where('position = 0').take,
current_user: user,
current_team: team,
file_name: 'Native_SDS-PAGE_for_complex_analysis.jpg'
)
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2019-02-05 18:15:16 +08:00
step: my_modules[6].protocol.steps.where('position = 4').take,
current_user: user,
current_team: team,
file_name: 'Native-PAGE-Nature_protocols.pdf'
)
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2019-02-05 18:15:16 +08:00
step: my_modules[6].protocol.steps.where('position = 5').take,
current_user: user,
current_team: team,
file_name: 'results.xlsx'
)
# Add checklist to step 2
2017-01-25 17:24:50 +08:00
step = my_modules[6].protocol.steps.where('position = 1').take
2019-02-05 18:15:16 +08:00
checklist = Checklist.new(
name: 'QA Native PAGE',
step: step
)
module_checklist_items = [
'Check buffer stock & prepare new stock if needed',
'Check stock of reagents & order new stock if needed',
'Use gloves at all times'
]
module_checklist_items.each_with_index do |item, ind|
checklist.checklist_items << ChecklistItem.new(text: item, position: ind)
2019-02-05 18:15:16 +08:00
end
checklist.save
# Results
# Add table result
temp_result = Result.new(
name: 'qPCR results',
my_module: my_modules[6],
user: user,
created_at: generate_random_time(my_modules[6].created_at, 1.days)
)
2019-02-05 18:15:16 +08:00
temp_result.table = Table.new(
created_by: user,
team: team,
contents: tab_content['module7']['qpcr_results']
)
temp_result.save
2016-07-21 19:11:15 +08:00
# ----------------- Module 8 ------------------
2016-02-12 23:52:43 +08:00
module_step_names = [
2017-01-25 17:24:50 +08:00
'Template for ddCq analysis'
2016-02-12 23:52:43 +08:00
]
module_step_descriptions = [
2019-02-05 18:15:16 +08:00
'Sample information here.'
2016-02-12 23:52:43 +08:00
]
2017-01-25 17:24:50 +08:00
generate_module_steps(my_modules[7],
module_step_names,
module_step_descriptions)
2016-02-12 23:52:43 +08:00
2016-07-21 19:11:15 +08:00
# Add file to existig step
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2017-01-25 17:24:50 +08:00
step: my_modules[7].protocol.steps.where('position = 0').take,
2016-07-21 19:11:15 +08:00
current_user: user,
current_team: team,
2017-01-25 17:24:50 +08:00
file_name: 'ddCq-quantification_diagnostics-template.xls'
2016-02-12 23:52:43 +08:00
)
2016-07-21 19:11:15 +08:00
DelayedUploaderDemo.delay(queue: asset_queue).add_step_asset(
2019-02-05 18:15:16 +08:00
step: my_modules[7].protocol.steps.where('position = 0').take,
current_user: user,
current_team: team,
file_name: 'SDHACOX1Beta-Actin-Kits-ab123545-1.gif'
)
# Add comment to step 3
step = my_modules[7].protocol.steps.where('position = 0').take
generate_step_comment(
step,
user,
'I actually ran it for 15 minutes and not 10.'
)
2016-07-21 19:11:15 +08:00
# Add result
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2016-07-21 19:11:15 +08:00
my_module: my_modules[7],
current_user: user,
current_team: team,
2019-02-05 18:15:16 +08:00
result_name: 'Template for ddCq analysis',
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_modules[7].created_at, 1.days),
2017-01-25 17:24:50 +08:00
file_name: 'ddCq-quantification_diagnostics-results.xls'
2016-02-12 23:52:43 +08:00
)
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2016-07-21 19:11:15 +08:00
my_module: my_modules[7],
current_user: user,
current_team: team,
2017-01-25 17:24:50 +08:00
result_name: 'Dilution curve and efficiency',
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_modules[7].created_at, 2.days),
2017-01-25 17:24:50 +08:00
file_name: 'dilution_curve-efficiency.JPG'
2016-07-21 19:11:15 +08:00
)
2016-02-12 23:52:43 +08:00
DelayedUploaderDemo.delay(queue: asset_queue).generate_result_asset(
2016-07-21 19:11:15 +08:00
my_module: my_modules[7],
current_user: user,
current_team: team,
2017-01-25 17:24:50 +08:00
result_name: 'Relative quantification results',
2016-07-21 19:11:15 +08:00
created_at: generate_random_time(my_modules[7].created_at, 3.days),
2017-01-25 17:24:50 +08:00
file_name: 'result-ddCq.JPG'
2016-02-12 23:52:43 +08:00
)
# create thumbnail
experiment.generate_workflow_img
2016-02-12 23:52:43 +08:00
end
# Used for delayed jobs
def self.seed_demo_data_with_id(user_id, team_id)
extend self
user = User.find(user_id)
team = Team.find(team_id)
unless user || team
Rails.logger.warning("Could not retrieve user or team in " \
"seed_demo_data_with_id. " \
"User #{user_id} was mapped to #{user.inspect}." \
"Team #{team_id} was mapped to #{team.inspect}.")
return
end
seed_demo_data(user, team, :new_demo_project)
end
2016-02-12 23:52:43 +08:00
# WARNING: This only works on PostgreSQL
def pluck_random(scope)
2017-01-25 17:24:50 +08:00
scope.order('RANDOM()').first
2016-02-12 23:52:43 +08:00
end
2016-07-21 19:11:15 +08:00
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
2016-02-12 23:52:43 +08:00
# Create steps for given module
def generate_module_steps(my_module, step_names, step_descriptions)
step_names.each_with_index do |name, i|
2016-07-21 19:11:15 +08:00
created_at = generate_random_time(my_module.created_at, 5.hours)
2016-02-12 23:52:43 +08:00
completed = rand <= 0.3
2017-01-25 17:24:50 +08:00
completed_on = nil
completed_on = generate_random_time(created_at, 10.hours) if completed
2016-02-12 23:52:43 +08:00
step = Step.create(
created_at: created_at,
name: name,
description: step_descriptions[i],
position: i,
completed: completed,
user: @user,
2016-07-21 19:11:15 +08:00
protocol: my_module.protocol,
2016-02-12 23:52:43 +08:00
completed_on: completed_on
)
2017-01-25 17:24:50 +08:00
if completed
2016-02-12 23:52:43 +08:00
# Also add random comments to completed steps
if rand < 0.3
2017-01-25 17:24:50 +08:00
polite_comment = 'This looks well.'
2016-02-12 23:52:43 +08:00
elsif rand < 0.4
polite_comment = 'Great job!'
2016-02-12 23:52:43 +08:00
elsif rand < 0.4
polite_comment = 'Thanks for getting this done.'
2016-02-12 23:52:43 +08:00
end
if polite_comment
2016-07-21 19:11:15 +08:00
commented_on = generate_random_time(completed_on)
generate_step_comment(
step,
@user,
polite_comment,
commented_on
2016-02-12 23:52:43 +08:00
)
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
)
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
)
end
def generate_result_comment(result, user, message, created_at = nil)
created_at ||= generate_random_time(result.created_at, 1.days)
2019-02-05 18:15:16 +08:00
ResultComment.create(
user: user,
message: message,
created_at: created_at,
result: result
)
end
def generate_step_comment(step, user, message, created_at = nil)
created_at ||= generate_random_time(step.created_at, 2.hours)
2019-02-05 18:15:16 +08:00
StepComment.create(
user: user,
message: message,
created_at: created_at,
step: step
)
end
def smart_annotate_rep_item(item)
"#{item.name}~rep_item~#{Base62.encode(item.id)}"
end
2016-07-21 19:11:15 +08:00
end