Rename 'blocked_build' attribute by 'blocked_node' (#844)

SlimaneAmar · Slimane AMAR · web-flow · commit d4596cafbd77 · 2025-09-24T17:00:23.000+02:00
Co-authored-by: Slimane AMAR &lt;slimane.amar_externe@rte-france.com&gt;
diff --git a/src/main/java/org/gridsuite/study/server/controller/StudyController.java b/src/main/java/org/gridsuite/study/server/controller/StudyController.java
diff --git a/src/main/java/org/gridsuite/study/server/dto/InvalidateNodeTreeParameters.java b/src/main/java/org/gridsuite/study/server/dto/InvalidateNodeTreeParameters.java
@@ -16,7 +16,7 @@
 @Builder
 public record InvalidateNodeTreeParameters(
     InvalidationMode invalidationMode,
-    boolean withBlockedNodeBuild,
+    boolean withBlockedNode,
     ComputationsInvalidationMode computationsInvalidationMode // Only for the first node (root node)
 ) {
     public static InvalidateNodeTreeParameters ALL = new InvalidateNodeTreeParameters(InvalidationMode.ALL, false, ComputationsInvalidationMode.ALL);
diff --git a/src/main/java/org/gridsuite/study/server/networkmodificationtree/entities/RootNetworkNodeInfoEntity.java b/src/main/java/org/gridsuite/study/server/networkmodificationtree/entities/RootNetworkNodeInfoEntity.java
@@ -102,8 +102,8 @@ public class RootNetworkNodeInfoEntity {
     @Column(name = "stateEstimationResultUuid")
     private UUID stateEstimationResultUuid;
 
-    @Column(name = "blockedBuild")
-    private Boolean blockedBuild;
+    @Column(name = "blockedNode")
+    private Boolean blockedNode;
 
     @Embedded
     @AttributeOverrides(value = {
diff --git a/src/main/java/org/gridsuite/study/server/repository/rootnetwork/RootNetworkNodeInfoRepository.java b/src/main/java/org/gridsuite/study/server/repository/rootnetwork/RootNetworkNodeInfoRepository.java
@@ -63,6 +63,6 @@ public interface RootNetworkNodeInfoRepository extends JpaRepository<RootNetwork
 
     List<RootNetworkNodeInfoEntity> getAllByRootNetworkIdAndNodeInfoIdIn(UUID rootNetworkUuid, List<UUID> nodesUuids);
 
-    @Query(value = "SELECT count(rnni) > 0 FROM RootNetworkNodeInfoEntity rnni WHERE rnni.rootNetwork.id = :rootNetworkUuid AND rnni.nodeInfo.idNode IN :nodesUuids AND rnni.blockedBuild = true ")
-    boolean existsByNodeUuidsAndBlockedBuild(UUID rootNetworkUuid, List<UUID> nodesUuids);
+    @Query(value = "SELECT count(rnni) > 0 FROM RootNetworkNodeInfoEntity rnni WHERE rnni.rootNetwork.id = :rootNetworkUuid AND rnni.nodeInfo.idNode IN :nodesUuids AND rnni.blockedNode = true ")
+    boolean existsByNodeUuidsAndBlockedNode(UUID rootNetworkUuid, List<UUID> nodesUuids);
 }
diff --git a/src/main/java/org/gridsuite/study/server/service/ConsumerService.java b/src/main/java/org/gridsuite/study/server/service/ConsumerService.java
@@ -136,7 +136,7 @@ private void handleBuildResultWorkflow(UUID studyUuid, UUID nodeUuid, UUID rootN
             WorkflowType workflowType = WorkflowType.valueOf(workflowTypeStr);
             if (WorkflowType.RERUN_LOAD_FLOW.equals(workflowType)) {
                 RerunLoadFlowInfos workflowInfos = objectMapper.readValue(URLDecoder.decode(workflowInfosStr, StandardCharsets.UTF_8), RerunLoadFlowInfos.class);
-                studyService.sendLoadflowRequest(studyUuid, nodeUuid, rootNetworkUuid, workflowInfos.getLoadflowResultUuid(), workflowInfos.isWithRatioTapChangers(), false, workflowInfos.getUserId());
+                studyService.sendLoadflowRequestWorflow(studyUuid, nodeUuid, rootNetworkUuid, workflowInfos.getLoadflowResultUuid(), workflowInfos.isWithRatioTapChangers(), workflowInfos.getUserId());
             }
         }
     }
@@ -274,7 +274,7 @@ private void handleConsumeCaseImportSucceeded(CaseImportReceiver receiver, UUID
             }
             if (caseImportAction == CaseImportAction.ROOT_NETWORK_MODIFICATION) {
                 UUID rootNodeUuid = networkModificationTreeService.getStudyRootNodeUuid(studyUuid);
-                networkModificationTreeService.invalidateBlockedBuildNodeTree(rootNetworkUuid, rootNodeUuid);
+                networkModificationTreeService.unblockNodeTree(rootNetworkUuid, rootNodeUuid);
             }
             LOGGER.trace("{} for study uuid '{}' : {} seconds", caseImportAction.getLabel(), studyUuid,
                 TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime));
@@ -534,7 +534,7 @@ public void consumeCalculationFailed(Message<String> msg, ComputationType comput
             } finally {
                 if (receiverObj != null) {
                     if (computationType == LOAD_FLOW) {
-                        networkModificationTreeService.invalidateBlockedBuildNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());
+                        networkModificationTreeService.unblockNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());
                     }
 
                     // send notification for failed computation
@@ -603,7 +603,7 @@ private void consumeLoadFlowResult(Message<String> msg, boolean withRatioTapChan
                     // update DB
                     rootNetworkNodeInfoService.updateLoadflowResultUuid(receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), resultUuid, withRatioTapChangers);
                 } finally {
-                    networkModificationTreeService.invalidateBlockedBuildNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());
+                    networkModificationTreeService.unblockNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());
 
                     // send notifications
                     UUID studyUuid = networkModificationTreeService.getStudyUuidForNodeId(receiverObj.getNodeUuid());
diff --git a/src/main/java/org/gridsuite/study/server/service/NetworkModificationTreeService.java b/src/main/java/org/gridsuite/study/server/service/NetworkModificationTreeService.java
@@ -934,7 +934,7 @@ private InvalidateNodeInfos invalidateChildrenNodes(UUID nodeUuid, UUID rootNetw
 
         InvalidateNodeTreeParameters invalidateChildrenParameters = InvalidateNodeTreeParameters.builder()
             .invalidationMode(InvalidateNodeTreeParameters.InvalidationMode.ALL)
-            .withBlockedNodeBuild(invalidateTreeParameters.withBlockedNodeBuild())
+            .withBlockedNode(invalidateTreeParameters.withBlockedNode())
             .build();
         rootNetworkNodeInfoEntities.forEach(child ->
             invalidateNodeInfos.add(rootNetworkNodeInfoService.invalidateRootNetworkNode(child, invalidateChildrenParameters))
@@ -944,8 +944,8 @@ private InvalidateNodeInfos invalidateChildrenNodes(UUID nodeUuid, UUID rootNetw
     }
 
     @Transactional
-    public void invalidateBlockedBuildNodeTree(UUID rootNetworkUuid, UUID nodeUuid) {
-        rootNetworkNodeInfoService.invalidateBlockedBuild(rootNetworkUuid, getNodeTreeUuids(nodeUuid));
+    public void unblockNodeTree(UUID rootNetworkUuid, UUID nodeUuid) {
+        rootNetworkNodeInfoService.unblockNodes(rootNetworkUuid, getNodeTreeUuids(nodeUuid));
     }
 
     /**
diff --git a/src/main/java/org/gridsuite/study/server/service/RootNetworkNodeInfoService.java b/src/main/java/org/gridsuite/study/server/service/RootNetworkNodeInfoService.java
@@ -135,7 +135,7 @@ private static RootNetworkNodeInfoEntity createDefaultEntity(UUID nodeUuid, Set<
             .variantId(UUID.randomUUID().toString())
             .modificationReports(new HashMap<>(Map.of(nodeUuid, UUID.randomUUID())))
             .modificationsUuidsToExclude(modificationsToExclude)
-            .blockedBuild(false)
+            .blockedNode(false)
             .build();
     }
 
@@ -244,8 +244,8 @@ public InvalidateNodeInfos invalidateRootNetworkNode(RootNetworkNodeInfoEntity r
         boolean notOnlyChildrenBuildStatus = !invalidateTreeParameters.isOnlyChildrenBuildStatus();
 
         // Always update blocked build info
-        if (invalidateTreeParameters.withBlockedNodeBuild()) {
-            rootNetworkNodeInfoEntity.setBlockedBuild(true);
+        if (invalidateTreeParameters.withBlockedNode()) {
+            rootNetworkNodeInfoEntity.setBlockedNode(true);
         }
 
         // No need to delete node results with a status different of "BUILT"
@@ -400,14 +400,14 @@ public void assertNetworkNodeIsNotBuilding(UUID rootNetworkUuid, UUID nodeUuid)
         }
     }
 
-    public void assertNoBlockedBuild(UUID rootNetworkUuid, List<UUID> nodesUuids) {
-        if (rootNetworkNodeInfoRepository.existsByNodeUuidsAndBlockedBuild(rootNetworkUuid, nodesUuids)) {
+    public void assertNoBlockedNode(UUID rootNetworkUuid, List<UUID> nodesUuids) {
+        if (rootNetworkNodeInfoRepository.existsByNodeUuidsAndBlockedNode(rootNetworkUuid, nodesUuids)) {
             throw new StudyException(NOT_ALLOWED, "Another action is in progress in this branch !");
         }
     }
 
-    public void invalidateBlockedBuild(UUID rootNetworkUuid, List<UUID> nodesUuids) {
-        getRootNetworkNodes(rootNetworkUuid, nodesUuids).stream().forEach(rnn -> rnn.setBlockedBuild(false));
+    public void unblockNodes(UUID rootNetworkUuid, List<UUID> nodesUuids) {
+        getRootNetworkNodes(rootNetworkUuid, nodesUuids).stream().forEach(rnn -> rnn.setBlockedNode(false));
     }
 
     private void addLink(NetworkModificationNodeInfoEntity nodeInfoEntity, RootNetworkEntity rootNetworkEntity, RootNetworkNodeInfoEntity rootNetworkNodeInfoEntity) {
diff --git a/src/main/java/org/gridsuite/study/server/service/StudyService.java b/src/main/java/org/gridsuite/study/server/service/StudyService.java
@@ -980,11 +980,11 @@ public String getAllMapData(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid,
 
     @Transactional
     public void rerunLoadflow(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, UUID loadflowResultUuid, Boolean withRatioTapChangers, String userId) {
-        boolean isSecurityNode = networkModificationTreeService.isSecurityNode(nodeUuid);
-        if (isSecurityNode) {
+        StudyEntity studyEntity = studyRepository.findById(studyUuid).orElseThrow(() -> new StudyException(STUDY_NOT_FOUND));
+        if (networkModificationTreeService.isSecurityNode(nodeUuid)) {
             invalidateNodeTree(studyUuid, nodeUuid, rootNetworkUuid, InvalidateNodeTreeParameters.builder()
                 .invalidationMode(InvalidationMode.ALL)
-                .withBlockedNodeBuild(true)
+                .withBlockedNode(true)
                 .computationsInvalidationMode(ComputationsInvalidationMode.PRESERVE_LOAD_FLOW_RESULTS)
                 .build());
 
@@ -994,7 +994,7 @@ public void rerunLoadflow(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, U
                 .userId(userId)
                 .build());
         } else {
-            handleLoadflowRequest(studyUuid, nodeUuid, rootNetworkUuid, loadflowResultUuid, withRatioTapChangers, userId);
+            handleLoadflowRequest(studyEntity, nodeUuid, rootNetworkUuid, loadflowResultUuid, withRatioTapChangers, userId);
         }
     }
 
@@ -1015,20 +1015,26 @@ public void deleteLoadflowResult(UUID studyUuid, UUID nodeUuid, UUID rootNetwork
     }
 
     @Transactional
-    public void sendLoadflowRequest(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, UUID loadflowResultUuid, boolean withRatioTapChangers, boolean invalidateNodeTree, String userId) {
-        if (invalidateNodeTree) {
+    public void sendLoadflowRequestWorflow(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, UUID loadflowResultUuid, boolean withRatioTapChangers, String userId) {
+        StudyEntity studyEntity = studyRepository.findById(studyUuid).orElseThrow(() -> new StudyException(STUDY_NOT_FOUND));
+        handleLoadflowRequest(studyEntity, nodeUuid, rootNetworkUuid, loadflowResultUuid, withRatioTapChangers, userId);
+    }
+
+    @Transactional
+    public void sendLoadflowRequest(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, UUID loadflowResultUuid, boolean withRatioTapChangers, String userId) {
+        StudyEntity studyEntity = studyRepository.findById(studyUuid).orElseThrow(() -> new StudyException(STUDY_NOT_FOUND));
+        if (networkModificationTreeService.isSecurityNode(nodeUuid)) {
             invalidateNodeTree(studyUuid, nodeUuid, rootNetworkUuid, InvalidateNodeTreeParameters.builder()
                 .invalidationMode(InvalidationMode.ONLY_CHILDREN_BUILD_STATUS)
-                .withBlockedNodeBuild(true)
+                .withBlockedNode(true)
                 .computationsInvalidationMode(ComputationsInvalidationMode.ALL)
                 .build());
         }
 
-        handleLoadflowRequest(studyUuid, nodeUuid, rootNetworkUuid, loadflowResultUuid, withRatioTapChangers, userId);
+        handleLoadflowRequest(studyEntity, nodeUuid, rootNetworkUuid, loadflowResultUuid, withRatioTapChangers, userId);
     }
 
-    private void handleLoadflowRequest(UUID studyUuid, UUID nodeUuid, UUID rootNetworkUuid, UUID loadflowResultUuid, boolean withRatioTapChangers, String userId) {
-        StudyEntity studyEntity = studyRepository.findById(studyUuid).orElseThrow(() -> new StudyException(STUDY_NOT_FOUND));
+    private void handleLoadflowRequest(StudyEntity studyEntity, UUID nodeUuid, UUID rootNetworkUuid, UUID loadflowResultUuid, boolean withRatioTapChangers, String userId) {
         UUID lfParametersUuid = loadflowService.getLoadFlowParametersOrDefaultsUuid(studyEntity);
         UUID lfReportUuid = networkModificationTreeService.getComputationReports(nodeUuid, rootNetworkUuid).getOrDefault(LOAD_FLOW.name(), UUID.randomUUID());
         UUID networkUuid = rootNetworkService.getNetworkUuid(rootNetworkUuid);
@@ -1039,7 +1045,7 @@ private void handleLoadflowRequest(UUID studyUuid, UUID nodeUuid, UUID rootNetwo
         UUID result = loadflowService.runLoadFlow(new NodeReceiver(nodeUuid, rootNetworkUuid), loadflowResultUuid, new VariantInfos(networkUuid, variantId), new LoadFlowService.ParametersInfos(lfParametersUuid, withRatioTapChangers, isSecurityNode), lfReportUuid, userId);
         rootNetworkNodeInfoService.updateLoadflowResultUuid(nodeUuid, rootNetworkUuid, result, withRatioTapChangers);
 
-        notificationService.emitStudyChanged(studyUuid, nodeUuid, rootNetworkUuid, LOAD_FLOW.getUpdateStatusType());
+        notificationService.emitStudyChanged(studyEntity.getId(), nodeUuid, rootNetworkUuid, LOAD_FLOW.getUpdateStatusType());
     }
 
     public void exportNetwork(UUID nodeUuid, UUID rootNetworkUuid, String format, String parametersJson, String fileName, HttpServletResponse exportNetworkResponse) {
@@ -1102,18 +1108,18 @@ public void assertNoBuildNoComputationForRootNetworkNode(UUID nodeUuid, UUID roo
     }
 
     @Transactional(readOnly = true)
-    public void assertNoBlockedBuildInNodeTree(UUID nodeUuid, UUID rootNetworkUuid) {
-        rootNetworkNodeInfoService.assertNoBlockedBuild(rootNetworkUuid, networkModificationTreeService.getNodeTreeUuids(nodeUuid));
+    public void assertNoBlockedNodeInTree(UUID nodeUuid, UUID rootNetworkUuid) {
+        rootNetworkNodeInfoService.assertNoBlockedNode(rootNetworkUuid, networkModificationTreeService.getNodeTreeUuids(nodeUuid));
     }
 
     @Transactional(readOnly = true)
-    public void assertNoBlockedBuildInStudy(UUID studyUuid, UUID nodeUuid) {
+    public void assertNoBlockedNodeInStudy(UUID studyUuid, UUID nodeUuid) {
         if (nodeUuid == null) {
             throw new StudyException(MISSING_PARAMETER, "The parameter 'nodeUuid' must be defined !");
         }
         List<UUID> nodesUuids = networkModificationTreeService.getNodeTreeUuids(nodeUuid);
         getStudyRootNetworks(studyUuid).stream().forEach(rootNetwork ->
-            rootNetworkNodeInfoService.assertNoBlockedBuild(rootNetwork.getId(), nodesUuids)
+            rootNetworkNodeInfoService.assertNoBlockedNode(rootNetwork.getId(), nodesUuids)
         );
     }
 
@@ -2060,7 +2066,7 @@ private void invalidateNodeTreeWithLF(UUID studyUuid, UUID nodeUuid, UUID rootNe
         boolean invalidateAll = networkModificationTreeService.isSecurityNode(nodeUuid) && rootNetworkNodeInfoService.isLoadflowDone(nodeUuid, rootNetworkUuid);
         InvalidateNodeTreeParameters invalidateNodeTreeParameters = InvalidateNodeTreeParameters.builder()
             .invalidationMode(invalidateAll ? InvalidationMode.ALL : InvalidationMode.ONLY_CHILDREN_BUILD_STATUS)
-            .withBlockedNodeBuild(true)
+            .withBlockedNode(true)
             .computationsInvalidationMode(invalidateAll ? ComputationsInvalidationMode.ALL : computationsInvalidationMode)
             .build();
         invalidateNodeTree(studyUuid, nodeUuid, rootNetworkUuid, invalidateNodeTreeParameters);
@@ -2088,9 +2094,9 @@ private void invalidateNodeTree(UUID studyUuid, UUID nodeUuid, UUID rootNetworkU
     }
 
     @Transactional
-    public void invalidateBlockedBuildNodeTree(UUID studyUuid, UUID nodeUuid) {
+    public void unblockNodeTree(UUID studyUuid, UUID nodeUuid) {
         getStudyRootNetworks(studyUuid).forEach(rootNetworkEntity ->
-            networkModificationTreeService.invalidateBlockedBuildNodeTree(rootNetworkEntity.getId(), nodeUuid)
+            networkModificationTreeService.unblockNodeTree(rootNetworkEntity.getId(), nodeUuid)
         );
     }
 
@@ -3130,7 +3136,7 @@ public void insertVoltageInitModifications(UUID studyUuid, UUID nodeUuid, UUID r
             // send notification voltage init result has changed
             notificationService.emitStudyChanged(studyUuid, nodeUuid, rootNetworkUuid, NotificationService.UPDATE_TYPE_VOLTAGE_INIT_RESULT);
         } finally {
-            networkModificationTreeService.invalidateBlockedBuildNodeTree(rootNetworkUuid, nodeUuid);
+            networkModificationTreeService.unblockNodeTree(rootNetworkUuid, nodeUuid);
             notificationService.emitEndModificationEquipmentNotification(studyUuid, nodeUuid, childrenUuids);
         }
         notificationService.emitElementUpdated(studyUuid, userId);
diff --git a/src/main/resources/db/changelog/changesets/changelog_20250910T092726Z.xml b/src/main/resources/db/changelog/changesets/changelog_20250910T092726Z.xml
@@ -0,0 +1,9 @@
+<?xml version="1.1" encoding="UTF-8" standalone="no"?>
+<databaseChangeLog xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+                   xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
+                   xmlns:pro="http://www.liquibase.org/xml/ns/pro" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+                   xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd http://www.liquibase.org/xml/ns/pro http://www.liquibase.org/xml/ns/pro/liquibase-pro-latest.xsd http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-latest.xsd">
+    <changeSet author="amarsli (generated)" id="1757496463482-20">
+        <renameColumn tableName="root_network_node_info" oldColumnName="blocked_build" newColumnName="blocked_node"/>
+    </changeSet>
+</databaseChangeLog>
diff --git a/src/main/resources/db/changelog/db.changelog-master.yaml b/src/main/resources/db/changelog/db.changelog-master.yaml
@@ -341,3 +341,6 @@ databaseChangeLog:
   - include:
       file: changesets/changelog_20250917T153853Z.xml
       relativeToChangelogFile: true
+  - include:
+      file: changesets/changelog_20250910T092726Z.xml
+      relativeToChangelogFile: true
diff --git a/src/test/java/org/gridsuite/study/server/LoadFLowIntegrationTest.java b/src/test/java/org/gridsuite/study/server/LoadFLowIntegrationTest.java
@@ -191,7 +191,7 @@ private static Stream<Arguments> argumentsProvider() {
     @Test
     void testDynaFlowNotAllowed() throws Exception {
         UUID loadFlowProviderStubUuid = wireMockUtils.stubLoadFlowProvider(parametersUuid, DYNA_FLOW_PROVIDER);
-        doNothing().when(studyService).sendLoadflowRequest(any(), any(), any(), any(), anyBoolean(), anyBoolean(), anyString());
+        doNothing().when(studyService).sendLoadflowRequest(any(), any(), any(), any(), anyBoolean(), anyString());
 
         // Construction node : forbidden
         mockMvc.perform(put("/v1/studies/{studyUuid}/root-networks/{rootNetworkUuid}/nodes/{nodeUuid}/loadflow/run", studyUuid, rootNetworkUuid, constructionNodeUuid, userId)
@@ -281,7 +281,7 @@ private void rerunLoadFlow(boolean withRatioTapChangers, boolean isSecurityNode)
     private void assertNodeBlocked(UUID nodeUuid, UUID rootNetworkUuid, boolean isNodeBlocked) {
         Optional<RootNetworkNodeInfoEntity> networkNodeInfoEntity = rootNetworkNodeInfoService.getRootNetworkNodeInfo(nodeUuid, rootNetworkUuid);
         assertTrue(networkNodeInfoEntity.isPresent());
-        assertEquals(isNodeBlocked, networkNodeInfoEntity.get().getBlockedBuild());
+        assertEquals(isNodeBlocked, networkNodeInfoEntity.get().getBlockedNode());
     }
 
     private StudyEntity insertStudy() {
@@ -302,7 +302,7 @@ private UUID insertNode(StudyEntity study, String variantId, UUID reportUuid, No
     // We can't use the method RootNetworkNodeInfoService::createNodeLinks because there is no transaction in a session
     private void createNodeLinks(RootNetworkEntity rootNetworkEntity, NetworkModificationNodeInfoEntity modificationNodeInfoEntity,
                                  String variantId, UUID reportUuid, BuildStatus buildStatus) {
-        RootNetworkNodeInfoEntity rootNetworkNodeInfoEntity = RootNetworkNodeInfoEntity.builder().variantId(variantId).modificationReports(Map.of(modificationNodeInfoEntity.getId(), reportUuid)).nodeBuildStatus(NodeBuildStatus.from(buildStatus).toEntity()).blockedBuild(false).build();
+        RootNetworkNodeInfoEntity rootNetworkNodeInfoEntity = RootNetworkNodeInfoEntity.builder().variantId(variantId).modificationReports(Map.of(modificationNodeInfoEntity.getId(), reportUuid)).nodeBuildStatus(NodeBuildStatus.from(buildStatus).toEntity()).blockedNode(false).build();
         modificationNodeInfoEntity.addRootNetworkNodeInfo(rootNetworkNodeInfoEntity);
         rootNetworkEntity.addRootNetworkNodeInfo(rootNetworkNodeInfoEntity);
         rootNetworkNodeInfoRepository.save(rootNetworkNodeInfoEntity);
diff --git a/src/test/java/org/gridsuite/study/server/LoadFLowUnitTest.java b/src/test/java/org/gridsuite/study/server/LoadFLowUnitTest.java
diff --git a/src/test/java/org/gridsuite/study/server/LoadFlowTest.java b/src/test/java/org/gridsuite/study/server/LoadFlowTest.java
diff --git a/src/test/java/org/gridsuite/study/server/WorkflowTest.java b/src/test/java/org/gridsuite/study/server/WorkflowTest.java
diff --git a/src/test/java/org/gridsuite/study/server/rootnetworks/RootNetworkTest.java b/src/test/java/org/gridsuite/study/server/rootnetworks/RootNetworkTest.java

Original file line number	Diff line number	Diff line change
`@@ -63,6 +63,6 @@ public interface RootNetworkNodeInfoRepository extends JpaRepository<RootNetwork`
`63`	`63`
`64`	`64`	`List<RootNetworkNodeInfoEntity> getAllByRootNetworkIdAndNodeInfoIdIn(UUID rootNetworkUuid, List<UUID> nodesUuids);`
`65`	`65`
`66`		`- @Query(value = "SELECT count(rnni) > 0 FROM RootNetworkNodeInfoEntity rnni WHERE rnni.rootNetwork.id = :rootNetworkUuid AND rnni.nodeInfo.idNode IN :nodesUuids AND rnni.blockedBuild = true ")`
`67`		`- boolean existsByNodeUuidsAndBlockedBuild(UUID rootNetworkUuid, List<UUID> nodesUuids);`
	`66`	`+ @Query(value = "SELECT count(rnni) > 0 FROM RootNetworkNodeInfoEntity rnni WHERE rnni.rootNetwork.id = :rootNetworkUuid AND rnni.nodeInfo.idNode IN :nodesUuids AND rnni.blockedNode = true ")`
	`67`	`+ boolean existsByNodeUuidsAndBlockedNode(UUID rootNetworkUuid, List<UUID> nodesUuids);`
`68`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ private void handleBuildResultWorkflow(UUID studyUuid, UUID nodeUuid, UUID rootN`
`136`	`136`	`WorkflowType workflowType = WorkflowType.valueOf(workflowTypeStr);`
`137`	`137`	`if (WorkflowType.RERUN_LOAD_FLOW.equals(workflowType)) {`
`138`	`138`	`RerunLoadFlowInfos workflowInfos = objectMapper.readValue(URLDecoder.decode(workflowInfosStr, StandardCharsets.UTF_8), RerunLoadFlowInfos.class);`
`139`		`- studyService.sendLoadflowRequest(studyUuid, nodeUuid, rootNetworkUuid, workflowInfos.getLoadflowResultUuid(), workflowInfos.isWithRatioTapChangers(), false, workflowInfos.getUserId());`
	`139`	`+ studyService.sendLoadflowRequestWorflow(studyUuid, nodeUuid, rootNetworkUuid, workflowInfos.getLoadflowResultUuid(), workflowInfos.isWithRatioTapChangers(), workflowInfos.getUserId());`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`	`}`
`@@ -274,7 +274,7 @@ private void handleConsumeCaseImportSucceeded(CaseImportReceiver receiver, UUID`
`274`	`274`	`}`
`275`	`275`	`if (caseImportAction == CaseImportAction.ROOT_NETWORK_MODIFICATION) {`
`276`	`276`	`UUID rootNodeUuid = networkModificationTreeService.getStudyRootNodeUuid(studyUuid);`
`277`		`- networkModificationTreeService.invalidateBlockedBuildNodeTree(rootNetworkUuid, rootNodeUuid);`
	`277`	`+ networkModificationTreeService.unblockNodeTree(rootNetworkUuid, rootNodeUuid);`
`278`	`278`	`}`
`279`	`279`	`LOGGER.trace("{} for study uuid '{}' : {} seconds", caseImportAction.getLabel(), studyUuid,`
`280`	`280`	`TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - startTime));`
`@@ -534,7 +534,7 @@ public void consumeCalculationFailed(Message<String> msg, ComputationType comput`
`534`	`534`	`} finally {`
`535`	`535`	`if (receiverObj != null) {`
`536`	`536`	`if (computationType == LOAD_FLOW) {`
`537`		`- networkModificationTreeService.invalidateBlockedBuildNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());`
	`537`	`+ networkModificationTreeService.unblockNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());`
`538`	`538`	`}`
`539`	`539`
`540`	`540`	`// send notification for failed computation`
`@@ -603,7 +603,7 @@ private void consumeLoadFlowResult(Message<String> msg, boolean withRatioTapChan`
`603`	`603`	`// update DB`
`604`	`604`	`rootNetworkNodeInfoService.updateLoadflowResultUuid(receiverObj.getNodeUuid(), receiverObj.getRootNetworkUuid(), resultUuid, withRatioTapChangers);`
`605`	`605`	`} finally {`
`606`		`- networkModificationTreeService.invalidateBlockedBuildNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());`
	`606`	`+ networkModificationTreeService.unblockNodeTree(receiverObj.getRootNetworkUuid(), receiverObj.getNodeUuid());`
`607`	`607`
`608`	`608`	`// send notifications`
`609`	`609`	`UUID studyUuid = networkModificationTreeService.getStudyUuidForNodeId(receiverObj.getNodeUuid());`
Original file line number	Diff line number	Diff line change
`@@ -135,7 +135,7 @@ private static RootNetworkNodeInfoEntity createDefaultEntity(UUID nodeUuid, Set<`
`135`	`135`	`.variantId(UUID.randomUUID().toString())`
`136`	`136`	`.modificationReports(new HashMap<>(Map.of(nodeUuid, UUID.randomUUID())))`
`137`	`137`	`.modificationsUuidsToExclude(modificationsToExclude)`
`138`		`- .blockedBuild(false)`
	`138`	`+ .blockedNode(false)`
`139`	`139`	`.build();`
`140`	`140`	`}`
`141`	`141`
`@@ -244,8 +244,8 @@ public InvalidateNodeInfos invalidateRootNetworkNode(RootNetworkNodeInfoEntity r`
`244`	`244`	`boolean notOnlyChildrenBuildStatus = !invalidateTreeParameters.isOnlyChildrenBuildStatus();`
`245`	`245`
`246`	`246`	`// Always update blocked build info`
`247`		`- if (invalidateTreeParameters.withBlockedNodeBuild()) {`
`248`		`- rootNetworkNodeInfoEntity.setBlockedBuild(true);`
	`247`	`+ if (invalidateTreeParameters.withBlockedNode()) {`
	`248`	`+ rootNetworkNodeInfoEntity.setBlockedNode(true);`
`249`	`249`	`}`
`250`	`250`
`251`	`251`	`// No need to delete node results with a status different of "BUILT"`
`@@ -400,14 +400,14 @@ public void assertNetworkNodeIsNotBuilding(UUID rootNetworkUuid, UUID nodeUuid)`
`400`	`400`	`}`
`401`	`401`	`}`
`402`	`402`
`403`		`- public void assertNoBlockedBuild(UUID rootNetworkUuid, List<UUID> nodesUuids) {`
`404`		`- if (rootNetworkNodeInfoRepository.existsByNodeUuidsAndBlockedBuild(rootNetworkUuid, nodesUuids)) {`
	`403`	`+ public void assertNoBlockedNode(UUID rootNetworkUuid, List<UUID> nodesUuids) {`
	`404`	`+ if (rootNetworkNodeInfoRepository.existsByNodeUuidsAndBlockedNode(rootNetworkUuid, nodesUuids)) {`
`405`	`405`	`throw new StudyException(NOT_ALLOWED, "Another action is in progress in this branch !");`
`406`	`406`	`}`
`407`	`407`	`}`
`408`	`408`
`409`		`- public void invalidateBlockedBuild(UUID rootNetworkUuid, List<UUID> nodesUuids) {`
`410`		`- getRootNetworkNodes(rootNetworkUuid, nodesUuids).stream().forEach(rnn -> rnn.setBlockedBuild(false));`
	`409`	`+ public void unblockNodes(UUID rootNetworkUuid, List<UUID> nodesUuids) {`
	`410`	`+ getRootNetworkNodes(rootNetworkUuid, nodesUuids).stream().forEach(rnn -> rnn.setBlockedNode(false));`
`411`	`411`	`}`
`412`	`412`
`413`	`413`	`private void addLink(NetworkModificationNodeInfoEntity nodeInfoEntity, RootNetworkEntity rootNetworkEntity, RootNetworkNodeInfoEntity rootNetworkNodeInfoEntity) {`