DPL-829 pbmc plate to tube rack bed verification

app/controllers/robots_controller.rb

@@ -23,22 +23,7 @@ def show
 
   def start # rubocop:todo Metrics/AbcSize
     @robot.perform_transfer(stripped_beds)
-    if params[:robot_barcode].present?
-      @robot.beds.each_value do |bed|
-        next unless bed.transitions? && bed.labware
-
-        labware_barcode = bed.labware.barcode.machine
-        begin
-          LabwareMetadata
-            .new(api: api, user: current_user_uuid, barcode: labware_barcode)
-            .update!(created_with_robot: params[:robot_barcode])
-        rescue Sequencescape::Api::ResourceNotFound
-          respond_to do |format|
-            format.html { redirect_to robot_path(id: @robot.id), notice: "Plate #{plate_barcode} not found." }
-          end
-        end
-      end
-    end
+    update_labware_metadata(params[:robot_barcode]) if params[:robot_barcode].present?
     respond_to { |format| format.html { redirect_to search_path, notice: "Robot #{@robot.name} has been started." } }
   rescue Robots::Bed::BedError => e
     # Our beds complained, nothing has happened.
@@ -47,6 +32,28 @@ def start # rubocop:todo Metrics/AbcSize
     end
   end
 
+  def update_labware_metadata(robot_barcode)
+    @robot.beds.each_value do |bed|
+      next unless bed.transitions? && bed.labware
+      labware_barcode = bed.labware.barcode.machine
+      if bed.respond_to?(:labware_created_with_robot)
+        bed.labware_created_with_robot(robot_barcode)
+      else
+        labware_created_with_robot(labware_barcode, robot_barcode)
+      end
+    rescue Sequencescape::Api::ResourceNotFound
+      respond_to do |format|
+        format.html { redirect_to robot_path(id: @robot.id), notice: "Labware #{labware_barcode} not found." }
+      end
+    end
+  end
+
+  def labware_created_with_robot(labware_barcode, robot_barcode)
+    LabwareMetadata
+      .new(api: api, user: current_user_uuid, barcode: labware_barcode)
+      .update!(created_with_robot: robot_barcode)
+  end
+
   def verify
     render(json: @robot.verify(robot_params))
   end

app/models/robots/bed/plate_to_tube_racks_bed.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Robots::Bed
+  # Plate to tube racks robot beds
+  class PlateToTubeRacksBed < Robots::Bed::Base
+    # TODO: Do I need this accessor?
+    attr_accessor :parents
+
+    def labware_created_with_robot(robot_barcode)
+      labware.tubes.each do |tube|
+        LabwareMetadata
+          .new(api: api, user: user_uuid, barcode: tube.barcode.machine)
+          .update!(created_with_robot: robot_barcode)
+      end
+    end
+
+    def child_labware
+      return [] if labware.blank?
+
+      @child_labware ||= robot.child_labware(labware)
+    end
+
+    def load(barcodes)
+      @barcodes = Array(barcodes).filter_map(&:strip).uniq
+      @labware = @barcodes.present? ? robot.find_bed_labware(@barcodes) : []
+    end
+  end
+end

app/models/robots/plate_to_tube_racks_robot.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Robots
+  class PlateToTubeRacksRobot < Robots::Robot
+    attr_writer :relationships
+
+    PLATE_INCLUDES = 'purpose,wells,wells.downstream_tubes,wells.downstream_tubes.custom_metadatum_collection'
+
+    def bed_class
+      Robots::Bed::PlateToTubeRacksBed
+    end
+
+    def perform_transfer(bed_settings)
+      init_labware_store(bed_settings)
+      super
+    end
+
+    def verify(params)
+      init_labware_store(params[:bed_labwares])
+      super
+    end
+
+    def valid_relationships # rubocop:todo Metrics/AbcSize
+      raise StandardError, "Relationships for #{name} are empty" if @relationships.empty?
+
+      @relationships.each_with_object({}) do |relationship, validations|
+        parent_bed = relationship.dig('options', 'parent')
+        child_beds = relationship.dig('options', 'children')
+
+        validations[parent_bed] = beds[parent_bed].child_labware.present?
+        error(beds[parent_bed], 'should not be empty.') if beds[parent_bed].empty?
+        error(beds[parent_bed], 'should have children.') if beds[parent_bed].child_labware.empty?
+
+        expected_children = beds[parent_bed].child_labware
+        expected_children.each_with_index do |expected_child, index|
+          child_bed = child_beds[index]
+          validations[child_bed] = check_labware_identity([expected_child], child_bed)
+        end
+      end
+    end
+
+    def find_bed_labware(barcodes)
+      barcodes.filter_map { |barcode| labware_store[barcode] }
+    end
+
+    def child_labware(plate)
+      labware_store.values.select { |labware| labware.respond_to?(:parent) && labware.parent.uuid == plate.uuid }
+    end
+
+    def init_labware_store(bed_labwares)
+      return if labware_store.present?
+      stripped_barcodes(bed_labwares).each do |barcode|
+        plate = find_plate(barcode)
+        next if plate.blank?
+        add_plate_to_labware_store(plate)
+        add_tube_racks_to_labware_store(plate)
+      end
+    end
+
+    def stripped_barcodes(bed_labwares)
+      bed_labwares.values.flatten.filter_map(&:strip).uniq
+    end
+
+    def add_plate_to_labware_store(plate)
+      labware_store[plate.barcode.machine] = plate
+    end
+
+    def add_tube_racks_to_labware_store(plate)
+      find_tube_racks(plate).each { |rack| labware_store[rack.barcode.machine] = rack }
+    end
+
+    def labware_store
+      @labware_store ||= {}
+    end
+
+    def find_plate(barcode)
+      Sequencescape::Api::V2::Plate.find_all({ barcode: barcode }, includes: PLATE_INCLUDES).first
+    end
+
+    def find_tube_racks(plate)
+      plate
+        .wells
+        .sort_by(&well_order)
+        .each_with_object([]) do |well, racks|
+          next if well.downstream_tubes.empty?
+          well.downstream_tubes.each do |tube|
+            barcode = tube.custom_metadatum_collection.metadata[:tube_rack_barcode]
+            rack = racks.detect { |tube_rack| tube_rack.barcode.machine == barcode }
+            if rack.nil?
+              labware_barcode = LabwareBarcode.new(human: barcode, machine: barcode)
+              rack = racks.push(TubeRackWrapper.new(labware_barcode, plate)).last
+            end
+            rack.tubes << tube
+          end
+        end
+    end
+  end
+end

app/models/robots/tube_rack_wrapper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Robots
+  # Tube rack info from tube metadata
+  class TubeRackWrapper
+    attr_accessor :barcode, :parent, :tubes
+    delegate :purpose_name, :purpose, :human_barcode, :state, :uuid, to: :first_tube, allow_nil: true
+
+    def initialize(barcode, parent, tubes: [])
+      @barcode = barcode
+      @parent = parent
+      @tubes = tubes
+    end
+
+    def first_tube
+      @tubes.first
+    end
+  end
+end

config/robots.rb

@@ -3061,4 +3061,40 @@
         }
       }
     )
+
+    # LRC Hamilton Star bed verification
+    # LRC PBMC Bank to LRC Bank Seq and LRC Bank Spare
+    custom_robot(
+      'hamilton-lrc-pbmc-bank-to-lrc-bank-seq-and-lrc-bank-spare',
+      name: 'Hamilton LRC PBMC Bank => LRC Bank Seq and LRC Bank Spare',
+      beds: {
+        bed(12).barcode => {
+          purpose: 'LRC PBMC Bank',
+          states: ['passed'],
+          label: 'Bed 12'
+        },
+        bed(15).barcode => {
+          purpose: 'LRC Bank Seq',
+          states: ['pending'],
+          label: 'Bed 15',
+          target_state: 'passed'
+        },
+        bed(14).barcode => {
+          purpose: 'LRC Bank Spare',
+          states: ['pending'],
+          label: 'Bed 14',
+          target_state: 'passed'
+        }
+      },
+      class: 'Robots::PlateToTubeRacksRobot',
+      relationships: [
+        {
+          'type' => 'LRC PBMC Bank to LRC Bank Seq/Spare',
+          'options' => {
+            'parent' => bed(12).barcode,
+            'children' => [bed(15).barcode, bed(14).barcode]
+          }
+        }
+      ]
+    )
   end