scinote-web/app/models/step.rb

258 lines
7.4 KiB
Ruby
Raw Normal View History

2017-06-23 21:19:08 +08:00
class Step < ApplicationRecord
2016-02-12 23:52:43 +08:00
include SearchableModel
include SearchableByNameModel
2019-03-11 20:43:50 +08:00
include TinyMceImages
include ViewableModel
2016-02-12 23:52:43 +08:00
attr_accessor :skip_position_adjust # to be used in bulk deletion
2020-11-17 22:33:25 +08:00
enum assets_view_mode: { thumbnail: 0, list: 1, inline: 2 }
auto_strip_attributes :name, :description, nullify: false
validates :name,
presence: true,
length: { maximum: Constants::NAME_MAX_LENGTH }
2016-11-11 18:42:16 +08:00
validates :description, length: { maximum: Constants::RICH_TEXT_MAX_LENGTH }
validates :position, presence: true
2016-02-12 23:52:43 +08:00
validates :completed, inclusion: { in: [true, false] }
2016-07-21 19:11:15 +08:00
validates :user, :protocol, presence: true
validates :completed_on, presence: true, if: proc { |s| s.completed? }
validates :position, uniqueness: { scope: :protocol }, if: :position_changed?
2016-02-12 23:52:43 +08:00
before_validation :set_completed_on, if: :completed_changed?
before_save :set_last_modified_by
before_destroy :cascade_before_destroy
after_destroy :adjust_positions_after_destroy, unless: -> { skip_position_adjust }
belongs_to :user, inverse_of: :steps
belongs_to :last_modified_by, foreign_key: 'last_modified_by_id', class_name: 'User', optional: true
belongs_to :protocol, inverse_of: :steps, touch: true
has_many :step_orderable_elements, inverse_of: :step, dependent: :destroy
has_many :checklists, inverse_of: :step, dependent: :destroy
has_many :step_comments, foreign_key: :associated_id, dependent: :destroy
has_many :step_texts, inverse_of: :step, dependent: :destroy
has_many :step_assets, inverse_of: :step, dependent: :destroy
2016-02-12 23:52:43 +08:00
has_many :assets, through: :step_assets
has_many :step_tables, inverse_of: :step, dependent: :destroy
2016-02-12 23:52:43 +08:00
has_many :tables, through: :step_tables
has_many :report_elements, inverse_of: :step, dependent: :destroy
2016-02-12 23:52:43 +08:00
accepts_nested_attributes_for :checklists,
2017-01-27 23:36:03 +08:00
reject_if: :all_blank,
allow_destroy: true
2016-02-12 23:52:43 +08:00
accepts_nested_attributes_for :assets,
2017-01-27 23:36:03 +08:00
reject_if: :all_blank,
allow_destroy: true
2016-02-12 23:52:43 +08:00
accepts_nested_attributes_for :tables,
2017-01-27 23:36:03 +08:00
reject_if: proc { |attributes|
attributes['contents'].blank?
},
allow_destroy: true
2016-02-12 23:52:43 +08:00
scope :in_order, -> { order(position: :asc) }
scope :desc_order, -> { order(position: :desc) }
2017-05-05 22:41:23 +08:00
def self.search(user,
include_archived,
query = nil,
page = 1,
_current_team = nil,
options = {})
protocol_ids = Protocol.search(user, include_archived, nil, Constants::SEARCH_NO_LIMIT)
.pluck(:id)
2016-02-12 23:52:43 +08:00
new_query = Step.distinct
.left_outer_joins(:step_texts)
.where(steps: { protocol_id: protocol_ids })
.where_attributes_like(['name', 'step_texts.text'], query, options)
2016-02-12 23:52:43 +08:00
# Show all results if needed
if page == Constants::SEARCH_NO_LIMIT
2016-02-12 23:52:43 +08:00
new_query
else
new_query.limit(Constants::SEARCH_LIMIT).offset((page - 1) * Constants::SEARCH_LIMIT)
2016-02-12 23:52:43 +08:00
end
end
def self.filter_by_teams(teams = [])
return self if teams.blank?
joins(protocol: { my_module: { experiment: :project } })
.where(protocol: { my_modules: { experiments: { projects: { team: teams } } } })
end
def default_view_state
{ 'assets' => { 'sort' => 'new' } }
end
def validate_view_state(view_state)
unless %w(new old atoz ztoa).include?(view_state.state.dig('assets', 'sort'))
view_state.errors.add(:state, :wrong_state)
end
end
def self.viewable_by_user(user, teams)
where(protocol: Protocol.viewable_by_user(user, teams))
end
def can_destroy?
!assets.map(&:locked?).any?
end
2016-07-21 19:11:15 +08:00
def my_module
protocol.present? ? protocol.my_module : nil
end
def position_plus_one
position + 1
end
def last_comments(last_id = 1, per_page = Constants::COMMENTS_SEARCH_LIMIT)
last_id = Constants::INFINITY if last_id <= 1
comments = StepComment.joins(:step)
.where(steps: { id: id })
.where('comments.id < ?', last_id)
.order(created_at: :desc)
.limit(per_page)
StepComment.from(comments, :comments).order(created_at: :asc)
2016-02-12 23:52:43 +08:00
end
def space_taken
st = 0
assets.each do |asset|
st += asset.estimated_size
end
st
end
def asset_position(asset)
2019-10-09 03:40:44 +08:00
assets.order(:updated_at).each_with_index do |step_asset, i|
return { count: assets.count, pos: i } if asset.id == step_asset.id
end
end
def move_up
return if position.zero?
move_in_protocol(:up)
end
def move_down
return if position == protocol.steps.count - 1
move_in_protocol(:down)
end
2020-11-20 19:29:40 +08:00
def comments
step_comments
end
def description_step_text
step_texts.order(created_at: :asc).first
end
def duplicate(protocol, user, step_position: nil, step_name: nil)
ActiveRecord::Base.transaction do
assets_to_clone = []
new_step = protocol.steps.new(
name: step_name || name,
position: step_position || protocol.steps.length,
completed: false,
user: user
)
new_step.save!
# Copy texts
step_texts.each do |step_text|
step_text.duplicate(new_step, step_text.step_orderable_element.position)
end
2022-08-23 23:54:33 +08:00
# Copy checklists
checklists.asc.each do |checklist|
checklist.duplicate(new_step, user, checklist.step_orderable_element.position)
end
2022-08-23 23:54:33 +08:00
# "Shallow" Copy assets
assets.each do |asset|
new_asset = asset.dup
new_asset.save!
new_step.assets << new_asset
assets_to_clone << [asset.id, new_asset.id]
end
2022-08-23 23:54:33 +08:00
# Copy tables
tables.each do |table|
table.duplicate(new_step, user, table.step_table.step_orderable_element.position)
end
2022-08-23 23:54:33 +08:00
# Call clone helper
Protocol.delay(queue: :assets).deep_clone_assets(assets_to_clone)
2022-08-23 23:54:33 +08:00
new_step
end
2022-08-23 23:54:33 +08:00
end
private
def move_in_protocol(direction)
transaction do
re_index_following_steps
case direction
when :up
new_position = position - 1
when :down
new_position = position + 1
else
return
end
step_to_swap = protocol.steps.find_by(position: new_position)
position_to_swap = position
if step_to_swap
step_to_swap.update!(position: -1)
update!(position: new_position)
step_to_swap.update!(position: position_to_swap)
else
update!(position: new_position)
end
end
end
def adjust_positions_after_destroy
re_index_following_steps
protocol.steps.where('position > ?', position).order(:position).each do |step|
step.update!(position: step.position - 1)
end
end
2016-02-12 23:52:43 +08:00
def re_index_following_steps
steps = protocol.steps.where(position: position..).order(:position).where.not(id: id)
i = position
steps.each do |step|
i += 1
step.position = i
end
steps.reverse_each do |step|
step.save! if step.position_changed?
end
end
def cascade_before_destroy
assets.each(&:destroy)
tables.each(&:destroy)
2016-02-12 23:52:43 +08:00
end
def set_completed_on
return if completed? && completed_on.present?
self.completed_on = completed? ? DateTime.now : nil
end
2016-02-12 23:52:43 +08:00
def set_last_modified_by
self.last_modified_by_id ||= user_id
2016-02-12 23:52:43 +08:00
end
end