Merge pull request #7241 from deutschebank/db-contrib/waltz-7237-bulk-upload-functionality-not-working-for-assessment-def

Db contrib/waltz 7237 bulk upload functionality not working for assessment def

Author: davidwatkins73

waltz-integration-test/src/test/java/org/finos/waltz/integration_test/inmem/service/BulkAssessmentRatingServiceTest.java

@@ -195,4 +195,64 @@ private String mkBadTsv(String externalId) {
                 + externalId + "\tbadRatingCode\ttrue\tcomment\n";
     }
 
+    @Test
+    public void bulkPreviewForCardinalityZeroToMany() {
+        String appName = mkName(stem, "previewApp");
+        String appExternalId = mkName(stem, "previewAppCode");
+        String appName1 = mkName(stem, "previewApp1");
+        String appExternalId1 = mkName(stem, "previewAppCode1");
+        Long schemeId = ratingSchemeHelper.createEmptyRatingScheme(mkName(stem, "SchemeApp1"));
+        ratingSchemeHelper.saveRatingItem(schemeId, "Yes", 0, "green", "Y");
+        ratingSchemeHelper.saveRatingItem(schemeId, "No", 0, "red", "N");
+        appHelper.createNewApp(
+                appName,
+                ouIds.root,
+                appExternalId);
+        appHelper.createNewApp(
+                appName1,
+                ouIds.root,
+                appExternalId1);
+        long defId = assessmentHelper.createDefinition(schemeId, "Assessment_DefinitionA", "", AssessmentVisibility.PRIMARY, "Test",
+                EntityKind.LEGAL_ENTITY_RELATIONSHIP, Cardinality.ZERO_MANY, Optional.ofNullable(null));
+        AssessmentDefinition def = assessmentDefinitionService.getById(defId);
+        String[] externalIds = {appExternalId,appExternalId1};
+        String[] ratingCodes = {"Y","N"};
+        AssessmentRatingValidationResult result = bulkAssessmentRatingService.bulkPreview(
+                mkRef(def.entityKind(), def.id().get()),
+                mkTsvWithForCardinalityCheck(externalIds, ratingCodes));
+
+        assertEquals(2, result.validatedItems().size(), "Expected 2 items");
+    }
+
+    @Test
+    public void bulkUpdateForCardinalityZeroToMany() {
+        String name = mkName(stem, "previewApp1");
+        String kindExternalId = mkName(stem, "previewAppExtId");
+        Long schemeId = ratingSchemeHelper.createEmptyRatingScheme(name + "SchemeApp1");
+        ratingSchemeHelper.saveRatingItem(schemeId, "Yes", 0, "green", "Y");
+        appHelper.createNewApp(
+                mkName(stem, "previewUpdatesApp1"),
+                ouIds.root,
+                kindExternalId);
+        long defId = assessmentHelper.createDefinition(schemeId, "Assessment_Definition1", "", AssessmentVisibility.PRIMARY, "Test",
+                EntityKind.APPLICATION, Cardinality.ZERO_MANY, Optional.ofNullable(null));
+        AssessmentDefinition def1 = assessmentDefinitionService.getById(defId);
+        EntityReference cfg = mkRef(EntityKind.APPLICATION, defId);
+        SaveAssessmentRatingCommand cmd = ImmutableSaveAssessmentRatingCommand.builder()
+                .entityReference(cfg)
+                .assessmentDefinitionId(defId)
+                .ratingId(26)
+                .lastUpdatedBy("test")
+                .build();
+        try {
+            assessmentRatingService.store(cmd, "test");
+        } catch (InsufficientPrivelegeException e) {
+            e.printStackTrace();
+        }
+        AssessmentRatingValidationResult result1 = bulkAssessmentRatingService.bulkPreview(
+                mkRef(def1.entityKind(), def1.id().get()),
+                mkGoodTsv(kindExternalId));
+
+        assertNotNull(result1.validatedItems().get(0).changeOperation(), ChangeOperation.UPDATE.name());
+    }
 }

waltz-service/src/main/java/org/finos/waltz/service/assessment_rating/BulkAssessmentRatingService.java

@@ -156,13 +156,23 @@ public AssessmentRatingValidationResult bulkPreview(EntityReference assessmentRe
 
         List<AssessmentRating> existingAssessmentRatings = assessmentRatingService.findByDefinitionId(assessmentReference.id());
 
-        DiffResult<AssessmentRating> assessmentRatingDiffResult = DiffResult
-                .mkDiff(
-                        existingAssessmentRatings,
-                        requiredAssessmentRatings,
-                        d -> tuple(d.entityReference(), d.assessmentDefinitionId()),
-                        (a, b) -> StringUtilities.safeEq(a.comment(), b.comment())
-                                && a.ratingId() == b.ratingId());
+        DiffResult<AssessmentRating> assessmentRatingDiffResult;
+        if (isCardinalityZeroToOne) {
+            assessmentRatingDiffResult = DiffResult
+                    .mkDiff(
+                            existingAssessmentRatings,
+                            requiredAssessmentRatings,
+                            d -> tuple(d.entityReference(), d.assessmentDefinitionId()),
+                            (a, b) -> StringUtilities.safeEq(a.comment(), b.comment())
+                                    && a.ratingId() == b.ratingId());
+        } else {
+            assessmentRatingDiffResult = DiffResult
+                    .mkDiff(
+                            existingAssessmentRatings,
+                            requiredAssessmentRatings,
+                            d -> tuple(d.entityReference(), d.assessmentDefinitionId(), d.ratingId()),
+                            (a, b) -> StringUtilities.safeEq(a.comment(), b.comment()));
+        }
 
         Set<Tuple2<EntityReference, Long>> toAdd = SetUtilities.map(assessmentRatingDiffResult.otherOnly(), d -> tuple(d.entityReference(), d.ratingId()));
         Set<Tuple2<EntityReference, Long>> toUpdate = SetUtilities.map(assessmentRatingDiffResult.differingIntersection(), d -> tuple(d.entityReference(), d.ratingId()));
@@ -212,6 +222,9 @@ public BulkAssessmentRatingApplyResult apply(EntityReference assessmentRef,
         }
         Timestamp now = DateTimeUtilities.nowUtcTimestamp();
 
+        AssessmentDefinition assessmentDefinition = assessmentDefinitionService.getById(assessmentRef.id());
+        boolean isCardinalityZeroToOne = assessmentDefinition.cardinality().equals(Cardinality.ZERO_ONE);
+
         Set<AssessmentRatingRecord> toAdd = preview
                 .validatedItems()
                 .stream()
@@ -231,20 +244,37 @@ public BulkAssessmentRatingApplyResult apply(EntityReference assessmentRef,
                 })
                 .collect(Collectors.toSet());
 
-        Set<UpdateConditionStep<AssessmentRatingRecord>> toUpdate = preview
+
+        Set<UpdateConditionStep<AssessmentRatingRecord>> toUpdate;
+        if (isCardinalityZeroToOne) {
+            toUpdate = preview
                     .validatedItems()
                     .stream()
                     .filter(d -> d.changeOperation() == ChangeOperation.UPDATE && d.errors().isEmpty())
                     .map(d ->
                             DSL
-                            .update(ar)
-                            .set(ar.RATING_ID, d.ratingSchemeItem().id().get())
-                            .set(ar.DESCRIPTION, sanitizeCharacters(d.parsedItem().comment()))
-                            .where(ar.ASSESSMENT_DEFINITION_ID.eq(assessmentRef.id())
-                                    .and(ar.ENTITY_KIND.eq(d.entityKindReference().kind().name())
-                                            .and(ar.ENTITY_ID.eq(d.entityKindReference().id()))
-                                            .and(ar.RATING_ID.eq(d.ratingSchemeItem().id().get())))))
+                                    .update(ar)
+                                    .set(ar.RATING_ID, d.ratingSchemeItem().id().get())
+                                    .set(ar.DESCRIPTION, sanitizeCharacters(d.parsedItem().comment()))
+                                    .where(ar.ASSESSMENT_DEFINITION_ID.eq(assessmentRef.id())
+                                            .and(ar.ENTITY_KIND.eq(d.entityKindReference().kind().name())
+                                                    .and(ar.ENTITY_ID.eq(d.entityKindReference().id())))))
                     .collect(Collectors.toSet());
+        } else {
+            toUpdate = preview
+                    .validatedItems()
+                    .stream()
+                    .filter(d -> d.changeOperation() == ChangeOperation.UPDATE && d.errors().isEmpty())
+                    .map(d ->
+                            DSL
+                                    .update(ar)
+                                    .set(ar.DESCRIPTION, sanitizeCharacters(d.parsedItem().comment()))
+                                    .where(ar.ASSESSMENT_DEFINITION_ID.eq(assessmentRef.id())
+                                            .and(ar.ENTITY_KIND.eq(d.entityKindReference().kind().name())
+                                                    .and(ar.ENTITY_ID.eq(d.entityKindReference().id()))
+                                                    .and(ar.RATING_ID.eq(d.ratingSchemeItem().id().get())))))
+                    .collect(Collectors.toSet());
+        }
 
         Set<DeleteConditionStep<AssessmentRatingRecord>> toRemove = preview
                 .removals()