Marmelator/persistence-service
1
0
Fork 0
Code Issues Pull Requests 17 Actions Packages Projects Releases 1.1k Wiki Activity

DM-285: flush add redaction removal #193

Merged
kilian.schuettler1 merged 3 commits from DM-285 into master 2023-10-23 14:17:13 +02:00
Conversation 8 Commits 3 Files Changed 12 +281 -80
12 changed files with 281 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/CommentService.java
View File

@ -4,6 +4,7 @@ import java.time.OffsetDateTime;
import java.time.temporal.ChronoUnit;
import java.util.List;
import java.util.Map;
import java.util.function.BiConsumer;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
@ -30,8 +31,6 @@ public class CommentService {
CommentPersistenceService commentPersistenceService;
FileStatusPersistenceService fileStatusPersistenceService;
FileStatusService fileStatusService;
FileManagementStorageService fileManagementStorageService;
private final int COMMENT_MAX_LENGTH = 4000;
@ -66,7 +65,13 @@ public class CommentService {
return new Comments(commentPersistenceService.findCommentsByFileID(fileId, false)
.entrySet()
.stream()
.collect(Collectors.toMap(Map.Entry::getKey, entry -> MagicConverter.convert(entry.getValue(), Comment.class))));
.collect(Collectors.toMap(Map.Entry::getKey, entry -> MagicConverter.convert(entry.getValue(), Comment.class, getDeltaMapper()))));
}
private static BiConsumer<CommentEntity, Comment> getDeltaMapper() {
return (c1, c2) -> c2.setUserId(c1.getUser());
}
@ -96,6 +101,7 @@ public class CommentService {
return createdComment;
}
private void checkComment(String text) {
if (!StringUtils.isEmpty(text) && text.length() > COMMENT_MAX_LENGTH) {
@ -103,6 +109,7 @@ public class CommentService {
}
}
public Long addCommentAndGetId(String fileId, String annotationId, String comment, String user) {
if (comment == null) {
@ -128,6 +135,12 @@ public class CommentService {
.build());
}
public void hardDelete(String fileId, String annotationId) {
commentPersistenceService.hardDelete(fileId, annotationId);
}
//
// private void reprocess(String dossierId, String fileId) {
//

6
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/DossierTemplateImportService.java
View File

@ -509,21 +509,21 @@ public class DossierTemplateImportService {
}
private void setRulesWhenCompiled(ImportTemplateResult request, String dossierTemplateEntity) {
private void setRulesWhenCompiled(ImportTemplateResult request, String dossierTemplateId) {
DroolsSyntaxValidation droolsSyntaxValidation = rulesValidationService.validateRules(RuleFileType.ENTITY, request.getRuleSet());
if (!droolsSyntaxValidation.isCompiled()) {
droolsSyntaxValidation.getDroolsSyntaxErrorMessages().forEach(errorMessage -> log.error(errorMessage.getMessage()));
throw new BadRequestException("The entity rules do not compile!");
}
rulesPersistenceService.setRules(request.getRuleSet(), dossierTemplateEntity, RuleFileType.ENTITY);
rulesPersistenceService.setRules(request.getRuleSet(), dossierTemplateId, RuleFileType.ENTITY);
if (request.getComponentRuleSet() != null) {
DroolsSyntaxValidation componentDroolsSyntaxValidation = rulesValidationService.validateRules(RuleFileType.COMPONENT, request.getComponentRuleSet());
if (!componentDroolsSyntaxValidation.isCompiled()) {
componentDroolsSyntaxValidation.getDroolsSyntaxErrorMessages().forEach(errorMessage -> log.error(errorMessage.getMessage()));
throw new BadRequestException("The component rules do not compile!");
}
rulesPersistenceService.setRules(request.getComponentRuleSet(), dossierTemplateEntity, RuleFileType.COMPONENT);
rulesPersistenceService.setRules(request.getComponentRuleSet(), dossierTemplateId, RuleFileType.COMPONENT);
}
}

32
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionProviderService.java
View File

@ -2,21 +2,19 @@ package com.iqser.red.service.persistence.management.v1.processor.service.manual
import static com.knecon.fforesight.databasetenantcommons.providers.utils.MagicConverter.convert;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.dao.EmptyResultDataAccessException;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.CommentEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.ManualRedactionEntryEntity;
import com.iqser.red.service.persistence.management.v1.processor.service.CommentService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.AddRedactionPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.CommentPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.ForceRedactionPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.LegalBasisChangePersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.RecategorizationPersistenceService;
@ -25,7 +23,7 @@ import com.iqser.red.service.persistence.management.v1.processor.service.persist
import com.iqser.red.service.persistence.management.v1.processor.utils.ManualImageRecategorizationMapper;
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.Comment;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.Comments;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.ManualRedactions;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.IdRemoval;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualForceRedaction;
@ -45,16 +43,19 @@ public class ManualRedactionProviderService {
private final AddRedactionPersistenceService addRedactionPersistenceService;
private final RemoveRedactionPersistenceService removeRedactionPersistenceService;
private final ForceRedactionPersistenceService forceRedactionPersistenceService;
private final CommentPersistenceService commentPersistenceService;
private final CommentService commentService;
private final RecategorizationPersistenceService recategorizationPersistenceService;
private final LegalBasisChangePersistenceService legalBasisChangePersistenceService;
private final ResizeRedactionPersistenceService resizeRedactionPersistenceService;
@Transactional
public ManualRedactions getManualRedactions(String fileId) {
return getManualRedactions(fileId, false);
}
@Transactional
public ManualRedactions getManualRedactions(String fileId, boolean unprocessed) {
@ -89,19 +90,10 @@ public class ManualRedactionProviderService {
new ManualResizeRedactionMapper()));
}
Map<String, List<CommentEntity>> commentEntities = commentPersistenceService.findCommentsByFileID(fileId, false);
// deprecated anyway, remove as soon as UI uses EntityLog
Comments comments = commentService.getComments(fileId);
Map<String, List<Comment>> comments = new HashMap<>();
commentEntities.forEach((s, c) -> comments.put(s, convert(c, Comment.class)));
return new ManualRedactions(removals, entriesToAdd, forceRedactions, recategorizations, legalBasisChanges, resizeRedactions, comments);
}
@Transactional
public ManualRedactionEntry getAddRedaction(String fileId, String annotationId) {
return convert(addRedactionPersistenceService.findAddRedaction(fileId, annotationId), ManualRedactionEntry.class, new ManualRedactionMapper());
return new ManualRedactions(removals, entriesToAdd, forceRedactions, recategorizations, legalBasisChanges, resizeRedactions, comments.getComments());
}
@ -111,7 +103,7 @@ public class ManualRedactionProviderService {
}
@Transactional(noRollbackFor = {EmptyResultDataAccessException.class})
@Transactional(noRollbackFor = {EmptyResultDataAccessException.class}, propagation = Propagation.REQUIRES_NEW)
public void hardDeleteManualRedactions(String fileId, String annotationId) {
addRedactionPersistenceService.hardDelete(fileId, annotationId);
@ -120,7 +112,7 @@ public class ManualRedactionProviderService {
recategorizationPersistenceService.hardDelete(fileId, annotationId);
legalBasisChangePersistenceService.hardDelete(fileId, annotationId);
resizeRedactionPersistenceService.hardDelete(fileId, annotationId);
commentPersistenceService.hardDelete(fileId, annotationId);
commentService.hardDelete(fileId, annotationId);
}
}

4
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/manualredactions/ManualRedactionService.java
View File

@ -113,6 +113,8 @@ public class ManualRedactionService {
manualRedactionDictionaryUpdateHandler.validateDictionariesForDelete(removeRedactionRequest,
removeRedactionRequest.getTypeToRemove(),
removeRedactionRequest.getDossierTemplateId());
log.info("add removeRedaction for file {} and annotation {}", fileId, removeRedactionRequest.getAnnotationId());
removeRedactionPersistenceService.insert(fileId, removeRedactionRequest);
if (manualAddRedactionsContains(manualRedactions, removeRedactionRequest.getAnnotationId())) {
@ -121,8 +123,6 @@ public class ManualRedactionService {
continue;
}
log.info("add removeRedaction for file {} and annotation {}", fileId, removeRedactionRequest.getAnnotationId());
Long commentId = commentService.addCommentAndGetId(fileId,
removeRedactionRequest.getAnnotationId(),
removeRedactionRequest.getComment(),

7
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/annotations/AddRedactionPersistenceService.java
View File

@ -58,7 +58,6 @@ public class AddRedactionPersistenceService {
}
public ManualRedactionEntryEntity findAddRedaction(String fileId, String annotationId) {
return manualRedactionRepository.findAddRedaction(new AnnotationEntityId(annotationId, fileId))
@ -66,9 +65,6 @@ public class AddRedactionPersistenceService {
}
public List<ManualRedactionEntryEntity> findAddRedactions(String fileId, boolean includeDeletions) {
return manualRedactionRepository.findByFileIdIncludeDeletions(fileId, includeDeletions);
@ -80,6 +76,7 @@ public class AddRedactionPersistenceService {
return manualRedactionRepository.findAll();
}
public List<ManualRedactionEntryEntity> findUnprocessedRedactions(String fileId) {
return manualRedactionRepository.findByFileIdAndUnprocessed(fileId);
@ -113,6 +110,7 @@ public class AddRedactionPersistenceService {
manualRedactionRepository.updateStatus(new AnnotationEntityId(annotationId, fileId), annotationStatus, processedDate);
}
@Transactional
public void updateStatus(String fileId,
String annotationId,
@ -131,7 +129,6 @@ public class AddRedactionPersistenceService {
}
@Transactional
public void approveStatusForRequestedRedactionsWithSameValue(Set<String> fileIds, String value) {

2
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/annotations/ForceRedactionPersistenceService.java
View File

@ -77,11 +77,13 @@ public class ForceRedactionPersistenceService {
return new HashSet<>(forceRedactionRepository.findByFileIdIncludeDeletions(fileId, includeDeletions));
}
public Set<ManualForceRedactionEntity> findUnprocessedForceRedactions(String fileId) {
return new HashSet<>(forceRedactionRepository.findByFileIdAndUnprocessed(fileId));
}
@Transactional
public void markAsProcessed(String annotationId, String fileId) {

3
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/annotations/LegalBasisChangePersistenceService.java
View File

@ -4,7 +4,6 @@ import java.time.OffsetDateTime;
import java.time.temporal.ChronoUnit;
import java.util.HashSet;
import java.util.Set;
import java.util.stream.Collectors;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
@ -43,6 +42,7 @@ public class LegalBasisChangePersistenceService {
}
private void checkSection(String section) {
if (!StringUtils.isEmpty(section) && section.length() > SECTION_MAX_LENGTH) {
@ -91,6 +91,7 @@ public class LegalBasisChangePersistenceService {
return new HashSet<>(legalBasisChangeRepository.findByFileIdIncludeDeletions(fileId, includeDeletions));
}
public Set<ManualLegalBasisChangeEntity> findUnprocessedLegalBasisChanges(String fileId) {
return new HashSet<>(legalBasisChangeRepository.findUnprocessedByFileId(fileId));

1
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/annotations/RecategorizationPersistenceService.java
View File

@ -99,6 +99,7 @@ public class RecategorizationPersistenceService {
return recategorizationRepository.findByFileIdIncludeDeletions(fileId, includeDeletions);
}
public List<ManualRecategorizationEntity> findUnprocessedRecategorizations(String fileId) {
return recategorizationRepository.findUnprocessedByFileId(fileId);

2
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/annotations/RemoveRedactionPersistenceService.java
View File

@ -5,7 +5,6 @@ import java.time.temporal.ChronoUnit;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;
@ -54,6 +53,7 @@ public class RemoveRedactionPersistenceService {
return new HashSet<>(removeRedactionRepository.findByFileIdIncludeDeletions(fileId, includeDeletions));
}
public Set<IdRemovalEntity> findUnprocessedRemoveRedactions(String fileId) {
return new HashSet<>(removeRedactionRepository.findByFileIdAndUnprocessed(fileId));

1
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/annotations/ResizeRedactionPersistenceService.java
View File

@ -93,6 +93,7 @@ public class ResizeRedactionPersistenceService {
return resizeRedactionRepository.findByFileIdIncludeDeletions(fileId, includeDeletions);
}
public List<ManualResizeRedactionEntity> findUnprocessedResizeRedactions(String fileId) {
return resizeRedactionRepository.findUnprocessedByFileId(fileId);

281
persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/tests/ManualRedactionTest.java
View File

@ -49,6 +49,7 @@ 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;
@ -117,7 +118,14 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
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()),
List.of(EntityLogEntry.builder()
.id("AnnotationId")
.type(type.getType())
.value("Luke Skywalker")
.entryType(EntryType.ENTITY)
.state(EntryState.APPLIED)
.dictionaryEntry(true)
.build()),
null,
0,
0,
@ -266,7 +274,14 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
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()),
List.of(EntityLogEntry.builder()
.id("AnnotationId")
.type("test")
.value("Luke Skywalker")
.entryType(EntryType.ENTITY)
.state(EntryState.APPLIED)
.dictionaryEntry(true)
.build()),
null,
0,
0,
@ -314,7 +329,14 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
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()),
List.of(EntityLogEntry.builder()
.id("AnnotationId")
.type("test")
.value("Luke Skywalker")
.entryType(EntryType.ENTITY)
.state(EntryState.APPLIED)
.dictionaryEntry(true)
.build()),
null,
0,
0,
@ -355,7 +377,14 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
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()),
List.of(EntityLogEntry.builder()
.id("AnnotationId")
.type("test")
.value("Luke Skywalker")
.entryType(EntryType.ENTITY)
.state(EntryState.APPLIED)
.dictionaryEntry(true)
.build()),
null,
0,
0,
@ -488,9 +517,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
assertThat(loadedRedactionsFile1.getResizeRedactions()).hasSize(1);
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);
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();
var dictionaryOfTypeDosDictInDossier1 = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId());
@ -643,16 +670,12 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
assertThat(loadedRedactionsFile1.getResizeRedactions()).hasSize(1);
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);
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);
assertThat(dictEntriesOldValue.stream()
.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);
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();
var dictionaryOfTypeDosDictInDossier1 = dictionaryClient.getDictionaryForType(typeDosDict.getType(), dossier1.getDossierTemplateId(), dossier1.getId());
@ -1040,7 +1063,14 @@ 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()),
List.of(EntityLogEntry.builder()
.id(annotationId)
.type(type.getType())
.value(lukeSkywalker)
.dictionaryEntry(true)
.entryType(EntryType.ENTITY)
.state(EntryState.APPLIED)
.build()),
null,
0,
0,
@ -1110,7 +1140,14 @@ 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()),
List.of(EntityLogEntry.builder()
.id(annotationId)
.type(type.getType())
.value(lukeSkywalker)
.dictionaryEntry(true)
.entryType(EntryType.ENTITY)
.state(EntryState.APPLIED)
.build()),
null,
0,
0,
@ -1147,6 +1184,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
assertThat(dossierDictionary2.getEntries()).isEmpty();
}
@Test
public void testUnprocessedManualRedactionsAddRedaction() {
@ -1180,9 +1218,15 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
assertEquals(unprocessedManualRedactions.getEntriesToAdd().size(), 1);
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());
fileProcessingClient.analysisSuccessful(dossier.getId(),
file.getId(),
AnalyzeResult.builder()
.manualRedactions(allManualRedactions)
.messageType(MessageType.ANALYSE)
.analysisVersion(0)
.fileId(file.getId())
.dossierId(dossier.getId())
.build());
manualRedactionClient.addRedactionBulk(dossier.getId(),
file.getId(),
@ -1209,9 +1253,15 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
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());
fileProcessingClient.analysisSuccessful(dossier.getId(),
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);
@ -1224,6 +1274,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
dictionaryClient.addEntry(type.getType(), type.getDossierTemplateId(), List.of("Luke Skywalker"), false, dossier.getId(), DictionaryEntryType.ENTRY);
}
@Test
public void testUnprocessedManualRedactionsRemoveRedaction() {
@ -1237,8 +1288,22 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
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()),
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,
@ -1262,7 +1327,13 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
fileProcessingClient.analysisSuccessful(dossier.getId(),
file.getId(),
AnalyzeResult.builder().manualRedactions(allManualRedactions).messageType(MessageType.ANALYSE).analysisVersion(0).fileId(file.getId()).dossierId(dossier.getId()).build());
AnalyzeResult.builder()
.manualRedactions(allManualRedactions)
.messageType(MessageType.ANALYSE)
.analysisVersion(0)
.fileId(file.getId())
.dossierId(dossier.getId())
.build());
manualRedactionClient.removeRedactionBulk(dossier.getId(),
file.getId(),
@ -1280,7 +1351,13 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
fileProcessingClient.analysisSuccessful(dossier.getId(),
file.getId(),
AnalyzeResult.builder().manualRedactions(allManualRedactions).messageType(MessageType.ANALYSE).analysisVersion(1).fileId(file.getId()).dossierId(dossier.getId()).build());
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);
@ -1291,6 +1368,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
assertTrue(unprocessedManualRedactions.getIdsToRemove().isEmpty());
}
@Test
public void testUnprocessedManualRedactionsForceRedaction() {
@ -1312,7 +1390,13 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
fileProcessingClient.analysisSuccessful(dossier.getId(),
file.getId(),
AnalyzeResult.builder().manualRedactions(allManualRedactions).messageType(MessageType.ANALYSE).analysisVersion(0).fileId(file.getId()).dossierId(dossier.getId()).build());
AnalyzeResult.builder()
.manualRedactions(allManualRedactions)
.messageType(MessageType.ANALYSE)
.analysisVersion(0)
.fileId(file.getId())
.dossierId(dossier.getId())
.build());
manualRedactionClient.forceRedactionBulk(dossier.getId(),
file.getId(),
@ -1330,7 +1414,13 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
fileProcessingClient.analysisSuccessful(dossier.getId(),
file.getId(),
AnalyzeResult.builder().manualRedactions(allManualRedactions).messageType(MessageType.ANALYSE).analysisVersion(1).fileId(file.getId()).dossierId(dossier.getId()).build());
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);
@ -1341,8 +1431,9 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
assertTrue(unprocessedManualRedactions.getForceRedactions().isEmpty());
}
@Test
public void testUnprocessedManualRedactionsRecategorizations() {
@Test
public void testUnprocessedManualRedactionsRecategorizations() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
@ -1354,8 +1445,22 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
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()),
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,
@ -1365,9 +1470,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
when(entityLogService.getEntityLog(Mockito.any(), Mockito.any())).thenReturn(entityLog);
manualRedactionClient.recategorizeBulk(dossier.getId(),
file.getId(),
Set.of(RecategorizationRequestModel.builder().annotationId("dv").build()));
manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(RecategorizationRequestModel.builder().annotationId("dv").build()));
var allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false);
assertEquals(allManualRedactions.getRecategorizations().size(), 1);
@ -1379,11 +1482,15 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
fileProcessingClient.analysisSuccessful(dossier.getId(),
file.getId(),
AnalyzeResult.builder().manualRedactions(allManualRedactions).messageType(MessageType.ANALYSE).analysisVersion(0).fileId(file.getId()).dossierId(dossier.getId()).build());
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()));
manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(RecategorizationRequestModel.builder().annotationId("dv2").build()));
allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false);
assertEquals(allManualRedactions.getRecategorizations().size(), 2);
@ -1397,7 +1504,13 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
fileProcessingClient.analysisSuccessful(dossier.getId(),
file.getId(),
AnalyzeResult.builder().manualRedactions(allManualRedactions).messageType(MessageType.ANALYSE).analysisVersion(1).fileId(file.getId()).dossierId(dossier.getId()).build());
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);
@ -1408,6 +1521,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
assertTrue(unprocessedManualRedactions.getRecategorizations().isEmpty());
}
@Test
public void testUnprocessedManualRedactionsLegalBasisChanges() {
@ -1421,8 +1535,22 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
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()),
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,
@ -1446,7 +1574,13 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
fileProcessingClient.analysisSuccessful(dossier.getId(),
file.getId(),
AnalyzeResult.builder().manualRedactions(allManualRedactions).messageType(MessageType.ANALYSE).analysisVersion(0).fileId(file.getId()).dossierId(dossier.getId()).build());
AnalyzeResult.builder()
.manualRedactions(allManualRedactions)
.messageType(MessageType.ANALYSE)
.analysisVersion(0)
.fileId(file.getId())
.dossierId(dossier.getId())
.build());
manualRedactionClient.legalBasisChangeBulk(dossier.getId(),
file.getId(),
@ -1464,7 +1598,13 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
fileProcessingClient.analysisSuccessful(dossier.getId(),
file.getId(),
AnalyzeResult.builder().manualRedactions(allManualRedactions).messageType(MessageType.ANALYSE).analysisVersion(1).fileId(file.getId()).dossierId(dossier.getId()).build());
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);
@ -1475,4 +1615,59 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
assertTrue(unprocessedManualRedactions.getResizeRedactions().isEmpty());
}
@Test
public void testRemoveManualRedactionEntityRemovesAllManualRedactions() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
String type = "manual";
String value = "Luke Skywalker";
var manualAddResponse = manualRedactionClient.addRedactionBulk(dossier.getId(),
file.getId(),
Set.of(AddRedactionRequestModel.builder()
.sourceId("sourceId")
.type(type)
.value(value)
.reason("Reason")
.positions(List.of(new Rectangle(new Point(0, 0), 100, 100, 0)))
.build())).get(0);
String annotationId = manualAddResponse.getAnnotationId();
var entityLog = new EntityLog(1,
1,
List.of(EntityLogEntry.builder().id(annotationId).type(type).value(value).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);
assertEquals(1, manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false).getEntriesToAdd().size());
assertEquals(annotationId,
manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false).getEntriesToAdd().stream().findFirst().orElseThrow().getAnnotationId());
manualRedactionClient.legalBasisChangeBulk(dossier.getId(),
file.getId(),
Set.of(LegalBasisChangeRequestModel.builder().annotationId(annotationId).legalBasis("some legal basis").build()));
manualRedactionClient.forceRedactionBulk(dossier.getId(), file.getId(), Set.of(ForceRedactionRequestModel.builder().annotationId(annotationId).build()));
manualRedactionClient.recategorizeBulk(dossier.getId(), file.getId(), Set.of(RecategorizationRequestModel.builder().annotationId(annotationId).type("other type").build()));
manualRedactionClient.resizeRedactionBulk(dossier.getId(),
file.getId(),
Set.of(ResizeRedactionRequestModel.builder()
.annotationId(annotationId)
.value("Luke Skywalker and some more text")
.positions(List.of(new Rectangle(new Point(10, 10), 100, 100, 1)))
.build()));
manualRedactionClient.removeRedactionBulk(dossier.getId(), file.getId(), Set.of(RemoveRedactionRequestModel.builder().annotationId(annotationId).build()));
assertTrue(manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false).getEntriesToAdd().isEmpty());
assertTrue(manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false).getLegalBasisChanges().isEmpty());
assertTrue(manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false).getForceRedactions().isEmpty());
assertTrue(manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false).getRecategorizations().isEmpty());
assertTrue(manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false).getResizeRedactions().isEmpty());
assertEquals(1, manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false).getIdsToRemove().size());
}
}

3
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/annotations/Comment.java
View File

@ -15,10 +15,9 @@ public class Comment {
private long id;
private String fileId;
private String annotationId;
private OffsetDateTime date;
private String text;
private String user;
private String userId;
private OffsetDateTime softDeletedTime;
}