Merge pull request #677 from sanger/release_rows

x1575: Combine rows of the same sample in the release file

Author: khelwood

src/main/java/uk/ac/sanger/sccp/stan/ReleaseFileController.java

@@ -28,13 +28,13 @@ public ReleaseFileController(ReleaseFileService releaseFileService) {
 
     @RequestMapping(value="/release", method = RequestMethod.GET, produces = "text/tsv")
     @ResponseBody
-    public TsvFile<ReleaseEntry> getReleaseFile(@RequestParam(name="id") List<Integer> ids,
+    public TsvFile<?> getReleaseFile(@RequestParam(name="id") List<Integer> ids,
                                                 @RequestParam(name="groups", required=false) List<String> groupNames,
                                                 @RequestParam(name="type", required=false) String fileType) {
         final String filename = filenameForType(fileType);
         ReleaseFileContent rfc = releaseFileService.getReleaseFileContent(ids, parseOptions(groupNames));
-        List<? extends TsvColumn<ReleaseEntry>> columns = releaseFileService.computeColumns(rfc);
-        return new TsvFile<>(filename, rfc.getEntries(), columns);
+        List<? extends TsvColumn<List<ReleaseEntry>>> columns = releaseFileService.computeRowColumns(rfc);
+        return new TsvFile<>(filename, rfc.getRows(), columns);
     }
 
     /**

src/main/java/uk/ac/sanger/sccp/stan/service/releasefile/ReleaseFileContent.java

@@ -11,11 +11,14 @@ public class ReleaseFileContent {
     private final Set<ReleaseFileMode> modes;
     private final List<ReleaseEntry> entries;
     private final Set<ReleaseFileOption> options;
+    private final List<List<ReleaseEntry>> rows;
 
-    public ReleaseFileContent(Set<ReleaseFileMode> modes, List<ReleaseEntry> entries, Set<ReleaseFileOption> options) {
+    public ReleaseFileContent(Set<ReleaseFileMode> modes, List<ReleaseEntry> entries, Set<ReleaseFileOption> options,
+                              List<List<ReleaseEntry>> rows) {
         this.modes = modes==null ? Set.of() : modes;
         this.entries = entries;
         this.options = options;
+        this.rows = rows;
     }
 
     public Set<ReleaseFileMode> getModes() {
@@ -30,6 +33,10 @@ public Set<ReleaseFileOption> getOptions() {
         return this.options;
     }
 
+    public List<List<ReleaseEntry>> getRows() {
+        return this.rows;
+    }
+
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
@@ -38,11 +45,12 @@ public boolean equals(Object o) {
         return (this.modes.equals(that.modes)
                 && Objects.equals(this.entries, that.entries)
                 && Objects.equals(this.options, that.options)
+                && Objects.equals(this.rows, that.rows)
         );
     }
 
     @Override
     public int hashCode() {
-        return Objects.hash(modes, entries, options);
+        return Objects.hash(modes, entries, options, rows);
     }
 }

src/main/java/uk/ac/sanger/sccp/stan/service/releasefile/ReleaseFileService.java

@@ -14,6 +14,7 @@
 import uk.ac.sanger.sccp.stan.service.releasefile.Ancestoriser.Ancestry;
 import uk.ac.sanger.sccp.stan.service.releasefile.Ancestoriser.SlotSample;
 import uk.ac.sanger.sccp.utils.UCMap;
+import uk.ac.sanger.sccp.utils.tsv.CombinerColumn;
 import uk.ac.sanger.sccp.utils.tsv.TsvColumn;
 
 import javax.persistence.EntityNotFoundException;
@@ -101,7 +102,7 @@ public ReleaseFileService(Ancestoriser ancestoriser,
      */
     public ReleaseFileContent getReleaseFileContent(Collection<Integer> releaseIds, Set<ReleaseFileOption> options) {
         if (releaseIds.isEmpty()) {
-            return new ReleaseFileContent(EnumSet.of(ReleaseFileMode.NORMAL), List.of(), options);
+            return new ReleaseFileContent(EnumSet.of(ReleaseFileMode.NORMAL), List.of(), options, List.of());
         }
         List<Release> releases = getReleases(releaseIds);
         Map<Integer, Snapshot> snapshots = loadSnapshots(releases);
@@ -142,7 +143,21 @@ public ReleaseFileContent getReleaseFileContent(Collection<Integer> releaseIds,
         }
         loadXeniumFields(entries, slotIds);
         loadFlags(entries);
-        return new ReleaseFileContent(modes, entries, options);
+        return new ReleaseFileContent(modes, entries, options, groupRows(entries));
+    }
+
+    /** Groups the entries by labware and sample */
+    public List<List<ReleaseEntry>> groupRows(List<ReleaseEntry> entries) {
+        record RowKey(int labwareId, int sampleId) {
+            RowKey(ReleaseEntry entry) {
+                this(entry.getLabware().getId(), entry.getSample().getId());
+            }
+        }
+        Map<RowKey, List<ReleaseEntry>> rows = new LinkedHashMap<>();
+        for (ReleaseEntry entry : entries) {
+            rows.computeIfAbsent(new RowKey(entry), k -> new ArrayList<>()).add(entry);
+        }
+        return asList(rows.values());
     }
 
     /**
@@ -1391,6 +1406,11 @@ public String describeFlags(Collection<FlagDetail.FlagSummary> summaries) {
                 .collect(joining(" "));
     }
 
+    public List<TsvColumn<List<ReleaseEntry>>> computeRowColumns(ReleaseFileContent rfc) {
+        var innerColumns = computeColumns(rfc);
+        return innerColumns.stream().<TsvColumn<List<ReleaseEntry>>>map(CombinerColumn::new).toList();
+    }
+
     public List<? extends TsvColumn<ReleaseEntry>> computeColumns(ReleaseFileContent rfc) {
         List<ReleaseColumn> modeColumns = ReleaseColumn.forModesAndOptions(rfc.getModes(), rfc.getOptions());
         int dualColumnIndex = modeColumns.indexOf(ReleaseColumn.Dual_index_plate_name);

src/main/java/uk/ac/sanger/sccp/utils/tsv/CombinerColumn.java

@@ -0,0 +1,44 @@
+package uk.ac.sanger.sccp.utils.tsv;
+
+import java.util.*;
+
+import static uk.ac.sanger.sccp.utils.BasicUtils.nullOrEmpty;
+import static uk.ac.sanger.sccp.utils.BasicUtils.toLinkedHashSet;
+
+/**
+ * Column value generator that joins values from combined entries
+ * @author dr6
+ */
+public class CombinerColumn<E> implements TsvColumn<List<E>> {
+    public final TsvColumn<? super E> innerColumn;
+
+    public CombinerColumn(TsvColumn<? super E> innerColumn) {
+        this.innerColumn = innerColumn;
+    }
+
+    @Override
+    public String get(List<E> entries) {
+        if (nullOrEmpty(entries)) {
+            return null;
+        }
+        if (entries.size() == 1) {
+            return innerColumn.get(entries.getFirst());
+        }
+        Set<String> values = entries.stream()
+                .map(innerColumn::get)
+                .filter(Objects::nonNull)
+                .collect(toLinkedHashSet());
+        if (values.isEmpty()) {
+            return null;
+        }
+        if (values.size()==1) {
+            return values.iterator().next();
+        }
+        return String.join(", ", values);
+    }
+
+    @Override
+    public String toString() {
+        return this.innerColumn.toString();
+    }
+}

src/test/java/uk/ac/sanger/sccp/stan/integrationtest/TestReleaseMutation.java

@@ -146,7 +146,7 @@ public void testRelease() throws Exception {
 
         String tsvString = getReleaseFile(releaseIds, EnumSet.allOf(ReleaseFileOption.class));
         var tsvMaps = tsvToMap(tsvString);
-        assertEquals(4, tsvMaps.size());
+        assertEquals(3, tsvMaps.size());
         Set<String> expectedColumns = Arrays.stream(ReleaseColumn.values())
                 .filter(c -> c.getMode()!=ReleaseFileMode.CDNA)
                 .map(ReleaseColumn::toString)
@@ -158,11 +158,13 @@ public void testRelease() throws Exception {
         assertMapValue(row0, ReleaseColumn.Last_section_number, "6");
         assertMapValue(row0, ReleaseColumn.Released_from_box_name, "Box 1");
         assertMapValue(row0, ReleaseColumn.Released_from_box_location, "4");
+        assertMapValue(row0, ReleaseColumn.Slot_of_labware, "A1");
         var row1 = tsvMaps.get(1);
         assertMapValue(row1, ReleaseColumn.Released_from_box_name, "Box 1");
         assertMapValue(row1, ReleaseColumn.Released_from_box_location, "C4");
+        assertMapValue(row1, ReleaseColumn.Slot_of_labware, "A1, A2");
         String bsName = sample.getBioState().getName();
-        for (int i = 1; i < 4; ++i) {
+        for (int i = 1; i < tsvMaps.size(); ++i) {
             var row = tsvMaps.get(i);
             assertMapValue(row, ReleaseColumn.Released_labware_barcode, lw.getBarcode());
             assertMapValue(row, ReleaseColumn.Labware_type, lw.getLabwareType().getName());

src/test/java/uk/ac/sanger/sccp/stan/service/releasefile/TestReleaseFileService.java

@@ -16,6 +16,9 @@
 import uk.ac.sanger.sccp.stan.service.releasefile.Ancestoriser.Ancestry;
 import uk.ac.sanger.sccp.stan.service.releasefile.Ancestoriser.SlotSample;
 import uk.ac.sanger.sccp.stan.service.releasefile.ReleaseFileService.StorageDetail;
+import uk.ac.sanger.sccp.utils.Zip;
+import uk.ac.sanger.sccp.utils.tsv.CombinerColumn;
+import uk.ac.sanger.sccp.utils.tsv.TsvColumn;
 
 import javax.persistence.EntityNotFoundException;
 import java.time.LocalDate;
@@ -234,6 +237,26 @@ public void testGetReleaseFileContent(StorageDetail detail, boolean includeVisiu
         verify(service).loadFlags(entries);
     }
 
+    @Test
+    void testGroupRows() {
+        setupLabware();
+        Address A2 = new Address(1,2);
+        ReleaseEntry[] entries = {
+                new ReleaseEntry(lw1, lw1.getFirstSlot(), sample),
+                new ReleaseEntry(lw1, lw1.getSlot(A2), sample),
+                new ReleaseEntry(lw1, lw1.getFirstSlot(), sample2),
+                new ReleaseEntry(lw2, lw2.getFirstSlot(), sample),
+                new ReleaseEntry(lw2, lw2.getFirstSlot(), sample2),
+                new ReleaseEntry(lw2, lw2.getSlot(A2), sample)
+        };
+        List<List<ReleaseEntry>> grouped = service.groupRows(Arrays.asList(entries));
+        assertThat(grouped).hasSize(4);
+        assertThat(grouped.get(0)).containsExactly(entries[0], entries[1]);
+        assertThat(grouped.get(1)).containsExactly(entries[2]);
+        assertThat(grouped.get(2)).containsExactly(entries[3], entries[5]);
+        assertThat(grouped.get(3)).containsExactly(entries[4]);
+    }
+
     @ParameterizedTest
     @CsvSource(delimiter=';', value={
             "null,null;null,null;null,null;NONE",
@@ -1217,6 +1240,24 @@ public void testLoadParaffinProcessingProgram() {
         assertEquals("Pears", entries.get(1).getParaffinProcessingProgram());
     }
 
+    @SuppressWarnings("rawtypes")
+    @Test
+    public void testComputeRowColumns() {
+        List<TsvColumn<?>> innerColumns = List.of(
+                v -> "Alpha", v -> "Beta"
+        );
+        doReturn(innerColumns).when(service).computeColumns(any());
+        ReleaseFileContent rfc = new ReleaseFileContent(null, null, null, null);
+
+        var rowColumns = service.computeRowColumns(rfc);
+        assertThat(rowColumns).hasSameSizeAs(innerColumns);
+        verify(service).computeColumns(same(rfc));
+        Zip.of(innerColumns.stream(), rowColumns.stream()).forEach((innerCol, outerCol) -> {
+            assertThat(outerCol).isInstanceOf(CombinerColumn.class);
+            assertSame(innerCol, ((CombinerColumn) outerCol).innerColumn);
+        });
+    }
+
     @SuppressWarnings({"unchecked", "rawtypes"})
     @ParameterizedTest
     @CsvSource({
@@ -1246,7 +1287,8 @@ public void testComputeColumns(boolean anyTagData, String joinedOptions) {
             entries.get(1).setTagData(orderedMap("Alpha", "A", "Beta", "B"));
             entries.get(2).setTagData(orderedMap("Beta", "8", "Gamma", "9"));
         }
-        var columns = service.computeColumns(new ReleaseFileContent(EnumSet.of(mode), entries, options));
+        List<List<ReleaseEntry>> rows = entries.stream().map(List::of).toList();
+        var columns = service.computeColumns(new ReleaseFileContent(EnumSet.of(mode), entries, options, rows));
         List modeColumns = ReleaseColumn.forModesAndOptions(modes, options);
         if (!anyTagData || !options.contains(ReleaseFileOption.Visium)) {
             assertThat(columns).containsExactlyElementsOf(modeColumns);

src/test/java/uk/ac/sanger/sccp/utils/tsv/TestCombinerColumn.java

@@ -0,0 +1,41 @@
+package uk.ac.sanger.sccp.utils.tsv;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import uk.ac.sanger.sccp.stan.service.releasefile.ReleaseColumn;
+import uk.ac.sanger.sccp.stan.service.releasefile.ReleaseEntry;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.IntStream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/** Test {@link CombinerColumn} */
+class TestCombinerColumn {
+    private TsvColumn<ReleaseEntry> innerColumn;
+    private TsvColumn<List<ReleaseEntry>> column;
+    @BeforeEach
+    void setup() {
+        innerColumn = ReleaseColumn.Bond_barcode;
+        column = new CombinerColumn<>(innerColumn);
+    }
+
+    @Test
+    void testGet() {
+        ReleaseEntry[] entries = IntStream.range(0,4)
+                .mapToObj(i -> new ReleaseEntry(null, null, null))
+                .toArray(ReleaseEntry[]::new);
+        entries[0].setBondBarcode("Bond1");
+        entries[1].setBondBarcode("Bond2");
+        entries[2].setBondBarcode(null);
+        entries[3].setBondBarcode("Bond1");
+
+        assertEquals("Bond1, Bond2", column.get(Arrays.asList(entries)));
+    }
+
+    @Test
+    void testToString() {
+        assertEquals(innerColumn.toString(), column.toString());
+    }
+}