mirror of
https://github.com/scinote-eln/scinote-web.git
synced 2024-11-16 06:06:56 +08:00
823 lines
25 KiB
Ruby
823 lines
25 KiB
Ruby
class Experiment < ActiveRecord::Base
|
|
include ArchivableModel, SearchableModel
|
|
|
|
belongs_to :project, inverse_of: :experiments
|
|
belongs_to :created_by, foreign_key: :created_by_id, class_name: 'User'
|
|
belongs_to :last_modified_by, foreign_key: :last_modified_by_id,
|
|
class_name: 'User'
|
|
belongs_to :archived_by, foreign_key: :archived_by_id, class_name: 'User'
|
|
belongs_to :restored_by, foreign_key: :restored_by_id, class_name: 'User'
|
|
|
|
has_many :my_modules, inverse_of: :experiment, dependent: :destroy
|
|
has_many :my_module_groups, inverse_of: :experiment, dependent: :destroy
|
|
has_many :report_elements, inverse_of: :experiment, dependent: :destroy
|
|
|
|
has_attached_file :workflowimg
|
|
validates_attachment :workflowimg,
|
|
content_type: { content_type: ['image/png'] },
|
|
if: :workflowimg_check
|
|
|
|
auto_strip_attributes :name, :description, nullify: false
|
|
validates :name,
|
|
length: { minimum: Constants::NAME_MIN_LENGTH,
|
|
maximum: Constants::NAME_MAX_LENGTH },
|
|
uniqueness: { scope: :project, case_sensitive: false }
|
|
validates :description, length: { maximum: Constants::TEXT_MAX_LENGTH }
|
|
validates :project, presence: true
|
|
validates :created_by, presence: true
|
|
validates :last_modified_by, presence: true
|
|
with_options if: :archived do |experiment|
|
|
experiment.validates :archived_by, presence: true
|
|
experiment.validates :archived_on, presence: true
|
|
end
|
|
|
|
scope :is_archived, ->(is_archived) { where("archived = ?", is_archived) }
|
|
|
|
def self.search(
|
|
user,
|
|
include_archived,
|
|
query = nil,
|
|
page = 1,
|
|
current_organization = nil
|
|
)
|
|
project_ids =
|
|
Project
|
|
.search(user, include_archived, nil, Constants::SEARCH_NO_LIMIT)
|
|
.select('id')
|
|
|
|
if query
|
|
a_query = '%' + query.strip.gsub("_","\\_").gsub("%","\\%") + '%'
|
|
else
|
|
a_query = query
|
|
end
|
|
|
|
if current_organization
|
|
projects_ids =
|
|
Project
|
|
.search(user,
|
|
include_archived,
|
|
nil,
|
|
1,
|
|
current_organization)
|
|
.select('id')
|
|
|
|
new_query =
|
|
Experiment
|
|
.where('experiments.project_id IN (?)', projects_ids)
|
|
.where_attributes_like([:name], a_query)
|
|
.limit(Constants::ATWHO_SEARCH_LIMIT)
|
|
return new_query
|
|
elsif include_archived
|
|
new_query =
|
|
Experiment
|
|
.where(project: project_ids)
|
|
.where_attributes_like([:name, :description], a_query)
|
|
else
|
|
new_query =
|
|
Experiment
|
|
.is_archived(false)
|
|
.where(project: project_ids)
|
|
.where_attributes_like([:name, :description], a_query)
|
|
end
|
|
|
|
# Show all results if needed
|
|
if page == Constants::SEARCH_NO_LIMIT
|
|
new_query
|
|
else
|
|
new_query
|
|
.limit(Constants::SEARCH_LIMIT)
|
|
.offset((page - 1) * Constants::SEARCH_LIMIT)
|
|
end
|
|
end
|
|
|
|
def modules_without_group
|
|
MyModule.where(experiment_id: id).where(my_module_group: nil)
|
|
.where(archived: false)
|
|
end
|
|
|
|
def active_module_groups
|
|
self.my_module_groups.joins(:my_modules)
|
|
.where('my_modules.archived = ?', false)
|
|
.distinct
|
|
end
|
|
|
|
def active_modules
|
|
my_modules.where(:archived => false)
|
|
end
|
|
|
|
def archived_modules
|
|
my_modules.where(:archived => true)
|
|
end
|
|
|
|
def assigned_samples
|
|
Sample.joins(:my_modules).where(my_modules: {id: my_modules} )
|
|
end
|
|
|
|
def unassigned_samples(assigned_samples)
|
|
Sample.where(organization_id: organization).where.not(id: assigned_samples)
|
|
end
|
|
|
|
def update_canvas(
|
|
to_archive,
|
|
to_add,
|
|
to_rename,
|
|
to_move,
|
|
to_move_groups,
|
|
to_clone,
|
|
connections,
|
|
positions,
|
|
current_user,
|
|
module_groups
|
|
)
|
|
cloned_modules = []
|
|
begin
|
|
Experiment.transaction do
|
|
# First, add new modules
|
|
new_ids, cloned_pairs, originals = add_modules(
|
|
to_add, to_clone, current_user)
|
|
cloned_modules = cloned_pairs.collect { |mn, _| mn }
|
|
|
|
# Rename modules
|
|
rename_modules(to_rename)
|
|
|
|
# Add activities that modules were created
|
|
originals.each do |m|
|
|
Activity.create(
|
|
type_of: :create_module,
|
|
user: current_user,
|
|
project: self.project,
|
|
my_module: m,
|
|
message: I18n.t(
|
|
"activities.create_module",
|
|
user: current_user.full_name,
|
|
module: m.name
|
|
)
|
|
)
|
|
end
|
|
|
|
# Add activities that modules were cloned
|
|
cloned_pairs.each do |mn, mo|
|
|
Activity.create(
|
|
type_of: :clone_module,
|
|
project: mn.experiment.project,
|
|
my_module: mn,
|
|
user: current_user,
|
|
message: I18n.t(
|
|
"activities.clone_module",
|
|
user: current_user.full_name,
|
|
module_new: mn.name,
|
|
module_original: mo.name
|
|
)
|
|
)
|
|
end
|
|
|
|
# Then, archive modules that need to be archived
|
|
archive_modules(to_archive, current_user)
|
|
|
|
# Update connections, positions & module group variables
|
|
# with actual IDs retrieved from the new modules creation
|
|
updated_to_move = {}
|
|
to_move.each do |id, value|
|
|
updated_to_move[new_ids.fetch(id, id)] = value
|
|
end
|
|
updated_to_move_groups = {}
|
|
to_move_groups.each do |ids, value|
|
|
mapped = []
|
|
ids.each do |id|
|
|
mapped << new_ids.fetch(id, id)
|
|
end
|
|
updated_to_move_groups[mapped] = value
|
|
end
|
|
updated_connections = []
|
|
connections.each do |a,b|
|
|
updated_connections << [new_ids.fetch(a, a), new_ids.fetch(b, b)]
|
|
end
|
|
updated_positions = Hash.new
|
|
positions.each do |id, pos|
|
|
updated_positions[new_ids.fetch(id, id)] = pos
|
|
end
|
|
updated_module_groups = {}
|
|
module_groups.each do |id, name|
|
|
updated_module_groups[new_ids.fetch(id, id)] = name
|
|
end
|
|
|
|
# Update connections
|
|
update_module_connections(updated_connections)
|
|
|
|
# Update module positions (no validation needed here)
|
|
update_module_positions(updated_positions)
|
|
|
|
# Normalize module positions
|
|
normalize_module_positions
|
|
|
|
# Finally, update module groups
|
|
update_module_groups(updated_module_groups, current_user)
|
|
|
|
# Finally move any modules to another experiment
|
|
move_modules(updated_to_move)
|
|
|
|
# Everyhing is set, now we can move any module groups
|
|
move_module_groups(updated_to_move_groups)
|
|
end
|
|
rescue ActiveRecord::ActiveRecordError, ArgumentError, ActiveRecord::RecordNotSaved
|
|
return false
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
# This method generate the workflow image and saves it as
|
|
# experiment attachment
|
|
def generate_workflow_img
|
|
require 'graphviz'
|
|
|
|
graph = GraphViz.new(:G,
|
|
type: :digraph,
|
|
use: :neato)
|
|
|
|
graph[:size] = '4,4'
|
|
graph.node[color: Constants::COLOR_ALTO,
|
|
style: :filled,
|
|
fontcolor: Constants::COLOR_EMPEROR,
|
|
shape: 'circle',
|
|
fontname: 'Arial',
|
|
fontsize: '16.0']
|
|
|
|
graph.edge[color: Constants::COLOR_ALTO]
|
|
|
|
label = ''
|
|
subg = {}
|
|
|
|
# Draw orphan modules
|
|
if modules_without_group
|
|
modules_without_group.each do |my_module|
|
|
graph
|
|
.subgraph(rank: 'same')
|
|
.add_nodes("Orphan-#{my_module.id}",
|
|
label: label,
|
|
pos: "#{my_module.x / 10},-#{my_module.y / 10}!")
|
|
end
|
|
end
|
|
|
|
# Draw grouped modules
|
|
if my_module_groups.many?
|
|
my_module_groups.each_with_index do |group, gindex|
|
|
subgraph_name = "cluster-#{gindex}"
|
|
subg[subgraph_name] = graph.subgraph(rank: 'same')
|
|
group.ordered_modules.each_with_index do |my_module, index|
|
|
if my_module.outputs.any?
|
|
parent = subg[subgraph_name]
|
|
.add_nodes("#{subgraph_name}-#{index}",
|
|
label: label,
|
|
pos: "#{my_module.x / 10},-#{my_module.y / 10}!")
|
|
|
|
my_module.outputs.each_with_index do |output, i|
|
|
child_mod = MyModule.find_by_id(output.input_id)
|
|
child_node = subg[subgraph_name]
|
|
.add_nodes("#{subgraph_name}-O#{child_mod.id}-#{i}",
|
|
label: label,
|
|
pos: "#{child_mod.x / 10},-#{child_mod.y / 10}!")
|
|
|
|
subg[subgraph_name].add_edges(parent, child_node)
|
|
end
|
|
elsif my_module.inputs.any?
|
|
parent = subg[subgraph_name]
|
|
.add_nodes("#{subgraph_name}-#{index}",
|
|
label: label,
|
|
pos: "#{my_module.x / 10},-#{my_module.y / 10}!")
|
|
|
|
my_module.inputs.each_with_index do |input, i|
|
|
child_mod = MyModule.find_by_id(input.output_id)
|
|
child_node = subg[subgraph_name]
|
|
.add_nodes("#{subgraph_name}-I#{child_mod.id}-#{i}",
|
|
label: label,
|
|
pos: "#{child_mod.x / 10},-#{child_mod.y / 10}!")
|
|
|
|
subg[subgraph_name].add_edges(child_node, parent)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
else
|
|
my_module_groups.each do |group|
|
|
group.ordered_modules.each_with_index do |my_module, index|
|
|
if my_module.outputs.any?
|
|
parent = graph.add_nodes("N-#{index}",
|
|
label: label,
|
|
pos: "#{my_module.x / 10},-#{ my_module.y / 10}!")
|
|
|
|
my_module.outputs.each_with_index do |output, i|
|
|
child_mod = MyModule.find_by_id(output.input_id)
|
|
child_node = graph
|
|
.add_nodes("N-O#{child_mod.id}-#{i}",
|
|
label: label,
|
|
pos: "#{child_mod.x / 10},-#{child_mod.y / 10}!")
|
|
graph.add_edges(parent, child_node)
|
|
end
|
|
elsif my_module.inputs.any?
|
|
parent = graph.add_nodes("N-#{index}",
|
|
label: label,
|
|
pos: "#{my_module.x / 10},-#{my_module.y / 10}!")
|
|
my_module.inputs.each_with_index do |input, i|
|
|
child_mod = MyModule.find_by_id(input.output_id)
|
|
child_node = graph
|
|
.add_nodes("N-I#{child_mod.id}-#{i}",
|
|
label: label,
|
|
pos: "#{child_mod.x / 10},-#{child_mod.y / 10}!")
|
|
graph.add_edges(child_node, parent)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
file_location = Tempfile.open(['wimg', '.png'],
|
|
Rails.root.join('tmp'))
|
|
|
|
graph.output(png: file_location.path)
|
|
|
|
begin
|
|
file = File.open(file_location)
|
|
self.workflowimg = file
|
|
file.close
|
|
save
|
|
touch(:workflowimg_updated_at)
|
|
rescue => ex
|
|
logger.error ex.message
|
|
end
|
|
end
|
|
|
|
# Clone this experiment to given project
|
|
def deep_clone_to_project(current_user, project)
|
|
# First we have to find unique name for our little experiment
|
|
experiment_names = project.experiments.map(&:name)
|
|
format = 'Clone %d - %s'
|
|
|
|
i = 1
|
|
i += 1 while experiment_names.include?(format(format, i, name))
|
|
|
|
clone = Experiment.new(
|
|
name: format(format, i, name),
|
|
description: description,
|
|
created_by: current_user,
|
|
last_modified_by: current_user,
|
|
project: project
|
|
)
|
|
|
|
# Copy all workflows
|
|
my_module_groups.each do |g|
|
|
clone.my_module_groups << g.deep_clone_to_experiment(current_user, clone)
|
|
end
|
|
|
|
# Copy modules without group
|
|
clone.my_modules << modules_without_group.map do |m|
|
|
m.deep_clone_to_experiment(current_user, clone)
|
|
end
|
|
clone.save
|
|
|
|
# Create workflow image
|
|
clone.delay.generate_workflow_img
|
|
|
|
clone
|
|
end
|
|
|
|
def move_to_project(project)
|
|
self.project = project
|
|
|
|
my_modules.each do |m|
|
|
new_tags = []
|
|
m.tags.each do |t|
|
|
new_tags << t.deep_clone_to_project(project)
|
|
end
|
|
m.my_module_tags.destroy_all
|
|
|
|
project.tags << new_tags
|
|
m.tags << new_tags
|
|
end
|
|
result = save
|
|
touch(:workflowimg_updated_at) if result
|
|
result
|
|
end
|
|
|
|
# Get projects where user is either owner or user in the same organization
|
|
# as this experiment
|
|
def projects_with_role_above_user(current_user)
|
|
organization = project.organization
|
|
projects = organization.projects.where(archived: false)
|
|
|
|
current_user.user_projects
|
|
.where(project: projects)
|
|
.where('role < 2')
|
|
.map(&:project)
|
|
end
|
|
|
|
# Projects to which this experiment can be moved (inside the same
|
|
# organization and not archived), all users assigned on experiment.project has
|
|
# to be assigned on such project
|
|
def moveable_projects(current_user)
|
|
projects = projects_with_role_above_user(current_user)
|
|
|
|
projects = projects.each_with_object([]) do |p, arr|
|
|
arr << p if (project.users - p.users).empty?
|
|
arr
|
|
end
|
|
projects - [project]
|
|
end
|
|
|
|
private
|
|
|
|
# Archive all modules. Receives an array of module integer IDs.
|
|
def archive_modules(module_ids)
|
|
module_ids.each do |m_id|
|
|
my_module = self.my_modules.find_by_id(m_id)
|
|
unless my_module.blank?
|
|
my_module.archive!
|
|
end
|
|
end
|
|
modules.reload
|
|
end
|
|
|
|
# Archive all modules. Receives an array of module integer IDs and current user.
|
|
def archive_modules(module_ids, current_user)
|
|
module_ids.each do |m_id|
|
|
my_module = self.my_modules.find_by_id(m_id)
|
|
unless my_module.blank?
|
|
my_module.archive!(current_user)
|
|
end
|
|
end
|
|
my_modules.reload
|
|
end
|
|
|
|
# Add modules, and returns a map of "virtual" IDs with
|
|
# actual IDs of saved modules.
|
|
# to_add is an array of hashes, each containing 'name',
|
|
# 'x', 'y' and 'id'.
|
|
# to_clone is a hash, storing new cloned modules as keys,
|
|
# and original modules as values.
|
|
def add_modules(to_add, to_clone, current_user)
|
|
originals = []
|
|
cloned_pairs = {}
|
|
ids_map = Hash.new
|
|
to_add.each do |m|
|
|
original = MyModule.find_by_id(to_clone.fetch(m[:id], nil))
|
|
if original.present? then
|
|
my_module = original.deep_clone(current_user)
|
|
cloned_pairs[my_module] = original
|
|
else
|
|
my_module = MyModule.new(
|
|
experiment: self)
|
|
originals << my_module
|
|
end
|
|
|
|
my_module.name = m[:name]
|
|
my_module.x = m[:x]
|
|
my_module.y = m[:y]
|
|
my_module.created_by = current_user
|
|
my_module.last_modified_by = current_user
|
|
my_module.save!
|
|
|
|
ids_map[m[:id]] = my_module.id.to_s
|
|
end
|
|
my_modules.reload
|
|
return ids_map, cloned_pairs, originals
|
|
end
|
|
|
|
# Rename modules; this method accepts a map where keys
|
|
# represent IDs of modules, and values new names for
|
|
# such modules. If a module with given ID doesn't exist,
|
|
# it's obviously not updated.
|
|
def rename_modules(to_rename)
|
|
to_rename.each do |id, new_name|
|
|
my_module = MyModule.find_by_id(id)
|
|
if my_module.present?
|
|
my_module.name = new_name
|
|
my_module.save!
|
|
end
|
|
end
|
|
end
|
|
|
|
# Move modules; this method accepts a map where keys
|
|
# represent IDs of modules, and values represent experiment
|
|
# IDs of new names to which the given modules should be moved.
|
|
# If a module with given ID doesn't exist (or experiment ID)
|
|
# it's obviously not updated. Any connection on module is destroyed.
|
|
def move_modules(to_move)
|
|
to_move.each do |id, experiment_id|
|
|
my_module = my_modules.find_by_id(id)
|
|
experiment = project.experiments.find_by_id(experiment_id)
|
|
next unless my_module.present? && experiment.present?
|
|
|
|
my_module.experiment = experiment
|
|
|
|
# Calculate new module position
|
|
new_pos = my_module.get_new_position
|
|
my_module.x = new_pos[:x]
|
|
my_module.y = new_pos[:y]
|
|
|
|
unless my_module.outputs.destroy_all && my_module.inputs.destroy_all
|
|
raise ActiveRecord::ActiveRecordError
|
|
end
|
|
|
|
my_module.save
|
|
end
|
|
|
|
# Generate workflow image for the experiment in which we moved the task
|
|
generate_workflow_img_for_moved_modules(to_move)
|
|
end
|
|
|
|
# Move module groups; this method accepts a map where keys
|
|
# represent IDs of modules which are in module group,
|
|
# and values represent experiment
|
|
# IDs of new names to which the given module group should be moved.
|
|
# If a module with given ID doesn't exist (or experiment ID)
|
|
# it's obviously not updated. Position for entire module group is updated
|
|
# to bottom left corner.
|
|
def move_module_groups(to_move)
|
|
to_move.each do |ids, experiment_id|
|
|
modules = my_modules.where(id: ids)
|
|
groups = Set.new(modules.map(&:my_module_group))
|
|
experiment = project.experiments.find_by_id(experiment_id)
|
|
|
|
groups.each do |group|
|
|
next unless group && experiment.present?
|
|
|
|
# Find the lowest point for current modules(max_y) and the leftmost
|
|
# module(min_x)
|
|
if experiment.active_modules.empty?
|
|
max_y = 0
|
|
min_x = 0
|
|
else
|
|
max_y = experiment.active_modules.maximum(:y) + MyModule::HEIGHT
|
|
min_x = experiment.active_modules.minimum(:x)
|
|
end
|
|
|
|
# Set new positions
|
|
curr_min_x = modules.min_by(&:x).x
|
|
curr_min_y = modules.min_by(&:y).y
|
|
modules.each { |m| m.x += -curr_min_x + min_x }
|
|
modules.each { |m| m.y += -curr_min_y + max_y }
|
|
|
|
modules.each do |m|
|
|
m.experiment = experiment
|
|
m.save!
|
|
end
|
|
|
|
group.experiment = experiment
|
|
group.save!
|
|
end
|
|
end
|
|
|
|
# Generate workflow image for the experiment in which we moved the workflow
|
|
generate_workflow_img_for_moved_modules(to_move)
|
|
end
|
|
|
|
# Generates workflow img when the workflow or module is moved
|
|
# to other experiment
|
|
def generate_workflow_img_for_moved_modules(to_move)
|
|
to_move.values.uniq.each do |id|
|
|
experiment = Experiment.find_by_id(id)
|
|
next unless experiment
|
|
experiment.delay.generate_workflow_img
|
|
end
|
|
end
|
|
|
|
# Update connections for all modules in this project.
|
|
# Input is an array of arrays, where first element represents
|
|
# source node, and second element represents target node.
|
|
# Example input: [ [1, 2], [2, 3], [4, 5], [2, 5] ]
|
|
def update_module_connections(connections)
|
|
require 'rgl/base'
|
|
require 'rgl/adjacency'
|
|
require 'rgl/topsort'
|
|
|
|
dg = RGL::DirectedAdjacencyGraph.new
|
|
connections.each do |a,b|
|
|
# Check if both vertices exist
|
|
if (my_modules.find_all {|m| [a.to_i, b.to_i].include? m.id }).count == 2
|
|
dg.add_edge(a, b)
|
|
end
|
|
end
|
|
|
|
# Check if cycles exist!
|
|
topsort = dg.topsort_iterator.to_a
|
|
if topsort.length == 0 and dg.edges.size > 1
|
|
raise ArgumentError, "Cycles exist."
|
|
end
|
|
|
|
# First, delete existing connections
|
|
# but keep a copy of previous state
|
|
previous_sources = {}
|
|
previous_sources.default = []
|
|
my_modules.each do |m|
|
|
previous_sources[m.id] = []
|
|
m.inputs.each do |c|
|
|
previous_sources[m.id] << c.from
|
|
end
|
|
end
|
|
self.my_modules.each do |m|
|
|
unless m.outputs.destroy_all
|
|
raise ActiveRecord::ActiveRecordError
|
|
end
|
|
end
|
|
|
|
|
|
# Add new connections
|
|
filtered_edges = dg.edges.collect { |e| [e.source, e.target] }
|
|
filtered_edges.each do |a, b|
|
|
Connection.create!(:input_id => b, :output_id => a)
|
|
end
|
|
|
|
# Unassign samples from former downstream modules
|
|
# for all destroyed connections
|
|
unassign_samples_from_old_downstream_modules(previous_sources)
|
|
|
|
visited = []
|
|
# Assign samples to all new downstream modules
|
|
filtered_edges.each do |a, b|
|
|
source = self.my_modules.find(a.to_i)
|
|
target = self.my_modules.find(b.to_i)
|
|
# Do this only for new edges
|
|
if previous_sources[target.id].exclude?(source)
|
|
# Go as high upstream as new edges take us
|
|
# and then assign samples to all downsteam samples
|
|
assign_samples_to_new_downstream_modules(previous_sources, visited, source)
|
|
end
|
|
end
|
|
|
|
# Save topological order of modules (for modules without workflow,
|
|
# leave them unordered)
|
|
self.my_modules.each do |m|
|
|
if topsort.include? m.id.to_s
|
|
m.workflow_order = topsort.find_index(m.id.to_s)
|
|
else
|
|
m.workflow_order = -1
|
|
end
|
|
m.save!
|
|
end
|
|
|
|
# Make sure to reload my modules, which now have updated connections and samples
|
|
self.my_modules.reload
|
|
true
|
|
end
|
|
|
|
# When connections are deleted, unassign samples that
|
|
# are not inherited anymore
|
|
def unassign_samples_from_old_downstream_modules(sources)
|
|
self.my_modules.each do |my_module|
|
|
sources[my_module.id].each do |s|
|
|
# Only do this for newly deleted connections
|
|
if s.outputs.map{|i| i.to}.exclude? my_module
|
|
my_module.get_downstream_modules.each do |dm|
|
|
# Get unique samples for all upstream modules
|
|
um = dm.get_upstream_modules
|
|
um.shift # remove current module
|
|
ums = um.map{|m| m.samples}.flatten.uniq
|
|
s.samples.each do |sample|
|
|
dm.samples.delete(sample) if ums.exclude? sample
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
# Assign samples to new connections recursively
|
|
def assign_samples_to_new_downstream_modules(sources, visited, my_module)
|
|
# If samples are already assigned for this module, stop going upstream
|
|
if visited.include? (my_module)
|
|
return
|
|
end
|
|
visited << my_module
|
|
# Edge case, when module is source or it doesn't have any new input connections
|
|
if my_module.inputs.blank? or (
|
|
my_module.inputs.map{|c| c.from} -
|
|
sources[my_module.id]
|
|
).empty?
|
|
my_module.get_downstream_modules.each do |dm|
|
|
new_samples = my_module.samples.select { |el| dm.samples.exclude?(el) }
|
|
dm.samples.push(*new_samples)
|
|
end
|
|
else
|
|
my_module.inputs.each do |input|
|
|
# Go upstream for new in connections
|
|
if sources[my_module.id].exclude?(input.from)
|
|
assign_samples_to_new_downstream_modules(input.from)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
# Updates positions of modules.
|
|
# Input is a map where keys are module IDs, and values are
|
|
# hashes like { x: <x>, y: <y> }.
|
|
def update_module_positions(positions)
|
|
positions.each do |id, pos|
|
|
unless MyModule.update(id, x: pos[:x], y: pos[:y])
|
|
raise ActiveRecord::ActiveRecordError
|
|
end
|
|
end
|
|
self.my_modules.reload
|
|
end
|
|
|
|
# Normalize module positions in this project.
|
|
def normalize_module_positions
|
|
# This method normalizes module positions so x-s and y-s
|
|
# are all positive
|
|
x_diff = (self.my_modules.collect { |m| m.x }).min
|
|
y_diff = (self.my_modules.collect { |m| m.y }).min
|
|
|
|
self.my_modules.each do |m|
|
|
unless
|
|
m.update_attribute(:x, m.x - x_diff) and
|
|
m.update_attribute(:y, m.y - y_diff)
|
|
raise ActiveRecord::ActiveRecordError
|
|
end
|
|
end
|
|
end
|
|
|
|
# Recalculate module groups in this project. Input is
|
|
# a hash of module ids and their corresponding module names.
|
|
def update_module_groups(module_groups, current_user)
|
|
require 'rgl/base'
|
|
require 'rgl/adjacency'
|
|
require 'rgl/connected_components'
|
|
|
|
dg = RGL::DirectedAdjacencyGraph[]
|
|
group_ids = Set.new
|
|
active_modules.each do |m|
|
|
unless m.my_module_group.blank?
|
|
group_ids << m.my_module_group.id
|
|
end
|
|
unless dg.has_vertex? m.id
|
|
dg.add_vertex m.id
|
|
end
|
|
m.outputs.each do |o|
|
|
dg.add_edge m.id, o.to.id
|
|
end
|
|
end
|
|
workflows = []
|
|
dg.to_undirected.each_connected_component { |w| workflows << w }
|
|
|
|
# Retrieve maximum allowed module group name
|
|
max_length = (MyModuleGroup.validators_on(:name).select { |v| v.class == ActiveModel::Validations::LengthValidator }).first.options[:maximum]
|
|
# For each workflow, generate new names
|
|
new_index = 1
|
|
wf_names = []
|
|
suffix = I18n.t("my_module_groups.new.suffix")
|
|
cut_index = -(suffix.length + 1)
|
|
workflows.each do |w|
|
|
modules = MyModule.find(w)
|
|
|
|
# Get an array of module names
|
|
names = []
|
|
modules.each do |m|
|
|
names << module_groups.fetch(m.id.to_s, "")
|
|
end
|
|
names = names.uniq
|
|
name = (names.select { |v| v != "" }).join(", ")
|
|
|
|
if w.length <= 1
|
|
name = nil
|
|
elsif name.blank?
|
|
name = I18n.t("my_module_groups.new.name", index: new_index)
|
|
new_index += 1
|
|
while MyModuleGroup.find_by(name: name).present?
|
|
name = I18n.t("my_module_groups.new.name", index: new_index)
|
|
new_index += 1
|
|
end
|
|
elsif name.length > max_length
|
|
# If length is too long, shorten it
|
|
name = name[0..(max_length + cut_index)] + suffix
|
|
end
|
|
|
|
wf_names << name
|
|
end
|
|
|
|
# Remove any existing module groups from modules
|
|
unless MyModuleGroup.destroy_all(:id => group_ids.to_a)
|
|
raise ActiveRecord::ActiveRecordError
|
|
end
|
|
|
|
# Second, create new groups
|
|
workflows.each_with_index do |w, i|
|
|
# Single modules are not considered part of any workflow
|
|
if w.length > 1
|
|
group = MyModuleGroup.new(
|
|
name: wf_names[i],
|
|
experiment: self,
|
|
my_modules: MyModule.find(w))
|
|
group.created_by = current_user
|
|
group.save!
|
|
end
|
|
end
|
|
|
|
my_module_groups.reload
|
|
true
|
|
end
|
|
|
|
def workflowimg_check
|
|
workflowimg_content_type
|
|
rescue
|
|
false
|
|
end
|
|
end
|