Merge pull request #7342 from hmxlabs/7336-Phys-Flow-Search

#7336 Support Search for Physical Flows

Author: kamransaleem

waltz-data/src/main/java/org/finos/waltz/data/physical_flow/PhysicalFlowDao.java

@@ -19,11 +19,14 @@
 package org.finos.waltz.data.physical_flow;
 
 import org.finos.waltz.data.InlineSelectFieldFactory;
+import org.finos.waltz.data.JooqUtilities;
+import org.finos.waltz.data.SearchUtilities;
 import org.finos.waltz.data.enum_value.EnumValueDao;
 import org.finos.waltz.model.EntityKind;
 import org.finos.waltz.model.EntityLifecycleStatus;
 import org.finos.waltz.model.EntityReference;
 import org.finos.waltz.model.UserTimestamp;
+import org.finos.waltz.model.entity_search.EntitySearchOptions;
 import org.finos.waltz.model.enum_value.EnumValueKind;
 import org.finos.waltz.model.physical_flow.CriticalityValue;
 import org.finos.waltz.model.physical_flow.FrequencyKindValue;
@@ -33,6 +36,7 @@
 import org.finos.waltz.model.physical_flow.PhysicalFlowInfo;
 import org.finos.waltz.model.physical_flow.PhysicalFlowParsed;
 import org.finos.waltz.model.physical_flow.TransportKindValue;
+import org.finos.waltz.schema.Tables;
 import org.finos.waltz.schema.tables.PhysicalSpecDataType;
 import org.finos.waltz.schema.tables.records.PhysicalFlowRecord;
 import org.jooq.Condition;
@@ -42,6 +46,7 @@
 import org.jooq.Record1;
 import org.jooq.RecordMapper;
 import org.jooq.Select;
+import org.jooq.SelectQuery;
 import org.jooq.TableField;
 import org.jooq.impl.DSL;
 import org.slf4j.Logger;
@@ -69,6 +74,7 @@
 import static org.finos.waltz.schema.tables.LogicalFlow.LOGICAL_FLOW;
 import static org.finos.waltz.schema.tables.PhysicalFlow.PHYSICAL_FLOW;
 import static org.finos.waltz.schema.tables.PhysicalSpecification.PHYSICAL_SPECIFICATION;
+import static org.jooq.impl.DSL.select;
 
 
 @Repository
@@ -554,4 +560,46 @@ private int updateEnum(long flowId, TableField<PhysicalFlowRecord, String> field
                 .where(PHYSICAL_FLOW.ID.eq(flowId))
                 .execute();
     }
+
+    public List<PhysicalFlow> search(EntitySearchOptions options) {
+        List<String> terms = SearchUtilities.mkTerms(options.searchQuery());
+        if (terms.isEmpty()) {
+            return newArrayList();
+        }
+
+        boolean showRemoved = options
+                .entityLifecycleStatuses()
+                .contains(EntityLifecycleStatus.REMOVED);
+
+        Condition maybeFilterRemoved = showRemoved
+                ? DSL.trueCondition()  // match anything
+                : PHYSICAL_FLOW.IS_REMOVED.isFalse();
+
+        Condition likeName = JooqUtilities.mkBasicTermSearch(PHYSICAL_FLOW.NAME, terms);
+        Condition likeDesc = JooqUtilities.mkBasicTermSearch(PHYSICAL_FLOW.DESCRIPTION, terms);
+        Condition likeExternalIdentifier = JooqUtilities.mkStartsWithTermSearch(PHYSICAL_FLOW.EXTERNAL_ID, terms)
+                .or(JooqUtilities.mkStartsWithTermSearch(EXTERNAL_IDENTIFIER.EXTERNAL_ID, terms));
+
+        Condition searchFilter = likeName.or(likeDesc).or(likeExternalIdentifier);
+
+        SelectQuery<Record> query = dsl
+                .selectDistinct(PHYSICAL_FLOW.fields())
+                .from(PHYSICAL_FLOW)
+                .leftOuterJoin(EXTERNAL_IDENTIFIER)
+                .on(EXTERNAL_IDENTIFIER.ENTITY_KIND.eq(EntityKind.PHYSICAL_FLOW.name())
+                        .and(EXTERNAL_IDENTIFIER.ENTITY_ID.eq(Tables.PHYSICAL_FLOW.ID)))
+                .where(searchFilter)
+                .and(maybeFilterRemoved)
+                .orderBy(PHYSICAL_FLOW.NAME)
+                .limit(options.limit())
+                .getQuery();
+
+                return query.fetch(r -> {
+            PhysicalFlow flow = PhysicalFlowDao.TO_DOMAIN_MAPPER.map(r);
+            return ImmutablePhysicalFlow
+                    .copyOf(flow)
+                    .withDescription(flow.description());
+        });
+    }
+
 }

waltz-model/src/main/java/org/finos/waltz/model/physical_flow/PhysicalFlow.java

@@ -100,6 +100,8 @@ public EntityReference entityReference() {
                 .kind(EntityKind.PHYSICAL_FLOW)
                 .id(id().get())
                 .description(description())
+                .externalId(externalId())
+                .name(name())
                 .build();
     }
 

waltz-ng/client/navbar/components/nav-search-overlay/nav-search-overlay.js

@@ -47,6 +47,7 @@ const initialState = {
         entity.MEASURABLE.key,
         entity.DATA_TYPE.key,
         entity.PHYSICAL_SPECIFICATION.key,
+        entity.PHYSICAL_FLOW.key,
         entity.END_USER_APPLICATION.key,
         entity.LEGAL_ENTITY.key,
         entity.SERVER.key,
@@ -150,7 +151,7 @@ function controller($element,
         handleSearch(query, [entity.APPLICATION.key, entity.PERSON.key])
             .then(() => handleSearch(query, [entity.APP_GROUP.key, entity.CHANGE_INITIATIVE.key, entity.ORG_UNIT.key]))
             .then(() => handleSearch(query, [entity.ACTOR.key, entity.MEASURABLE.key, entity.LEGAL_ENTITY.key, entity.END_USER_APPLICATION.key]))
-            .then(() => handleSearch(query, [entity.PHYSICAL_SPECIFICATION.key, entity.DATA_TYPE.key, entity.SERVER.key, entity.DATABASE.key]))
+            .then(() => handleSearch(query, [entity.PHYSICAL_SPECIFICATION.key, entity.PHYSICAL_FLOW.key, entity.DATA_TYPE.key, entity.SERVER.key, entity.DATABASE.key]))
             .then(() => handleSearch(query, [entity.SOFTWARE.key, entity.ROADMAP.key, entity.LOGICAL_DATA_ELEMENT.key, entity.LICENCE.key]))
             .catch(e => displayError("Failed to search"))
             .finally(() => vm.searching = false);

waltz-service/src/main/java/org/finos/waltz/service/entity_search/EntitySearchService.java

@@ -33,6 +33,7 @@
 import org.finos.waltz.service.orgunit.OrganisationalUnitService;
 import org.finos.waltz.service.person.PersonService;
 import org.finos.waltz.service.physical_specification.PhysicalSpecificationService;
+import org.finos.waltz.service.physical_flow.PhysicalFlowService;
 import org.finos.waltz.service.roadmap.RoadmapService;
 import org.finos.waltz.service.server_information.ServerInformationService;
 import org.finos.waltz.service.software_catalog.SoftwareCatalogService;
@@ -71,6 +72,7 @@ public class EntitySearchService {
     private final OrganisationalUnitService organisationalUnitService;
     private final PersonService personService;
     private final PhysicalSpecificationService physicalSpecificationService;
+    private final PhysicalFlowService physicalFlowService;
     private final RoadmapService roadmapService;
     private final ServerInformationService serverInformationService;
     private final SoftwareCatalogService softwareCatalogService;
@@ -93,6 +95,7 @@ public EntitySearchService(DBExecutorPoolInterface dbExecutorPool,
                                OrganisationalUnitService organisationalUnitService,
                                PersonService personService,
                                PhysicalSpecificationService physicalSpecificationService,
+                               PhysicalFlowService physicalFlowService,
                                RoadmapService roadmapService,
                                ServerInformationService serverInformationService,
                                SoftwareCatalogService softwareCatalogService,
@@ -114,6 +117,7 @@ public EntitySearchService(DBExecutorPoolInterface dbExecutorPool,
         checkNotNull(organisationalUnitService, "organisationalUnitService cannot be null");
         checkNotNull(personService, "personService cannot be null");
         checkNotNull(physicalSpecificationService, "physicalSpecificationService cannot be null");
+        checkNotNull(physicalFlowService, "physicalFlowService cannot be null");
         checkNotNull(roadmapService, "roadmapService cannot be null");
         checkNotNull(serverInformationService, "serverInformationService cannot be null");
         checkNotNull(softwareCatalogService, "softwareCatalogService cannot be null");
@@ -134,6 +138,7 @@ public EntitySearchService(DBExecutorPoolInterface dbExecutorPool,
         this.organisationalUnitService = organisationalUnitService;
         this.personService = personService;
         this.physicalSpecificationService = physicalSpecificationService;
+        this.physicalFlowService = physicalFlowService;
         this.roadmapService = roadmapService;
         this.serverInformationService = serverInformationService;
         this.softwareCatalogService = softwareCatalogService;
@@ -198,6 +203,8 @@ private Callable<Collection<? extends WaltzEntity>> mkCallable(EntityKind entity
                 return () -> personService.search(options);
             case PHYSICAL_SPECIFICATION:
                 return () -> physicalSpecificationService.search(options);
+            case PHYSICAL_FLOW:
+                return () -> physicalFlowService.search(options);
             case ROADMAP:
                 return () -> roadmapService.search(options);
             case SERVER:

waltz-service/src/main/java/org/finos/waltz/service/physical_flow/PhysicalFlowService.java

@@ -21,6 +21,7 @@
 import org.finos.waltz.common.exception.InsufficientPrivelegeException;
 import org.finos.waltz.common.exception.ModifyingReadOnlyRecordException;
 import org.finos.waltz.common.exception.NotFoundException;
+import org.finos.waltz.model.entity_search.EntitySearchOptions;
 import org.finos.waltz.service.changelog.ChangeLogService;
 import org.finos.waltz.service.data_type.DataTypeDecoratorService;
 import org.finos.waltz.service.external_identifier.ExternalIdentifierService;
@@ -453,4 +454,8 @@ public void checkHasPermission(long flowId, String username) throws Insufficient
         checkLogicalFlowPermission(EntityReference.mkRef(EntityKind.LOGICAL_DATA_FLOW, physFlow.logicalFlowId()), username);
     }
 
+    public List<PhysicalFlow> search(EntitySearchOptions options) {
+        checkNotNull(options, "Search options cannot be null");
+        return physicalFlowDao.search(options);
+    }
 }