Add UpdatePolicyDevice implementation

src/policy/src/main/java/eu/teraflow/policy/PolicyGatewayImpl.java

@@ -73,13 +73,12 @@ public class PolicyGatewayImpl implements PolicyGateway {
 
     @Override
     public Uni<PolicyRuleState> policyUpdateDevice(PolicyRuleDevice request) {
-        return Uni.createFrom()
-                .item(
-                        () ->
-                                Policy.PolicyRuleState.newBuilder()
-                                        .setPolicyRuleState(
-                                                request.getPolicyRuleBasic().getPolicyRuleState().getPolicyRuleState())
-                                        .build());
+        final var policyRuleDevice = serializer.deserialize(request);
+
+        return policyService
+                .updatePolicyDevice(policyRuleDevice)
+                .onItem()
+                .transform(serializer::serialize);
     }
 
     @Override

src/policy/src/main/java/eu/teraflow/policy/PolicyService.java

@@ -28,4 +28,6 @@ public interface PolicyService {
     Uni<PolicyRuleState> updatePolicyService(PolicyRuleService policyRuleService);
 
     Uni<PolicyRuleState> addPolicyDevice(PolicyRuleDevice policyRuleDevice);
+
+    Uni<PolicyRuleState> updatePolicyDevice(PolicyRuleDevice policyRuleDevice);
 }

src/policy/src/main/java/eu/teraflow/policy/PolicyServiceImpl.java

@@ -176,6 +176,24 @@ public class PolicyServiceImpl implements PolicyService {
         return Uni.createFrom().item(policyRuleBasic.getPolicyRuleState());
     }
 
+    @Override
+    public Uni<PolicyRuleState> updatePolicyDevice(PolicyRuleDevice policyRuleDevice) {
+        LOGGER.infof("Received %s", policyRuleDevice);
+
+        final var policyRuleBasic = policyRuleDevice.getPolicyRuleBasic();
+        policyRuleBasic.setPolicyRuleState(UPDATED_POLICYRULE_STATE);
+
+        new Thread(
+                        () -> {
+                            validateUpdatedPolicyDevice(policyRuleDevice);
+                        })
+                .start();
+
+        contextService.setPolicyRule(policyRuleBasic);
+
+        return Uni.createFrom().item(policyRuleBasic.getPolicyRuleState());
+    }
+
     private void provisionAlarm(
             PolicyRuleBasic policyRuleBasic,
             List<AlarmDescriptor> alarmDescriptorList,
@@ -450,6 +468,27 @@ public class PolicyServiceImpl implements PolicyService {
                         });
     }
 
+    private void validateUpdatedPolicyDevice(PolicyRuleDevice policyRuleDevice) {
+
+        final var policyRuleBasic = policyRuleDevice.getPolicyRuleBasic();
+        final var isUpdatedPolicyRuleValid =
+                policyRuleConditionValidator.validateUpdatedPolicyRuleId(policyRuleBasic.getPolicyRuleId());
+
+        isUpdatedPolicyRuleValid
+                .subscribe()
+                .with(
+                        policyRuleBoolean -> {
+                            if (Boolean.TRUE.equals(isUpdatedPolicyRuleValid)) {
+                                validateDevice(policyRuleDevice);
+                                return;
+                            } else {
+                                policyRuleBasic.setPolicyRuleState(FAILED_POLICYRULE_STATE);
+                                contextService.setPolicyRule(policyRuleBasic);
+                                return;
+                            }
+                        });
+    }
+
     private void validateService(PolicyRuleService policyRuleService) {
         final var serviceId = policyRuleService.getServiceId();
         final var deviceIds = policyRuleService.getDeviceIds();

src/policy/src/test/java/eu/teraflow/policy/PolicyServiceTest.java

@@ -205,15 +205,25 @@ class PolicyServiceTest {
             throws ExecutionException, InterruptedException, TimeoutException {
         CompletableFuture<String> message = new CompletableFuture<>();
 
+        final var expectedDeviceIdUuid =
+                serializer.serializeUuid("20db867c-772d-4872-9179-244ecafb3257");
+
+        final var expectedDeviceId =
+                ContextOuterClass.DeviceId.newBuilder().setDeviceUuid(expectedDeviceIdUuid).build();
+
         final var expectedPolicyRuleState =
                 Policy.PolicyRuleState.newBuilder()
-                        .setPolicyRuleState(PolicyRuleStateEnum.POLICY_ENFORCED)
+                        .setPolicyRuleState(PolicyRuleStateEnum.POLICY_UPDATED)
                         .build();
 
         final var policyRuleBasic =
                 PolicyRuleBasic.newBuilder().setPolicyRuleState(expectedPolicyRuleState).build();
+        final var deviceIds = List.of(expectedDeviceId);
         final var policyRuleDevice =
-                Policy.PolicyRuleDevice.newBuilder().setPolicyRuleBasic(policyRuleBasic).build();
+                Policy.PolicyRuleDevice.newBuilder()
+                        .setPolicyRuleBasic(policyRuleBasic)
+                        .addAllDeviceList(deviceIds)
+                        .build();
 
         client
                 .policyUpdateDevice(policyRuleDevice)