allow to have a list of temporary limits in line catalog

src/main/java/org/gridsuite/modification/server/NetworkModificationController.java

@@ -207,10 +207,20 @@ public ResponseEntity<List<LineTypeInfos>> getLineTypes() {
     }
 
     @GetMapping(value = "/network-modifications/catalog/line_types/{uuid}", produces = MediaType.APPLICATION_JSON_VALUE)
-    @Operation(summary = "Get a line types catalog")
+    @Operation(summary = "Get a line type from the catalog with area and temperature but no limits")
+    @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The line types catalog is returned")})
+    public ResponseEntity<LineTypeInfos> getOneLineTypeWithAreaAndTemperature(@PathVariable("uuid") UUID uuid) {
+        return ResponseEntity.ok().body(lineTypesCatalogService.getLineTypesWithAreaTemperatureShapeFactors(uuid));
+    }
+
+    @GetMapping(value = "/network-modifications/catalog/line_types/{uuid}/with-limits", produces = MediaType.APPLICATION_JSON_VALUE)
+    @Operation(summary = "Get a line type from the catalog with the limits associated with requested area, temperature and shape factor")
     @ApiResponses(value = {@ApiResponse(responseCode = "200", description = "The line types catalog is returned")})
-    public ResponseEntity<LineTypeInfos> getOneLineTypeWithLimits(@PathVariable("uuid") UUID uuid) {
-        return ResponseEntity.ok().body(lineTypesCatalogService.getLineTypesWithLimits(uuid));
+    public ResponseEntity<LineTypeInfos> getOneLineTypeWithLimits(@PathVariable UUID uuid, @RequestParam String area,
+                                                                  @RequestParam(required = false) String temperature,
+                                                                  @RequestParam(required = false) String shapeFactor) {
+        LineTypeInfos test = lineTypesCatalogService.getLineTypesWithLimits(uuid, area, temperature, shapeFactor);
+        return ResponseEntity.ok().body(test);
     }
 
     @PostMapping(value = "/network-modifications/catalog/line_types", consumes = MediaType.MULTIPART_FORM_DATA_VALUE)

src/main/java/org/gridsuite/modification/server/dto/catalog/LimitsForLineTypeInfos.java

@@ -14,6 +14,7 @@
 import lombok.Setter;
 import lombok.experimental.SuperBuilder;
 
+import java.util.List;
 import java.util.UUID;
 
 /**
@@ -36,14 +37,8 @@ public class LimitsForLineTypeInfos {
     @Schema(description = "Permanent limit")
     private Double permanentLimit;
 
-    @Schema(description = "Temporary limit value")
-    private Double temporaryLimitValue;
-
-    @Schema(description = "Temporary limit acceptable duration")
-    private Integer temporaryLimitAcceptableDuration;
-
-    @Schema(description = "Temporary limit name")
-    private String temporaryLimitName;
+    @Schema(description = "temporary limits list")
+    List<TemporaryLimitInfos> temporaryLimits;
 
     @Schema(description = "Area")
     private String area;

src/main/java/org/gridsuite/modification/server/dto/catalog/TemporaryLimitInfos.java

@@ -0,0 +1,48 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+package org.gridsuite.modification.server.dto.catalog;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+import org.gridsuite.modification.server.entities.catalog.TemporaryLimitEntity;
+
+import java.util.UUID;
+
+/**
+ * @author Etienne Lesot <etienne.lesot at rte-france.com>
+ */
+@SuperBuilder
+@NoArgsConstructor
+@AllArgsConstructor
+@Getter
+@Setter
+@Schema(description = "Temporary limit infos")
+public class TemporaryLimitInfos {
+    @Schema(description = "id")
+    private UUID id;
+
+    @Schema(description = "Temporary limit value")
+    private Double limitValue;
+
+    @Schema(description = "Temporary limit acceptable duration")
+    private Integer acceptableDuration;
+
+    @Schema(description = "Temporary limit name")
+    private String name;
+
+    public TemporaryLimitEntity toTemporaryLimitEntity() {
+        return TemporaryLimitEntity.builder()
+                .limitValue(limitValue)
+                .acceptableDuration(acceptableDuration)
+                .name(name).build();
+    }
+}

src/main/java/org/gridsuite/modification/server/entities/catalog/AerialLineTypeEntity.java

@@ -9,6 +9,7 @@
 import jakarta.persistence.*;
 import lombok.NoArgsConstructor;
 import org.gridsuite.modification.server.dto.catalog.AerialLineTypeInfos;
+import org.gridsuite.modification.server.dto.catalog.LineTypeInfos;
 
 /**
  * @author Sylvain Bouzols <sylvain.bouzols at rte-france.com>
@@ -60,10 +61,20 @@ public AerialLineTypeInfos toDto() {
     }
 
     @Override
-    public AerialLineTypeInfos toDtoWithLimits() {
+    public AerialLineTypeInfos toDtoWithLimits(String area, String temperature, String shapeFactor) {
         return toDtoBuilder()
-            .limitsForLineType(this.getLimitsForLineType().stream().map(LimitsForLineTypeEntity::toLineTypeInfos).toList())
-            .build();
+                .limitsForLineType(this.getLimitsForLineType().stream()
+                        .filter(limitsForLineTypeEntity -> limitsForLineTypeEntity.getArea().equals(area) &&
+                                limitsForLineTypeEntity.getTemperature().equals(temperature))
+                        .map(LimitsForLineTypeEntity::toLineTypeInfos).toList())
+                .build();
+    }
+
+    @Override
+    public LineTypeInfos toDtoWithAreaTemperatureShapeFactors() {
+        return toDtoBuilder()
+                .limitsForLineType(this.getLimitsForLineType().stream().map(LimitsForLineTypeEntity::toLineTypeInfosWithoutLimits).toList())
+                .build();
     }
 }
 

src/main/java/org/gridsuite/modification/server/entities/catalog/LimitsForLineTypeEntity.java

@@ -11,15 +11,19 @@
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
+import lombok.Setter;
 import lombok.experimental.SuperBuilder;
 import org.gridsuite.modification.server.dto.catalog.LimitsForLineTypeInfos;
+import org.gridsuite.modification.server.dto.catalog.TemporaryLimitInfos;
 
+import java.util.List;
 import java.util.UUID;
 
 /**
  * @author Etienne Lesot <etienne.lesot at rte-france.com>
  */
 @Getter
+@Setter
 @NoArgsConstructor
 @AllArgsConstructor
 @SuperBuilder
@@ -38,29 +42,30 @@ public class LimitsForLineTypeEntity {
     @Column
     private Double permanentLimit;
 
-    @Column
-    private Double temporaryLimitValue;
-
-    @Column
-    private Integer temporaryLimitAcceptableDuration;
-
-    @Column
-    private String temporaryLimitName;
+    @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL, orphanRemoval = true)
+    @JoinColumn(name = "temporary_limit_id", nullable = false)
+    private List<TemporaryLimitEntity> temporaryLimits;
 
     @Column
     private String area;
 
     @Column
     private String temperature;
 
+    public LimitsForLineTypeInfos toLineTypeInfosWithoutLimits() {
+        return LimitsForLineTypeInfos.builder()
+                .id(id)
+                .area(area)
+                .temperature(temperature)
+                .build();
+    }
+
     public LimitsForLineTypeInfos toLineTypeInfos() {
         return LimitsForLineTypeInfos.builder()
             .id(id)
             .limitSetName(limitSetName)
             .permanentLimit(permanentLimit)
-            .temporaryLimitValue(temporaryLimitValue)
-            .temporaryLimitAcceptableDuration(temporaryLimitAcceptableDuration)
-            .temporaryLimitName(temporaryLimitName)
+            .temporaryLimits(temporaryLimits.stream().map(TemporaryLimitEntity::toTemporaryLimitInfos).toList())
             .area(area)
             .temperature(temperature)
             .build();
@@ -70,9 +75,7 @@ public LimitsForLineTypeEntity(LimitsForLineTypeInfos limitsForLineTypeInfos) {
         this(limitsForLineTypeInfos.getId(),
             limitsForLineTypeInfos.getLimitSetName(),
             limitsForLineTypeInfos.getPermanentLimit(),
-            limitsForLineTypeInfos.getTemporaryLimitValue(),
-            limitsForLineTypeInfos.getTemporaryLimitAcceptableDuration(),
-            limitsForLineTypeInfos.getTemporaryLimitName(),
+            limitsForLineTypeInfos.getTemporaryLimits() != null ? limitsForLineTypeInfos.getTemporaryLimits().stream().map(TemporaryLimitInfos::toTemporaryLimitEntity).toList() : null,
             limitsForLineTypeInfos.getArea(),
             limitsForLineTypeInfos.getTemperature());
     }

src/main/java/org/gridsuite/modification/server/entities/catalog/LineTypeEntity.java

@@ -88,10 +88,14 @@ public LineTypeInfos toDto() {
         return toBuilder().build();
     }
 
-    public LineTypeInfos toDtoWithLimits() {
+    public LineTypeInfos toDtoWithAreaTemperatureShapeFactors() {
         return toBuilder()
-            .limitsForLineType(this.limitsForLineType.stream().map(LimitsForLineTypeEntity::toLineTypeInfos).toList())
-            .build();
+                .limitsForLineType(this.limitsForLineType.parallelStream().map(LimitsForLineTypeEntity::toLineTypeInfosWithoutLimits).toList())
+                .build();
+    }
+
+    public LineTypeInfos toDtoWithLimits(String area, String temperature, String shapeFactor) {
+        throw new UnsupportedOperationException("Not implemented, only implemented for subClasses AerialLineTypeEntity and UndergroundLineTypeEntity");
     }
 }
 

src/main/java/org/gridsuite/modification/server/entities/catalog/TemporaryLimitEntity.java

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2026, RTE (http://www.rte-france.com)
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ * SPDX-License-Identifier: MPL-2.0
+ */
+package org.gridsuite.modification.server.entities.catalog;
+
+import jakarta.persistence.*;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+import lombok.Setter;
+import lombok.experimental.SuperBuilder;
+import org.gridsuite.modification.server.dto.catalog.TemporaryLimitInfos;
+
+import java.util.UUID;
+
+/**
+ * @author Etienne Lesot <etienne.lesot at rte-france.com>
+ */
+@Getter
+@Setter
+@NoArgsConstructor
+@AllArgsConstructor
+@SuperBuilder
+@Entity
+@Table(name = "temporary_limit_for_line_catalog")
+public class TemporaryLimitEntity {
+
+    @Id
+    @GeneratedValue(strategy = GenerationType.AUTO)
+    @Column(name = "id")
+    private UUID id;
+
+    @Column
+    private Double limitValue;
+
+    @Column
+    private Integer acceptableDuration;
+
+    @Column
+    private String name;
+
+    public TemporaryLimitInfos toTemporaryLimitInfos() {
+        return TemporaryLimitInfos.builder()
+                .id(id)
+                .limitValue(limitValue)
+                .acceptableDuration(acceptableDuration)
+                .name(name)
+                .build();
+    }
+}

src/main/java/org/gridsuite/modification/server/entities/catalog/UndergroundLineTypeEntity.java

@@ -8,8 +8,11 @@
 
 import jakarta.persistence.*;
 import lombok.NoArgsConstructor;
+import org.gridsuite.modification.server.dto.catalog.LimitsForLineTypeInfos;
+import org.gridsuite.modification.server.dto.catalog.LineTypeInfos;
 import org.gridsuite.modification.server.dto.catalog.UndergroundLineTypeInfos;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -59,12 +62,29 @@ public UndergroundLineTypeInfos toDto() {
     }
 
     @Override
-    public UndergroundLineTypeInfos toDtoWithLimits() {
+    public UndergroundLineTypeInfos toDtoWithLimits(String area, String temperature, String shapeFactor) {
+        double shapeFactorValue = shapeFactor == null ? 1 : Double.parseDouble(shapeFactor);
+        List<LimitsForLineTypeInfos> filterAndAdaptedLimits = new ArrayList<>();
+        for (LimitsForLineTypeEntity limitsForLineTypeEntity : this.getLimitsForLineType()) {
+            if (limitsForLineTypeEntity.getArea().equals(area)) {
+                limitsForLineTypeEntity.setPermanentLimit(shapeFactorValue * limitsForLineTypeEntity.getPermanentLimit());
+                limitsForLineTypeEntity.getTemporaryLimits().forEach(temporaryLimit ->
+                        temporaryLimit.setLimitValue(shapeFactorValue * temporaryLimit.getLimitValue()));
+                filterAndAdaptedLimits.add(limitsForLineTypeEntity.toLineTypeInfos());
+            }
+        }
         return toDtoBuilder()
-            .shapeFactors(SHAPE_FACTORS)
-            .limitsForLineType(this.getLimitsForLineType().stream().map(LimitsForLineTypeEntity::toLineTypeInfos).toList())
+            .limitsForLineType(filterAndAdaptedLimits)
             .build();
     }
+
+    @Override
+    public LineTypeInfos toDtoWithAreaTemperatureShapeFactors() {
+        return toDtoBuilder()
+                .shapeFactors(SHAPE_FACTORS)
+                .limitsForLineType(this.getLimitsForLineType().stream().map(LimitsForLineTypeEntity::toLineTypeInfosWithoutLimits).toList())
+                .build();
+    }
 }
 
 

src/main/java/org/gridsuite/modification/server/repositories/LineTypesCatalogRepository.java

@@ -8,7 +8,10 @@
 
 import org.gridsuite.modification.server.entities.catalog.LineTypeEntity;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.UUID;
 
@@ -17,4 +20,14 @@
  */
 @Repository
 public interface LineTypesCatalogRepository extends JpaRepository<LineTypeEntity, UUID> {
+
+    @Transactional
+    @Modifying
+    @Query(value = """
+        TRUNCATE TABLE line_types_catalog,
+                      aerial_line_types_catalog,
+                      underground_line_types_catalog
+        RESTART IDENTITY CASCADE
+        """, nativeQuery = true)
+    void truncateCatalogFast();
 }