adds substationOrVoltageLevelFilters to GlobalFilter (#102)

Signed-off-by: Mathieu DEHARBE <mathieu.deharbe@rte-france.com>

Author: Mathieu-Deharbe

src/main/java/org/gridsuite/filter/globalfilter/GlobalFilter.java

@@ -31,6 +31,7 @@
 public class GlobalFilter {
     private List<String> nominalV;
     private List<Country> countryCode;
+    private List<UUID> substationOrVoltageLevelFilter; // list of generic filters containing only voltage level and substation filters
     private List<UUID> genericFilter;
     private Map<String, List<String>> substationProperty;
 
@@ -41,6 +42,7 @@ public boolean isEmpty() {
         return CollectionUtils.isEmpty(this.nominalV)
             && CollectionUtils.isEmpty(this.countryCode)
             && CollectionUtils.isEmpty(this.genericFilter)
+            && CollectionUtils.isEmpty(this.substationOrVoltageLevelFilter)
             && (MapUtils.isEmpty(this.substationProperty) || this.substationProperty.values().stream().allMatch(CollectionUtils::isEmpty));
     }
 }

src/main/java/org/gridsuite/filter/globalfilter/GlobalFilterUtils.java

@@ -70,7 +70,6 @@ public static List<FieldType> getCountryCodeFieldType(@Nonnull final EquipmentTy
                  SHUNT_COMPENSATOR, STATIC_VAR_COMPENSATOR, SUBSTATION,
                  THREE_WINDINGS_TRANSFORMER, TWO_WINDINGS_TRANSFORMER, VOLTAGE_LEVEL, LCC_CONVERTER_STATION, VSC_CONVERTER_STATION -> List.of(FieldType.COUNTRY);
             case LINE, HVDC_LINE -> List.of(FieldType.COUNTRY_1, FieldType.COUNTRY_2);
-            default -> List.of();
         };
     }
 
@@ -150,18 +149,23 @@ public static AbstractExpertRule buildGenericFilterRule(@Nonnull final List<Abst
                                                             @Nonnull final EquipmentType actualType) {
         final List<AbstractExpertRule> rules = new ArrayList<>();
 
-        // Create only one OR rule for all filters with same type (matches actualType exclude substation and voltage levels)
-        if (actualType != EquipmentType.VOLTAGE_LEVEL && actualType != EquipmentType.SUBSTATION) {
-            List<AbstractFilter> typeMatches = genericFilters.stream()
-                    .filter(abstractFilter -> abstractFilter.getEquipmentType() == actualType)
-                    .toList();
+        // Create only one OR rule for all filters with same type
+        List<AbstractFilter> typeMatches = genericFilters.stream()
+                .filter(abstractFilter -> abstractFilter.getEquipmentType() == actualType)
+                .toList();
 
-            AbstractExpertRule typeMatchesRule = createFilterBasedRule(typeMatches, Set.of(FieldType.ID));
-            if (typeMatchesRule != null) {
-                rules.add(typeMatchesRule);
-            }
+        AbstractExpertRule typeMatchesRule = createFilterBasedRule(typeMatches, Set.of(FieldType.ID));
+        if (typeMatchesRule != null) {
+            rules.add(typeMatchesRule);
         }
 
+        return ExpertFilterUtils.buildAndCombination(rules).orElse(null);
+    }
+
+    public static AbstractExpertRule buildSubstationOrVoltageLevelFilterRule(@Nonnull final List<AbstractFilter> genericFilters,
+                                                                             @Nonnull final EquipmentType actualType) {
+        final List<AbstractExpertRule> rules = new ArrayList<>();
+
         // Create one rule for substations and voltage levels (combined with Or)
         List<AbstractExpertRule> subsStationsAndVoltageLevelsRules = new ArrayList<>();
 
@@ -204,21 +208,30 @@ public static AbstractExpertRule buildGenericFilterRule(@Nonnull final List<Abst
     @Nullable
     public static ExpertFilter buildExpertFilter(@Nonnull final GlobalFilter globalFilter,
                                                  @Nonnull final EquipmentType equipmentType,
-                                                 @Nonnull final List<AbstractFilter> genericFilters) {
+                                                 @Nonnull final List<AbstractFilter> genericFilters,
+                                                 @Nonnull final List<AbstractFilter> substationOrVoltageLevelFilters) {
         final List<AbstractExpertRule> andRules = new ArrayList<>();
 
         // Generic filter have a priority on other filter types
         if (!shouldProcessEquipmentType(equipmentType, genericFilters)) {
             return null;
         }
 
-        if (CollectionUtils.isNotEmpty(genericFilters)) {
+        // substation and voltage levels are handled specifically in buildSubstationOrVoltageLevelFilterRule, they are ignored here
+        if (CollectionUtils.isNotEmpty(genericFilters) && equipmentType != EquipmentType.VOLTAGE_LEVEL && equipmentType != EquipmentType.SUBSTATION) {
             AbstractExpertRule genericRule = buildGenericFilterRule(genericFilters, equipmentType);
             if (genericRule != null) {
                 andRules.add(genericRule);
             }
         }
 
+        if (CollectionUtils.isNotEmpty(substationOrVoltageLevelFilters)) {
+            AbstractExpertRule genericRule = buildSubstationOrVoltageLevelFilterRule(substationOrVoltageLevelFilters, equipmentType);
+            if (genericRule != null) {
+                andRules.add(genericRule);
+            }
+        }
+
         if (globalFilter.getNominalV() != null) {
             buildNominalVoltageRules(globalFilter.getNominalV(), equipmentType).ifPresent(andRules::add);
         }
@@ -261,17 +274,20 @@ public static List<String> applyFilterOnNetwork(@Nonnull final AbstractFilter fi
     /**
      * Extracts filtered {@link Identifiable#getId() equipment ID}s by applying {@link ExpertFilter expert}
      * and {@link AbstractFilter generic filter}s.
+     * @param genericFilters loaded filters from globalFilter.getGenericFilter() (cache)
+     * @param substationOrVoltageLevelFilters loaded filters from globalFilter.getSubstationOrVoltageLevelFilter() (cache)
      */
     @Nonnull
     public static List<String> applyGlobalFilterOnNetwork(@Nonnull final Network network,
                                                           @Nonnull final GlobalFilter globalFilter,
                                                           @Nonnull final EquipmentType equipmentType,
                                                           final List<AbstractFilter> genericFilters,
+                                                          final List<AbstractFilter> substationOrVoltageLevelFilters,
                                                           @Nonnull final FilterLoader filterLoader) {
         List<String> allFilterResults = null;
 
         // Extract IDs from expert filter
-        final ExpertFilter expertFilter = buildExpertFilter(globalFilter, equipmentType, genericFilters);
+        final ExpertFilter expertFilter = buildExpertFilter(globalFilter, equipmentType, genericFilters, substationOrVoltageLevelFilters);
         if (expertFilter != null) {
             allFilterResults = filterNetwork(expertFilter, network, filterLoader);
         }
@@ -287,9 +303,10 @@ public static List<String> applyGlobalFilterOnNetwork(@Nonnull final Network net
      * type filters
      * @param equipmentType : equipment type that should be processed
      * @param genericFilters : generic filters list
-     * **/
+     * @return false if the global filter should not be processed because of the generic filters equipment types
+     */
     public static boolean shouldProcessEquipmentType(@Nonnull final EquipmentType equipmentType,
-                                                     @Nonnull final List<AbstractFilter>genericFilters) {
+                                                     @Nonnull final List<AbstractFilter> genericFilters) {
 
         // The current equipment type will be process IF
         // list genericFilters is empty
@@ -322,13 +339,25 @@ public static Map<EquipmentType, List<String>> applyGlobalFilterOnNetwork(@Nonnu
                                                                               @Nonnull final FilterLoader filterLoader) {
         Map<EquipmentType, List<String>> result = new EnumMap<>(EquipmentType.class);
 
-        List<AbstractFilter> genericFilters = null;
+        List<AbstractFilter> genericFilters = new ArrayList<>();
         if (CollectionUtils.isNotEmpty(globalFilter.getGenericFilter())) {
             genericFilters = filterLoader.getFilters(globalFilter.getGenericFilter());
         }
 
+        List<AbstractFilter> substationOrVoltageLevelFilters = new ArrayList<>();
+        if (CollectionUtils.isNotEmpty(globalFilter.getSubstationOrVoltageLevelFilter())) {
+            substationOrVoltageLevelFilters = filterLoader.getFilters(globalFilter.getSubstationOrVoltageLevelFilter());
+        }
+
         for (final EquipmentType equipmentType : equipmentTypes) {
-            final List<String> filteredIds = applyGlobalFilterOnNetwork(network, globalFilter, equipmentType, genericFilters, filterLoader);
+            final List<String> filteredIds = applyGlobalFilterOnNetwork(
+                    network,
+                    globalFilter,
+                    equipmentType,
+                    genericFilters,
+                    substationOrVoltageLevelFilters,
+                    filterLoader
+            );
             if (!filteredIds.isEmpty()) {
                 result.put(equipmentType, filteredIds);
             }

src/test/java/org/gridsuite/filter/globalfilter/GlobalFilterUtilsTest.java

@@ -117,7 +117,7 @@ void testFiltersOnOtherEquipmentTypes() {
             Mockito.when(voltageLevelFilter.getEquipmentType()).thenReturn(EquipmentType.VOLTAGE_LEVEL);
 
             Mockito.when(loader.getFilters(genericFiltersUuids)).thenReturn(List.of(
-                lineFilter, voltageLevelFilter));
+                    lineFilter, voltageLevelFilter));
 
             List<AbstractFilter> genericFilters = loader.getFilters(genericFiltersUuids);
 
@@ -295,16 +295,16 @@ private static Stream<Arguments> substationPropertyFieldTypeData() {
     class BuildExpertFilter {
         @Test
         void shouldReturnNullWhenNoExpertFiltersProvided() {
-            final GlobalFilter globalFilter = new GlobalFilter(null, null, null, null);
-            assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR, List.of()))
+            final GlobalFilter globalFilter = new GlobalFilter(null, null, null, null, null);
+            assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR, List.of(), List.of()))
                     .as("result").isNull();
         }
 
         @Test
         void shouldReturnNullWhenNoRules() {
-            final GlobalFilter globalFilter = new GlobalFilter(List.of(), List.of(), List.of(), Map.of());
+            final GlobalFilter globalFilter = new GlobalFilter(List.of(), List.of(), List.of(), List.of(), Map.of());
             assertTrue(globalFilter.isEmpty());
-            assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR, List.of()))
+            assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR, List.of(), List.of()))
                 .as("result").isNull();
         }
 
@@ -316,8 +316,8 @@ void shouldReturnResult() {
                     List.of(new IdentifierListFilterEquipmentAttributes("GEN1", 50.),
                         new IdentifierListFilterEquipmentAttributes("GEN2", 50.)
                 )));
-            final GlobalFilter globalFilter = new GlobalFilter(List.of("380", "225"), List.of(Country.FR, Country.BE), filterUuids, Map.of());
-            assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR, filters))
+            final GlobalFilter globalFilter = new GlobalFilter(List.of("380", "225"), List.of(Country.FR, Country.BE), filterUuids, List.of(), Map.of());
+            assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR, filters, List.of()))
                 .as("result").isNotNull();
         }
 
@@ -329,8 +329,8 @@ void shouldReturnResultWithGenericFilterTypeDifferentFromEquipmentType() {
                     List.of(new IdentifierListFilterEquipmentAttributes("GEN1", 50.),
                         new IdentifierListFilterEquipmentAttributes("GEN2", 50.)
                     )));
-            final GlobalFilter globalFilter = new GlobalFilter(List.of("380", "225"), List.of(Country.FR, Country.BE), filterUuids, Map.of());
-            assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR, filters))
+            final GlobalFilter globalFilter = new GlobalFilter(List.of("380", "225"), List.of(Country.FR, Country.BE), filterUuids, List.of(), Map.of());
+            assertThat(GlobalFilterUtils.buildExpertFilter(globalFilter, EquipmentType.GENERATOR, List.of(), filters))
                 .as("result").isNotNull();
         }
     }
@@ -497,7 +497,35 @@ void shouldBuildVoltageLevelFilterWhenVoltageLevelType() {
                 final List<Identifiable<?>> attributes = List.of(line1, line2);
                 mockedFU.when(() -> FiltersUtils.getIdentifiables(any(ExpertFilter.class), eq(network), eq(loader))).thenReturn(attributes);
                 mockedFU.clearInvocations(); //important because stubbing static method counts as call
-                assertThat(GlobalFilterUtils.applyGlobalFilterOnNetwork(network, globalFilter, EquipmentType.LINE, List.of(filter), loader))
+                assertThat(GlobalFilterUtils.applyGlobalFilterOnNetwork(network, globalFilter, EquipmentType.LINE, List.of(), List.of(filter), loader))
+                    .as("result").containsExactlyInAnyOrder("line1", "line2");
+                Mockito.verify(filter, Mockito.atLeastOnce()).getEquipmentType();
+                Mockito.verify(filter, Mockito.atLeastOnce()).getId();
+                Mockito.verify(line1, Mockito.atLeastOnce()).getId();
+                Mockito.verify(line2, Mockito.atLeastOnce()).getId();
+                Mockito.verifyNoMoreInteractions(filter, network, line1, line2);
+                mockedFU.verify(() -> FiltersUtils.getIdentifiables(any(ExpertFilter.class), eq(network), eq(loader)), Mockito.atLeastOnce());
+            }
+        }
+
+        @Test
+        void shouldBuildSubstationFilterWhenSubstationType() {
+            final Network network = Mockito.mock(Network.class);
+            final FilterLoader loader = Mockito.mock(FilterLoader.class);
+            final AbstractFilter filter = Mockito.mock(AbstractFilter.class);
+            final GlobalFilter globalFilter = Mockito.mock(GlobalFilter.class);
+            when(filter.getEquipmentType()).thenReturn(EquipmentType.SUBSTATION);
+            final UUID filterUuid = UuidUtils.createUUID(0);
+            when(filter.getId()).thenReturn(filterUuid);
+            try (final MockedStatic<FiltersUtils> mockedFU = Mockito.mockStatic(FiltersUtils.class, Mockito.CALLS_REAL_METHODS)) {
+                final Identifiable<?> line1 = Mockito.mock(Identifiable.class);
+                when(line1.getId()).thenReturn("line1");
+                final Identifiable<?> line2 = Mockito.mock(Identifiable.class);
+                when(line2.getId()).thenReturn("line2");
+                final List<Identifiable<?>> attributes = List.of(line1, line2);
+                mockedFU.when(() -> FiltersUtils.getIdentifiables(any(ExpertFilter.class), eq(network), eq(loader))).thenReturn(attributes);
+                mockedFU.clearInvocations(); //important because stubbing static method counts as call
+                assertThat(GlobalFilterUtils.applyGlobalFilterOnNetwork(network, globalFilter, EquipmentType.LINE, List.of(), List.of(filter), loader))
                     .as("result").containsExactlyInAnyOrder("line1", "line2");
                 Mockito.verify(filter, Mockito.atLeastOnce()).getEquipmentType();
                 Mockito.verify(filter, Mockito.atLeastOnce()).getId();
@@ -515,7 +543,7 @@ void shouldReturnEmptyWhenDifferentEquipmentType() {
             final AbstractFilter filter = Mockito.mock(AbstractFilter.class);
             final GlobalFilter globalFilter = Mockito.mock(GlobalFilter.class);
             when(filter.getEquipmentType()).thenReturn(EquipmentType.LOAD);
-            assertThat(GlobalFilterUtils.applyGlobalFilterOnNetwork(network, globalFilter, EquipmentType.GENERATOR, List.of(filter), loader))
+            assertThat(GlobalFilterUtils.applyGlobalFilterOnNetwork(network, globalFilter, EquipmentType.GENERATOR, List.of(filter), List.of(), loader))
                 .as("result").isEmpty();
             Mockito.verify(filter, Mockito.atLeastOnce()).getEquipmentType();
             Mockito.verifyNoMoreInteractions(network, filter);
@@ -540,9 +568,16 @@ void shouldReturnFilteredNetwork() {
             final UUID filterTransUuid = UuidUtils.createUUID(1);
             when(filterTrans.getId()).thenReturn(filterTransUuid);
 
+            final AbstractFilter filterSubstation = Mockito.mock(AbstractFilter.class);
+            when(filterSubstation.getEquipmentType()).thenReturn(EquipmentType.SUBSTATION);
+            final UUID filterSubstationUuid = UuidUtils.createUUID(2);
+            when(filterSubstation.getId()).thenReturn(filterSubstationUuid);
+
             final GlobalFilter globalFilter = Mockito.mock(GlobalFilter.class);
             List<UUID> genericFilterUuids = List.of(filterLineUuid, filterTransUuid);
             when(globalFilter.getGenericFilter()).thenReturn(genericFilterUuids);
+            List<UUID> substationOrVoltageLevelFilteUuids = List.of(filterSubstationUuid);
+            when(globalFilter.getSubstationOrVoltageLevelFilter()).thenReturn(substationOrVoltageLevelFilteUuids);
 
             when(loader.getFilters(genericFilterUuids)).thenReturn(List.of(filterLine, filterTrans));
 
@@ -612,9 +647,12 @@ void testSubstationAndVoltageLevelOnAnyEquipmentType() {
             when(filter2.getId()).thenReturn(filterUuids.get(1));
 
             List<AbstractFilter> filters = Arrays.asList(filter1, filter2);
-            assertNotNull(GlobalFilterUtils.buildGenericFilterRule(filters, EquipmentType.LINE));
-            assertNotNull(GlobalFilterUtils.buildGenericFilterRule(filters, EquipmentType.GENERATOR));
-            assertNotNull(GlobalFilterUtils.buildGenericFilterRule(filters, EquipmentType.TWO_WINDINGS_TRANSFORMER));
+            assertNull(GlobalFilterUtils.buildGenericFilterRule(filters, EquipmentType.LINE));
+            assertNull(GlobalFilterUtils.buildGenericFilterRule(filters, EquipmentType.GENERATOR));
+            assertNull(GlobalFilterUtils.buildGenericFilterRule(filters, EquipmentType.TWO_WINDINGS_TRANSFORMER));
+            assertNotNull(GlobalFilterUtils.buildSubstationOrVoltageLevelFilterRule(filters, EquipmentType.LINE));
+            assertNotNull(GlobalFilterUtils.buildSubstationOrVoltageLevelFilterRule(filters, EquipmentType.GENERATOR));
+            assertNotNull(GlobalFilterUtils.buildSubstationOrVoltageLevelFilterRule(filters, EquipmentType.TWO_WINDINGS_TRANSFORMER));
         }
 
         @Test