diff --git a/persistence-service-v1/persistence-service-external-api-impl-v1/src/main/java/com/iqser/red/persistence/service/v1/external/api/impl/controller/ManualRedactionController.java b/persistence-service-v1/persistence-service-external-api-impl-v1/src/main/java/com/iqser/red/persistence/service/v1/external/api/impl/controller/ManualRedactionController.java index 1dc10b509..54c392cba 100644 --- a/persistence-service-v1/persistence-service-external-api-impl-v1/src/main/java/com/iqser/red/persistence/service/v1/external/api/impl/controller/ManualRedactionController.java +++ b/persistence-service-v1/persistence-service-external-api-impl-v1/src/main/java/com/iqser/red/persistence/service/v1/external/api/impl/controller/ManualRedactionController.java @@ -59,9 +59,9 @@ import lombok.extern.slf4j.Slf4j; @FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE) public class ManualRedactionController implements ManualRedactionResource { - final static String FILE_ID = "fileId"; - final static String DOSSIER_ID = "dossierId"; - final static String ANNOTATION_ID = "annotationId"; + static final String FILE_ID = "fileId"; + static final String DOSSIER_ID = "dossierId"; + static final String ANNOTATION_ID = "annotationId"; ManualRedactionService manualRedactionService; ManualRedactionUndoService manualRedactionUndoService; DossierManagementService dossierManagementService; diff --git a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/annotations/ManualRecategorizationEntity.java b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/annotations/ManualRecategorizationEntity.java index d8aa89bff..c6a81135c 100644 --- a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/annotations/ManualRecategorizationEntity.java +++ b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/annotations/ManualRecategorizationEntity.java @@ -47,6 +47,8 @@ public class ManualRecategorizationEntity implements IBaseAnnotation { private boolean addToDictionary; @Column private boolean addToAllDossiers; + @Column(length = 4000) + private String legalBasis; @ManyToOne private FileEntity fileStatus; diff --git a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/annotations/ManualRedactionEntryEntity.java b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/annotations/ManualRedactionEntryEntity.java index 0c4a274d1..fc3d0f1a3 100644 --- a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/annotations/ManualRedactionEntryEntity.java +++ b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/annotations/ManualRedactionEntryEntity.java @@ -44,7 +44,7 @@ public class ManualRedactionEntryEntity implements IBaseAnnotation { private String value; @Column(length = 4000) private String reason; - @Column + @Column(length = 4000) private String legalBasis; @Column private String section; diff --git a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionMapper.java b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionMapper.java index 53c476d07..e3a146180 100644 --- a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionMapper.java +++ b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionMapper.java @@ -6,10 +6,10 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Set; -import java.util.stream.Collectors; import org.springframework.stereotype.Service; +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.EntityLogService; import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLog; @@ -49,7 +49,7 @@ public class ManualRedactionMapper { return addRedactionRequests.stream() .map(addRedactionRequest -> toAddRedactionRequest(dossierId, dossier.getDossierTemplateId(), addRedactionRequest)) - .collect(Collectors.toList()); + .toList(); } @@ -115,7 +115,7 @@ public class ManualRedactionMapper { .legalBasis(forceRedactionRequest.getLegalBasis()) .comment(forceRedactionRequest.getComment()) .build()) - .collect(Collectors.toList()); + .toList(); } @@ -130,7 +130,7 @@ public class ManualRedactionMapper { .comment(legalBasisChangeRequest.getComment()) .value(legalBasisChangeRequest.getValue()) .build()) - .collect(Collectors.toList()); + .toList(); } @@ -156,6 +156,7 @@ public class ManualRedactionMapper { .value(entityLogEntry.getValue()) .typeToRemove(entityLogEntry.getType()) .dossierTemplateTypeId(toTypeId(recategorizationRequest.getType(), dossierTemplateId)) + .legalBasis(recategorizationRequest.getLegalBasis()) .build(); requests.add(build); } @@ -176,7 +177,7 @@ public class ManualRedactionMapper { .updateDictionary(resizeRedactionRequest.getUpdateDictionary()) .addToAllDossiers(resizeRedactionRequest.isAddToAllDossiers()) .build()) - .collect(Collectors.toList()); + .toList(); } diff --git a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionProviderService.java b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionProviderService.java index 9adf8366a..c60937d4e 100644 --- a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionProviderService.java +++ b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionProviderService.java @@ -20,7 +20,7 @@ import com.iqser.red.service.persistence.management.v1.processor.service.persist import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.RecategorizationPersistenceService; import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.RemoveRedactionPersistenceService; import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.ResizeRedactionPersistenceService; -import com.iqser.red.service.persistence.management.v1.processor.utils.ManualImageRecategorizationMapper; +import com.iqser.red.service.persistence.management.v1.processor.utils.ManualRecategorizationMapper; import com.iqser.red.service.persistence.management.v1.processor.utils.ManualRedactionMapper; import com.iqser.red.service.persistence.management.v1.processor.utils.ManualResizeRedactionMapper; import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.ManualRedactions; @@ -70,7 +70,7 @@ public class ManualRedactionProviderService { forceRedactions = convert(forceRedactionPersistenceService.findUnprocessedForceRedactions(fileId), ManualForceRedaction.class); recategorizations = new HashSet<>(convert(recategorizationPersistenceService.findUnprocessedRecategorizations(fileId), ManualRecategorization.class, - new ManualImageRecategorizationMapper())); + new ManualRecategorizationMapper())); legalBasisChanges = convert(legalBasisChangePersistenceService.findUnprocessedLegalBasisChanges(fileId), ManualLegalBasisChange.class); resizeRedactions = new HashSet<>(convert(resizeRedactionPersistenceService.findUnprocessedResizeRedactions(fileId), ManualResizeRedaction.class, @@ -81,7 +81,7 @@ public class ManualRedactionProviderService { forceRedactions = convert(forceRedactionPersistenceService.findForceRedactions(fileId, false), ManualForceRedaction.class); recategorizations = new HashSet<>(convert(recategorizationPersistenceService.findRecategorizations(fileId, false), ManualRecategorization.class, - new ManualImageRecategorizationMapper())); + new ManualRecategorizationMapper())); legalBasisChanges = convert(legalBasisChangePersistenceService.findLegalBasisChanges(fileId, false), ManualLegalBasisChange.class); resizeRedactions = new HashSet<>(convert(resizeRedactionPersistenceService.findResizeRedactions(fileId, false), ManualResizeRedaction.class, diff --git a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionService.java b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionService.java index f632b302e..53e0850e5 100644 --- a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionService.java +++ b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionService.java @@ -75,6 +75,8 @@ public class ManualRedactionService { EntityLogMergeService entityLogMergeService; FileStatusPersistenceService fileStatusPersistenceService; + private static final int MAX_LEGAL_BASIS_LENGTH = 4000; + @Transactional @Observed(name = "ManualRedactionService", contextualName = "add-manual-redaction") @@ -94,14 +96,15 @@ public class ManualRedactionService { manualRedactionEntryEntities.add(addRedactionPersistenceService.insert(fileId, annotationId, addRedactionRequest)); Set typeIdsOfModifiedDictionaries = manualRedactionDictionaryUpdateHandler.handleAddToDictionaryAndReturnModifiedTypeIds(fileId, - addRedactionRequest.getValue(), - addRedactionRequest); + addRedactionRequest.getValue(), + addRedactionRequest); addRedactionPersistenceService.updateModifiedDictionaries(fileId, annotationId, !typeIdsOfModifiedDictionaries.isEmpty(), typeIdsOfModifiedDictionaries); Long commentId = commentService.addCommentAndGetId(fileId, annotationId, addRedactionRequest.getComment(), addRedactionRequest.getUser()); - response.add(ManualAddResponse.builder().annotationId(annotationId).commentId(commentId).build()); + response.add(ManualAddResponse.builder().annotationId(annotationId).commentId(commentId) + .build()); } manualRedactionEntryEntities = manualRedactionEntryEntities.stream() @@ -110,7 +113,8 @@ public class ManualRedactionService { FileModel fileStatus = fileStatusService.getStatus(fileId); if (!manualRedactionEntryEntities.isEmpty() && fileStatus.isExcludedFromAutomaticAnalysis()) { - ManualRedactions manualRedactions = ManualRedactions.builder().entriesToAdd(convertEntriesToAdd(manualRedactionEntryEntities)).build(); + ManualRedactions manualRedactions = ManualRedactions.builder().entriesToAdd(convertEntriesToAdd(manualRedactionEntryEntities)) + .build(); entityLogMergeService.sendToAnalyseQueue(fileId, dossierEntity, fileStatusService.getStatus(fileId), manualRedactions); } else { reprocess(dossierId, fileId); @@ -123,7 +127,9 @@ public class ManualRedactionService { private Set convertEntriesToAdd(List source) { - return source.stream().map(entry -> convert(entry, ManualRedactionEntry.class, new ManualRedactionMapper())).collect(Collectors.toSet()); + return source.stream() + .map(entry -> convert(entry, ManualRedactionEntry.class, new ManualRedactionMapper())) + .collect(Collectors.toSet()); } @@ -135,27 +141,25 @@ public class ManualRedactionService { //validate removing from dossier template dictionary for (RemoveRedactionRequest removeRedactionRequest : removeRedactionRequests) { manualRedactionDictionaryUpdateHandler.validateDictionariesForDelete(removeRedactionRequest, - removeRedactionRequest.getTypeToRemove(), - removeRedactionRequest.getDossierTemplateId()); + removeRedactionRequest.getTypeToRemove(), + removeRedactionRequest.getDossierTemplateId()); log.info("add removeRedaction for file {} and annotation {}", fileId, removeRedactionRequest.getAnnotationId()); removeRedactionPersistenceService.insert(fileId, removeRedactionRequest); Long commentId = commentService.addCommentAndGetId(fileId, - removeRedactionRequest.getAnnotationId(), - removeRedactionRequest.getComment(), - removeRedactionRequest.getUser()); + removeRedactionRequest.getAnnotationId(), + removeRedactionRequest.getComment(), + removeRedactionRequest.getUser()); Set typeIdsOfModifiedDictionaries = manualRedactionDictionaryUpdateHandler.handleRemoveFromDictionaryAndReturnModifiedTypeIds(fileId, removeRedactionRequest); boolean removedFromDictionary = !typeIdsOfModifiedDictionaries.isEmpty(); - removeRedactionPersistenceService.updateModifiedDictionaries(fileId, - removeRedactionRequest.getAnnotationId(), - removedFromDictionary, - typeIdsOfModifiedDictionaries); + removeRedactionPersistenceService.updateModifiedDictionaries(fileId, removeRedactionRequest.getAnnotationId(), removedFromDictionary, typeIdsOfModifiedDictionaries); - response.add(ManualAddResponse.builder().annotationId(removeRedactionRequest.getAnnotationId()).commentId(commentId).build()); + response.add(ManualAddResponse.builder().annotationId(removeRedactionRequest.getAnnotationId()).commentId(commentId) + .build()); } reprocess(dossierId, fileId); @@ -176,11 +180,12 @@ public class ManualRedactionService { forceRedactionPersistenceService.insert(fileId, forceRedactionRequest); Long commentId = commentService.addCommentAndGetId(fileId, - forceRedactionRequest.getAnnotationId(), - forceRedactionRequest.getComment(), - forceRedactionRequest.getUser()); + forceRedactionRequest.getAnnotationId(), + forceRedactionRequest.getComment(), + forceRedactionRequest.getUser()); - response.add(ManualAddResponse.builder().annotationId(forceRedactionRequest.getAnnotationId()).commentId(commentId).build()); + response.add(ManualAddResponse.builder().annotationId(forceRedactionRequest.getAnnotationId()).commentId(commentId) + .build()); } reprocess(dossierId, fileId); @@ -201,11 +206,12 @@ public class ManualRedactionService { legalBasisChangePersistenceService.insert(fileId, legalBasisChangeRequest); Long commentId = commentService.addCommentAndGetId(fileId, - legalBasisChangeRequest.getAnnotationId(), - legalBasisChangeRequest.getComment(), - legalBasisChangeRequest.getUser()); + legalBasisChangeRequest.getAnnotationId(), + legalBasisChangeRequest.getComment(), + legalBasisChangeRequest.getUser()); - response.add(ManualAddResponse.builder().annotationId(legalBasisChangeRequest.getAnnotationId()).commentId(commentId).build()); + response.add(ManualAddResponse.builder().annotationId(legalBasisChangeRequest.getAnnotationId()).commentId(commentId) + .build()); } reprocess(dossierId, fileId); fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now()); @@ -221,28 +227,31 @@ public class ManualRedactionService { for (var recategorizationRequest : recategorizationRequests) { manualRedactionDictionaryUpdateHandler.validateDictionariesForAdd(recategorizationRequest, recategorizationRequest.getValue()); manualRedactionDictionaryUpdateHandler.validateDictionariesForDelete(recategorizationRequest, - recategorizationRequest.getTypeToRemove(), - recategorizationRequest.getDossierTemplateId()); + recategorizationRequest.getTypeToRemove(), + recategorizationRequest.getDossierTemplateId()); + + checkLegalBasisLength(recategorizationRequest.getLegalBasis()); recategorizationPersistenceService.insert(fileId, recategorizationRequest); Set typeIdsOfDictionariesWithAdd = manualRedactionDictionaryUpdateHandler.handleAddToDictionaryAndReturnModifiedTypeIds(fileId, - recategorizationRequest.getValue(), - recategorizationRequest); + recategorizationRequest.getValue(), + recategorizationRequest); Set typeIdsOfDictionariesWithDelete = manualRedactionDictionaryUpdateHandler.handleRemoveFromDictionaryAndReturnModifiedTypeIds(fileId, - recategorizationRequest); + recategorizationRequest); recategorizationPersistenceService.updateModifiedDictionaries(fileId, - recategorizationRequest.getAnnotationId(), - typeIdsOfDictionariesWithAdd, - typeIdsOfDictionariesWithDelete); + recategorizationRequest.getAnnotationId(), + typeIdsOfDictionariesWithAdd, + typeIdsOfDictionariesWithDelete); Long commentId = commentService.addCommentAndGetId(fileId, - recategorizationRequest.getAnnotationId(), - recategorizationRequest.getComment(), - recategorizationRequest.getUser()); + recategorizationRequest.getAnnotationId(), + recategorizationRequest.getComment(), + recategorizationRequest.getUser()); - response.add(ManualAddResponse.builder().annotationId(recategorizationRequest.getAnnotationId()).commentId(commentId).build()); + response.add(ManualAddResponse.builder().annotationId(recategorizationRequest.getAnnotationId()).commentId(commentId) + .build()); } reprocess(dossierId, fileId); @@ -252,6 +261,14 @@ public class ManualRedactionService { } + private void checkLegalBasisLength(String legalBasis) { + + if (legalBasis.length() > MAX_LEGAL_BASIS_LENGTH) { + throw new BadRequestException(String.format("The legal basis is too long (%s), max length %s", legalBasis.length(), MAX_LEGAL_BASIS_LENGTH)); + } + } + + @Transactional @Observed(name = "ManualRedactionService", contextualName = "add-manual-redaction") public List addResizeRedaction(String dossierId, String fileId, List resizeRedactionRequests, boolean includeUnprocessed) { @@ -267,18 +284,23 @@ public class ManualRedactionService { if (resizeRedactionRequest.getComment() != null) { Long commentId = commentService.addCommentAndGetId(fileId, - resizeRedactionRequest.getAnnotationId(), - resizeRedactionRequest.getComment(), - resizeRedactionRequest.getUser()); - response.add(ManualAddResponse.builder().annotationId(resizeRedactionRequest.getAnnotationId()).commentId(commentId).build()); + resizeRedactionRequest.getAnnotationId(), + resizeRedactionRequest.getComment(), + resizeRedactionRequest.getUser()); + response.add(ManualAddResponse.builder().annotationId(resizeRedactionRequest.getAnnotationId()).commentId(commentId) + .build()); } Set typeIdsOfModifiedDictionaries = manualRedactionDictionaryUpdateHandler.updateDictionaryForResizeRedactions(dossierId, - fileId, - resizeRedaction, - getEntityLogEntry(entityLog, resizeRedaction.getId().getAnnotationId())); + fileId, + resizeRedaction, + getEntityLogEntry(entityLog, + resizeRedaction.getId() + .getAnnotationId())); - resizeRedactionPersistenceService.updateModifiedDictionaries(resizeRedaction.getId().getFileId(), resizeRedaction.getId().getAnnotationId(), typeIdsOfModifiedDictionaries); + resizeRedactionPersistenceService.updateModifiedDictionaries(resizeRedaction.getId().getFileId(), + resizeRedaction.getId().getAnnotationId(), + typeIdsOfModifiedDictionaries); } manualResizeRedactionEntities = manualResizeRedactionEntities.stream() @@ -287,7 +309,8 @@ public class ManualRedactionService { FileModel fileStatus = fileStatusService.getStatus(fileId); if (!manualResizeRedactionEntities.isEmpty() && fileStatus.isExcludedFromAutomaticAnalysis()) { - ManualRedactions manualRedactions = ManualRedactions.builder().resizeRedactions(convertResizeRedactions(manualResizeRedactionEntities)).build(); + ManualRedactions manualRedactions = ManualRedactions.builder().resizeRedactions(convertResizeRedactions(manualResizeRedactionEntities)) + .build(); entityLogMergeService.sendToAnalyseQueue(fileId, dossierPersistenceService.getAndValidateDossier(dossierId), fileStatusService.getStatus(fileId), manualRedactions); } else { reprocess(dossierId, fileId); @@ -301,14 +324,20 @@ public class ManualRedactionService { private Set convertResizeRedactions(List source) { - return source.stream().map(entry -> convert(entry, ManualResizeRedaction.class, new ManualResizeRedactionMapper())).collect(Collectors.toSet()); + return source.stream() + .map(entry -> convert(entry, ManualResizeRedaction.class, new ManualResizeRedactionMapper())) + .collect(Collectors.toSet()); } private void validatePositions(String fileId, AddRedactionRequest addRedactionRequest) { var numberOfPages = fileStatusService.getStatus(fileId).getNumberOfPages(); - addRedactionRequest.getPositions().stream().filter(p -> p.getPage() > numberOfPages).findAny().ifPresent(p -> new BadRequestException("Invalid page found in the request")); + addRedactionRequest.getPositions() + .stream() + .filter(p -> p.getPage() > numberOfPages) + .findAny() + .ifPresent(p -> new BadRequestException("Invalid page found in the request")); } @@ -340,46 +369,52 @@ public class ManualRedactionService { if (manualRedactions != null) { if (manualRedactions.getEntriesToAdd() != null) { - manualRedactions.getEntriesToAdd().forEach(e -> { - if (e.getProcessedDate() == null) { - addRedactionPersistenceService.markAsProcessed(e); - } - }); + manualRedactions.getEntriesToAdd() + .forEach(e -> { + if (e.getProcessedDate() == null) { + addRedactionPersistenceService.markAsProcessed(e); + } + }); } if (manualRedactions.getIdsToRemove() != null) { - manualRedactions.getIdsToRemove().forEach(e -> { - if (e.getProcessedDate() == null) { - removeRedactionPersistenceService.markAsProcessed(e); - } - }); + manualRedactions.getIdsToRemove() + .forEach(e -> { + if (e.getProcessedDate() == null) { + removeRedactionPersistenceService.markAsProcessed(e); + } + }); } if (manualRedactions.getForceRedactions() != null) { - manualRedactions.getForceRedactions().forEach(e -> { - if (e.getProcessedDate() == null) { - forceRedactionPersistenceService.markAsProcessed(e.getAnnotationId(), e.getFileId()); - } - }); + manualRedactions.getForceRedactions() + .forEach(e -> { + if (e.getProcessedDate() == null) { + forceRedactionPersistenceService.markAsProcessed(e.getAnnotationId(), e.getFileId()); + } + }); } if (manualRedactions.getRecategorizations() != null) { - manualRedactions.getRecategorizations().forEach(e -> { - if (e.getProcessedDate() == null) { - recategorizationPersistenceService.markAsProcessed(e.getAnnotationId(), e.getFileId()); - } - }); + manualRedactions.getRecategorizations() + .forEach(e -> { + if (e.getProcessedDate() == null) { + recategorizationPersistenceService.markAsProcessed(e.getAnnotationId(), e.getFileId()); + } + }); } if (manualRedactions.getResizeRedactions() != null) { - manualRedactions.getResizeRedactions().forEach(e -> { - if (e.getProcessedDate() == null) { - resizeRedactionPersistenceService.markAsProcessed(e.getAnnotationId(), e.getFileId()); - } - }); + manualRedactions.getResizeRedactions() + .forEach(e -> { + if (e.getProcessedDate() == null) { + resizeRedactionPersistenceService.markAsProcessed(e.getAnnotationId(), e.getFileId()); + } + }); } if (manualRedactions.getLegalBasisChanges() != null) { - manualRedactions.getLegalBasisChanges().forEach(e -> { - if (e.getProcessedDate() == null) { - legalBasisChangePersistenceService.markAsProcessed(e.getAnnotationId(), e.getFileId()); - } - }); + manualRedactions.getLegalBasisChanges() + .forEach(e -> { + if (e.getProcessedDate() == null) { + legalBasisChangePersistenceService.markAsProcessed(e.getAnnotationId(), e.getFileId()); + } + }); } } } diff --git a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/annotations/RecategorizationPersistenceService.java b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/annotations/RecategorizationPersistenceService.java index 4bceae2bf..390405ae9 100644 --- a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/annotations/RecategorizationPersistenceService.java +++ b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/annotations/RecategorizationPersistenceService.java @@ -28,21 +28,18 @@ public class RecategorizationPersistenceService { public void insert(String fileId, RecategorizationRequest recategorizationRequest) { - ManualRecategorizationEntity manualImageRecategorization = new ManualRecategorizationEntity(); - manualImageRecategorization.setId(new AnnotationEntityId(recategorizationRequest.getAnnotationId(), fileId)); - BeanUtils.copyProperties(recategorizationRequest, manualImageRecategorization); - manualImageRecategorization.setRequestDate(OffsetDateTime.now()); - manualImageRecategorization.setTypeId(recategorizationRequest.getDossierTemplateTypeId()); - recategorizationRepository.saveAndFlush(manualImageRecategorization); + ManualRecategorizationEntity manualRecategorization = new ManualRecategorizationEntity(); + manualRecategorization.setId(new AnnotationEntityId(recategorizationRequest.getAnnotationId(), fileId)); + BeanUtils.copyProperties(recategorizationRequest, manualRecategorization); + manualRecategorization.setRequestDate(OffsetDateTime.now()); + manualRecategorization.setTypeId(recategorizationRequest.getDossierTemplateTypeId()); + recategorizationRepository.saveAndFlush(manualRecategorization); } - @Transactional - public void updateModifiedDictionaries(String fileId, - String annotationId, Set typeIdsOfDictionaryWithAdd, - Set typeIdsOfDictionaryWithDelete) { + public void updateModifiedDictionaries(String fileId, String annotationId, Set typeIdsOfDictionaryWithAdd, Set typeIdsOfDictionaryWithDelete) { ManualRecategorizationEntity addRedaction = recategorizationRepository.findById(new AnnotationEntityId(annotationId, fileId)) .orElseThrow(() -> new NotFoundException("Unknown file/annotation combination: " + fileId + "/" + annotationId)); diff --git a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/utils/ManualImageRecategorizationMapper.java b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/utils/ManualRecategorizationMapper.java similarity index 83% rename from persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/utils/ManualImageRecategorizationMapper.java rename to persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/utils/ManualRecategorizationMapper.java index ccacca70d..57db20cf4 100644 --- a/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/utils/ManualImageRecategorizationMapper.java +++ b/persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/utils/ManualRecategorizationMapper.java @@ -5,7 +5,7 @@ import java.util.function.BiConsumer; import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.ManualRecategorizationEntity; import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRecategorization; -public class ManualImageRecategorizationMapper implements BiConsumer { +public class ManualRecategorizationMapper implements BiConsumer { @Override public void accept(ManualRecategorizationEntity manualRecategorizationEntity, ManualRecategorization manualRedactionEntry) { diff --git a/persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/db.changelog-tenant.yaml b/persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/db.changelog-tenant.yaml index ba852e780..8c8ee04bc 100644 --- a/persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/db.changelog-tenant.yaml +++ b/persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/db.changelog-tenant.yaml @@ -181,3 +181,5 @@ databaseChangeLog: file: db/changelog/tenant/118-delete-unapproved-manual-changes-and-drop-column-status.yaml - include: file: db/changelog/tenant/119-set-add-to-all-dossiers-correctly-in-manual-redaction-table.yaml + - include: + file: db/changelog/tenant/120-add-legal-basis-change-to-manual-recategorization.yaml diff --git a/persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/tenant/120-add-legal-basis-change-to-manual-recategorization.yaml b/persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/tenant/120-add-legal-basis-change-to-manual-recategorization.yaml new file mode 100644 index 000000000..5bf6255f4 --- /dev/null +++ b/persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/tenant/120-add-legal-basis-change-to-manual-recategorization.yaml @@ -0,0 +1,18 @@ +databaseChangeLog: + - changeSet: + id: add-legal-basis-change-to-manual-recategorization + author: ali + changes: + - addColumn: + tableName: manual_recategorization + columns: + - column: + name: legal_basis + type: VARCHAR(4000) + defaultValue: '' + constraints: + nullable: false + - modifyDataType: + columnName: legal_basis + newDataType: VARCHAR(4000) + tableName: manual_redaction \ No newline at end of file diff --git a/persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/FileTest.java b/persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/FileTest.java index e59615b6f..be60ef452 100644 --- a/persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/FileTest.java +++ b/persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/FileTest.java @@ -416,7 +416,7 @@ public class FileTest extends AbstractPersistenceServerServiceTest { .build())); manualRedactionClient.recategorizeBulk(dossierId, fileId, - Set.of(RecategorizationRequestModel.builder().annotationId(annotationId).comment("comment").type("new-type") + Set.of(RecategorizationRequestModel.builder().annotationId(annotationId).comment("comment").type("new-type").legalBasis("") .build()), false); @@ -424,22 +424,22 @@ public class FileTest extends AbstractPersistenceServerServiceTest { fileManagementClient.deleteFile(dossier.getId(), file.getId()); var softDeletedFiles = fileClient.getSoftDeletedDossierStatus(dossier.getId()); - assertThat(softDeletedFiles.size()).isEqualTo(1); + assertThat(softDeletedFiles).hasSize(1); var activeFiles = fileClient.getDossierStatus(dossier.getId()); - assertThat(activeFiles.size()).isEqualTo(0); + assertThat(activeFiles).isEmpty(); fileManagementClient.restoreFiles(dossier.getId(), Sets.newHashSet(file.getId())); softDeletedFiles = fileClient.getSoftDeletedDossierStatus(dossier.getId()); - assertThat(softDeletedFiles.size()).isEqualTo(0); + assertThat(softDeletedFiles).isEmpty(); activeFiles = fileClient.getDossierStatus(dossier.getId()); - assertThat(activeFiles.size()).isEqualTo(1); + assertThat(activeFiles).hasSize(1); fileManagementClient.hardDeleteFiles(dossier.getId(), List.of(file.getId())); softDeletedFiles = fileClient.getSoftDeletedDossierStatus(dossier.getId()); - assertThat(softDeletedFiles.size()).isEqualTo(0); + assertThat(softDeletedFiles).isEmpty(); activeFiles = fileClient.getDossierStatus(dossier.getId()); - assertThat(activeFiles.size()).isEqualTo(0); + assertThat(activeFiles).isEmpty(); } diff --git a/persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/ManualRedactionTest.java b/persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/ManualRedactionTest.java index a6943be2a..9fafe45e9 100644 --- a/persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/ManualRedactionTest.java +++ b/persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/ManualRedactionTest.java @@ -2,6 +2,7 @@ package com.iqser.red.service.peristence.v1.server.integration.tests; import static com.iqser.red.service.persistence.management.v1.processor.utils.TypeIdUtils.toTypeId; import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; @@ -13,9 +14,9 @@ import java.util.ArrayList; import java.util.List; import java.util.Set; +import org.apache.commons.lang3.RandomStringUtils; import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; -import org.mockito.Mock; import org.mockito.Mockito; import org.springframework.beans.factory.annotation.Autowired; @@ -53,7 +54,6 @@ import com.iqser.red.service.persistence.service.v1.api.shared.model.manual.Lega import com.iqser.red.service.persistence.service.v1.api.shared.model.manual.RecategorizationRequestModel; import com.iqser.red.service.persistence.service.v1.api.shared.model.manual.RemoveRedactionRequestModel; import com.iqser.red.service.persistence.service.v1.api.shared.model.manual.ResizeRedactionRequestModel; -import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.Point; import feign.FeignException; @@ -121,28 +121,33 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { dictionaryClient.addEntry(type.getType(), type.getDossierTemplateId(), List.of("Luke Skywalker"), false, dossier.getId(), DictionaryEntryType.ENTRY); var entityLog = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id("AnnotationId") - .type(type.getType()) - .value("Luke Skywalker") - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .dictionaryEntry(true) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id("AnnotationId") + .type(type.getType()) + .value("Luke Skywalker") + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .dictionaryEntry(true) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), Mockito.any(), Mockito.anyBoolean())).thenReturn(entityLog); Assertions.assertThrows(FeignException.Forbidden.class, - () -> manualRedactionClient.removeRedactionBulk(dossier.getId(), - file.getId(), - Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build()), false));//.get(0); + () -> manualRedactionClient.removeRedactionBulk(dossier.getId(), + file.getId(), + Set.of(RemoveRedactionRequestModel.builder() + .annotationId("AnnotationId") + .removeFromDictionary(true) + .removeFromAllDossiers(true) + .build()), + false));//.get(0); var dossierTemplateDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId()), null); assertThat(dossierTemplateDictionary.getEntries().size()).isZero(); @@ -162,18 +167,19 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { Assertions.assertThrows(FeignException.Forbidden.class, () -> manualRedactionClient.addRedactionBulk(dossier.getId(), - file.getId(), - Set.of(AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().topLeftY(1).topLeftX(1).height(1).width(1).build())) - .section("section test") - .addToDictionary(true) - .addToAllDossiers(true) - .type(type.getType()) - .reason("1") - .value("Luke Skywalker") - .legalBasis("1") - .sourceId("SourceId") - .build()))); + file.getId(), + Set.of(AddRedactionRequestModel.builder() + .positions(List.of(Rectangle.builder().topLeftY(1).topLeftX(1).height(1).width(1) + .build())) + .section("section test") + .addToDictionary(true) + .addToAllDossiers(true) + .type(type.getType()) + .reason("1") + .value("Luke Skywalker") + .legalBasis("1") + .sourceId("SourceId") + .build()))); var dossierTemplateDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId()), null); assertThat(dossierTemplateDictionary.getEntries().size()).isZero(); @@ -194,30 +200,34 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var dossierDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId(), dossier.getId()), null); assertThat(dossierDictionary.getEntries().size()).isEqualTo(1); - assertThat(dossierDictionary.getEntries().get(0).isDeleted()).isTrue(); + assertThat(dossierDictionary.getEntries() + .get(0).isDeleted()).isTrue(); manualRedactionClient.addRedactionBulk(dossier.getId(), - file.getId(), - Set.of(AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().topLeftY(1).topLeftX(1).height(1).width(1).build())) - .section("section test") - .addToDictionary(true) - .addToAllDossiers(true) - .dictionaryEntryType(DictionaryEntryType.ENTRY) - .type(type.getType()) - .reason("1") - .value("Luke Skywalker") - .legalBasis("1") - .sourceId("SourceId") - .build())); + file.getId(), + Set.of(AddRedactionRequestModel.builder() + .positions(List.of(Rectangle.builder().topLeftY(1).topLeftX(1).height(1).width(1) + .build())) + .section("section test") + .addToDictionary(true) + .addToAllDossiers(true) + .dictionaryEntryType(DictionaryEntryType.ENTRY) + .type(type.getType()) + .reason("1") + .value("Luke Skywalker") + .legalBasis("1") + .sourceId("SourceId") + .build())); dossierDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId(), dossier.getId()), null); assertThat(dossierDictionary.getEntries().size()).isEqualTo(1); - assertThat(dossierDictionary.getEntries().get(0).isDeleted()).isFalse(); + assertThat(dossierDictionary.getEntries() + .get(0).isDeleted()).isFalse(); var dossierTemplateDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId()), null); assertThat(dossierTemplateDictionary.getEntries().size()).isEqualTo(1); - assertThat(dossierTemplateDictionary.getEntries().get(0).isDeleted()).isFalse(); + assertThat(dossierTemplateDictionary.getEntries() + .get(0).isDeleted()).isFalse(); } @@ -232,22 +242,24 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var type = typeProvider.testAndProvideType(dossierTemplate); manualRedactionClient.addRedactionBulk(dossier.getId(), - file.getId(), - Set.of(AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().topLeftY(1).topLeftX(1).height(1).width(1).build())) - .section("section test") - .addToDictionary(true) - .addToAllDossiers(false) - .type(type.getType()) - .reason("1") - .value("Luke Skywalker") - .legalBasis("1") - .sourceId("SourceId") - .build())); + file.getId(), + Set.of(AddRedactionRequestModel.builder() + .positions(List.of(Rectangle.builder().topLeftY(1).topLeftX(1).height(1).width(1) + .build())) + .section("section test") + .addToDictionary(true) + .addToAllDossiers(false) + .type(type.getType()) + .reason("1") + .value("Luke Skywalker") + .legalBasis("1") + .sourceId("SourceId") + .build())); var dossierDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId(), dossier.getId()), null); assertThat(dossierDictionary.getEntries().size()).isEqualTo(1); - assertThat(dossierDictionary.getEntries().get(0).isDeleted()).isFalse(); + assertThat(dossierDictionary.getEntries() + .get(0).isDeleted()).isFalse(); var dossierTemplateDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId()), null); assertThat(dossierTemplateDictionary.getEntries().isEmpty()).isTrue(); @@ -277,27 +289,29 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { assertThat(dossierDictionary.getEntries()).containsExactlyInAnyOrder("Luke Skywalker"); var entityLog = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id("AnnotationId") - .type("test") - .value("Luke Skywalker") - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .dictionaryEntry(true) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id("AnnotationId") + .type("test") + .value("Luke Skywalker") + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .dictionaryEntry(true) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog); manualRedactionClient.removeRedactionBulk(dossier.getId(), - file.getId(), - Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build()), false); + file.getId(), + Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true) + .build()), + false); dossierTemplateDictionary = dictionaryClient.getDictionaryForType(type.getType(), type.getDossierTemplateId(), null); assertThat(dossierTemplateDictionary.getEntries()).containsExactlyInAnyOrder("Darth Vader"); @@ -332,36 +346,44 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { // dictionaryClient.addType(dossierDictionaryType, dossier.getId()); var entityLog = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id("AnnotationId") - .type("test") - .value("Luke Skywalker") - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .dictionaryEntry(true) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id("AnnotationId") + .type("test") + .value("Luke Skywalker") + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .dictionaryEntry(true) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog); manualRedactionClient.removeRedactionBulk(dossier.getId(), - file.getId(), - Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).build()), false).get(0); + file.getId(), + Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true) + .build()), + false) + .get(0); var dossierDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId(), dossier.getId()), null); var dossierTemplateDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId()), null); assertThat(dossierTemplateDictionary.getEntries().size()).isEqualTo(2); - assertThat(dossierTemplateDictionary.getEntries().stream().filter(e -> e.getValue().equals("Luke Skywalker")).findFirst().get().isDeleted()).isFalse(); + assertThat(dossierTemplateDictionary.getEntries() + .stream() + .filter(e -> e.getValue().equals("Luke Skywalker")) + .findFirst() + .get().isDeleted()).isFalse(); assertThat(dossierDictionary.getEntries().size()).isEqualTo(1); - assertThat(dossierDictionary.getEntries().get(0).isDeleted()).isTrue(); + assertThat(dossierDictionary.getEntries() + .get(0).isDeleted()).isTrue(); } @@ -380,31 +402,35 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { dictionaryClient.addEntry(type.getType(), type.getDossierTemplateId(), List.of("Luke Skywalker"), false, dossier.getId(), DictionaryEntryType.ENTRY); var entityLog = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id("AnnotationId") - .type("test") - .value("Luke Skywalker") - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .dictionaryEntry(true) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id("AnnotationId") + .type("test") + .value("Luke Skywalker") + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .dictionaryEntry(true) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog); manualRedactionClient.removeRedactionBulk(dossier.getId(), - file.getId(), - Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build()), false).get(0); + file.getId(), + Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true) + .build()), + false) + .get(0); var dossierDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId(), dossier.getId()), null); assertThat(dossierDictionary.getEntries().size()).isEqualTo(1); - assertThat(dossierDictionary.getEntries().get(0).isDeleted()).isTrue(); + assertThat(dossierDictionary.getEntries() + .get(0).isDeleted()).isTrue(); var dossierTemplateDictionary = internalDictionaryClient.getDictionaryForType(toTypeId(type.getType(), dossierTemplate.getId()), null); assertThat(dossierTemplateDictionary.getEntries().size()).isEqualTo(0); @@ -429,7 +455,8 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var userId = userProvider.getUserId(); var redactionDos = AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1).build())) + .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1) + .build())) .section("section test") .addToDictionary(true) .addToAllDossiers(false) @@ -443,7 +470,8 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { .build(); var redactionDosTempDict = AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1).build())) + .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1) + .build())) .section("section test") .addToDictionary(true) .addToAllDossiers(true) @@ -460,49 +488,51 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var loadedRedactionsFile1 = manualRedactionClient.getManualRedactions(file1.getDossierId(), file1.getFileId(), false); var entityLog1 = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id(addRedactions.get(0).getAnnotationId()) - .type(typeDosDict.getType()) - .value("test redaction in dossier") - .dossierDictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build(), - EntityLogEntry.builder() - .id(addRedactions.get(1).getAnnotationId()) - .type(typeDosTempDict.getType()) - .value("test redaction in dossier template") - .dictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id(addRedactions.get(0).getAnnotationId()) + .type(typeDosDict.getType()) + .value("test redaction in dossier") + .dossierDictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build(), + EntityLogEntry.builder() + .id(addRedactions.get(1).getAnnotationId()) + .type(typeDosTempDict.getType()) + .value("test redaction in dossier template") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier1.getId(), file1.getId(), FileType.ENTITY_LOG, entityLog1); - var redactionRequest1 = RedactionRequest.builder().dossierId(file1.getDossierId()).fileId(file1.getFileId()).dossierTemplateId(file1.getDossierTemplateId()).build(); + var redactionRequest1 = RedactionRequest.builder().dossierId(file1.getDossierId()).fileId(file1.getFileId()).dossierTemplateId(file1.getDossierTemplateId()) + .build(); when(entityLogService.getEntityLog(eq(file1.getDossierId()), eq(file1.getFileId()), any(), anyBoolean())).thenReturn(entityLog1); var entityLog2 = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id(addRedactions.get(1).getAnnotationId()) - .type(typeDosTempDict.getType()) - .value("test redaction in dossier template") - .dictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id(addRedactions.get(1).getAnnotationId()) + .type(typeDosTempDict.getType()) + .value("test redaction in dossier template") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier2.getId(), file2.getId(), FileType.ENTITY_LOG, entityLog2); - var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()).build(); + var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()) + .build(); when(entityLogService.getEntityLog(eq(file2.getDossierId()), eq(file2.getFileId()), any(), anyBoolean())).thenReturn(entityLog2); // resize redaction in dossier 1 @@ -519,21 +549,27 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { loadedRedactionsFile1 = manualRedactionClient.getManualRedactions(file1.getDossierId(), file1.getFileId(), false); assertThat(loadedRedactionsFile1.getResizeRedactions()).hasSize(1); - assertThat(loadedRedactionsFile1.getResizeRedactions().stream().toList().get(0).getValue()).isEqualTo("test redaction in dossier dictionary"); + assertThat(loadedRedactionsFile1.getResizeRedactions() + .stream() + .toList() + .get(0).getValue()).isEqualTo("test redaction in dossier dictionary"); var dictEntries = dictionaryManagementService.getAllEntriesInDossierTemplate(dossierTemplate.getId(), "test redaction in dossier dictionary", DictionaryEntryType.ENTRY); - assertThat(dictEntries.stream().filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier dictionary"))).isNotEmpty(); + assertThat(dictEntries.stream() + .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier dictionary"))).isNotEmpty(); var dictionaryOfTypeDosDictInDossier1 = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(dictionaryOfTypeDosDictInDossier1.getEntries()).hasSize(1); - assertThat(dictionaryOfTypeDosDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier"); + assertThat(dictionaryOfTypeDosDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier"); var dictionaryOfTypeDosDictInDossier2 = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(dictionaryOfTypeDosDictInDossier2.getEntries()).isEmpty(); var dictionaryOfTypeDosDictInDossierTemplate = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossierTemplate.getId(), null); assertThat(dictionaryOfTypeDosDictInDossierTemplate.getEntries()).hasSize(1); - assertThat(dictionaryOfTypeDosDictInDossierTemplate.getEntries().get(0)).isEqualTo("test redaction in dossier dictionary"); + assertThat(dictionaryOfTypeDosDictInDossierTemplate.getEntries() + .get(0)).isEqualTo("test redaction in dossier dictionary"); var dictionaryOfTypeDosTempDictInDossier1 = dictionaryClient.getDictionaryForType(typeDosTempDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(dictionaryOfTypeDosTempDictInDossier1.getEntries()).isEmpty(); @@ -543,24 +579,30 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var dictionaryOfTypeDosTempDictInDossierTemplate = dictionaryClient.getDictionaryForType(typeDosTempDict.getType(), dossierTemplate.getId(), null); assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries()).hasSize(1); - assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries().get(0)).isEqualTo("test redaction in dossier template"); + assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries() + .get(0)).isEqualTo("test redaction in dossier template"); var mergedDictForTypeDosDictInDossier1 = dictionaryClient.getMergedDictionaries(typeDosDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(mergedDictForTypeDosDictInDossier1.getEntries()).hasSize(2); - assertThat(mergedDictForTypeDosDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier"); - assertThat(mergedDictForTypeDosDictInDossier1.getEntries().get(1)).isEqualTo("test redaction in dossier dictionary"); + assertThat(mergedDictForTypeDosDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier"); + assertThat(mergedDictForTypeDosDictInDossier1.getEntries() + .get(1)).isEqualTo("test redaction in dossier dictionary"); var mergedDictForTypeDosTempDictInDossier1 = dictionaryClient.getMergedDictionaries(typeDosTempDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries()).hasSize(1); - assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier template"); + assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier template"); var mergedDictForTypeDosDictInDossier2 = dictionaryClient.getMergedDictionaries(typeDosDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(mergedDictForTypeDosDictInDossier2.getEntries()).hasSize(1); - assertThat(mergedDictForTypeDosDictInDossier2.getEntries().get(0)).isEqualTo("test redaction in dossier dictionary"); + assertThat(mergedDictForTypeDosDictInDossier2.getEntries() + .get(0)).isEqualTo("test redaction in dossier dictionary"); var mergedDictForTypeDosTempDictInDossier2 = dictionaryClient.getMergedDictionaries(typeDosTempDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries()).hasSize(1); - assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries().get(0)).isEqualTo("test redaction in dossier template"); + assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries() + .get(0)).isEqualTo("test redaction in dossier template"); } @@ -582,7 +624,8 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var userId = userProvider.getUserId(); var redactionDos = AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1).build())) + .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1) + .build())) .section("section test") .addToDictionary(true) .addToAllDossiers(false) @@ -596,7 +639,8 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { .build(); var redactionDosTempDict = AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1).build())) + .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1) + .build())) .section("section test") .addToDictionary(true) .addToAllDossiers(true) @@ -613,49 +657,51 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var loadedRedactionsFile1 = manualRedactionClient.getManualRedactions(file1.getDossierId(), file1.getFileId(), false); var entityLog1 = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id(addRedactions.get(0).getAnnotationId()) - .type(typeDosDict.getType()) - .value("test redaction in dossier yayy") - .dossierDictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build(), - EntityLogEntry.builder() - .id(addRedactions.get(1).getAnnotationId()) - .type(typeDosTempDict.getType()) - .value("test redaction in dossier template yayy") - .dictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id(addRedactions.get(0).getAnnotationId()) + .type(typeDosDict.getType()) + .value("test redaction in dossier yayy") + .dossierDictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build(), + EntityLogEntry.builder() + .id(addRedactions.get(1).getAnnotationId()) + .type(typeDosTempDict.getType()) + .value("test redaction in dossier template yayy") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier1.getId(), file1.getId(), FileType.ENTITY_LOG, entityLog1); - var redactionRequest1 = RedactionRequest.builder().dossierId(file1.getDossierId()).fileId(file1.getFileId()).dossierTemplateId(file1.getDossierTemplateId()).build(); + var redactionRequest1 = RedactionRequest.builder().dossierId(file1.getDossierId()).fileId(file1.getFileId()).dossierTemplateId(file1.getDossierTemplateId()) + .build(); when(entityLogService.getEntityLog(eq(file1.getDossierId()), eq(file1.getFileId()), any(), anyBoolean())).thenReturn(entityLog1); var entityLog2 = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id(addRedactions.get(1).getAnnotationId()) - .type(typeDosTempDict.getType()) - .value("test redaction in dossier template yayy") - .dictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id(addRedactions.get(1).getAnnotationId()) + .type(typeDosTempDict.getType()) + .value("test redaction in dossier template yayy") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier2.getId(), file2.getId(), FileType.ENTITY_LOG, entityLog2); - var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()).build(); + var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()) + .build(); when(entityLogService.getEntityLog(eq(file2.getDossierId()), eq(file2.getFileId()), any(), anyBoolean())).thenReturn(entityLog2); // resize redaction in dossier 1 @@ -672,26 +718,32 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { loadedRedactionsFile1 = manualRedactionClient.getManualRedactions(file1.getDossierId(), file1.getFileId(), false); assertThat(loadedRedactionsFile1.getResizeRedactions()).hasSize(1); - assertThat(loadedRedactionsFile1.getResizeRedactions().stream().toList().get(0).getValue()).isEqualTo("test redaction in dossier"); + assertThat(loadedRedactionsFile1.getResizeRedactions() + .stream() + .toList() + .get(0).getValue()).isEqualTo("test redaction in dossier"); var dictEntriesOldValue = dictionaryManagementService.getAllEntriesInDossierTemplate(dossierTemplate.getId(), "test redaction in dossier yayy", DictionaryEntryType.ENTRY); assertThat(dictEntriesOldValue.stream() - .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier yayy") && dictionaryEntry.isDeleted())).hasSize(1); + .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier yayy") && dictionaryEntry.isDeleted())).hasSize(1); assertThat(dictEntriesOldValue.stream() - .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier yayy") && !dictionaryEntry.isDeleted())).hasSize(1); + .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier yayy") && !dictionaryEntry.isDeleted())).hasSize(1); var dictEntriesNewValue = dictionaryManagementService.getAllEntriesInDossierTemplate(dossierTemplate.getId(), "test redaction in dossier", DictionaryEntryType.ENTRY); - assertThat(dictEntriesNewValue.stream().filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier"))).isNotEmpty(); + assertThat(dictEntriesNewValue.stream() + .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier"))).isNotEmpty(); var dictionaryOfTypeDosDictInDossier1 = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(dictionaryOfTypeDosDictInDossier1.getEntries()).hasSize(1); - assertThat(dictionaryOfTypeDosDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier yayy"); + assertThat(dictionaryOfTypeDosDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier yayy"); var dictionaryOfTypeDosDictInDossier2 = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(dictionaryOfTypeDosDictInDossier2.getEntries()).isEmpty(); var dictionaryOfTypeDosDictInDossierTemplate = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossierTemplate.getId(), null); assertThat(dictionaryOfTypeDosDictInDossierTemplate.getEntries()).hasSize(1); - assertThat(dictionaryOfTypeDosDictInDossierTemplate.getEntries().get(0)).isEqualTo("test redaction in dossier"); + assertThat(dictionaryOfTypeDosDictInDossierTemplate.getEntries() + .get(0)).isEqualTo("test redaction in dossier"); var dictionaryOfTypeDosTempDictInDossier1 = dictionaryClient.getDictionaryForType(typeDosTempDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(dictionaryOfTypeDosTempDictInDossier1.getEntries()).isEmpty(); @@ -701,24 +753,30 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var dictionaryOfTypeDosTempDictInDossierTemplate = dictionaryClient.getDictionaryForType(typeDosTempDict.getType(), dossierTemplate.getId(), null); assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries()).hasSize(1); - assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries().get(0)).isEqualTo("test redaction in dossier template yayy"); + assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries() + .get(0)).isEqualTo("test redaction in dossier template yayy"); var mergedDictForTypeDosDictInDossier1 = dictionaryClient.getMergedDictionaries(typeDosDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(mergedDictForTypeDosDictInDossier1.getEntries()).hasSize(2); - assertThat(mergedDictForTypeDosDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier"); - assertThat(mergedDictForTypeDosDictInDossier1.getEntries().get(1)).isEqualTo("test redaction in dossier yayy"); + assertThat(mergedDictForTypeDosDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier"); + assertThat(mergedDictForTypeDosDictInDossier1.getEntries() + .get(1)).isEqualTo("test redaction in dossier yayy"); var mergedDictForTypeDosTempDictInDossier1 = dictionaryClient.getMergedDictionaries(typeDosTempDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries()).hasSize(1); - assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier template yayy"); + assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier template yayy"); var mergedDictForTypeDosDictInDossier2 = dictionaryClient.getMergedDictionaries(typeDosDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(mergedDictForTypeDosDictInDossier2.getEntries()).hasSize(1); - assertThat(mergedDictForTypeDosDictInDossier2.getEntries().get(0)).isEqualTo("test redaction in dossier"); + assertThat(mergedDictForTypeDosDictInDossier2.getEntries() + .get(0)).isEqualTo("test redaction in dossier"); var mergedDictForTypeDosTempDictInDossier2 = dictionaryClient.getMergedDictionaries(typeDosTempDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries()).hasSize(1); - assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries().get(0)).isEqualTo("test redaction in dossier template yayy"); + assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries() + .get(0)).isEqualTo("test redaction in dossier template yayy"); } @@ -740,7 +798,8 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var userId = userProvider.getUserId(); var redactionDos = AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1).build())) + .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1) + .build())) .section("section test") .addToDictionary(true) .addToAllDossiers(false) @@ -754,7 +813,8 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { .build(); var redactionDosTempDict = AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1).build())) + .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1) + .build())) .section("section test") .addToDictionary(true) .addToAllDossiers(true) @@ -770,49 +830,51 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var addRedactions = manualRedactionClient.addRedactionBulk(dossier1.getId(), file1.getId(), Set.of(redactionDos, redactionDosTempDict)); var entityLog1 = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id(addRedactions.get(0).getAnnotationId()) - .type(typeDosDict.getType()) - .value("test redaction in dossier") - .dossierDictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build(), - EntityLogEntry.builder() - .id(addRedactions.get(1).getAnnotationId()) - .type(typeDosTempDict.getType()) - .value("test redaction in dossier template") - .dictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id(addRedactions.get(0).getAnnotationId()) + .type(typeDosDict.getType()) + .value("test redaction in dossier") + .dossierDictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build(), + EntityLogEntry.builder() + .id(addRedactions.get(1).getAnnotationId()) + .type(typeDosTempDict.getType()) + .value("test redaction in dossier template") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier1.getId(), file1.getId(), FileType.ENTITY_LOG, entityLog1); - var redactionRequest1 = RedactionRequest.builder().dossierId(file1.getDossierId()).fileId(file1.getFileId()).dossierTemplateId(file1.getDossierTemplateId()).build(); + var redactionRequest1 = RedactionRequest.builder().dossierId(file1.getDossierId()).fileId(file1.getFileId()).dossierTemplateId(file1.getDossierTemplateId()) + .build(); when(entityLogService.getEntityLog(file1.getDossierId(), file1.getFileId())).thenReturn(entityLog1); var entityLog2 = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id(addRedactions.get(1).getAnnotationId()) - .type(typeDosTempDict.getType()) - .value("test redaction in dossier template") - .dictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id(addRedactions.get(1).getAnnotationId()) + .type(typeDosTempDict.getType()) + .value("test redaction in dossier template") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier2.getId(), file2.getId(), FileType.ENTITY_LOG, entityLog2); - var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()).build(); + var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()) + .build(); when(entityLogService.getEntityLog(eq(file2.getDossierId()), eq(file2.getFileId()), any(), anyBoolean())).thenReturn(entityLog2); // resize redaction in dossier dict @@ -829,16 +891,21 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var loadedRedactionsFile2 = manualRedactionClient.getManualRedactions(file2.getDossierId(), file2.getFileId(), false); assertThat(loadedRedactionsFile2.getResizeRedactions()).hasSize(1); - assertThat(loadedRedactionsFile2.getResizeRedactions().stream().toList().get(0).getValue()).isEqualTo("test redaction in dossier template dictionary"); + assertThat(loadedRedactionsFile2.getResizeRedactions() + .stream() + .toList() + .get(0).getValue()).isEqualTo("test redaction in dossier template dictionary"); var dictEntries = dictionaryManagementService.getAllEntriesInDossierTemplate(dossierTemplate.getId(), - "test redaction in dossier template dictionary", - DictionaryEntryType.ENTRY); - assertThat(dictEntries.stream().filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier template dictionary"))).hasSize(1); + "test redaction in dossier template dictionary", + DictionaryEntryType.ENTRY); + assertThat(dictEntries.stream() + .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier template dictionary"))).hasSize(1); var dictionaryOfTypeDosDictInDossier1 = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(dictionaryOfTypeDosDictInDossier1.getEntries()).hasSize(1); - assertThat(dictionaryOfTypeDosDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier"); + assertThat(dictionaryOfTypeDosDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier"); var dictionaryOfTypeDosDictInDossier2 = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(dictionaryOfTypeDosDictInDossier2.getEntries()).isEmpty(); @@ -854,25 +921,32 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var dictionaryOfTypeDosTempDictInDossierTemplate = dictionaryClient.getDictionaryForType(typeDosTempDict.getType(), dossierTemplate.getId(), null); assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries()).hasSize(2); - assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries().get(0)).isEqualTo("test redaction in dossier template"); - assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries().get(1)).isEqualTo("test redaction in dossier template dictionary"); + assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries() + .get(0)).isEqualTo("test redaction in dossier template"); + assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries() + .get(1)).isEqualTo("test redaction in dossier template dictionary"); var mergedDictForTypeDosDictInDossier1 = dictionaryClient.getMergedDictionaries(typeDosDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(mergedDictForTypeDosDictInDossier1.getEntries()).hasSize(1); - assertThat(mergedDictForTypeDosDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier"); + assertThat(mergedDictForTypeDosDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier"); var mergedDictForTypeDosTempDictInDossier1 = dictionaryClient.getMergedDictionaries(typeDosTempDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries()).hasSize(2); - assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier template"); - assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries().get(1)).isEqualTo("test redaction in dossier template dictionary"); + assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier template"); + assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries() + .get(1)).isEqualTo("test redaction in dossier template dictionary"); var mergedDictForTypeDosDictInDossier2 = dictionaryClient.getMergedDictionaries(typeDosDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(mergedDictForTypeDosDictInDossier2.getEntries()).isEmpty(); var mergedDictForTypeDosTempDictInDossier2 = dictionaryClient.getMergedDictionaries(typeDosTempDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries()).hasSize(2); - assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries().get(0)).isEqualTo("test redaction in dossier template"); - assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries().get(1)).isEqualTo("test redaction in dossier template dictionary"); + assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries() + .get(0)).isEqualTo("test redaction in dossier template"); + assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries() + .get(1)).isEqualTo("test redaction in dossier template dictionary"); } @@ -894,7 +968,8 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var userId = userProvider.getUserId(); var redactionDos = AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1).build())) + .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1) + .build())) .section("section test") .addToDictionary(true) .addToAllDossiers(false) @@ -908,7 +983,8 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { .build(); var redactionDosTempDict = AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1).build())) + .positions(List.of(Rectangle.builder().page(1).topLeftY(1).topLeftX(1).height(1).width(1) + .build())) .section("section test") .addToDictionary(true) .addToAllDossiers(true) @@ -924,49 +1000,51 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var addRedactions = manualRedactionClient.addRedactionBulk(dossier1.getId(), file1.getId(), Set.of(redactionDos, redactionDosTempDict)); var entityLog1 = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id(addRedactions.get(0).getAnnotationId()) - .type(typeDosDict.getType()) - .value("test redaction in dossier yayy") - .dossierDictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build(), - EntityLogEntry.builder() - .id(addRedactions.get(1).getAnnotationId()) - .type(typeDosTempDict.getType()) - .value("test redaction in dossier template yayy") - .dictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id(addRedactions.get(0).getAnnotationId()) + .type(typeDosDict.getType()) + .value("test redaction in dossier yayy") + .dossierDictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build(), + EntityLogEntry.builder() + .id(addRedactions.get(1).getAnnotationId()) + .type(typeDosTempDict.getType()) + .value("test redaction in dossier template yayy") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier1.getId(), file1.getId(), FileType.ENTITY_LOG, entityLog1); - var redactionRequest1 = RedactionRequest.builder().dossierId(file1.getDossierId()).fileId(file1.getFileId()).dossierTemplateId(file1.getDossierTemplateId()).build(); + var redactionRequest1 = RedactionRequest.builder().dossierId(file1.getDossierId()).fileId(file1.getFileId()).dossierTemplateId(file1.getDossierTemplateId()) + .build(); when(entityLogService.getEntityLog(file1.getDossierId(), file1.getFileId())).thenReturn(entityLog1); var entityLog2 = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id(addRedactions.get(1).getAnnotationId()) - .type(typeDosTempDict.getType()) - .value("test redaction in dossier template yayy") - .dictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id(addRedactions.get(1).getAnnotationId()) + .type(typeDosTempDict.getType()) + .value("test redaction in dossier template yayy") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier2.getId(), file2.getId(), FileType.ENTITY_LOG, entityLog2); - var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()).build(); + var redactionRequest2 = RedactionRequest.builder().dossierId(file2.getDossierId()).fileId(file2.getFileId()).dossierTemplateId(file2.getDossierTemplateId()) + .build(); when(entityLogService.getEntityLog(eq(file2.getDossierId()), eq(file2.getFileId()), any(), anyBoolean())).thenReturn(entityLog2); // resize redaction in dossier dict @@ -983,23 +1061,28 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var loadedRedactionsFile2 = manualRedactionClient.getManualRedactions(file2.getDossierId(), file2.getFileId(), false); assertThat(loadedRedactionsFile2.getResizeRedactions()).hasSize(1); - assertThat(loadedRedactionsFile2.getResizeRedactions().stream().toList().get(0).getValue()).isEqualTo("test redaction in dossier template"); + assertThat(loadedRedactionsFile2.getResizeRedactions() + .stream() + .toList() + .get(0).getValue()).isEqualTo("test redaction in dossier template"); var dictEntriesOldValue = dictionaryManagementService.getAllEntriesInDossierTemplate(dossierTemplate.getId(), - "test redaction in dossier template yayy", - DictionaryEntryType.ENTRY); + "test redaction in dossier template yayy", + DictionaryEntryType.ENTRY); assertThat(dictEntriesOldValue.stream() - .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier template yayy") && dictionaryEntry.isDeleted())).hasSize(3); + .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier template yayy") && dictionaryEntry.isDeleted())).hasSize(3); assertThat(dictEntriesOldValue.stream() - .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier template yayy") && !dictionaryEntry.isDeleted())).isEmpty(); + .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier template yayy") && !dictionaryEntry.isDeleted())).isEmpty(); var dictEntriesNewValue = dictionaryManagementService.getAllEntriesInDossierTemplate(dossierTemplate.getId(), - "test redaction in dossier template", - DictionaryEntryType.ENTRY); - assertThat(dictEntriesNewValue.stream().filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier template"))).isNotEmpty(); + "test redaction in dossier template", + DictionaryEntryType.ENTRY); + assertThat(dictEntriesNewValue.stream() + .filter(dictionaryEntry -> dictionaryEntry.getValue().equals("test redaction in dossier template"))).isNotEmpty(); var dictionaryOfTypeDosDictInDossier1 = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(dictionaryOfTypeDosDictInDossier1.getEntries()).hasSize(1); - assertThat(dictionaryOfTypeDosDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier yayy"); + assertThat(dictionaryOfTypeDosDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier yayy"); var dictionaryOfTypeDosDictInDossier2 = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(dictionaryOfTypeDosDictInDossier2.getEntries()).isEmpty(); @@ -1015,22 +1098,26 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var dictionaryOfTypeDosTempDictInDossierTemplate = dictionaryClient.getDictionaryForType(typeDosTempDict.getType(), dossierTemplate.getId(), null); assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries()).hasSize(1); - assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries().get(0)).isEqualTo("test redaction in dossier template"); + assertThat(dictionaryOfTypeDosTempDictInDossierTemplate.getEntries() + .get(0)).isEqualTo("test redaction in dossier template"); var mergedDictForTypeDosDictInDossier1 = dictionaryClient.getMergedDictionaries(typeDosDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(mergedDictForTypeDosDictInDossier1.getEntries()).hasSize(1); - assertThat(mergedDictForTypeDosDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier yayy"); + assertThat(mergedDictForTypeDosDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier yayy"); var mergedDictForTypeDosTempDictInDossier1 = dictionaryClient.getMergedDictionaries(typeDosTempDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId()); assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries()).hasSize(1); - assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries().get(0)).isEqualTo("test redaction in dossier template"); + assertThat(mergedDictForTypeDosTempDictInDossier1.getEntries() + .get(0)).isEqualTo("test redaction in dossier template"); var mergedDictForTypeDosDictInDossier2 = dictionaryClient.getMergedDictionaries(typeDosDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(mergedDictForTypeDosDictInDossier2.getEntries()).isEmpty(); var mergedDictForTypeDosTempDictInDossier2 = dictionaryClient.getMergedDictionaries(typeDosTempDict.getType(), dossier2.getDossierTemplateId(), dossier2.getId()); assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries()).hasSize(1); - assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries().get(0)).isEqualTo("test redaction in dossier template"); + assertThat(mergedDictForTypeDosTempDictInDossier2.getEntries() + .get(0)).isEqualTo("test redaction in dossier template"); } @@ -1066,28 +1153,34 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var annotationId = "AnnotationId"; var entityLog = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id(annotationId) - .type(type.getType()) - .value(lukeSkywalker) - .dictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id(annotationId) + .type(type.getType()) + .value(lukeSkywalker) + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog); manualRedactionClient.recategorizeBulk(dossier.getId(), - file.getId(), - Set.of(RecategorizationRequestModel.builder().type(type2.getType()).annotationId(annotationId).addToDictionary(true).addToAllDossiers(true).build()), - false); + file.getId(), + Set.of(RecategorizationRequestModel.builder() + .type(type2.getType()) + .annotationId(annotationId) + .addToDictionary(true) + .addToAllDossiers(true) + .legalBasis("") + .build()), + false); dossierTemplateDictionary = dictionaryClient.getDictionaryForType(type.getType(), type.getDossierTemplateId(), null); assertThat(dossierTemplateDictionary.getEntries()).containsExactlyInAnyOrder(darthVader); @@ -1144,28 +1237,34 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var annotationId = "AnnotationId"; var entityLog = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id(annotationId) - .type(type.getType()) - .value(lukeSkywalker) - .dictionaryEntry(true) - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id(annotationId) + .type(type.getType()) + .value(lukeSkywalker) + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog); manualRedactionClient.recategorizeBulk(dossier.getId(), - file.getId(), - Set.of(RecategorizationRequestModel.builder().type(type2.getType()).annotationId(annotationId).addToDictionary(true).addToAllDossiers(false).build()), - false); + file.getId(), + Set.of(RecategorizationRequestModel.builder() + .type(type2.getType()) + .annotationId(annotationId) + .addToDictionary(true) + .addToAllDossiers(false) + .legalBasis("") + .build()), + false); dossierTemplateDictionary = dictionaryClient.getDictionaryForType(type.getType(), type.getDossierTemplateId(), null); assertThat(dossierTemplateDictionary.getEntries()).isEmpty(); @@ -1202,77 +1301,95 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { dictionaryClient.deleteEntries(type.getType(), type.getDossierTemplateId(), List.of("Luke Skywalker"), dossier.getId(), DictionaryEntryType.ENTRY); manualRedactionClient.addRedactionBulk(dossier.getId(), - file.getId(), - Set.of(AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().topLeftY(1).topLeftX(1).height(1).width(1).build())) - .section("section test") - .addToDictionary(false) - .addToAllDossiers(false) - .dictionaryEntryType(DictionaryEntryType.ENTRY) - .type(type.getType()) - .reason("1") - .value("Luke Skywalker") - .legalBasis("1") - .sourceId("SourceId") - .build())); + file.getId(), + Set.of(AddRedactionRequestModel.builder() + .positions(List.of(Rectangle.builder().topLeftY(1).topLeftX(1).height(1).width(1) + .build())) + .section("section test") + .addToDictionary(false) + .addToAllDossiers(false) + .dictionaryEntryType(DictionaryEntryType.ENTRY) + .type(type.getType()) + .reason("1") + .value("Luke Skywalker") + .legalBasis("1") + .sourceId("SourceId") + .build())); var allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getEntriesToAdd().size(), 1); - assertTrue(allManualRedactions.getEntriesToAdd().stream().anyMatch(entry -> entry.getValue().equals("Luke Skywalker"))); + assertTrue(allManualRedactions.getEntriesToAdd() + .stream() + .anyMatch(entry -> entry.getValue().equals("Luke Skywalker"))); var unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertEquals(unprocessedManualRedactions.getEntriesToAdd().size(), 1); - assertTrue(unprocessedManualRedactions.getEntriesToAdd().stream().anyMatch(entry -> entry.getValue().equals("Luke Skywalker"))); + assertTrue(unprocessedManualRedactions.getEntriesToAdd() + .stream() + .anyMatch(entry -> entry.getValue().equals("Luke Skywalker"))); fileProcessingClient.analysisSuccessful(dossier.getId(), - file.getId(), - AnalyzeResult.builder() - .manualRedactions(allManualRedactions) - .messageType(MessageType.ANALYSE) - .analysisVersion(0) - .fileId(file.getId()) - .dossierId(dossier.getId()) - .build()); + file.getId(), + AnalyzeResult.builder() + .manualRedactions(allManualRedactions) + .messageType(MessageType.ANALYSE) + .analysisVersion(0) + .fileId(file.getId()) + .dossierId(dossier.getId()) + .build()); manualRedactionClient.addRedactionBulk(dossier.getId(), - file.getId(), - Set.of(AddRedactionRequestModel.builder() - .positions(List.of(Rectangle.builder().topLeftY(2).topLeftX(2).height(2).width(2).build())) - .section("section test") - .addToDictionary(false) - .addToAllDossiers(false) - .dictionaryEntryType(DictionaryEntryType.ENTRY) - .type(type.getType()) - .reason("1") - .value("Skywalker Luke") - .legalBasis("1") - .sourceId("SourceId") - .build())); + file.getId(), + Set.of(AddRedactionRequestModel.builder() + .positions(List.of(Rectangle.builder().topLeftY(2).topLeftX(2).height(2).width(2) + .build())) + .section("section test") + .addToDictionary(false) + .addToAllDossiers(false) + .dictionaryEntryType(DictionaryEntryType.ENTRY) + .type(type.getType()) + .reason("1") + .value("Skywalker Luke") + .legalBasis("1") + .sourceId("SourceId") + .build())); allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getEntriesToAdd().size(), 2); - assertTrue(allManualRedactions.getEntriesToAdd().stream().anyMatch(entry -> entry.getValue().equals("Skywalker Luke"))); - assertTrue(allManualRedactions.getEntriesToAdd().stream().anyMatch(entry -> entry.getValue().equals("Luke Skywalker"))); + assertTrue(allManualRedactions.getEntriesToAdd() + .stream() + .anyMatch(entry -> entry.getValue().equals("Skywalker Luke"))); + assertTrue(allManualRedactions.getEntriesToAdd() + .stream() + .anyMatch(entry -> entry.getValue().equals("Luke Skywalker"))); unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertEquals(unprocessedManualRedactions.getEntriesToAdd().size(), 1); - assertTrue(unprocessedManualRedactions.getEntriesToAdd().stream().anyMatch(entry -> entry.getValue().equals("Skywalker Luke"))); - assertTrue(unprocessedManualRedactions.getEntriesToAdd().stream().noneMatch(entry -> entry.getValue().equals("Luke Skywalker"))); + assertTrue(unprocessedManualRedactions.getEntriesToAdd() + .stream() + .anyMatch(entry -> entry.getValue().equals("Skywalker Luke"))); + assertTrue(unprocessedManualRedactions.getEntriesToAdd() + .stream() + .noneMatch(entry -> entry.getValue().equals("Luke Skywalker"))); fileProcessingClient.analysisSuccessful(dossier.getId(), - file.getId(), - AnalyzeResult.builder() - .manualRedactions(allManualRedactions) - .messageType(MessageType.ANALYSE) - .analysisVersion(1) - .fileId(file.getId()) - .dossierId(dossier.getId()) - .build()); + file.getId(), + AnalyzeResult.builder() + .manualRedactions(allManualRedactions) + .messageType(MessageType.ANALYSE) + .analysisVersion(1) + .fileId(file.getId()) + .dossierId(dossier.getId()) + .build()); allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getEntriesToAdd().size(), 2); - assertTrue(allManualRedactions.getEntriesToAdd().stream().anyMatch(entry -> entry.getValue().equals("Skywalker Luke"))); - assertTrue(allManualRedactions.getEntriesToAdd().stream().anyMatch(entry -> entry.getValue().equals("Luke Skywalker"))); + assertTrue(allManualRedactions.getEntriesToAdd() + .stream() + .anyMatch(entry -> entry.getValue().equals("Skywalker Luke"))); + assertTrue(allManualRedactions.getEntriesToAdd() + .stream() + .anyMatch(entry -> entry.getValue().equals("Luke Skywalker"))); unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertTrue(unprocessedManualRedactions.getEntriesToAdd().isEmpty()); @@ -1293,82 +1410,102 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { dictionaryClient.addEntry(type.getType(), type.getDossierTemplateId(), List.of("Anakin"), false, dossier.getId(), DictionaryEntryType.ENTRY); var entityLog = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id("AnnotationId") - .type(type.getType()) - .value("Anakin") - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .dictionaryEntry(false) - .build(), - EntityLogEntry.builder() - .id("AnnotationId2") - .type(type.getType()) - .value("Anakin2") - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .dictionaryEntry(false) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id("AnnotationId") + .type(type.getType()) + .value("Anakin") + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .dictionaryEntry(false) + .build(), + EntityLogEntry.builder() + .id("AnnotationId2") + .type(type.getType()) + .value("Anakin2") + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .dictionaryEntry(false) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog); manualRedactionClient.removeRedactionBulk(dossier.getId(), - file.getId(), - Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true).build()), false); + file.getId(), + Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId").removeFromDictionary(true).removeFromAllDossiers(true) + .build()), + false); var allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getIdsToRemove().size(), 1); - assertTrue(allManualRedactions.getIdsToRemove().stream().anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId"))); + assertTrue(allManualRedactions.getIdsToRemove() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId"))); var unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertEquals(unprocessedManualRedactions.getIdsToRemove().size(), 1); - assertTrue(unprocessedManualRedactions.getIdsToRemove().stream().anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId"))); + assertTrue(unprocessedManualRedactions.getIdsToRemove() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId"))); fileProcessingClient.analysisSuccessful(dossier.getId(), - file.getId(), - AnalyzeResult.builder() - .manualRedactions(allManualRedactions) - .messageType(MessageType.ANALYSE) - .analysisVersion(0) - .fileId(file.getId()) - .dossierId(dossier.getId()) - .build()); + file.getId(), + AnalyzeResult.builder() + .manualRedactions(allManualRedactions) + .messageType(MessageType.ANALYSE) + .analysisVersion(0) + .fileId(file.getId()) + .dossierId(dossier.getId()) + .build()); manualRedactionClient.removeRedactionBulk(dossier.getId(), - file.getId(), - Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId2").removeFromDictionary(true).removeFromAllDossiers(true).build()), false); + file.getId(), + Set.of(RemoveRedactionRequestModel.builder().annotationId("AnnotationId2").removeFromDictionary(true).removeFromAllDossiers(true) + .build()), + false); allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getIdsToRemove().size(), 2); - assertTrue(allManualRedactions.getIdsToRemove().stream().anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId"))); - assertTrue(allManualRedactions.getIdsToRemove().stream().anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId2"))); + assertTrue(allManualRedactions.getIdsToRemove() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId"))); + assertTrue(allManualRedactions.getIdsToRemove() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId2"))); unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertEquals(unprocessedManualRedactions.getIdsToRemove().size(), 1); - assertTrue(unprocessedManualRedactions.getIdsToRemove().stream().noneMatch(entry -> entry.getAnnotationId().equals("AnnotationId"))); - assertTrue(unprocessedManualRedactions.getIdsToRemove().stream().anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId2"))); + assertTrue(unprocessedManualRedactions.getIdsToRemove() + .stream() + .noneMatch(entry -> entry.getAnnotationId().equals("AnnotationId"))); + assertTrue(unprocessedManualRedactions.getIdsToRemove() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId2"))); fileProcessingClient.analysisSuccessful(dossier.getId(), - file.getId(), - AnalyzeResult.builder() - .manualRedactions(allManualRedactions) - .messageType(MessageType.ANALYSE) - .analysisVersion(1) - .fileId(file.getId()) - .dossierId(dossier.getId()) - .build()); + file.getId(), + AnalyzeResult.builder() + .manualRedactions(allManualRedactions) + .messageType(MessageType.ANALYSE) + .analysisVersion(1) + .fileId(file.getId()) + .dossierId(dossier.getId()) + .build()); allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getIdsToRemove().size(), 2); - assertTrue(allManualRedactions.getIdsToRemove().stream().anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId"))); - assertTrue(allManualRedactions.getIdsToRemove().stream().anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId2"))); + assertTrue(allManualRedactions.getIdsToRemove() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId"))); + assertTrue(allManualRedactions.getIdsToRemove() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("AnnotationId2"))); unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertTrue(unprocessedManualRedactions.getIdsToRemove().isEmpty()); @@ -1383,55 +1520,73 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { var file = fileTesterAndProvider.testAndProvideFile(dossier); manualRedactionClient.forceRedactionBulk(dossier.getId(), - file.getId(), - Set.of(ForceRedactionRequestModel.builder().annotationId("forceRedactionAnnotation").comment("comment").legalBasis("1").build())); + file.getId(), + Set.of(ForceRedactionRequestModel.builder().annotationId("forceRedactionAnnotation").comment("comment").legalBasis("1") + .build())); var allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getForceRedactions().size(), 1); - assertTrue(allManualRedactions.getForceRedactions().stream().anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); + assertTrue(allManualRedactions.getForceRedactions() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); var unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertEquals(unprocessedManualRedactions.getForceRedactions().size(), 1); - assertTrue(unprocessedManualRedactions.getForceRedactions().stream().anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); + assertTrue(unprocessedManualRedactions.getForceRedactions() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); fileProcessingClient.analysisSuccessful(dossier.getId(), - file.getId(), - AnalyzeResult.builder() - .manualRedactions(allManualRedactions) - .messageType(MessageType.ANALYSE) - .analysisVersion(0) - .fileId(file.getId()) - .dossierId(dossier.getId()) - .build()); + file.getId(), + AnalyzeResult.builder() + .manualRedactions(allManualRedactions) + .messageType(MessageType.ANALYSE) + .analysisVersion(0) + .fileId(file.getId()) + .dossierId(dossier.getId()) + .build()); manualRedactionClient.forceRedactionBulk(dossier.getId(), - file.getId(), - Set.of(ForceRedactionRequestModel.builder().annotationId("forceRedactionAnnotation2").comment("comment").legalBasis("1").build())); + file.getId(), + Set.of(ForceRedactionRequestModel.builder().annotationId("forceRedactionAnnotation2").comment("comment").legalBasis("1") + .build())); allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getForceRedactions().size(), 2); - assertTrue(allManualRedactions.getForceRedactions().stream().anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); - assertTrue(allManualRedactions.getForceRedactions().stream().anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); + assertTrue(allManualRedactions.getForceRedactions() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); + assertTrue(allManualRedactions.getForceRedactions() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertEquals(unprocessedManualRedactions.getForceRedactions().size(), 1); - assertTrue(unprocessedManualRedactions.getForceRedactions().stream().noneMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); - assertTrue(unprocessedManualRedactions.getForceRedactions().stream().anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation2"))); + assertTrue(unprocessedManualRedactions.getForceRedactions() + .stream() + .noneMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); + assertTrue(unprocessedManualRedactions.getForceRedactions() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation2"))); fileProcessingClient.analysisSuccessful(dossier.getId(), - file.getId(), - AnalyzeResult.builder() - .manualRedactions(allManualRedactions) - .messageType(MessageType.ANALYSE) - .analysisVersion(1) - .fileId(file.getId()) - .dossierId(dossier.getId()) - .build()); + file.getId(), + AnalyzeResult.builder() + .manualRedactions(allManualRedactions) + .messageType(MessageType.ANALYSE) + .analysisVersion(1) + .fileId(file.getId()) + .dossierId(dossier.getId()) + .build()); allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getForceRedactions().size(), 2); - assertTrue(allManualRedactions.getForceRedactions().stream().anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); - assertTrue(allManualRedactions.getForceRedactions().stream().anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation2"))); + assertTrue(allManualRedactions.getForceRedactions() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation"))); + assertTrue(allManualRedactions.getForceRedactions() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("forceRedactionAnnotation2"))); unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertTrue(unprocessedManualRedactions.getForceRedactions().isEmpty()); @@ -1450,80 +1605,102 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { dictionaryClient.addEntry(type.getType(), type.getDossierTemplateId(), List.of("Darth Vader"), false, dossier.getId(), DictionaryEntryType.ENTRY); var entityLog = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id("dv") - .type(type.getType()) - .value("Darth Vader") - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .dictionaryEntry(false) - .build(), - EntityLogEntry.builder() - .id("dv2") - .type(type.getType()) - .value("Vader Darth") - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .dictionaryEntry(false) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id("dv") + .type(type.getType()) + .value("Darth Vader") + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .dictionaryEntry(false) + .build(), + EntityLogEntry.builder() + .id("dv2") + .type(type.getType()) + .value("Vader Darth") + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .dictionaryEntry(false) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog); - manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(RecategorizationRequestModel.builder().annotationId("dv").build()), - false); + manualRedactionClient.recategorizeBulk(dossier.getId(), + file.getId(), + Set.of(RecategorizationRequestModel.builder().annotationId("dv").legalBasis("") + .build()), + false); var allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getRecategorizations().size(), 1); - assertTrue(allManualRedactions.getRecategorizations().stream().anyMatch(entry -> entry.getAnnotationId().equals("dv"))); + assertTrue(allManualRedactions.getRecategorizations() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("dv"))); var unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertEquals(unprocessedManualRedactions.getRecategorizations().size(), 1); - assertTrue(unprocessedManualRedactions.getRecategorizations().stream().anyMatch(entry -> entry.getAnnotationId().equals("dv"))); + assertTrue(unprocessedManualRedactions.getRecategorizations() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("dv"))); fileProcessingClient.analysisSuccessful(dossier.getId(), - file.getId(), - AnalyzeResult.builder() - .manualRedactions(allManualRedactions) - .messageType(MessageType.ANALYSE) - .analysisVersion(0) - .fileId(file.getId()) - .dossierId(dossier.getId()) - .build()); + file.getId(), + AnalyzeResult.builder() + .manualRedactions(allManualRedactions) + .messageType(MessageType.ANALYSE) + .analysisVersion(0) + .fileId(file.getId()) + .dossierId(dossier.getId()) + .build()); - manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(RecategorizationRequestModel.builder().annotationId("dv2").build()), - false); + manualRedactionClient.recategorizeBulk(dossier.getId(), + file.getId(), + Set.of(RecategorizationRequestModel.builder().annotationId("dv2").legalBasis("") + .build()), + false); allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getRecategorizations().size(), 2); - assertTrue(allManualRedactions.getRecategorizations().stream().anyMatch(entry -> entry.getAnnotationId().equals("dv"))); - assertTrue(allManualRedactions.getRecategorizations().stream().anyMatch(entry -> entry.getAnnotationId().equals("dv2"))); + assertTrue(allManualRedactions.getRecategorizations() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("dv"))); + assertTrue(allManualRedactions.getRecategorizations() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("dv2"))); unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertEquals(unprocessedManualRedactions.getRecategorizations().size(), 1); - assertTrue(unprocessedManualRedactions.getRecategorizations().stream().noneMatch(entry -> entry.getAnnotationId().equals("dv"))); - assertTrue(unprocessedManualRedactions.getRecategorizations().stream().anyMatch(entry -> entry.getAnnotationId().equals("dv2"))); + assertTrue(unprocessedManualRedactions.getRecategorizations() + .stream() + .noneMatch(entry -> entry.getAnnotationId().equals("dv"))); + assertTrue(unprocessedManualRedactions.getRecategorizations() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("dv2"))); fileProcessingClient.analysisSuccessful(dossier.getId(), - file.getId(), - AnalyzeResult.builder() - .manualRedactions(allManualRedactions) - .messageType(MessageType.ANALYSE) - .analysisVersion(1) - .fileId(file.getId()) - .dossierId(dossier.getId()) - .build()); + file.getId(), + AnalyzeResult.builder() + .manualRedactions(allManualRedactions) + .messageType(MessageType.ANALYSE) + .analysisVersion(1) + .fileId(file.getId()) + .dossierId(dossier.getId()) + .build()); allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getRecategorizations().size(), 2); - assertTrue(allManualRedactions.getRecategorizations().stream().anyMatch(entry -> entry.getAnnotationId().equals("dv"))); - assertTrue(allManualRedactions.getRecategorizations().stream().anyMatch(entry -> entry.getAnnotationId().equals("dv2"))); + assertTrue(allManualRedactions.getRecategorizations() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("dv"))); + assertTrue(allManualRedactions.getRecategorizations() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("dv2"))); unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertTrue(unprocessedManualRedactions.getRecategorizations().isEmpty()); @@ -1542,85 +1719,174 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest { dictionaryClient.addEntry(type.getType(), type.getDossierTemplateId(), List.of("Luke Skywalker"), false, dossier.getId(), DictionaryEntryType.ENTRY); var entityLog = new EntityLog(1, - 1, - List.of(EntityLogEntry.builder() - .id("AnnotationId") - .type(type.getType()) - .value("Luke Skywalker") - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .dictionaryEntry(false) - .build(), - EntityLogEntry.builder() - .id("AnnotationId2") - .type(type.getType()) - .value("Skywalker Luke") - .entryType(EntryType.ENTITY) - .state(EntryState.APPLIED) - .dictionaryEntry(false) - .build()), - null, - 0, - 0, - 0, - 0); + 1, + List.of(EntityLogEntry.builder() + .id("AnnotationId") + .type(type.getType()) + .value("Luke Skywalker") + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .dictionaryEntry(false) + .build(), + EntityLogEntry.builder() + .id("AnnotationId2") + .type(type.getType()) + .value("Skywalker Luke") + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .dictionaryEntry(false) + .build()), + null, + 0, + 0, + 0, + 0); fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog); manualRedactionClient.legalBasisChangeBulk(dossier.getId(), - file.getId(), - Set.of(LegalBasisChangeRequestModel.builder().legalBasis("legalBasis").annotationId("AnnotationId").build())); + file.getId(), + Set.of(LegalBasisChangeRequestModel.builder().legalBasis("legalBasis").annotationId("AnnotationId") + .build())); var allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getLegalBasisChanges().size(), 1); - assertTrue(allManualRedactions.getLegalBasisChanges().stream().anyMatch(entry -> entry.getLegalBasis().equals("legalBasis"))); + assertTrue(allManualRedactions.getLegalBasisChanges() + .stream() + .anyMatch(entry -> entry.getLegalBasis().equals("legalBasis"))); var unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertEquals(unprocessedManualRedactions.getLegalBasisChanges().size(), 1); - assertTrue(unprocessedManualRedactions.getLegalBasisChanges().stream().anyMatch(entry -> entry.getLegalBasis().equals("legalBasis"))); + assertTrue(unprocessedManualRedactions.getLegalBasisChanges() + .stream() + .anyMatch(entry -> entry.getLegalBasis().equals("legalBasis"))); fileProcessingClient.analysisSuccessful(dossier.getId(), - file.getId(), - AnalyzeResult.builder() - .manualRedactions(allManualRedactions) - .messageType(MessageType.ANALYSE) - .analysisVersion(0) - .fileId(file.getId()) - .dossierId(dossier.getId()) - .build()); + file.getId(), + AnalyzeResult.builder() + .manualRedactions(allManualRedactions) + .messageType(MessageType.ANALYSE) + .analysisVersion(0) + .fileId(file.getId()) + .dossierId(dossier.getId()) + .build()); manualRedactionClient.legalBasisChangeBulk(dossier.getId(), - file.getId(), - Set.of(LegalBasisChangeRequestModel.builder().legalBasis("legalBasis2").annotationId("AnnotationId2").build())); + file.getId(), + Set.of(LegalBasisChangeRequestModel.builder().legalBasis("legalBasis2").annotationId("AnnotationId2") + .build())); allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getLegalBasisChanges().size(), 2); - assertTrue(allManualRedactions.getLegalBasisChanges().stream().anyMatch(entry -> entry.getLegalBasis().equals("legalBasis"))); - assertTrue(allManualRedactions.getLegalBasisChanges().stream().anyMatch(entry -> entry.getLegalBasis().equals("legalBasis2"))); + assertTrue(allManualRedactions.getLegalBasisChanges() + .stream() + .anyMatch(entry -> entry.getLegalBasis().equals("legalBasis"))); + assertTrue(allManualRedactions.getLegalBasisChanges() + .stream() + .anyMatch(entry -> entry.getLegalBasis().equals("legalBasis2"))); unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertEquals(unprocessedManualRedactions.getLegalBasisChanges().size(), 1); - assertTrue(unprocessedManualRedactions.getLegalBasisChanges().stream().noneMatch(entry -> entry.getLegalBasis().equals("legalBasis"))); - assertTrue(unprocessedManualRedactions.getLegalBasisChanges().stream().anyMatch(entry -> entry.getLegalBasis().equals("legalBasis2"))); + assertTrue(unprocessedManualRedactions.getLegalBasisChanges() + .stream() + .noneMatch(entry -> entry.getLegalBasis().equals("legalBasis"))); + assertTrue(unprocessedManualRedactions.getLegalBasisChanges() + .stream() + .anyMatch(entry -> entry.getLegalBasis().equals("legalBasis2"))); fileProcessingClient.analysisSuccessful(dossier.getId(), - file.getId(), - AnalyzeResult.builder() - .manualRedactions(allManualRedactions) - .messageType(MessageType.ANALYSE) - .analysisVersion(1) - .fileId(file.getId()) - .dossierId(dossier.getId()) - .build()); + file.getId(), + AnalyzeResult.builder() + .manualRedactions(allManualRedactions) + .messageType(MessageType.ANALYSE) + .analysisVersion(1) + .fileId(file.getId()) + .dossierId(dossier.getId()) + .build()); allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); assertEquals(allManualRedactions.getLegalBasisChanges().size(), 2); - assertTrue(allManualRedactions.getLegalBasisChanges().stream().anyMatch(entry -> entry.getLegalBasis().equals("legalBasis"))); - assertTrue(allManualRedactions.getLegalBasisChanges().stream().anyMatch(entry -> entry.getLegalBasis().equals("legalBasis2"))); + assertTrue(allManualRedactions.getLegalBasisChanges() + .stream() + .anyMatch(entry -> entry.getLegalBasis().equals("legalBasis"))); + assertTrue(allManualRedactions.getLegalBasisChanges() + .stream() + .anyMatch(entry -> entry.getLegalBasis().equals("legalBasis2"))); unprocessedManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), true); assertTrue(unprocessedManualRedactions.getResizeRedactions().isEmpty()); } + + @Test + public void testLegalBasisInManualRecategorization() { + + var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate(); + var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate); + var file = fileTesterAndProvider.testAndProvideFile(dossier); + + var type = typeProvider.testAndProvideType(dossierTemplate, null, "type", false); + + var entityLog = new EntityLog(1, + 1, + List.of(EntityLogEntry.builder() + .id("annotationId") + .type(type.getType()) + .value("lukeSkywalker") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build(), + EntityLogEntry.builder() + .id("annotationId2") + .type(type.getType()) + .value("Johannesbrotkernmehl") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build(), + EntityLogEntry.builder() + .id("annotationId3") + .type(type.getType()) + .value("Baustelle") + .dictionaryEntry(true) + .entryType(EntryType.ENTITY) + .state(EntryState.APPLIED) + .build()), + null, + 0, + 0, + 0, + 0); + fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); + fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog); + when(entityLogService.getEntityLog(Mockito.any(), Mockito.any(), any(), anyBoolean())).thenReturn(entityLog); + + var recatModel = RecategorizationRequestModel.builder().type(type.getType()).annotationId("annotationId").addToDictionary(true).addToAllDossiers(true).legalBasis("") + .build(); + var recatModelLongLegalBasis = RecategorizationRequestModel.builder() + .type(type.getType()) + .annotationId("annotationId2") + .addToDictionary(true) + .addToAllDossiers(true) + .legalBasis( + RandomStringUtils.randomAlphanumeric(4001)) + .build(); + + manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(recatModel), false); + + var allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false); + assertEquals(1, allManualRedactions.getRecategorizations().size()); + assertTrue(allManualRedactions.getRecategorizations() + .stream() + .anyMatch(entry -> entry.getAnnotationId().equals("annotationId"))); + + assertThatThrownBy(() -> manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(recatModelLongLegalBasis), false) + .get(0)).isInstanceOf(FeignException.class).hasMessageContaining("The legal basis is too long"); + assertThatThrownBy(() -> RecategorizationRequestModel.builder().type(type.getType()).annotationId("annotationId3").addToDictionary(true).addToAllDossiers(true) + .build()).isInstanceOf(NullPointerException.class); + + } + } diff --git a/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/annotations/RecategorizationRequest.java b/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/annotations/RecategorizationRequest.java index 5ff1a232a..58519a9c1 100644 --- a/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/annotations/RecategorizationRequest.java +++ b/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/annotations/RecategorizationRequest.java @@ -28,6 +28,7 @@ public class RecategorizationRequest implements ManualRequestWithAddToDictionary boolean addToDictionary; boolean addToAllDossiers; private DictionaryEntryType dictionaryEntryType; + String legalBasis; @Override diff --git a/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/annotations/entitymapped/ManualRecategorization.java b/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/annotations/entitymapped/ManualRecategorization.java index 73ec2f57a..40337d93d 100644 --- a/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/annotations/entitymapped/ManualRecategorization.java +++ b/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/annotations/entitymapped/ManualRecategorization.java @@ -14,5 +14,6 @@ import lombok.experimental.SuperBuilder; public class ManualRecategorization extends BaseAnnotation { private String type; + private String legalBasis; } diff --git a/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/manual/RecategorizationRequestModel.java b/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/manual/RecategorizationRequestModel.java index 33cd1a467..f6803a1a9 100644 --- a/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/manual/RecategorizationRequestModel.java +++ b/persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/manual/RecategorizationRequestModel.java @@ -5,6 +5,7 @@ import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; +import lombok.NonNull; import lombok.experimental.FieldDefaults; @Data @@ -19,5 +20,7 @@ public class RecategorizationRequestModel { String comment; boolean addToDictionary; boolean addToAllDossiers; + @NonNull + String legalBasis; }