Class: Order

Inherits:
ApplicationRecord show all
Includes:
ModelExtensions::Order, Submission::AssetGroupBehaviour, Submission::ProjectValidation, Submission::RequestOptionsBehaviour, Uuid::Uuidable
Defined in:
app/models/order.rb

Overview

An Order is used as the main means of requesting work in Sequencescape. Its key components are: Assets/AssetGroup: The assets on which the work will be conducted Study: The study for which work is being undertaken Project: The project who will be charged for the work Request options: The parameters for the request which will be built. eg. read length Request Types: An array of request type ids which will be built by the order. This is populated based on the submission template used. Submission: Multiple orders may be grouped together in a submission. This associates the two sets of requests, and is usually used to determine what gets pooled together during multiplexing. As a result, sequencing requests may be shared between multiple orders.

Constant Summary collapse

AssetTypeError =

Ensure order methods behave correctly

Class.new(StandardError)
DEFAULT_ASSET_INPUT_METHODS = 
['select an asset group'].freeze

Constants included from Submission::ProjectValidation

Submission::ProjectValidation::Error

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Submission::RequestOptionsBehaviour

included, #request_options=

Methods included from Submission::ProjectValidation

#checking_project?, included, #save_after_unmarshalling, #submittable?, #validating?

Methods included from Submission::AssetGroupBehaviour

#complete_building_asset_group, included

Methods included from Uuid::Uuidable

included, #unsaved_uuid!, #uuid

Methods inherited from ApplicationRecord

alias_association, convert_labware_to_receptacle_for, find_by_id_or_name, find_by_id_or_name!

Methods included from Squishify

extended

Instance Attribute Details

#asset_input_methods ⇒ Object 



230
231
232
 
# File 'app/models/order.rb', line 230

def asset_input_methods
  @asset_input_methods ||= DEFAULT_ASSET_INPUT_METHODS
end

#info_differential=(value) ⇒ Object (writeonly)

Unused. Maintained because some submission templates attempt to set the info



35
36
37
 
# File 'app/models/order.rb', line 35

def info_differential=(value)
  @info_differential = value
end

#input_field_infos ⇒ Object

Return the list of input fields to edit when creating a new submission Unless you are doing something fancy, fall back on the defaults



261
262
263
 
# File 'app/models/order.rb', line 261

def input_field_infos
  @input_field_infos ||= FieldInfo.for_request_types(request_types_list.flatten)
end

#request_type_ids_list ⇒ Object 



226
227
228
 
# File 'app/models/order.rb', line 226

def request_type_ids_list
  @request_type_ids_list ||= [[]]
end

Class Method Details

.render_class ⇒ Object 



95
96
97
 
# File 'app/models/order.rb', line 95

def render_class
  Api::OrderIo
end

Instance Method Details

#add_comment(comment_str, user) ⇒ Object 



284
285
286
287
288
289
290
291
 
# File 'app/models/order.rb', line 284

def add_comment(comment_str, user)
  update!(comments: [comments, comment_str].compact.join('; '))

  submission
    .requests
    .for_order_including_submission_based_requests(self)
    .map { |request| request.add_comment(comment_str, user) }
end

#all_assets ⇒ Object 



153
154
155
156
 
# File 'app/models/order.rb', line 153

def all_assets
  pull_assets_from_asset_group if assets.empty? && asset_group.present?
  assets
end

#all_samples ⇒ Object 



148
149
150
151
 
# File 'app/models/order.rb', line 148

def all_samples
  # slightly less naive way
  all_assets.map(&:samples).flatten.uniq
end

#asset_uuids ⇒ Object 



162
163
164
 
# File 'app/models/order.rb', line 162

def asset_uuids
  assets&.select(&:present?)&.map(&:uuid)
end

#assets=(assets_to_add) ⇒ Object 



109
110
111
 
# File 'app/models/order.rb', line 109

def assets=(assets_to_add)
  super(assets_to_add.map { |a| a.is_a?(Receptacle) ? a : a.receptacle })
end

#autodetection_default ⇒ Object 



100
101
102
 
# File 'app/models/order.rb', line 100

def autodetection_default
  false
end

#building? ⇒ Boolean

Are we still able to modify this instance?

Returns:

  • (Boolean) 


271
272
273
 
# File 'app/models/order.rb', line 271

def building?
  submission.nil?
end

#building_submission? ⇒ Boolean

We can't destroy orders once the submission has been finalized for building

Returns:

  • (Boolean) 


114
115
116
 
# File 'app/models/order.rb', line 114

def building_submission?
  throw :abort unless submission.building?
end

#calculated_request_metadata_by_request_key(request_type_key) ⇒ Object

Determines and returns calculated request metadata based on the request type key. This is to cover calculated metadata that does not require user input



176
177
178
179
180
181
182
183
184
185
 
# File 'app/models/order.rb', line 176

def calculated_request_metadata_by_request_key(request_type_key)
  case request_type_key
  # Checking for the presence of allowance_band, as it is calculated for
  # the bulk submission only
  when 'limber_scrna_core_cdna_prep_gem_x_5p'
    request_options['allowance_band'].present? ? { 'allowance_band' => request_options['allowance_band'] } : {}
  else
    {}
  end
end

#collect_gigabases_expected? ⇒ Boolean

Returns:

  • (Boolean) 


280
281
282
 
# File 'app/models/order.rb', line 280

def collect_gigabases_expected?
  input_field_infos.any? { |k| k.key == :gigabases_expected }
end

#complete_building ⇒ Object 



104
105
106
107
 
# File 'app/models/order.rb', line 104

def complete_building
  check_project_details!
  complete_building_asset_group
end

#create_request_of_type!(request_type, attributes = {}) ⇒ Object

rubocop:todo Metrics/MethodLength



188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
 
# File 'app/models/order.rb', line 188

def create_request_of_type!(request_type, attributes = {}) # rubocop:todo Metrics/AbcSize
  request_metadata = request_type.extract_metadata_from_hash(request_options)
  request_metadata = request_metadata.merge(calculated_request_metadata_by_request_key(request_type.key))
  request_type.create!(attributes) do |request|
    request.submission_id = submission_id
    request.study = study
    request.initial_project = project
    request.user = user
    request.request_metadata_attributes = request_metadata
    request.state = request_type.initial_state
    request.order = self

    if request.asset.present?
      unless asset_applicable_to_type?(request_type, request.asset)
        raise AssetTypeError, 'Asset type does not match that expected by request type.'
      end
    end
  end
end

#cross_compatible? ⇒ Boolean

Returns:

  • (Boolean) 


137
138
139
 
# File 'app/models/order.rb', line 137

def cross_compatible?
  false
end

#cross_project_allowed ⇒ Object 



133
134
135
 
# File 'app/models/order.rb', line 133

def cross_project_allowed
  false
end

#cross_study_allowed ⇒ Object 



129
130
131
 
# File 'app/models/order.rb', line 129

def cross_study_allowed
  false
end

#duplicates_within(timespan) {|matching_samples, matching_orders, matching_submissions| ... } ⇒ Object

rubocop:enable Metrics/MethodLength

Yields:

  • (matching_samples, matching_orders, matching_submissions) 


210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
 
# File 'app/models/order.rb', line 210

def duplicates_within(timespan) # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
  matching_orders =
    Order
      .containing_samples(all_samples)
      .where(template_name:)
      .includes(:submission, assets: :samples)
      .where.not(orders: { id: })
      .where('orders.created_at > ?', Time.current - timespan)
  return false if matching_orders.empty?

  matching_samples = matching_orders.map(&:samples).flatten & all_samples
  matching_submissions = matching_orders.map(&:submission).uniq
  yield matching_samples, matching_orders, matching_submissions if block_given?
  true
end

#first_request_type ⇒ Object 



255
256
257
 
# File 'app/models/order.rb', line 255

def first_request_type
  @first_request_type ||= RequestType.find(request_types.first)
end

#friendly_name ⇒ Object 



293
294
295
 
# File 'app/models/order.rb', line 293

def friendly_name
  asset_group.try(:name) || asset_group_name || id
end

#generate_broadcast_event ⇒ Object 



301
302
303
 
# File 'app/models/order.rb', line 301

def generate_broadcast_event
  BroadcastEvent::OrderMade.create!(seed: self, user: user)
end

#json_root ⇒ Object 



158
159
160
 
# File 'app/models/order.rb', line 158

def json_root
  'order'
end

#multiplexed? ⇒ Boolean

Returns:

  • (Boolean) 


166
167
168
 
# File 'app/models/order.rb', line 166

def multiplexed?
  RequestType.where(id: request_types).for_multiplexing.exists?
end

#multiplier_for(request_type_id) ⇒ Object 



170
171
172
 
# File 'app/models/order.rb', line 170

def multiplier_for(request_type_id)
  (request_options.dig(:multiplier, request_type_id.to_s) || 1).to_i
end

#next_request_type_id(request_type_id) ⇒ Object 



265
266
267
268
 
# File 'app/models/order.rb', line 265

def next_request_type_id(request_type_id)
  request_type_ids = request_types.map(&:to_i)
  request_type_ids[request_type_ids.index(request_type_id) + 1]
end

#not_ready_samples ⇒ Object

returns an array of samples, that potentially can not be included in submission



310
311
312
 
# File 'app/models/order.rb', line 310

def not_ready_samples
  all_samples.reject(&:can_be_included_in_submission?)
end

#on_delete_destroy_submission ⇒ Object 



118
119
120
121
122
123
124
125
126
127
 
# File 'app/models/order.rb', line 118

def on_delete_destroy_submission
  if building_submission?
    # After destroying an order, if it is the last order on it's submission
    # destroy the submission too.
    orders = submission.orders
    submission.destroy unless orders.size > 1
    return true
  end
  false
end

#request_types_list ⇒ Object

request_type_ids_list is set for orders created by submission templates It is used by the input_field_infos section, which controls rendering form fields appropriate to each request type in the submission interface request_type_ids is calculated from this in the various sub-classes and gets persisted to the database, and used for the actual construction. TODO: Simplify this - There are a few attributes which all refer to loosely the same thing, a list of request type ids: * request_type_ids_list - Set by submission templates, but also recalculated on the fly and used in various methods * request_types_ids - Setter on order subclasses. * request_types - Serialized version on order, persisted in the database - The request_types on the database should become the authoritative source. - request_type_ids_list should just be a setter, which populates request_types. It may need to transform the input slightly. Ideally we eliminate this entirely, and be consistent between templates and orders - There appear to be several methods which essentially do the same thing. They should be unified. - I'm not even 100% how request_types_ids factors in.



251
252
253
 
# File 'app/models/order.rb', line 251

def request_types_list
  request_type_ids_list.map { |ids| RequestType.find(ids) }
end

#samples ⇒ Object

TODO: Figure out why eager loading aliquots/samples returns [] even when we limit order_assets to receptacles.



143
144
145
146
 
# File 'app/models/order.rb', line 143

def samples
  # naive way
  assets.map(&:samples).flatten.uniq
end

#sequencing_order? ⇒ Boolean

Returns true if this is an order for sequencing

Returns:

  • (Boolean) 


276
277
278
 
# File 'app/models/order.rb', line 276

def sequencing_order?
  RequestType.find(request_types).any?(&:sequencing?)
end

#study_is_active ⇒ Object 



305
306
307
 
# File 'app/models/order.rb', line 305

def study_is_active
  errors.add(:study, 'is not active') if study.present? && !study.active?
end

#subject_type ⇒ Object 



297
298
299
 
# File 'app/models/order.rb', line 297

def subject_type
  'order'
end