Move global filter utils

pom.xml

@@ -44,7 +44,7 @@
     <properties>
         <gridsuite-dependencies.version>43.1.0</gridsuite-dependencies.version>
         <!-- TODO gridsuite-filter.version remove when upgrading gridsuite dependencies -->
-        <gridsuite-filter.version>1.9.0</gridsuite-filter.version>
+        <gridsuite-filter.version>1.10.0-SNAPSHOT</gridsuite-filter.version>
         <string-template.version>4.3.1</string-template.version>
         <liquibase-hibernate-package>org.gridsuite.filter.server</liquibase-hibernate-package>
         <sonar.coverage.exclusions>**/migrations/**/*</sonar.coverage.exclusions>
@@ -88,8 +88,6 @@
 
     <dependencyManagement>
         <dependencies>
-
-
             <!-- imports -->
             <dependency>
                 <groupId>org.gridsuite</groupId>

src/main/java/org/gridsuite/filter/server/GlobalFilterController.java

@@ -0,0 +1,45 @@
+package org.gridsuite.filter.server;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import lombok.AllArgsConstructor;
+import org.gridsuite.filter.globalfilter.GlobalFilter;
+import org.gridsuite.filter.utils.EquipmentType;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.lang.NonNull;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+import org.springframework.web.client.HttpClientErrorException;
+
+import java.util.List;
+import java.util.UUID;
+
+@Validated
+@RestController
+@RequestMapping(value = "/" + FilterApi.API_VERSION + "/global-filter",
+    produces = MediaType.APPLICATION_JSON_VALUE, consumes = MediaType.APPLICATION_JSON_VALUE)
+@Tag(name = "GlobalFilter component controller")
+@AllArgsConstructor
+public class GlobalFilterController {
+    private final GlobalFilterService service;
+
+    @PostMapping(value = "/")
+    @Operation(summary = "Get network equipments IDs that match the filter(s)")
+    @ApiResponse(responseCode = "200", description = "The filter")
+    @ApiResponse(responseCode = "400", description = "Invalid parameters")
+    @ApiResponse(responseCode = "404", description = "The filter does not exists")
+    public ResponseEntity<List<String>> getResults(
+            @Parameter(description = "The network UUID") @RequestParam(name = "networkUuid") @NonNull final UUID networkUuid,
+            @Parameter(description = "The variant ID of the network") @RequestParam(name = "variantId") @NonNull final String variantId,
+            @Parameter(description = "The equipments types to filter and return") @RequestParam(name = "equipmentTypes") @NonNull final List<EquipmentType> equipmentTypes,
+            @Parameter(description = "The filter(s) to apply") @RequestBody @NonNull final GlobalFilter filterParams) {
+        if (filterParams.isEmpty()) {
+            throw HttpClientErrorException.create(HttpStatus.BAD_REQUEST, "At least one filter must be specified.", null, null, null);
+        }
+        return ResponseEntity.ok(service.getFilteredIds(networkUuid, variantId, filterParams, equipmentTypes));
+    }
+}

src/main/java/org/gridsuite/filter/server/GlobalFilterService.java

@@ -0,0 +1,54 @@
+package org.gridsuite.filter.server;
+
+import com.powsybl.commons.PowsyblException;
+import com.powsybl.iidm.network.Network;
+import com.powsybl.network.store.client.NetworkStoreService;
+import com.powsybl.network.store.client.PreloadingStrategy;
+import lombok.AllArgsConstructor;
+import lombok.NonNull;
+import org.gridsuite.filter.AbstractFilter;
+import org.gridsuite.filter.globalfilter.AbstractGlobalFilterService;
+import org.gridsuite.filter.globalfilter.GlobalFilter;
+import org.gridsuite.filter.utils.EquipmentType;
+import org.springframework.http.HttpStatus;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.server.ResponseStatusException;
+
+import java.util.List;
+import java.util.UUID;
+
+@Service
+@AllArgsConstructor
+public class GlobalFilterService extends AbstractGlobalFilterService {
+    private final NetworkStoreService networkStoreService;
+    private final RepositoryService repositoriesService;
+
+    /** {@inheritDoc} */
+    @Override
+    protected Network getNetwork(@NonNull final UUID networkUuid, @NonNull final String variantId) {
+        try {
+            Network network = networkStoreService.getNetwork(networkUuid, PreloadingStrategy.COLLECTION);
+            network.getVariantManager().setWorkingVariant(variantId);
+            return network;
+        } catch (final PowsyblException ex) {
+            throw new ResponseStatusException(HttpStatus.NOT_FOUND, ex.getMessage());
+        }
+    }
+
+    /** {@inheritDoc} */
+    @Override
+    @Transactional(readOnly = true)
+    public List<AbstractFilter> getFilters(@NonNull final List<UUID> filtersUuids) {
+        return this.repositoriesService.getFilters(filtersUuids);
+    }
+
+    /* Expose it publicly */
+    /** {@inheritDoc} */
+    @Override
+    public List<String> getFilteredIds(@NonNull final UUID networkUuid, @NonNull final String variantId,
+                                       @NonNull final GlobalFilter globalFilter,
+                                       @NonNull final List<EquipmentType> equipmentTypes) {
+        return super.getFilteredIds(networkUuid, variantId, globalFilter, equipmentTypes);
+    }
+}

src/main/java/org/gridsuite/filter/server/RepositoryService.java

@@ -0,0 +1,98 @@
+package org.gridsuite.filter.server;
+
+import lombok.Getter;
+import lombok.NonNull;
+import org.apache.commons.collections4.ListUtils;
+import org.gridsuite.filter.AbstractFilter;
+import org.gridsuite.filter.FilterLoader;
+import org.gridsuite.filter.server.dto.FilterAttributes;
+import org.gridsuite.filter.server.repositories.expertfilter.ExpertFilterRepository;
+import org.gridsuite.filter.server.repositories.identifierlistfilter.IdentifierListFilterRepository;
+import org.gridsuite.filter.server.repositories.proxies.AbstractFilterRepositoryProxy;
+import org.gridsuite.filter.server.repositories.proxies.expertfiler.ExpertFilterRepositoryProxy;
+import org.gridsuite.filter.server.repositories.proxies.identifierlistfilter.IdentifierListFilterRepositoryProxy;
+import org.gridsuite.filter.utils.FilterType;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+import java.util.stream.Stream;
+
+/**
+ * More an utility service to call a methode on all {@link AbstractFilterRepositoryProxy repositories}
+ * and merge the result.
+ */
+@Service
+public class RepositoryService {
+    private final IdentifierListFilterRepositoryProxy identifierListFilterProxy;
+    private final ExpertFilterRepositoryProxy expertFilterProxy;
+    @Getter private final FilterLoader filterLoader;
+
+    public RepositoryService(final IdentifierListFilterRepository identifierListFilterRepository,
+                             final ExpertFilterRepository expertFilterRepository) {
+        this.identifierListFilterProxy = new IdentifierListFilterRepositoryProxy(identifierListFilterRepository);
+        this.expertFilterProxy = new ExpertFilterRepositoryProxy(expertFilterRepository);
+        this.filterLoader = new FilterLoaderImpl(Map.of(
+            FilterType.IDENTIFIER_LIST.name(), this.identifierListFilterProxy,
+            FilterType.EXPERT.name(), this.expertFilterProxy
+        ));
+    }
+
+    public AbstractFilterRepositoryProxy<?, ?> getRepositoryFromType(@NonNull final FilterType type) {
+        return switch (type) {
+            case IDENTIFIER_LIST -> identifierListFilterProxy;
+            case EXPERT -> expertFilterProxy;
+        };
+    }
+
+    public AbstractFilterRepositoryProxy<?, ?> getRepositoryFromType(@NonNull final AbstractFilter filter) {
+        return this.getRepositoryFromType(filter.getType());
+    }
+
+    /** @see AbstractFilterRepositoryProxy#deleteById(UUID) */
+    public boolean deleteFilter(@NonNull final UUID id) {
+        return this.identifierListFilterProxy.deleteById(id) || this.expertFilterProxy.deleteById(id);
+    }
+
+    /** @see AbstractFilterRepositoryProxy#deleteAllByIds(List) */
+    public void deleteFilters(@NonNull final List<UUID> ids) {
+        this.identifierListFilterProxy.deleteAllByIds(ids);
+        this.expertFilterProxy.deleteAllByIds(ids);
+    }
+
+    /** @see AbstractFilterRepositoryProxy#deleteAll() */
+    public void deleteAll() {
+        this.identifierListFilterProxy.deleteAll();
+        this.expertFilterProxy.deleteAll();
+    }
+
+    /** @see AbstractFilterRepositoryProxy#getFiltersAttributes() */
+    @Transactional(readOnly = true)
+    public Stream<FilterAttributes> getFiltersAttributes() {
+        return Stream.concat(this.identifierListFilterProxy.getFiltersAttributes(), this.expertFilterProxy.getFiltersAttributes());
+    }
+
+    /** @see AbstractFilterRepositoryProxy#getFiltersAttributes(List) */
+    @Transactional(readOnly = true)
+    public Stream<FilterAttributes> getFiltersAttributes(@NonNull final List<UUID> ids) {
+        return Stream.concat(this.identifierListFilterProxy.getFiltersAttributes(ids), this.expertFilterProxy.getFiltersAttributes(ids));
+    }
+
+    /** @see AbstractFilterRepositoryProxy#getFilters(List) */
+    @Transactional(readOnly = true)
+    public List<AbstractFilter> getFilters(@NonNull final List<UUID> ids) {
+        return ListUtils.union(
+            this.identifierListFilterProxy.getFilters(ids),
+            this.expertFilterProxy.getFilters(ids)
+        );
+    }
+
+    /** @see AbstractFilterRepositoryProxy#getFilter(UUID) */
+    @Transactional(readOnly = true)
+    public Optional<AbstractFilter> getFilter(@NonNull final UUID id) {
+        return this.identifierListFilterProxy.getFilter(id).or(() -> this.expertFilterProxy.getFilter(id));
+    }
+}

src/main/java/org/gridsuite/filter/server/repositories/FilterRepository.java

@@ -11,6 +11,7 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Query;
 import org.springframework.data.repository.NoRepositoryBean;
+import org.springframework.lang.NonNull;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
@@ -28,8 +29,14 @@ public interface FilterRepository<T extends AbstractFilterEntity> extends JpaRep
     @Query(value = "SELECT t.id as id, t.modificationDate as modificationDate from #{#entityName} as t WHERE t.id in (:ids)")
     List<FilterMetadata> findFiltersMetaDataById(List<UUID> ids);
 
+    /**
+     * Remove a filter by id.
+     * @param id the filter id
+     * @return the number of filter(s) removed ({@code 0} or {@code 1})
+     * @see #deleteById(Object) like deleteById(id) but with the indicator of either a filter has been removed or not
+     */
     @Transactional
-    Integer removeById(UUID id);
+    long removeById(@NonNull UUID id);
 
     @Transactional
     void deleteAllByIdIn(List<UUID> ids);

src/main/java/org/gridsuite/filter/server/repositories/proxies/AbstractFilterRepositoryProxy.java

@@ -47,11 +47,7 @@ public static SortedSet<String> setToSorterSet(Set<String> set) {
 
     public abstract FilterType getFilterType();
 
-    public abstract EquipmentType getEquipmentType();
-
-    public EquipmentType getEquipmentType(UUID id) {
-        return getEquipmentType();
-    }
+    public abstract EquipmentType getEquipmentType(UUID id);
 
     public Optional<AbstractFilter> getFilter(UUID id) {
         Optional<F> element = getRepository().findById(id);
@@ -76,7 +72,7 @@ public Stream<FilterAttributes> getFiltersAttributes(List<UUID> ids) {
         return getRepository().findFiltersMetaDataById(ids).stream().map(this::metadataToAttribute);
     }
 
-    FilterAttributes metadataToAttribute(FilterMetadata f) {
+    private FilterAttributes metadataToAttribute(final FilterMetadata f) {
         return new FilterAttributes(f, getFilterType(), getEquipmentType(f.getId()));
     }
 
@@ -94,8 +90,13 @@ public AbstractFilter modify(UUID id, AbstractFilter f) {
         return toDto(getRepository().save(fromDto(f)));
     }
 
+    /**
+     * Delete a filter by its id.
+     * @param id the filter id
+     * @return true if the filter has been deleted, false otherwise
+     */
     public boolean deleteById(UUID id) {
-        return getRepository().removeById(id) != 0;
+        return getRepository().removeById(id) > 0L;
     }
 
     public void deleteAllByIds(List<UUID> ids) {
@@ -106,7 +107,7 @@ public void deleteAll() {
         getRepository().deleteAll();
     }
 
-    public void buildAbstractFilter(AbstractFilterEntity.AbstractFilterEntityBuilder<?, ?> builder, AbstractFilter dto) {
+    public static void buildAbstractFilter(AbstractFilterEntity.AbstractFilterEntityBuilder<?, ?> builder, AbstractFilter dto) {
         /* modification date is managed by jpa, so we don't process it */
         builder.id(dto.getId());
     }

src/main/java/org/gridsuite/filter/server/repositories/proxies/expertfiler/ExpertFilterRepositoryProxy.java

@@ -244,11 +244,6 @@ public FilterType getFilterType() {
         return FilterType.EXPERT;
     }
 
-    @Override
-    public EquipmentType getEquipmentType() {
-        throw new UnsupportedOperationException("A filter id must be provided to get equipment type !!");
-    }
-
     @Override
     public EquipmentType getEquipmentType(UUID id) {
         return expertFilterRepository.findById(id)

src/main/java/org/gridsuite/filter/server/repositories/proxies/identifierlistfilter/IdentifierListFilterRepositoryProxy.java

@@ -75,11 +75,6 @@ public FilterType getFilterType() {
         return FilterType.IDENTIFIER_LIST;
     }
 
-    @Override
-    public EquipmentType getEquipmentType() {
-        throw new UnsupportedOperationException("A filter id must be provided to get equipment type !!");
-    }
-
     @Override
     public EquipmentType getEquipmentType(UUID id) {
         return identifierListFilterRepository.findById(id)