scinote-web/app/models/protocol.rb

684 lines
19 KiB
Ruby
Raw Normal View History

2016-07-21 19:11:15 +08:00
class Protocol < ActiveRecord::Base
include SearchableModel
include RenamingUtil
after_save :update_linked_children
after_destroy :decrement_linked_children
enum protocol_type: {
unlinked: 0,
linked: 1,
in_repository_private: 2,
in_repository_public: 3,
in_repository_archived: 4
}
auto_strip_attributes :name, :description, nullify: false
# Name is required when its actually specified (i.e. :in_repository? is true)
validates :name, length: { maximum: Constants::NAME_MAX_LENGTH }
validates :description, length: { maximum: Constants::TEXT_MAX_LENGTH }
2017-01-24 23:34:21 +08:00
validates :team, presence: true
2016-07-21 19:11:15 +08:00
validates :protocol_type, presence: true
with_options if: :in_module? do |protocol|
protocol.validates :my_module, presence: true
protocol.validates :published_on, absence: true
protocol.validates :archived_by, absence: true
protocol.validates :archived_on, absence: true
end
with_options if: :linked? do |protocol|
protocol.validates :added_by, presence: true
protocol.validates :parent, presence: true
protocol.validates :parent_updated_at, presence: true
end
with_options if: :in_repository? do |protocol|
protocol.validates :name, presence: true
protocol.validates :added_by, presence: true
protocol.validates :my_module, absence: true
protocol.validates :parent, absence: true
protocol.validates :parent_updated_at, absence: true
end
with_options if: :in_repository_public? do |protocol|
2017-01-24 23:34:21 +08:00
# Public protocol must have unique name inside its team
2017-01-31 20:33:55 +08:00
protocol
.validates_uniqueness_of :name,
scope: :team,
conditions: -> {
where(
protocol_type:
Protocol
.protocol_types[:in_repository_public]
)
}
2016-07-21 19:11:15 +08:00
protocol.validates :published_on, presence: true
end
with_options if: :in_repository_private? do |protocol|
2017-01-24 23:34:21 +08:00
# Private protocol must have unique name inside its team & user scope
2017-01-31 20:33:55 +08:00
protocol
.validates_uniqueness_of :name,
scope: [:team, :added_by],
conditions: -> {
where(
protocol_type:
Protocol
.protocol_types[:in_repository_private]
)
}
2016-07-21 19:11:15 +08:00
end
with_options if: :in_repository_archived? do |protocol|
2017-01-24 23:34:21 +08:00
# Archived protocol must have unique name inside its team & user scope
2017-01-31 20:33:55 +08:00
protocol
.validates_uniqueness_of :name,
scope: [:team, :added_by],
conditions: -> {
where(
protocol_type:
Protocol
.protocol_types[:in_repository_archived]
)
}
2016-07-21 19:11:15 +08:00
protocol.validates :archived_by, presence: true
protocol.validates :archived_on, presence: true
end
2017-01-31 20:33:55 +08:00
belongs_to :added_by,
foreign_key: 'added_by_id',
class_name: 'User',
inverse_of: :added_protocols
2016-07-21 19:11:15 +08:00
belongs_to :my_module, inverse_of: :protocols
2017-01-24 23:34:21 +08:00
belongs_to :team, inverse_of: :protocols
2016-07-21 19:11:15 +08:00
belongs_to :parent, foreign_key: 'parent_id', class_name: 'Protocol'
2017-01-31 20:33:55 +08:00
belongs_to :archived_by,
foreign_key: 'archived_by_id',
class_name: 'User',
inverse_of: :archived_protocols
belongs_to :restored_by,
foreign_key: 'restored_by_id',
class_name: 'User',
inverse_of: :restored_protocols
has_many :linked_children,
class_name: 'Protocol',
foreign_key: 'parent_id'
has_many :protocol_protocol_keywords,
inverse_of: :protocol,
dependent: :destroy
2016-07-21 19:11:15 +08:00
has_many :protocol_keywords, through: :protocol_protocol_keywords
has_many :steps, inverse_of: :protocol, dependent: :destroy
2017-05-05 22:41:23 +08:00
def self.search(user,
include_archived,
query = nil,
page = 1,
_current_team = nil,
options = {})
2017-01-31 20:33:55 +08:00
team_ids = Team.joins(:user_teams)
.where('user_teams.user_id = ?', user.id)
.distinct
2017-04-11 20:55:44 +08:00
.pluck(:id)
2017-01-31 20:33:55 +08:00
module_ids = MyModule.search(user,
include_archived,
nil,
Constants::SEARCH_NO_LIMIT)
2017-04-11 20:55:44 +08:00
.pluck(:id)
2016-07-21 19:11:15 +08:00
where_str =
2017-01-31 20:33:55 +08:00
'(protocol_type IN (?) AND my_module_id IN (?)) OR ' \
'(protocol_type = ? AND protocols.team_id IN (?) AND ' \
'added_by_id = ?) OR (protocol_type = ? AND protocols.team_id IN (?))'
2016-07-21 19:11:15 +08:00
if include_archived
where_str +=
2017-01-31 20:33:55 +08:00
' OR (protocol_type = ? AND protocols.team_id IN (?) ' \
'AND added_by_id = ?)'
2016-07-21 19:11:15 +08:00
new_query = Protocol
2017-01-31 20:33:55 +08:00
.where(
where_str,
[Protocol.protocol_types[:unlinked],
Protocol.protocol_types[:linked]],
module_ids,
Protocol.protocol_types[:in_repository_private],
team_ids,
user.id,
Protocol.protocol_types[:in_repository_public],
team_ids,
Protocol.protocol_types[:in_repository_archived],
team_ids,
user.id
)
2016-07-21 19:11:15 +08:00
else
new_query = Protocol
2017-01-31 20:33:55 +08:00
.where(
where_str,
[Protocol.protocol_types[:unlinked],
Protocol.protocol_types[:linked]],
module_ids,
Protocol.protocol_types[:in_repository_private],
team_ids,
user.id,
Protocol.protocol_types[:in_repository_public],
team_ids
)
2016-07-21 19:11:15 +08:00
end
new_query = new_query
2017-01-31 20:33:55 +08:00
.distinct
.joins('LEFT JOIN protocol_protocol_keywords ON ' \
'protocols.id = protocol_protocol_keywords.protocol_id')
.joins('LEFT JOIN protocol_keywords ' \
'ON protocol_keywords.id = ' \
'protocol_protocol_keywords.protocol_keyword_id')
.where_attributes_like(
[
'protocols.name',
'protocols.description',
'protocols.authors',
'protocol_keywords.name'
],
2017-05-05 22:41:23 +08:00
query, options
2017-01-31 20:33:55 +08:00
)
2016-07-21 19:11:15 +08:00
# Show all results if needed
if page == Constants::SEARCH_NO_LIMIT
2016-07-21 19:11:15 +08:00
new_query
else
new_query
.limit(Constants::SEARCH_LIMIT)
.offset((page - 1) * Constants::SEARCH_LIMIT)
2016-07-21 19:11:15 +08:00
end
end
def linked_modules
2016-09-02 17:54:20 +08:00
MyModule.joins(:protocols).where('protocols.parent_id = ?', id)
end
2016-09-05 16:58:37 +08:00
def linked_experiments(linked_mod)
Experiment.where('id IN (?)', linked_mod.pluck(:experiment_id).uniq)
end
2016-09-05 16:58:37 +08:00
def linked_projects(linked_exp)
Project.where('id IN (?)', linked_exp.pluck(:project_id).uniq)
end
2016-07-21 19:11:15 +08:00
def self.new_blank_for_module(my_module)
Protocol.new(
2017-01-24 23:34:21 +08:00
team: my_module.experiment.project.team,
2016-07-21 19:11:15 +08:00
protocol_type: :unlinked,
my_module: my_module
)
end
# Deep-clone given array of assets
2017-01-24 23:34:21 +08:00
def self.deep_clone_assets(assets_to_clone, team)
2016-07-21 19:11:15 +08:00
assets_to_clone.each do |src_id, dest_id|
src = Asset.find_by_id(src_id)
dest = Asset.find_by_id(dest_id)
if src.present? and dest.present? then
# Clone file
dest.file = src.file
dest.save
# Clone extracted text data if it exists
if (atd = src.asset_text_datum).present? then
atd2 = AssetTextDatum.new(
data: atd.data,
asset: dest
)
atd2.save
end
# Update estimated size of cloned asset
# (& file_present flag)
dest.update(
estimated_size: src.estimated_size,
file_present: true
)
2017-01-24 23:34:21 +08:00
# Update team's space taken
team.reload
team.take_space(dest.estimated_size)
team.save
2016-07-21 19:11:15 +08:00
end
end
end
def self.clone_contents(src, dest, current_user, clone_keywords)
assets_to_clone = []
# Update keywords
if clone_keywords then
src.protocol_keywords.each do |keyword|
ProtocolProtocolKeyword.create(
protocol: dest,
protocol_keyword: keyword
)
end
end
# Copy steps
src.steps.each do |step|
step2 = Step.new(
name: step.name,
description: step.description,
position: step.position,
completed: false,
user: current_user,
protocol: dest)
step2.save
# Copy checklists
step.checklists.asc.each do |checklist|
2016-07-21 19:11:15 +08:00
checklist2 = Checklist.new(
name: checklist.name,
step: step2
)
checklist2.created_by = current_user
checklist2.last_modified_by = current_user
checklist2.save
checklist.checklist_items.each do |item|
item2 = ChecklistItem.new(
text: item.text,
checked: false,
checklist: checklist2,
2016-09-22 22:48:15 +08:00
position: item.position
)
2016-07-21 19:11:15 +08:00
item2.created_by = current_user
item2.last_modified_by = current_user
item2.save
end
step2.checklists << checklist2
end
# "Shallow" Copy assets
step.assets.each do |asset|
asset2 = Asset.new_empty(
asset.file_file_name,
asset.file_file_size
)
asset2.created_by = current_user
asset2.team = dest.team
2016-07-21 19:11:15 +08:00
asset2.last_modified_by = current_user
asset2.file_processing = true if asset.is_image?
2016-07-21 19:11:15 +08:00
asset2.save
step2.assets << asset2
if asset.is_image?
asset2.file.delay.reprocess!(:large)
asset2.file.delay.reprocess!(:medium)
end
2016-07-21 19:11:15 +08:00
assets_to_clone << [asset.id, asset2.id]
end
# Copy tables
step.tables.each do |table|
2017-04-18 21:38:11 +08:00
table2 = Table.new(
name: table.name,
contents: table.contents.encode('UTF-8', 'UTF-8')
2017-04-18 21:38:11 +08:00
)
2016-07-21 19:11:15 +08:00
table2.created_by = current_user
table2.last_modified_by = current_user
table2.team = dest.team
2016-07-21 19:11:15 +08:00
step2.tables << table2
end
end
# Call clone helper
Protocol.delay(queue: :assets).deep_clone_assets(
assets_to_clone,
2017-01-24 23:34:21 +08:00
dest.team
2016-07-21 19:11:15 +08:00
)
end
def in_repository_active?
2017-01-31 20:33:55 +08:00
in_repository_private? || in_repository_public?
2016-07-21 19:11:15 +08:00
end
def in_repository?
2017-01-31 20:33:55 +08:00
in_repository_active? || in_repository_archived?
2016-07-21 19:11:15 +08:00
end
def in_module?
2017-01-31 20:33:55 +08:00
unlinked? || linked?
2016-07-21 19:11:15 +08:00
end
def linked_no_diff?
2017-01-31 20:33:55 +08:00
linked? &&
updated_at == parent_updated_at &&
parent.updated_at == parent_updated_at
2016-07-21 19:11:15 +08:00
end
def newer_than_parent?
linked? && parent.updated_at == parent_updated_at &&
2017-01-31 20:33:55 +08:00
updated_at > parent_updated_at
2016-07-21 19:11:15 +08:00
end
def parent_newer?
2017-01-31 20:33:55 +08:00
linked? &&
updated_at == parent_updated_at &&
parent.updated_at > parent_updated_at
2016-07-21 19:11:15 +08:00
end
def parent_and_self_newer?
2017-01-31 20:33:55 +08:00
linked? &&
parent.updated_at > parent_updated_at &&
updated_at > parent_updated_at
2016-07-21 19:11:15 +08:00
end
def number_of_steps
steps.count
end
def completed_steps
steps.where(completed: true)
2016-07-21 19:11:15 +08:00
end
def space_taken
st = 0
self.steps.find_each do |step|
st += step.space_taken
end
st
end
def make_private(user)
# Don't update "updated_at" timestamp
self.record_timestamps = false
self.added_by = user
self.published_on = nil
self.archived_by = nil
self.archived_on = nil
self.restored_by = nil
self.restored_on = nil
self.protocol_type = Protocol.protocol_types[:in_repository_private]
save
end
# This publish action simply moves the protocol from
# the private section in the repository into the public
# section
def publish(user)
# Don't update "updated_at" timestamp
self.record_timestamps = false
self.added_by = user
self.published_on = Time.now
self.archived_by = nil
self.archived_on = nil
self.restored_by = nil
self.restored_on = nil
self.protocol_type = Protocol.protocol_types[:in_repository_public]
save
end
def archive(user)
return nil unless can_destroy?
2016-07-21 19:11:15 +08:00
# Don't update "updated_at" timestamp
self.record_timestamps = false
# We keep published_on present, so we know (upon restoring)
# where the protocol was located
self.archived_by = user
self.archived_on = Time.now
self.restored_by = nil
self.restored_on = nil
self.protocol_type = Protocol.protocol_types[:in_repository_archived]
result = save
# Update all module protocols that had
# parent set to this protocol
if result then
Protocol.where(parent: self).find_each do |p|
p.update(
parent: nil,
parent_updated_at: nil,
protocol_type: :unlinked
)
end
end
result
end
def restore(user)
# Don't update "updated_at" timestamp
self.record_timestamps = false
self.archived_by = nil
self.archived_on = nil
self.restored_by = user
self.restored_on = Time.now
if self.published_on.present?
self.published_on = Time.now
self.protocol_type = Protocol.protocol_types[:in_repository_public]
else
self.protocol_type = Protocol.protocol_types[:in_repository_private]
end
save
end
def update_keywords(keywords)
result = true
begin
Protocol.transaction do
self.record_timestamps = false
# First, destroy all keywords
self.protocol_protocol_keywords.destroy_all
if keywords.present?
keywords.each do |kw_name|
kw = ProtocolKeyword.find_by(name: kw_name)
if kw.blank?
kw = ProtocolKeyword.create(
name: kw_name,
2017-01-24 23:34:21 +08:00
team: self.team
2016-07-21 19:11:15 +08:00
)
end
self.protocol_keywords << kw
end
end
end
rescue
result = false
end
result
end
def unlink
self.parent = nil
self.parent_updated_at = nil
self.protocol_type = Protocol.protocol_types[:unlinked]
self.save!
end
def update_parent(current_user)
# First, destroy parent's step contents
parent.destroy_contents(current_user)
parent.reload
# Now, clone step contents
Protocol.clone_contents(self, self.parent, current_user, false)
# Lastly, update the metadata
parent.reload
parent.record_timestamps = false
parent.updated_at = self.updated_at
parent.save!
self.record_timestamps = false
self.parent_updated_at = self.updated_at
self.save!
end
def update_from_parent(current_user)
# First, destroy step contents
destroy_contents(current_user)
# Now, clone parent's step contents
Protocol.clone_contents(self.parent, self, current_user, false)
# Lastly, update the metadata
self.reload
self.record_timestamps = false
self.updated_at = self.parent.updated_at
self.parent_updated_at = self.parent.updated_at
self.added_by = current_user
self.save!
end
def load_from_repository(source, current_user)
# First, destroy step contents
destroy_contents(current_user)
# Now, clone source's step contents
Protocol.clone_contents(source, self, current_user, false)
# Lastly, update the metadata
self.reload
self.record_timestamps = false
self.updated_at = source.updated_at
self.parent = source
self.parent_updated_at = source.updated_at
self.added_by = current_user
self.protocol_type = Protocol.protocol_types[:linked]
self.save!
end
def copy_to_repository(new_name, new_protocol_type, link_protocols, current_user)
clone = Protocol.new(
name: new_name,
protocol_type: new_protocol_type,
added_by: current_user,
2017-01-24 23:34:21 +08:00
team: self.team
2016-07-21 19:11:15 +08:00
)
if clone.in_repository_public?
clone.published_on = Time.now
end
# Don't proceed further if clone is invalid
if clone.invalid?
return clone
end
# Okay, clone seems to be valid: let's clone it
clone = deep_clone(clone, current_user)
# If the above operation went well, update published_on
# timestamp
if clone.in_repository_public?
clone.update(published_on: Time.now)
end
# Link protocols if neccesary
if link_protocols then
self.reload
self.record_timestamps = false
self.added_by = current_user
self.parent = clone
ts = clone.updated_at
self.parent_updated_at = ts
self.updated_at = ts
self.protocol_type = Protocol.protocol_types[:linked]
self.save!
end
return clone
end
def deep_clone_my_module(my_module, current_user)
clone = Protocol.new_blank_for_module(my_module)
clone.name = self.name
clone.authors = self.authors
clone.description = self.description
clone.protocol_type = self.protocol_type
if self.linked?
clone.added_by = current_user
clone.parent = self.parent
clone.parent_updated_at = self.parent_updated_at
end
deep_clone(clone, current_user)
end
def deep_clone_repository(current_user)
clone = Protocol.new(
name: self.name,
authors: self.authors,
description: self.description,
added_by: current_user,
2017-01-24 23:34:21 +08:00
team: self.team,
2016-07-21 19:11:15 +08:00
protocol_type: self.protocol_type,
published_on: self.in_repository_public? ? Time.now : nil,
)
deep_clone(clone, current_user)
end
def destroy_contents(current_user)
# Calculate total space taken by the protocol
st = self.space_taken
self.steps.find_each do |step|
unless step.destroy(current_user) then
raise ActiveRecord::RecordNotDestroyed
end
end
# Release space taken by the step
2017-01-24 23:34:21 +08:00
self.team.release_space(st)
self.team.save
2016-07-21 19:11:15 +08:00
# Reload protocol
self.reload
end
def can_destroy?
steps.map(&:can_destroy?).all?
end
2016-07-21 19:11:15 +08:00
private
def deep_clone(clone, current_user)
# Save cloned protocol first
success = clone.save
# Rename protocol if needed
unless success
rename_record(clone, :name)
success = clone.save
end
2017-01-31 20:33:55 +08:00
raise ActiveRecord::RecordNotSaved unless success
2016-07-21 19:11:15 +08:00
Protocol.clone_contents(self, clone, current_user, true)
clone.reload
2017-01-31 20:33:55 +08:00
clone
2016-07-21 19:11:15 +08:00
end
def update_linked_children
# Increment/decrement the parent's nr of linked children
if self.parent_id_changed?
if self.parent_id_was != nil
p = Protocol.find_by_id(self.parent_id_was)
p.record_timestamps = false
p.decrement!(:nr_of_linked_children)
end
if self.parent_id != nil
self.parent.record_timestamps = false
self.parent.increment!(:nr_of_linked_children)
end
end
end
def decrement_linked_children
self.parent.decrement!(:nr_of_linked_children) if self.parent.present?
end
2016-07-26 15:17:24 +08:00
end