RED-3392 Fixed bug when changing dossierTemplate and update dossier dictionary type and entries

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

@@ -1,23 +1,26 @@
 package com.iqser.red.service.persistence.management.v1.processor.service.persistence;
 
+import static com.iqser.red.service.persistence.management.v1.processor.utils.TypeIdUtils.toTypeId;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import javax.transaction.Transactional;
+
+import org.springframework.beans.BeanUtils;
+import org.springframework.stereotype.Service;
+
 import com.iqser.red.service.persistence.management.v1.processor.entity.configuration.TypeEntity;
 import com.iqser.red.service.persistence.management.v1.processor.exception.BadRequestException;
 import com.iqser.red.service.persistence.management.v1.processor.exception.NotFoundException;
 import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.DossierRepository;
 import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.DossierTemplateRepository;
+import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.EntryRepository;
 import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.TypeRepository;
 import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.type.DictionarySummaryResponse;
+
 import lombok.RequiredArgsConstructor;
-import org.springframework.beans.BeanUtils;
-import org.springframework.stereotype.Service;
-
-import javax.transaction.Transactional;
-import java.util.List;
-import java.util.Optional;
-import java.util.Set;
-
-import static com.iqser.red.service.persistence.management.v1.processor.utils.TypeIdUtils.toTypeId;
-
 
 @Service
 @RequiredArgsConstructor
@@ -29,26 +32,29 @@ public class DictionaryPersistenceService {
 
     private final DossierRepository dossierRepository;
 
-    public TypeEntity addType(String type, String dossierTemplateId, String hexColor, int rank, boolean isHint,
+    private final EntryRepository entryRepository;
-                              boolean caseInsensitive, boolean isRecommendation, String description,
+
-                              boolean addToDictionaryAction, String label, String dossierId) {
+
+    public TypeEntity addType(String type, String dossierTemplateId, String hexColor, int rank, boolean isHint, boolean caseInsensitive, boolean isRecommendation,
+                              String description, boolean addToDictionaryAction, String label, String dossierId) {
 
         checkRankAlreadyExists(type, dossierTemplateId, rank, dossierId);
 
-        TypeEntity t = new TypeEntity();
+        TypeEntity t = TypeEntity.builder()
-        t.setId(toTypeId(type, dossierTemplateId, dossierId));
+                .id(toTypeId(type, dossierTemplateId, dossierId))
-        t.setType(type);
+                .type(type)
-        t.setDossier(dossierId == null ? null : dossierRepository.getOne(dossierId));
+                .dossier(dossierId == null ? null : dossierRepository.getOne(dossierId))
-        t.setDossierTemplate(dossierTemplateRepository.getOne(dossierTemplateId));
+                .dossierTemplate(dossierTemplateRepository.getOne(dossierTemplateId))
-        t.setHexColor(hexColor);
+                .hexColor(hexColor)
-        t.setRank(rank);
+                .rank(rank)
-        t.setDescription(description);
+                .description(description)
-        t.setHint(isHint);
+                .isHint(isHint)
-        t.setCaseInsensitive(caseInsensitive);
+                .isCaseInsensitive(caseInsensitive)
-        t.setRecommendation(isRecommendation);
+                .isRecommendation(isRecommendation)
-        t.setAddToDictionaryAction(addToDictionaryAction);
+                .addToDictionaryAction(addToDictionaryAction)
-        t.setLabel(label);
+                .label(label)
-        t.setVersion(1);
+                .version(1)
+                .build();
 
         return typeRepository.save(t);
 
@@ -73,57 +79,100 @@ public class DictionaryPersistenceService {
     }
 
 
+    private void checkRankAlreadyExists(String type, String dossierTemplateId, int rank, String dossierId) {
+
+        Optional<TypeEntity> existingTypeValueForRank = getTypeForRank(dossierTemplateId, rank, dossierId);
+        // not the current type - which we are about to upsert -> throw exception
+        if (existingTypeValueForRank.isPresent() && !existingTypeValueForRank.get().getType().equalsIgnoreCase(type)) {
+            throw new BadRequestException("Rank already exists: " + rank + " on type: " + existingTypeValueForRank.get().getType());
+        }
+    }
+
+
     public List<TypeEntity> getCumulatedTypes(String dossierTemplateId, String dossierId) {
+
         return typeRepository.findAllTypesByDossierTemplateIdOrDossierId(dossierTemplateId, dossierId);
     }
 
 
     public List<TypeEntity> getAllTypesForDossierTemplate(String dossierTemplateId) {
+
         return typeRepository.getAllTypesForDossierTemplate(dossierTemplateId);
     }
 
+
     public List<TypeEntity> getAllTypesForDossier(String dossierId) {
+
         return typeRepository.findByDossierId(dossierId);
     }
 
 
     @Transactional
     public void deleteType(String typeId) {
+
         typeRepository.deleteById(typeId);
     }
 
 
     public TypeEntity getType(String typeId) {
+
         return typeRepository.findById(typeId).orElseThrow(() -> new NotFoundException("Type: " + typeId + " not found"));
     }
 
 
-    private void checkRankAlreadyExists(String type, String dossierTemplateId, int rank, String dossierId) {
-
-        Optional<TypeEntity> existingTypeValueForRank = getTypeForRank(dossierTemplateId, rank, dossierId);
-        // not the current type - which we are about to upsert -> throw exception
-        if (existingTypeValueForRank.isPresent() && !existingTypeValueForRank.get().getType().equalsIgnoreCase(type)) {
-            throw new BadRequestException("Rank already exists: " + rank + " on type: " + existingTypeValueForRank.get()
-                    .getType());
-        }
-    }
-
     @Transactional
     public void incrementVersion(String typeId) {
+
         typeRepository.updateByIdSetIncrementVersionByOne(typeId);
     }
 
+
     public long getVersion(String dossierTemplateId) {
+
         return typeRepository.getVersionForDossierTemplateId(dossierTemplateId);
     }
 
+
     public long getVersionForDossier(String dossierId) {
+
         return typeRepository.getVersionForDossierId(dossierId);
     }
 
+
     public List<DictionarySummaryResponse> getDictionarySummaryForDossierTemplateId(Set<String> dossierTemplateIds) {
+
         return typeRepository.findDictionarySummaryList(dossierTemplateIds);
     }
 
 
+    @Transactional
+    public void updateTypeIdAndIncrementVersionByOne(String typeId, String newTypeId, String newDossierTemplateId) {
+
+        Optional<TypeEntity> typeEntity = typeRepository.findById(typeId);
+        if (typeEntity.isEmpty()) {
+            throw new NotFoundException("Type '" + typeId + "' does not exist.");
+        }
+
+        checkRankAlreadyExists(typeEntity.get().getType(), newDossierTemplateId, typeEntity.get().getRank(), typeEntity.get().getDossierId());
+
+        typeRepository.saveAndFlush(TypeEntity.builder()
+                .id(newTypeId)
+                .type(typeEntity.get().getType())
+                .dossier(dossierRepository.getOne(typeEntity.get().getDossierId()))
+                .dossierTemplate(dossierTemplateRepository.getOne(newDossierTemplateId))
+                .hexColor(typeEntity.get().getHexColor())
+                .rank(typeEntity.get().getRank())
+                .description(typeEntity.get().getDescription())
+                .isHint(typeEntity.get().isHint())
+                .isCaseInsensitive(typeEntity.get().isCaseInsensitive())
+                .isRecommendation(typeEntity.get().isRecommendation())
+                .addToDictionaryAction(typeEntity.get().isAddToDictionaryAction())
+                .label(typeEntity.get().getLabel())
+                .version(typeEntity.get().getVersion() + 1)
+                .build());
+
+        entryRepository.updateTypeIdAndIncrementVersionByOne(typeId, newTypeId);
+        typeRepository.deleteById(typeId);
+    }
+
 }

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

@@ -1,11 +1,12 @@
 package com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository;
 
-import com.iqser.red.service.persistence.management.v1.processor.entity.configuration.DictionaryEntryEntity;
+import java.util.List;
+
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.data.jpa.repository.Modifying;
 import org.springframework.data.jpa.repository.Query;
 
-import java.util.List;
+import com.iqser.red.service.persistence.management.v1.processor.entity.configuration.DictionaryEntryEntity;
 
 public interface EntryRepository extends JpaRepository<DictionaryEntryEntity, Long> {
 
@@ -13,9 +14,17 @@ public interface EntryRepository extends JpaRepository<DictionaryEntryEntity, Lo
     @Query("update DictionaryEntryEntity e set e.deleted = true , e.version = :version where e.type.id =:typeId and e.value in :values")
     void deleteAllByTypeIdAndVersionAndValueIn(String typeId, long version, List<String> values);
 
+
     @Modifying
     @Query("update DictionaryEntryEntity e set e.version = :version where e.type.id =:typeId and  e.value in :values")
     void updateVersionWhereTypeIdAndValueIn(long version, String typeId, List<String> values);
 
+
+    @Modifying
+    @Query("update DictionaryEntryEntity e set e.type.id = :newTypeId, e.version = e.version + 1 where e.type.id =:typeId")
+    void updateTypeIdAndIncrementVersionByOne(String typeId, String newTypeId);
+
+
     List<DictionaryEntryEntity> findByTypeId(String typeId);
+
 }

persistence-service-v1/persistence-service-server-v1/src/main/java/com/iqser/red/service/peristence/v1/server/service/DossierService.java

@@ -1,22 +1,26 @@
 package com.iqser.red.service.peristence.v1.server.service;
 
-import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.DossierEntity;
-import com.iqser.red.service.persistence.management.v1.processor.exception.BadRequestException;
-import com.iqser.red.service.persistence.management.v1.processor.exception.ConflictException;
-import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DossierPersistenceService;
-import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DossierTemplatePersistenceService;
-import com.iqser.red.service.persistence.management.v1.processor.service.persistence.FileStatusPersistenceService;
-import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.DossierTemplateStatus;
-import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.dossier.CreateOrUpdateDossierRequest;
-import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.dossier.DossierChange;
-import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
-import org.springframework.stereotype.Service;
-
 import java.time.OffsetDateTime;
 import java.util.List;
 import java.util.Set;
 
+import org.springframework.stereotype.Service;
+
+import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.DossierEntity;
+import com.iqser.red.service.persistence.management.v1.processor.exception.BadRequestException;
+import com.iqser.red.service.persistence.management.v1.processor.exception.ConflictException;
+import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DictionaryPersistenceService;
+import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DossierPersistenceService;
+import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DossierTemplatePersistenceService;
+import com.iqser.red.service.persistence.management.v1.processor.service.persistence.FileStatusPersistenceService;
+import com.iqser.red.service.persistence.management.v1.processor.utils.TypeIdUtils;
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.DossierTemplateStatus;
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.dossier.CreateOrUpdateDossierRequest;
+import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.dossier.DossierChange;
+
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+
 /**
  * Provides the internal interface between dossier request and the actual persistence.
  */
@@ -31,13 +35,14 @@ public class DossierService {
 
     private final DossierTemplatePersistenceService dossierTemplatePersistenceService;
 
+    private final DictionaryPersistenceService dictionaryPersistenceService;
+
 
     public DossierEntity addDossier(CreateOrUpdateDossierRequest createOrUpdateDossierRequest) {
 
         if (dossierPersistenceService.findAllDossiers()
                 .stream()
-                .anyMatch(p -> p.getHardDeletedTime() == null && p.getDossierName()
+                .anyMatch(p -> p.getHardDeletedTime() == null && p.getDossierName().equals(createOrUpdateDossierRequest.getDossierName()))) {
-                        .equals(createOrUpdateDossierRequest.getDossierName()))) {
             throw new ConflictException("Dossier with this name already exists");
         }
 
@@ -60,17 +65,20 @@ public class DossierService {
 
         DossierEntity dossier = dossierPersistenceService.findByDossierId(dossierId);
 
-        if (dossier.getDossierName()
+        if (dossier.getDossierName().equals(dossierRequest.getDossierName()) || dossierPersistenceService.findAllDossiers()
-                .equals(dossierRequest.getDossierName()) || dossierPersistenceService.findAllDossiers()
                 .stream()
-                .filter(p -> p.getHardDeletedTime() == null && p.getDossierName()
+                .filter(p -> p.getHardDeletedTime() == null && p.getDossierName().equals(dossierRequest.getDossierName()))
-                        .equals(dossierRequest.getDossierName()))
                 .findAny()
                 .isEmpty()) {
 
             if (!dossier.getDossierTemplateId().equalsIgnoreCase(dossierRequest.getDossierTemplateId())) {
-                var canUpdateDossierTemplate = fileStatusPersistenceService.getStatusesForDossier(dossierId).isEmpty();
+                if (fileStatusPersistenceService.getStatusesForDossier(dossierId).isEmpty()) {
-                if (!canUpdateDossierTemplate) {
+
+                    String typeId = TypeIdUtils.toTypeId("dossier_redaction", dossier.getDossierTemplateId(), dossier.getId());
+                    String newTypeId = TypeIdUtils.toTypeId("dossier_redaction", dossierRequest.getDossierTemplateId(), dossier.getId());
+                    dictionaryPersistenceService.updateTypeIdAndIncrementVersionByOne(typeId, newTypeId, dossierRequest.getDossierTemplateId());
+
+                } else {
                     throw new BadRequestException("Cannot update Dossier Template. Dossier already has files");
                 }
             }
@@ -88,11 +96,13 @@ public class DossierService {
         dossierPersistenceService.markDossierAsDeleted(dossierId, softDeleteTime);
     }
 
+
     public void hardDeleteDossier(String dossierId) {
 
         dossierPersistenceService.hardDelete(dossierId);
     }
 
+
     public void undeleteDossier(String dossierId) {
 
         dossierPersistenceService.undelete(dossierId);