Bulk uploader for entity relationships

waltz-data/src/main/java/org/finos/waltz/data/entity_relationship/EntityRelationshipDao.java

@@ -281,6 +281,32 @@ private Condition mkExactRefMatchCondition(EntityReference ref) {
         return matchesA.or(matchesB);
     }
 
+    public Collection<EntityRelationship> getEntityRelationshipsByKind(org.finos.waltz.model.rel.RelationshipKind relationshipKind) {
+        return dsl
+                .select(ENTITY_RELATIONSHIP.fields())
+                .from(ENTITY_RELATIONSHIP)
+                .where(ENTITY_RELATIONSHIP.RELATIONSHIP.eq(relationshipKind.code()))
+                .fetch(r -> {
+                    EntityRelationshipRecord record = r.into(ENTITY_RELATIONSHIP);
+                    return ImmutableEntityRelationship.builder()
+                            .id(record.getId())
+                            .a(ImmutableEntityReference.builder()
+                                    .kind(EntityKind.valueOf(record.getKindA()))
+                                    .id(record.getIdA())
+                                    .build())
+                            .b(ImmutableEntityReference.builder()
+                                    .kind(EntityKind.valueOf(record.getKindB()))
+                                    .id(record.getIdB())
+                                    .build())
+                            .provenance(record.getProvenance())
+                            .relationship(record.getRelationship())
+                            .description(record.getDescription())
+                            .lastUpdatedBy(record.getLastUpdatedBy())
+                            .lastUpdatedAt(toLocalDateTime(record.getLastUpdatedAt()))
+                            .build();
+                });
+    }
+
 
     private Condition mkExactKeyMatchCondition(EntityRelationshipKey key) {
         return ENTITY_RELATIONSHIP.ID_A.eq(key.a().id())

waltz-data/src/main/java/org/finos/waltz/data/rel/RelationshipKindDao.java

@@ -95,6 +95,14 @@ public Set<RelationshipKind> findAll() {
                 .fetchSet(TO_DOMAIN_MAPPER);
     }
 
+    public RelationshipKind getById(long id) {
+        return dsl
+                .select()
+                .from(RELATIONSHIP_KIND)
+                .where(RELATIONSHIP_KIND.ID.eq(id))
+                .fetchOne(TO_DOMAIN_MAPPER);
+    }
+
 
     public Set<RelationshipKind> findRelationshipKindsBetweenEntites(EntityReference parent, EntityReference target){
 

waltz-model/src/main/java/org/finos/waltz/model/bulk_upload/entity_relationship/BulkUploadRelationshipApplyResult.java

@@ -0,0 +1,15 @@
+package org.finos.waltz.model.bulk_upload.entity_relationship;
+
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import org.immutables.value.Value;
+
+@Value.Immutable
+@JsonSerialize(as = ImmutableBulkUploadRelationshipApplyResult.class)
+public interface BulkUploadRelationshipApplyResult {
+
+    Long recordsAdded();
+
+    Long recordsUpdated();
+
+    Long skippedRows();
+}

waltz-model/src/main/java/org/finos/waltz/model/bulk_upload/entity_relationship/BulkUploadRelationshipItem.java

@@ -0,0 +1,25 @@
+package org.finos.waltz.model.bulk_upload.entity_relationship;
+
+import com.fasterxml.jackson.annotation.JsonAlias;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
+import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
+import org.finos.waltz.model.Nullable;
+import org.immutables.value.Value;
+
+@Value.Immutable
+@JsonDeserialize(as = ImmutableBulkUploadRelationshipItem.class)
+@JsonIgnoreProperties(ignoreUnknown = true)
+@JsonFormat(with = JsonFormat.Feature.ACCEPT_CASE_INSENSITIVE_PROPERTIES)
+public interface BulkUploadRelationshipItem {
+
+    @JsonAlias({"source_external_id", "source_id"})
+    String sourceExternalId();
+
+    @JsonAlias({"target_external_id", "target_id"})
+    String targetExternalId();
+
+    @Nullable
+    String description();
+
+}

waltz-model/src/main/java/org/finos/waltz/model/bulk_upload/entity_relationship/BulkUploadRelationshipParsedResult.java

@@ -0,0 +1,50 @@
+package org.finos.waltz.model.bulk_upload.entity_relationship;
+
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import org.finos.waltz.model.Nullable;
+import org.immutables.value.Value;
+
+import java.util.List;
+
+@Value.Immutable
+@JsonSerialize(as = ImmutableBulkUploadRelationshipParsedResult.class)
+public interface BulkUploadRelationshipParsedResult {
+
+    @Value.Immutable
+    interface BulkUploadRelationshipParseError {
+        String message();
+
+        @Nullable
+        Integer line();
+
+        @Nullable
+        Integer column();
+    }
+
+    String input();
+
+    List<BulkUploadRelationshipItem> parsedItems();
+
+    @Nullable
+    BulkUploadRelationshipParseError error();
+
+    static BulkUploadRelationshipParsedResult mkResult(List<BulkUploadRelationshipItem> items,
+                                                    String input) {
+        if(items.isEmpty()) {
+            return ImmutableBulkUploadRelationshipParsedResult
+                    .builder()
+                    .input(input)
+                    .error(ImmutableBulkUploadRelationshipParseError
+                            .builder()
+                            .message("Cannot parse input.")
+                            .build())
+                    .build();
+        }
+
+        return ImmutableBulkUploadRelationshipParsedResult
+                .builder()
+                .parsedItems(items)
+                .input(input)
+                .build();
+    }
+}

waltz-model/src/main/java/org/finos/waltz/model/bulk_upload/entity_relationship/BulkUploadRelationshipValidatedItem.java

@@ -0,0 +1,28 @@
+package org.finos.waltz.model.bulk_upload.entity_relationship;
+
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import org.finos.waltz.model.EntityReference;
+import org.finos.waltz.model.Nullable;
+import org.immutables.value.Value;
+
+import java.util.Set;
+
+@Value.Immutable
+@JsonSerialize(as = ImmutableBulkUploadRelationshipValidatedItem.class)
+public interface BulkUploadRelationshipValidatedItem {
+    BulkUploadRelationshipItem parsedItem();
+
+    @Nullable
+    EntityReference sourceEntityRef();
+
+    @Nullable
+    EntityReference targetEntityRef();
+
+    @Nullable
+    String description();
+
+    @Nullable
+    Set<ValidationError> error();
+
+    UploadOperation uploadOperation();
+}

waltz-model/src/main/java/org/finos/waltz/model/bulk_upload/entity_relationship/BulkUploadRelationshipValidationResult.java

@@ -0,0 +1,16 @@
+package org.finos.waltz.model.bulk_upload.entity_relationship;
+
+import com.fasterxml.jackson.databind.annotation.JsonSerialize;
+import org.finos.waltz.model.Nullable;
+import org.immutables.value.Value;
+
+import java.util.List;
+
+@Value.Immutable
+@JsonSerialize(as = ImmutableBulkUploadRelationshipValidationResult.class)
+public interface BulkUploadRelationshipValidationResult {
+    List<BulkUploadRelationshipValidatedItem> validatedItems();
+
+    @Nullable
+    BulkUploadRelationshipParsedResult.BulkUploadRelationshipParseError parseError();
+}

waltz-model/src/main/java/org/finos/waltz/model/bulk_upload/entity_relationship/UploadOperation.java

@@ -0,0 +1,7 @@
+package org.finos.waltz.model.bulk_upload.entity_relationship;
+
+public enum UploadOperation {
+    ADD,
+    UPDATE,
+    NONE
+}

waltz-model/src/main/java/org/finos/waltz/model/bulk_upload/entity_relationship/ValidationError.java

@@ -0,0 +1,9 @@
+package org.finos.waltz.model.bulk_upload.entity_relationship;
+
+public enum ValidationError {
+    SOURCE_INVALID,
+    SOURCE_NOT_FOUND,
+    TARGET_INVALID,
+    TARGET_NOT_FOUND
+
+}

waltz-ng/client/svelte-stores/entity-relationship-store.js

@@ -80,12 +80,29 @@ export function mkEntityRelationshipStore() {
 
     };
 
+    const bulkUploadRelationshipsPreview = (relationshipKindId, data) => remote
+            .execute(
+            "POST",
+            `api/entity-relationship/bulk/preview/${relationshipKindId}`,
+            data
+        );
+
+    const bulkUploadRelationshipsApply = (relationshipKindId, data) => remote
+            .execute(
+            "POST",
+            `api/entity-relationship/bulk/apply/${relationshipKindId}`,
+            data
+    );
+
+
     return {
         getById,
         findBetweenEntities,
         findForEntity,
         remove,
-        create
+        create,
+        bulkUploadRelationshipsPreview,
+        bulkUploadRelationshipsApply
     };
 }
 

waltz-ng/client/system/relationship-kinds-view.html

@@ -165,6 +165,11 @@ <h4 ng-bind="$ctrl.selectedRelationshipKind.name"></h4>
                                        class="clickable">
                                         Remove
                                     </a>
+                                    |
+                                    <a ng-click="$ctrl.bulkUploadRelationships()"
+                                        class="clickable">
+                                        Bulk Upload Relationships
+                                    </a>
                                 </span>
                             </div>
                         </div>
@@ -175,6 +180,11 @@ <h4 ng-bind="$ctrl.selectedRelationshipKind.name"></h4>
 
         <hr>
 
+        <div ng-if="$ctrl.visibility.bulk" class="col-sm-12">
+            <waltz-svelte-component component="$ctrl.BulkRelationshipUpload" selected-relationship-kind="$ctrl.selectedRelationshipKind">
+            </waltz-svelte-component>
+        </div>
+
         <div ng-if="$ctrl.visibility.update" class="col-sm-12">
             <hr>
             <h4> Update relationship kind: </h4>

waltz-ng/client/system/relationship-kinds-view.js

@@ -22,6 +22,7 @@ import * as _ from "lodash";
 import {displayError} from "../common/error-utils";
 import {entity} from "../common/services/enums/entity";
 import toasts from "../svelte-stores/toast-store";
+import BulkRelationshipUpload from "./svelte/bulk-relationships/BulkRelationshipUpload.svelte";
 
 const initialState = {
     relationshipKinds: [],
@@ -40,8 +41,10 @@ const initialState = {
     },
     visibility: {
         create: false,
-        edit: false
-    }
+        update: false,
+        bulk: false
+    },
+    BulkRelationshipUpload
 };
 
 
@@ -51,7 +54,7 @@ const columnDefs = [
         displayName: "Name",
         width: "25%",
     },{
-        field: "name",
+        field: "reverseName",
         displayName: "Reverse Name",
         width: "25%",
     }, {
@@ -127,12 +130,14 @@ function controller(serviceBroker, $q) {
         vm.form.position = vm.selectedRelationshipKind.position;
 
         vm.visibility.update = true;
+        vm.visibility.bulk = false;
     };
 
     vm.createRelationshipKind = () => {
         vm.resetForm();
         vm.visibility.create = true;
         vm.visibility.update = false;
+        vm.visibility.bulk = false;
         vm.selectedRelationshipKind = null;
     };
 
@@ -171,6 +176,7 @@ function controller(serviceBroker, $q) {
     vm.onDismiss = () => {
         vm.visibility.create = false;
         vm.visibility.update = false;
+        vm.visibility.bulk = false;
         vm.resetForm();
     };
 
@@ -225,6 +231,11 @@ function controller(serviceBroker, $q) {
                 });
         }
     }
+
+    vm.bulkUploadRelationships = () => {
+        vm.visibility.bulk = true;
+        vm.visibility.update = false;
+    }
 }
 
 controller.$inject = [