RED-4249-When I edit or create a dossier as an owner I want to select from multiple watermark configurations

- changed the 200 status instead of 201 status for create/update
- refactoring the creation/updating of watermark configuration
- no disabled watermarks allowed in dossier creation
- update tests

persistence-service-v1/persistence-service-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/resources/WatermarkResource.java

@@ -16,7 +16,7 @@ public interface WatermarkResource {
 
     String DOSSIER_TEMPLATE_ID_PARAMETER_NAME = "dossierTemplateId";
 
-    @ResponseStatus(HttpStatus.CREATED)
+    @ResponseStatus(HttpStatus.OK)
     @PostMapping(value = WATERMARK_PATH, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
     Watermark createOrUpdateWatermark(@RequestBody Watermark watermark);
 

persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/WatermarkService.java

@@ -16,6 +16,7 @@ import org.springframework.stereotype.Service;
 
 import javax.transaction.Transactional;
 import java.util.List;
+import java.util.Optional;
 
 @Slf4j
 @Service
@@ -28,7 +29,7 @@ public class WatermarkService {
 
 
     @Transactional
-    public void deleteWatermark(Long watermarkId) {
+    public void deleteWatermark(long watermarkId) {
         watermarkRepository.findById(watermarkId).ifPresentOrElse(loadedWatermark -> {
             dossierRepository.countDeleteWatermark(watermarkId);
             dossierRepository.countDeletePreviewWatermark(watermarkId);
@@ -39,7 +40,7 @@ public class WatermarkService {
     }
 
 
-    public WatermarkEntity getWatermark(Long watermarkId) {
+    public WatermarkEntity getWatermark(long watermarkId) {
 
         return watermarkRepository.findById(watermarkId)
                 .orElseThrow(() -> new NotFoundException("Watermark Configuration not found"));
@@ -51,22 +52,25 @@ public class WatermarkService {
 
         validateWatermark(watermark);
         if (watermark.getId() != null) { // update
-            watermarkRepository.findById(watermark.getId())
+            Optional<WatermarkEntity> loadedWatermark = watermarkRepository.findById(watermark.getId());
-                    .ifPresentOrElse(loadedWatermark -> {
+            if (loadedWatermark.isPresent()) {
-                        validateWatermarkNameIsUnique(watermark.getName(), watermark.getDossierTemplateId(), loadedWatermark.getId());
+                validateDossierTemplateId(watermark.getDossierTemplateId(), loadedWatermark.get().getDossierTemplateId());
-                        BeanUtils.copyProperties(watermark, loadedWatermark, "dossierTemplateId");
+                validateWatermarkNameIsUnique(watermark.getName(), loadedWatermark.get().getDossierTemplateId(), loadedWatermark.get().getId());
-                        var dossierTemplate = dossierTemplatePersistenceService.getDossierTemplate(watermark.getDossierTemplateId());
+                BeanUtils.copyProperties(watermark, loadedWatermark.get(), "dossierTemplateId");
-                        loadedWatermark.setDossierTemplate(dossierTemplate);
+                var dossierTemplate = dossierTemplatePersistenceService.getDossierTemplate(loadedWatermark.get().getDossierTemplateId());
-                    }, () -> {
+                loadedWatermark.get().setDossierTemplate(dossierTemplate);
-                        validateWatermarkNameIsUnique(watermark.getName(), watermark.getDossierTemplateId(), 0);
+                return loadedWatermark.get();
-                        WatermarkEntity watermarkEntity = new WatermarkEntity();
+            } else { // if not found by id -> add it as a new watermark
-                        BeanUtils.copyProperties(watermark, watermarkEntity, "id");
+                validateDossierTemplateId(watermark.getDossierTemplateId(), null);
-                        var dossierTemplate = dossierTemplatePersistenceService.getDossierTemplate(watermark.getDossierTemplateId());
+                validateWatermarkNameIsUnique(watermark.getName(), watermark.getDossierTemplateId(), 0);
-                        watermarkEntity.setDossierTemplate(dossierTemplate);
+                WatermarkEntity watermarkEntity = new WatermarkEntity();
-                        watermarkRepository.save(watermarkEntity);
+                BeanUtils.copyProperties(watermark, watermarkEntity, "id");
-                    });
+                var dossierTemplate = dossierTemplatePersistenceService.getDossierTemplate(watermark.getDossierTemplateId());
-            return watermarkRepository.findById(watermark.getId()).orElseThrow(() -> new NotFoundException("Watermark Configuration not found"));
+                watermarkEntity.setDossierTemplate(dossierTemplate);
+                return watermarkRepository.save(watermarkEntity);
+            }
         } else {
+            validateDossierTemplateId(watermark.getDossierTemplateId(), null);
             validateWatermarkNameIsUnique(watermark.getName(), watermark.getDossierTemplateId(), 0);
             WatermarkEntity watermarkEntity = new WatermarkEntity();
             BeanUtils.copyProperties(watermark, watermarkEntity, "id");
@@ -80,7 +84,7 @@ public class WatermarkService {
     private void validateWatermark(Watermark watermark) {
 
         if (StringUtils.isBlank(watermark.getName())) {
-            throw new BadRequestException("The watermark name must not be null");
+            throw new BadRequestException("The watermark name must not be empty");
         }
         if (StringUtils.isNotBlank(watermark.getText()) && !StringUtils.isAsciiPrintable(StringUtils.normalizeSpace(watermark.getText()))) {
             throw new BadRequestException("The watermark may only contain ASCII characters");
@@ -88,6 +92,14 @@ public class WatermarkService {
 
     }
 
+    private void validateDossierTemplateId(String newDossierTemplateId, String existingDossierTemplateId) {
+        if (newDossierTemplateId == null && existingDossierTemplateId == null) {
+            throw new BadRequestException("The dossier template id is not provided");
+        }
+        if (newDossierTemplateId != null && existingDossierTemplateId != null && !existingDossierTemplateId.equals(newDossierTemplateId)) {
+            throw new ConflictException("The watermark dossier template id does not match");
+        }
+    }
     private void validateWatermarkNameIsUnique(String watermarkName, String dossierTemplateId, long watermarkId) {
         getWatermarksForDossierTemplateId(dossierTemplateId).forEach(existing -> {
             if (existing.getName().equals(watermarkName) && existing.getId() != watermarkId) {

persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/DossierPersistenceService.java

@@ -101,9 +101,12 @@ public class DossierPersistenceService {
         if (createOrUpdateDossierRequest.getWatermarkId() != null) {
             var watermarkEntity = watermarkService.getWatermark(createOrUpdateDossierRequest.getWatermarkId());
             if (watermarkEntity.getDossierTemplateId().equals(createOrUpdateDossierRequest.getDossierTemplateId())) {
+                if (!watermarkEntity.isEnabled()) {
+                    throw new BadRequestException("Watermark configuration is disabled");
+                }
                 dossier.setWatermark(watermarkEntity);
             } else {
-                log.debug("Invalid watermark id");
+                throw new BadRequestException("Invalid watermark id - dossierTemplate id does not match");
             }
         } else {
             dossier.setWatermark(null);
@@ -111,9 +114,12 @@ public class DossierPersistenceService {
         if (createOrUpdateDossierRequest.getPreviewWatermarkId() != null) {
             var previewWatermarkEntity = watermarkService.getWatermark(createOrUpdateDossierRequest.getPreviewWatermarkId());
             if (previewWatermarkEntity.getDossierTemplateId().equals(createOrUpdateDossierRequest.getDossierTemplateId())) {
+                if (!previewWatermarkEntity.isEnabled()) {
+                    throw new BadRequestException("Preview watermark configuration is disabled");
+                }
                 dossier.setPreviewWatermark(previewWatermarkEntity);
             } else {
-                log.debug("Invalid preview watermark id");
+                throw new BadRequestException("Invalid preview watermark id - dossierTemplate id does not match");
             }
         } else {
             dossier.setPreviewWatermark(null);

persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/repository/DossierRepository.java

@@ -61,9 +61,9 @@ public interface DossierRepository extends JpaRepository<DossierEntity, String>
 
     @Modifying
     @Query("update DossierEntity d set d.watermarkId = null where d.watermarkId = :watermarkId")
-    int countDeleteWatermark(Long watermarkId);
+    int countDeleteWatermark(long watermarkId);
 
     @Modifying
     @Query("update DossierEntity d set d.previewWatermarkId = null where d.previewWatermarkId = :previewWatermarkId")
-    int countDeletePreviewWatermark(Long previewWatermarkId);
+    int countDeletePreviewWatermark(long previewWatermarkId);
 }

persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/WatermarkTest.java

@@ -46,11 +46,33 @@ public class WatermarkTest extends AbstractPersistenceServerServiceTest {
         var saved = watermarkClient.createOrUpdateWatermark(watermark);
         var loadedWatermark = watermarkClient.getWatermark(saved.getId());
         assertThat(loadedWatermark).isEqualTo(saved);
+        // try to save the same watermark without id
+        try {
+            watermarkClient.createOrUpdateWatermark(watermark);
+        } catch (FeignException e) {
+            assertThat(e.status()).isEqualTo(409);
+        }
+
+        // try to save the same watermark with id
+        try {
+            watermarkClient.createOrUpdateWatermark(saved);
+        } catch (FeignException e) {
+            assertThat(e.status()).isEqualTo(409);
+        }
+
         // update current watermark
         saved.setFontSize(14);
-        saved = watermarkClient.createOrUpdateWatermark(saved);
+        saved.setDossierTemplateId(null);
-        loadedWatermark = watermarkClient.getWatermark(saved.getId());
+        var updated = watermarkClient.createOrUpdateWatermark(saved);
-        assertThat(loadedWatermark).isEqualTo(saved);
+        assertThat(updated.getDossierTemplateId()).isEqualTo(dossierTemplate.getId());
+
+        // update current watermark with new dossier template id
+        updated.setDossierTemplateId("dossierTemplate2");
+        try {
+            watermarkClient.createOrUpdateWatermark(updated);
+        } catch (FeignException e) {
+            assertThat(e.status()).isEqualTo(409);
+        }
 
         var watermarkList = watermarkClient.getWatermarksForDossierTemplateId(dossierTemplate.getId());
         assertThat(watermarkList.size()).isEqualTo(1);
@@ -66,6 +88,29 @@ public class WatermarkTest extends AbstractPersistenceServerServiceTest {
         } catch (FeignException.FeignClientException e) {
             assertThat(e.status()).isEqualTo(409);
         }
+
+
+    }
+
+    @Test
+    public void testDeleteWatermark() {
+
+        var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
+
+        Watermark watermark = new Watermark();
+        watermark.setName("watermark name");
+        watermark.setText("Minions ipsum chasy para tu la bodaaa bananaaaa hana dul sae. Chasy hana dul sae pepete hana dul sae belloo! Tatata bala tu ti aamoo! Jeje.");
+        watermark.setFontSize(12);
+        watermark.setFontType("font");
+        watermark.setHexColor("#dddddd");
+        watermark.setOpacity(20);
+        watermark.setOrientation(WatermarkOrientation.DIAGONAL);
+        watermark.setDossierTemplateId(dossierTemplate.getId());
+
+        var saved = watermarkClient.createOrUpdateWatermark(watermark);
+        var loadedWatermark = watermarkClient.getWatermark(saved.getId());
+        assertThat(loadedWatermark).isEqualTo(saved);
+
         // Delete first time
         watermarkClient.deleteWatermark(saved.getId());
 
@@ -75,8 +120,52 @@ public class WatermarkTest extends AbstractPersistenceServerServiceTest {
             assertThat(e.status()).isEqualTo(404);
         }
 
+        // try to delete a not existing watermark
+        try {
+            watermarkClient.deleteWatermark(saved.getId());
+        } catch (FeignException e) {
+            assertThat(e.status()).isEqualTo(404);
+        }
+
+
     }
 
+    @Test
+    public void testCreateWatermark() {
+
+        var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
+
+        Watermark watermark = new Watermark();
+        watermark.setName("watermark name");
+        watermark.setText("Minions ipsum chasy para tu la bodaaa bananaaaa hana dul sae. Chasy hana dul sae pepete hana dul sae belloo! Tatata bala tu ti aamoo! Jeje.");
+        watermark.setFontSize(12);
+        watermark.setFontType("font");
+        watermark.setHexColor("#dddddd");
+        watermark.setOpacity(20);
+        watermark.setOrientation(WatermarkOrientation.DIAGONAL);
+        watermark.setDossierTemplateId(dossierTemplate.getId());
+
+        var saved = watermarkClient.createOrUpdateWatermark(watermark);
+        var loadedWatermark = watermarkClient.getWatermark(saved.getId());
+        assertThat(loadedWatermark).isEqualTo(saved);
+
+        // try to save the same watermark
+        try {
+            watermarkClient.createOrUpdateWatermark(watermark);
+        } catch (FeignException e) {
+            assertThat(e.status()).isEqualTo(409);
+        }
+
+        Watermark watermark2 = new Watermark();
+        watermark.setName("watermark name2");
+        watermark.setText("Minions ipsum chasy para tu la bodaaa bananaaaa hana dul sae. Chasy hana dul sae pepete hana dul sae belloo! Tatata bala tu ti aamoo! Jeje.");
+        watermark.setFontSize(12);
+        watermark.setOrientation(WatermarkOrientation.DIAGONAL);
+        watermark.setDossierTemplateId(dossierTemplate.getId());
+
+        var saved2 = watermarkClient.createOrUpdateWatermark(watermark);
+        var loadedWatermark2 = watermarkClient.getWatermark(saved.getId());
+    }
 
     @Test
     public void testWatermarkTextWithWrongText() {