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

RED-8998 - Get specific entry from entitylog and return the merged entry on manual changes endpoints

Browse Source
This commit is contained in:
Andrei Isvoran 2024-04-29 10:37:07 +02:00
parent 83d6ef71ef
commit 6280e342eb
10 changed files with 610 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
persistence-service-v1/persistence-service-external-api-impl-v1/src/main/java/com/iqser/red/persistence/service/v1/external/api/impl/controller/ManualRedactionController.java vendored
View File

@ -278,7 +278,7 @@ public class ManualRedactionController implements ManualRedactionResource {
List<ManualAddResponse> responseList = manualRedactionService.addRecategorization(dossierId,
fileId,
dossier.getDossierTemplateId(),
dossier,
recategorizationRequests,
includeUnprocessed);

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

@ -17,7 +17,6 @@ import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.apache.commons.lang3.StringUtils;
import org.assertj.core.util.Strings;
import org.springframework.stereotype.Service;
@ -236,15 +235,23 @@ public class EntityLogMergeService {
return Optional.empty();
}
EntityLogEntry entityLogEntry = buildEntityLogEntry(manualRedactionEntry, entityLog.getAnalysisNumber(), dossier);
entityLog.getEntityLogEntry().add(entityLogEntry);
return Optional.of(entityLogEntry);
}
public EntityLogEntry buildEntityLogEntry(ManualRedactionEntry manualRedactionEntry, int analysisNumber, DossierEntity dossier) {
List<ManualChange> manualChanges = new ArrayList<>();
manualChanges.add(ManualChangeFactory.toLocalManualChange(manualRedactionEntry));
List<Change> changes = new ArrayList<>();
changes.add(Change.builder().analysisNumber(entityLog.getAnalysisNumber()).dateTime(manualRedactionEntry.getRequestDate()).type(ChangeType.ADDED).build());
changes.add(Change.builder().analysisNumber(analysisNumber).dateTime(manualRedactionEntry.getRequestDate()).type(ChangeType.ADDED).build());
boolean isHint = isHint(manualRedactionEntry.getType(), dossier);
EntityLogEntry entityLogEntry = EntityLogEntry.builder()
return EntityLogEntry.builder()
.id(manualRedactionEntry.getAnnotationId())
.type(manualRedactionEntry.getType())
.value(manualRedactionEntry.getValue())
@ -272,9 +279,6 @@ public class EntityLogMergeService {
.startOffset(-1)
.endOffset(-1)
.build();
entityLog.getEntityLogEntry().add(entityLogEntry);
return Optional.of(entityLogEntry);
}
@ -297,7 +301,7 @@ public class EntityLogMergeService {
}
private void mergeIdToRemove(IdRemoval idRemoval, EntityLogEntry entityLogEntry, int analysisNumber) {
public void mergeIdToRemove(IdRemoval idRemoval, EntityLogEntry entityLogEntry, int analysisNumber) {
entityLogEntry.setState(EntryState.IGNORED);
entityLogEntry.getEngines().add(Engine.MANUAL);
@ -306,7 +310,7 @@ public class EntityLogMergeService {
}
private void mergeResizeRedaction(ManualResizeRedaction manualResizeRedaction, EntityLogEntry entityLogEntry, int analysisNumber) {
public void mergeResizeRedaction(ManualResizeRedaction manualResizeRedaction, EntityLogEntry entityLogEntry, int analysisNumber) {
entityLogEntry.setTextAfter(manualResizeRedaction.getTextAfter());
entityLogEntry.setTextBefore(manualResizeRedaction.getTextBefore());
@ -318,14 +322,14 @@ public class EntityLogMergeService {
}
private boolean isDuplicatedByAny(EntityLogEntry entry, Map<String, EntityLogEntry> addedLocalManualEntryIds) {
public boolean isDuplicatedByAny(EntityLogEntry entry, Map<String, EntityLogEntry> addedLocalManualEntryIds) {
return !entry.getEngines().contains(Engine.MANUAL) && addedLocalManualEntryIds.containsKey(entry.getId()) && !addedLocalManualEntryIds.get(entry.getId()).equals(entry);
}
@Deprecated(forRemoval = true)
private void mergeLegalBasisChange(ManualLegalBasisChange manualLegalBasisChange, EntityLogEntry entityLogEntry, int analysisNumber) {
public void mergeLegalBasisChange(ManualLegalBasisChange manualLegalBasisChange, EntityLogEntry entityLogEntry, int analysisNumber) {
entityLogEntry.setLegalBasis(manualLegalBasisChange.getLegalBasis());
entityLogEntry.setSection(manualLegalBasisChange.getSection());
@ -336,7 +340,7 @@ public class EntityLogMergeService {
}
private EntityLogEntry mergeRecategorization(ManualRecategorization recategorization, EntityLogEntry entityLogEntry, DossierEntity dossier, int analysisNumber) {
public EntityLogEntry mergeRecategorization(ManualRecategorization recategorization, EntityLogEntry entityLogEntry, DossierEntity dossier, int analysisNumber) {
if ((recategorization.getType() != null && !Objects.equals(recategorization.getType(), entityLogEntry.getType()) && Strings.isNullOrEmpty(recategorization.getLegalBasis()))//
&& (entityLogEntry.getEntryType().equals(EntryType.IMAGE) || entityLogEntry.getEntryType().equals(EntryType.IMAGE_HINT))) {
@ -374,7 +378,7 @@ public class EntityLogMergeService {
}
private void mergeForceRedaction(ManualForceRedaction forceRedaction, EntityLogEntry entityLogEntry, int analysisNumber) {
public void mergeForceRedaction(ManualForceRedaction forceRedaction, EntityLogEntry entityLogEntry, int analysisNumber) {
entityLogEntry.setLegalBasis(forceRedaction.getLegalBasis());
entityLogEntry.setState(entityLogEntry.getEntryType().equals(EntryType.HINT) ? EntryState.SKIPPED : EntryState.APPLIED);
@ -404,7 +408,7 @@ public class EntityLogMergeService {
}
private boolean isHint(String type, DossierEntity dossier) {
public boolean isHint(String type, DossierEntity dossier) {
String typeId = toTypeId(type, dossier.getDossierTemplateId());
TypeEntity typeEntity = dictionaryPersistenceService.getType(typeId);
@ -434,7 +438,7 @@ public class EntityLogMergeService {
}
private List<Position> convertPositions(List<Rectangle> rectangles) {
public List<Position> convertPositions(List<Rectangle> rectangles) {
return rectangles.stream()
.map(rectangle -> new Position(rectangle.getTopLeftX(), rectangle.getTopLeftY(), rectangle.getWidth(), rectangle.getHeight(), rectangle.getPage()))

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

@ -5,6 +5,7 @@ import static com.iqser.red.service.persistence.management.v1.processor.utils.Ty
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;
@ -13,7 +14,6 @@ import org.springframework.stereotype.Service;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.ManualRecategorizationEntity;
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.Engine;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLog;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
@ -23,6 +23,7 @@ import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.LegalBasisChangeRequest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.RecategorizationRequest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.RemoveRedactionRequest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.RequestEntryPair;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.ResizeRedactionRequest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.Dossier;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.type.DictionaryEntryType;
@ -32,6 +33,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.mongo.service.EntityLogMongoService;
import com.knecon.fforesight.keycloakcommons.security.KeycloakSecurity;
import io.micrometer.observation.annotation.Observed;
@ -44,7 +46,7 @@ import lombok.experimental.FieldDefaults;
@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
public class ManualRedactionMapper {
EntityLogService entityLogService;
EntityLogMongoService entityLogMongoService;
@Observed(name = "ManualRedactionMapper", contextualName = "to-add-redaction-request-list")
@ -78,62 +80,70 @@ public class ManualRedactionMapper {
}
public List<RemoveRedactionRequest> toRemoveRedactionRequestList(String dossierId,
public List<RequestEntryPair<RemoveRedactionRequest>> toRemoveRedactionRequestList(String dossierId,
String fileId,
String dossierTemplateId,
Set<RemoveRedactionRequestModel> removeRedactionRequests,
boolean includeUnprocessed) {
List<RemoveRedactionRequest> requests = new ArrayList<>();
EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId, includeUnprocessed);
List<RequestEntryPair<RemoveRedactionRequest>> requests = new ArrayList<>();
for (var removeRedactionRequest : removeRedactionRequests) {
EntityLogEntry entityLogEntry = getEntityLogEntry(entityLog, removeRedactionRequest.getAnnotationId());
var removeRedactionRequestBuilder = RemoveRedactionRequest.builder()
.annotationId(removeRedactionRequest.getAnnotationId())
.user(KeycloakSecurity.getUserId())
.removeFromDictionary(removeRedactionRequest.isRemoveFromDictionary())
.removeFromAllDossiers(removeRedactionRequest.isRemoveFromAllDossiers())
.value(entityLogEntry.getValue())
.dictionaryEntryType(getDictionaryEntryType(entityLogEntry))
.typeToRemove(entityLogEntry.getType())
.dossierId(dossierId)
.dossierTemplateId(dossierTemplateId);
Optional<EntityLogEntry> optionalEntityLogEntry = entityLogMongoService.findEntityLogEntryById(dossierId, fileId, removeRedactionRequest.getAnnotationId());
optionalEntityLogEntry.ifPresent(entityLogEntry -> {
var request = RemoveRedactionRequest.builder()
.annotationId(removeRedactionRequest.getAnnotationId())
.user(KeycloakSecurity.getUserId())
.removeFromDictionary(removeRedactionRequest.isRemoveFromDictionary())
.removeFromAllDossiers(removeRedactionRequest.isRemoveFromAllDossiers())
.value(entityLogEntry.getValue())
.dictionaryEntryType(getDictionaryEntryType(entityLogEntry))
.typeToRemove(entityLogEntry.getType())
.dossierId(dossierId)
.dossierTemplateId(dossierTemplateId);
if (removeRedactionRequest.getComment() != null) {
removeRedactionRequestBuilder.comment(removeRedactionRequest.getComment());
}
if (removeRedactionRequest.getComment() != null) {
request.comment(removeRedactionRequest.getComment());
}
requests.add(removeRedactionRequestBuilder.build());
requests.add(RequestEntryPair.<RemoveRedactionRequest>builder()
.request(request.build())
.entityLogEntry(entityLogEntry)
.build());
});
}
return requests;
}
public List<ForceRedactionRequest> toForceRedactionRequestList(String dossierId,
public List<RequestEntryPair<ForceRedactionRequest>> toForceRedactionRequestList(String dossierId,
String fileId,
Set<ForceRedactionRequestModel> forceRedactionRequests,
Consumer<EntityLogEntry> manualRedactionEntryConsumer) {
EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId, true);
List<ForceRedactionRequest> requests = new ArrayList<>();
List<RequestEntryPair<ForceRedactionRequest>> requests = new ArrayList<>();
for (ForceRedactionRequestModel forceRedactionRequestModel : forceRedactionRequests) {
EntityLogEntry entityLogEntry = getEntityLogEntry(entityLog, forceRedactionRequestModel.getAnnotationId());
ForceRedactionRequest forceRedactionRequest = ForceRedactionRequest.builder()
.annotationId(forceRedactionRequestModel.getAnnotationId())
.user(KeycloakSecurity.getUserId())
.legalBasis(forceRedactionRequestModel.getLegalBasis())
.comment(forceRedactionRequestModel.getComment())
.build();
Optional<EntityLogEntry> optionalEntityLogEntry = entityLogMongoService.findEntityLogEntryById(dossierId, fileId, forceRedactionRequestModel.getAnnotationId());
optionalEntityLogEntry.ifPresent(entityLogEntry -> {
ForceRedactionRequest request = ForceRedactionRequest.builder()
.annotationId(forceRedactionRequestModel.getAnnotationId())
.user(KeycloakSecurity.getUserId())
.legalBasis(forceRedactionRequestModel.getLegalBasis())
.comment(forceRedactionRequestModel.getComment())
.build();
if (!entityLogEntry.getEngines().contains(Engine.MANUAL) && entryIsEntityType(entityLogEntry)) {
manualRedactionEntryConsumer.accept(entityLogEntry);
}
if (!entityLogEntry.getEngines().contains(Engine.MANUAL) && entryIsEntityType(entityLogEntry)) {
manualRedactionEntryConsumer.accept(entityLogEntry);
}
requests.add(forceRedactionRequest);
requests.add(RequestEntryPair.<ForceRedactionRequest>builder()
.request(request)
.entityLogEntry(entityLogEntry)
.build());
});
}
return requests;
@ -141,92 +151,101 @@ public class ManualRedactionMapper {
@Deprecated(forRemoval = true)
public List<LegalBasisChangeRequest> toLegalBasisChangeRequestList(String dossierId,
public List<RequestEntryPair<LegalBasisChangeRequest>> toLegalBasisChangeRequestList(String dossierId,
String fileId,
Set<LegalBasisChangeRequestModel> legalBasisChangeRequests,
Consumer<EntityLogEntry> manualRedactionEntryConsumer) {
EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId, true);
List<LegalBasisChangeRequest> requests = new ArrayList<>();
List<RequestEntryPair<LegalBasisChangeRequest>> requests = new ArrayList<>();
for (LegalBasisChangeRequestModel legalBasisChangeRequest : legalBasisChangeRequests) {
EntityLogEntry entityLogEntry = getEntityLogEntry(entityLog, legalBasisChangeRequest.getAnnotationId());
LegalBasisChangeRequest request = LegalBasisChangeRequest.builder()
.annotationId(legalBasisChangeRequest.getAnnotationId())
.user(KeycloakSecurity.getUserId())
.section(legalBasisChangeRequest.getSection())
.legalBasis(legalBasisChangeRequest.getLegalBasis())
.comment(legalBasisChangeRequest.getComment())
.value(legalBasisChangeRequest.getValue())
.build();
Optional<EntityLogEntry> optionalEntityLogEntry = entityLogMongoService.findEntityLogEntryById(dossierId, fileId, legalBasisChangeRequest.getAnnotationId());
optionalEntityLogEntry.ifPresent(entityLogEntry -> {
LegalBasisChangeRequest request = LegalBasisChangeRequest.builder()
.annotationId(legalBasisChangeRequest.getAnnotationId())
.user(KeycloakSecurity.getUserId())
.section(legalBasisChangeRequest.getSection())
.legalBasis(legalBasisChangeRequest.getLegalBasis())
.comment(legalBasisChangeRequest.getComment())
.value(legalBasisChangeRequest.getValue())
.build();
if (!entityLogEntry.getEngines().contains(Engine.MANUAL) && entryIsEntityType(entityLogEntry)) {
manualRedactionEntryConsumer.accept(entityLogEntry);
}
if (!entityLogEntry.getEngines().contains(Engine.MANUAL) && entryIsEntityType(entityLogEntry)) {
manualRedactionEntryConsumer.accept(entityLogEntry);
}
requests.add(request);
requests.add(RequestEntryPair.<LegalBasisChangeRequest>builder()
.request(request)
.entityLogEntry(entityLogEntry)
.build());
});
}
return requests;
}
public List<RecategorizationRequest> toRecategorizationRequestList(String dossierId,
public List<RequestEntryPair<RecategorizationRequest>> toRecategorizationRequestList(String dossierId,
String fileId,
String dossierTemplateId,
Set<RecategorizationRequestModel> recategorizationRequests,
boolean includeUnprocessed,
Consumer<EntityLogEntry> manualRedactionEntryConsumer) {
EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId, includeUnprocessed);
List<RecategorizationRequest> requests = new ArrayList<>();
List<RequestEntryPair<RecategorizationRequest>> requests = new ArrayList<>();
for (RecategorizationRequestModel recategorizationRequest : recategorizationRequests) {
EntityLogEntry entityLogEntry = getEntityLogEntry(entityLog, recategorizationRequest.getAnnotationId());
Optional<EntityLogEntry> optionalEntityLogEntry = entityLogMongoService.findEntityLogEntryById(dossierId, fileId, recategorizationRequest.getAnnotationId());
optionalEntityLogEntry.ifPresent(entityLogEntry -> {
String changedValue;
String changedTypeId;
String changedValue;
String changedTypeId;
if (recategorizationRequest.isAddToDictionary() || recategorizationRequest.isAddToAllDossiers()) {
changedValue = recategorizationRequest.getValue();
changedTypeId = toTypeId(recategorizationRequest.getType(), dossierTemplateId);
} else {
changedValue = Objects.equals(recategorizationRequest.getValue(), entityLogEntry.getValue()) ? null : recategorizationRequest.getValue();
changedTypeId = Objects.equals(recategorizationRequest.getType(), entityLogEntry.getType()) ? null : toTypeId(recategorizationRequest.getType(), dossierTemplateId);
}
if (recategorizationRequest.isAddToDictionary() || recategorizationRequest.isAddToAllDossiers()) {
changedValue = recategorizationRequest.getValue();
changedTypeId = toTypeId(recategorizationRequest.getType(), dossierTemplateId);
} else {
changedValue = Objects.equals(recategorizationRequest.getValue(), entityLogEntry.getValue()) ? null : recategorizationRequest.getValue();
changedTypeId = Objects.equals(recategorizationRequest.getType(), entityLogEntry.getType()) ? null : toTypeId(recategorizationRequest.getType(),
dossierTemplateId);
}
String changedLegalBasis = Objects.equals(recategorizationRequest.getLegalBasis(), entityLogEntry.getLegalBasis()) ? null : recategorizationRequest.getLegalBasis();
String changedSection = Objects.equals(recategorizationRequest.getSection(), entityLogEntry.getSection()) ? null : recategorizationRequest.getSection();
String changedLegalBasis = Objects.equals(recategorizationRequest.getLegalBasis(), entityLogEntry.getLegalBasis()) ? null : recategorizationRequest.getLegalBasis();
String changedSection = Objects.equals(recategorizationRequest.getSection(), entityLogEntry.getSection()) ? null : recategorizationRequest.getSection();
checkLegalBasisLength(changedLegalBasis);
checkSectionLength(changedSection);
checkLegalBasisLength(changedLegalBasis);
checkSectionLength(changedSection);
RecategorizationRequest request = RecategorizationRequest.builder()
.annotationId(recategorizationRequest.getAnnotationId())
.user(KeycloakSecurity.getUserId())
.dossierTemplateId(dossierTemplateId)
.comment(recategorizationRequest.getComment())
.dossierId(dossierId)
.addToDictionary(recategorizationRequest.isAddToDictionary())
.addToAllDossiers(recategorizationRequest.isAddToAllDossiers())
.dictionaryEntryType(getDictionaryEntryType(entityLogEntry))
.typeToRemove(entityLogEntry.getType())
.value(changedValue)
.dictionaryTypeId(changedTypeId)
.legalBasis(changedLegalBasis)
.section(changedSection)
.build();
RecategorizationRequest request = RecategorizationRequest.builder()
.annotationId(recategorizationRequest.getAnnotationId())
.user(KeycloakSecurity.getUserId())
.dossierTemplateId(dossierTemplateId)
.comment(recategorizationRequest.getComment())
.dossierId(dossierId)
.addToDictionary(recategorizationRequest.isAddToDictionary())
.addToAllDossiers(recategorizationRequest.isAddToAllDossiers())
.dictionaryEntryType(getDictionaryEntryType(entityLogEntry))
.typeToRemove(entityLogEntry.getType())
.value(changedValue)
.dictionaryTypeId(changedTypeId)
.legalBasis(changedLegalBasis)
.section(changedSection)
.build();
if (!entityLogEntry.getEngines().contains(Engine.MANUAL)
&& !recategorizationRequest.isAddToAllDossiers()
&& !recategorizationRequest.isAddToDictionary()
&& entryIsEntityType(entityLogEntry)) {
manualRedactionEntryConsumer.accept(entityLogEntry);
}
if (!entityLogEntry.getEngines().contains(Engine.MANUAL)
&& !recategorizationRequest.isAddToAllDossiers()
&& !recategorizationRequest.isAddToDictionary()
&& entryIsEntityType(entityLogEntry)) {
manualRedactionEntryConsumer.accept(entityLogEntry);
}
requests.add(request);
requests.add(RequestEntryPair.<RecategorizationRequest>builder()
.request(request)
.entityLogEntry(entityLogEntry)
.build());
});
}
return requests;
@ -260,34 +279,40 @@ public class ManualRedactionMapper {
}
public List<ResizeRedactionRequest> toResizeRedactionRequestList(Set<ResizeRedactionRequestModel> resizeRedactionRequests,
Consumer<EntityLogEntry> manualRedactionEntryConsumer,
EntityLog entityLog) {
public List<RequestEntryPair<ResizeRedactionRequest>> toResizeRedactionRequestList(String dossierId,
String fileId,
Set<ResizeRedactionRequestModel> resizeRedactionRequests,
Consumer<EntityLogEntry> manualRedactionEntryConsumer) {
List<ResizeRedactionRequest> requests = new ArrayList<>();
List<RequestEntryPair<ResizeRedactionRequest>> requests = new ArrayList<>();
for (ResizeRedactionRequestModel resizeRedactionRequest : resizeRedactionRequests) {
EntityLogEntry entityLogEntry = getEntityLogEntry(entityLog, resizeRedactionRequest.getAnnotationId());
ResizeRedactionRequest request = ResizeRedactionRequest.builder()
.annotationId(resizeRedactionRequest.getAnnotationId())
.user(KeycloakSecurity.getUserId())
.positions(resizeRedactionRequest.getPositions())
.value(resizeRedactionRequest.getValue() == null ? "" : StringCleaningUtility.cleanString(resizeRedactionRequest.getValue()))
.comment(resizeRedactionRequest.getComment())
.updateDictionary(resizeRedactionRequest.getUpdateDictionary())
.addToAllDossiers(resizeRedactionRequest.isAddToAllDossiers())
.build();
Optional<EntityLogEntry> optionalEntityLogEntry = entityLogMongoService.findEntityLogEntryById(dossierId, fileId, resizeRedactionRequest.getAnnotationId());
optionalEntityLogEntry.ifPresent(entityLogEntry -> {
ResizeRedactionRequest request = ResizeRedactionRequest.builder()
.annotationId(resizeRedactionRequest.getAnnotationId())
.user(KeycloakSecurity.getUserId())
.positions(resizeRedactionRequest.getPositions())
.value(resizeRedactionRequest.getValue() == null ? "" : StringCleaningUtility.cleanString(resizeRedactionRequest.getValue()))
.comment(resizeRedactionRequest.getComment())
.updateDictionary(resizeRedactionRequest.getUpdateDictionary())
.addToAllDossiers(resizeRedactionRequest.isAddToAllDossiers())
.build();
if (!entityLogEntry.getEngines().contains(Engine.MANUAL)
&& entryIsEntityType(entityLogEntry)
&& !request.isAddToAllDossiers()
&& !request.getUpdateDictionary()
&& entryIsEntityType(entityLogEntry)) {
manualRedactionEntryConsumer.accept(entityLogEntry);
}
if (!entityLogEntry.getEngines().contains(Engine.MANUAL)
&& entryIsEntityType(entityLogEntry)
&& !request.isAddToAllDossiers()
&& !request.getUpdateDictionary()
&& entryIsEntityType(entityLogEntry)) {
manualRedactionEntryConsumer.accept(entityLogEntry);
}
requests.add(request);
requests.add(RequestEntryPair.<ResizeRedactionRequest>builder()
.request(request)
.entityLogEntry(entityLogEntry)
.build());
});
}
return requests;

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

@ -7,6 +7,7 @@ import java.nio.charset.StandardCharsets;
import java.time.OffsetDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.Set;
import java.util.function.Consumer;
import java.util.stream.Collectors;
@ -20,17 +21,18 @@ import com.google.common.hash.HashFunction;
import com.google.common.hash.Hashing;
import com.iqser.red.service.persistence.management.v1.processor.configuration.MessagingConfiguration;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.AnnotationEntityId;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.IdRemovalEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.ManualForceRedactionEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.ManualLegalBasisChangeEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.ManualRecategorizationEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.ManualRedactionEntryEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.ManualResizeRedactionEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.annotations.RectangleEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.DossierEntity;
import com.iqser.red.service.persistence.management.v1.processor.exception.BadRequestException;
import com.iqser.red.service.persistence.management.v1.processor.exception.NotFoundException;
import com.iqser.red.service.persistence.management.v1.processor.model.ManualChangesQueryOptions;
import com.iqser.red.service.persistence.management.v1.processor.service.CommentService;
import com.iqser.red.service.persistence.management.v1.processor.service.EntityLogMergeService;
import com.iqser.red.service.persistence.management.v1.processor.service.EntityLogService;
import com.iqser.red.service.persistence.management.v1.processor.service.FileStatusService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DossierPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.FileStatusPersistenceService;
@ -40,12 +42,13 @@ 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.ManualRecategorizationMapper;
import com.iqser.red.service.persistence.management.v1.processor.utils.ManualRedactionEntryMapper;
import com.iqser.red.service.persistence.management.v1.processor.utils.ManualResizeRedactionMapper;
import com.iqser.red.service.persistence.management.v1.processor.utils.TypeIdUtils;
import com.iqser.red.service.persistence.service.v1.api.shared.model.AnalyzeRequest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.MessageType;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLog;
import com.iqser.red.service.persistence.service.v1.api.shared.model.RequestEntryPair;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Position;
@ -58,6 +61,10 @@ import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.Rectangle;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.RemoveRedactionRequest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.ResizeRedactionRequest;
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;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualLegalBasisChange;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRecategorization;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualRedactionEntry;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.entitymapped.ManualResizeRedaction;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.Dossier;
@ -68,6 +75,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.mongo.service.EntityLogMongoService;
import com.knecon.fforesight.databasetenantcommons.providers.utils.MagicConverter;
import com.knecon.fforesight.keycloakcommons.security.KeycloakSecurity;
@ -93,13 +101,13 @@ public class ManualRedactionService {
ResizeRedactionPersistenceService resizeRedactionPersistenceService;
FileStatusService fileStatusService;
ManualRedactionProviderService manualRedactionProviderService;
EntityLogService entityLogService;
EntityLogMongoService entityLogMongoService;
HashFunction hashFunction = Hashing.murmur3_128();
ManualRedactionDictionaryUpdateHandler manualRedactionDictionaryUpdateHandler;
EntityLogMergeService entityLogMergeService;
FileStatusPersistenceService fileStatusPersistenceService;
ManualRedactionMapper manualRedactionMapper;
RabbitTemplate rabbitTemplate;
EntityLogMergeService entityLogMergeService;
@Transactional
@ -121,7 +129,8 @@ public class ManualRedactionService {
String annotationId = hashFunction.hashString(fileId + addRedactionRequest, StandardCharsets.UTF_8).toString();
manualRedactionEntryEntities.add(addRedactionPersistenceService.insert(fileId, annotationId, addRedactionRequest));
ManualRedactionEntryEntity manualRedactionEntryEntity = addRedactionPersistenceService.insert(fileId, annotationId, addRedactionRequest);
manualRedactionEntryEntities.add(manualRedactionEntryEntity);
Set<String> typeIdsOfModifiedDictionaries = manualRedactionDictionaryUpdateHandler.handleAddToDictionaryAndReturnModifiedTypeIds(fileId,
addRedactionRequest.getValue(),
@ -129,9 +138,14 @@ public class ManualRedactionService {
addRedactionPersistenceService.updateModifiedDictionaries(fileId, annotationId, !typeIdsOfModifiedDictionaries.isEmpty(), typeIdsOfModifiedDictionaries);
EntityLogEntry entityLogEntry = null;
if (!addRedactionRequest.isAddToDictionary() && !addRedactionRequest.isAddToAllDossiers()) {
entityLogEntry = entityLogMergeService.buildEntityLogEntry(MagicConverter.convert(manualRedactionEntryEntity, ManualRedactionEntry.class, new ManualRedactionEntryMapper()),
getAnalysisNumber(dossierId, fileId),
dossierEntity);
}
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).entityLogEntry(entityLogEntry).build());
}
var localManualRedactionEntryEntities = manualRedactionEntryEntities.stream()
@ -175,20 +189,22 @@ public class ManualRedactionService {
boolean includeUnprocessed) {
var response = new ArrayList<ManualAddResponse>();
List<RemoveRedactionRequest> requests = manualRedactionMapper.toRemoveRedactionRequestList(dossierId,
fileId,
dossierTemplateId,
removeRedactionRequests,
includeUnprocessed);
List<RequestEntryPair<RemoveRedactionRequest>> requests = manualRedactionMapper.toRemoveRedactionRequestList(dossierId,
fileId,
dossierTemplateId,
removeRedactionRequests,
includeUnprocessed);
//validate removing from dossier template dictionary
for (RemoveRedactionRequest removeRedactionRequest : requests) {
for (RequestEntryPair<RemoveRedactionRequest> removeRedactionRequestRequestEntryPair : requests) {
RemoveRedactionRequest removeRedactionRequest = removeRedactionRequestRequestEntryPair.getRequest();
EntityLogEntry entityLogEntry = removeRedactionRequestRequestEntryPair.getEntityLogEntry();
manualRedactionDictionaryUpdateHandler.validateDictionariesForDelete(removeRedactionRequest,
removeRedactionRequest.getTypeToRemove(),
removeRedactionRequest.getDossierTemplateId());
log.info("add removeRedaction for file {} and annotation {}", fileId, removeRedactionRequest.getAnnotationId());
removeRedactionPersistenceService.insert(fileId, removeRedactionRequest);
IdRemovalEntity idRemoval = removeRedactionPersistenceService.insert(fileId, removeRedactionRequest);
Long commentId = commentService.addCommentAndGetId(fileId,
removeRedactionRequest.getAnnotationId(),
@ -201,7 +217,10 @@ public class ManualRedactionService {
removeRedactionPersistenceService.updateModifiedDictionaries(fileId, removeRedactionRequest.getAnnotationId(), removedFromDictionary, typeIdsOfModifiedDictionaries);
response.add(ManualAddResponse.builder().annotationId(removeRedactionRequest.getAnnotationId()).commentId(commentId).build());
if (!idRemoval.isRemoveFromAllDossiers() && !idRemoval.isRemoveFromDictionary()) {
entityLogMergeService.mergeIdToRemove(MagicConverter.convert(idRemoval, IdRemoval.class), entityLogEntry, getAnalysisNumber(dossierId, fileId));
}
response.add(ManualAddResponse.builder().annotationId(removeRedactionRequest.getAnnotationId()).commentId(commentId).entityLogEntry(entityLogEntry).build());
}
reprocess(dossierId, fileId);
@ -217,17 +236,25 @@ public class ManualRedactionService {
var response = new ArrayList<ManualAddResponse>();
dossierPersistenceService.getAndValidateDossier(dossierId);
List<ForceRedactionRequest> requests = manualRedactionMapper.toForceRedactionRequestList(dossierId, fileId, forceRedactionRequests, getEntityLogEntryConsumer(fileId));
List<RequestEntryPair<ForceRedactionRequest>> requests = manualRedactionMapper.toForceRedactionRequestList(dossierId,
fileId,
forceRedactionRequests,
getEntityLogEntryConsumer(fileId));
for (var forceRedactionRequest : requests) {
forceRedactionPersistenceService.insert(fileId, forceRedactionRequest);
for (RequestEntryPair<ForceRedactionRequest> forceRedactionRequestRequestEntryPair : requests) {
ForceRedactionRequest forceRedactionRequest = forceRedactionRequestRequestEntryPair.getRequest();
EntityLogEntry entityLogEntry = forceRedactionRequestRequestEntryPair.getEntityLogEntry();
ManualForceRedactionEntity manualForceRedaction = forceRedactionPersistenceService.insert(fileId, forceRedactionRequest);
Long commentId = commentService.addCommentAndGetId(fileId,
forceRedactionRequest.getAnnotationId(),
forceRedactionRequest.getComment(),
forceRedactionRequest.getUser());
response.add(ManualAddResponse.builder().annotationId(forceRedactionRequest.getAnnotationId()).commentId(commentId).build());
entityLogMergeService.mergeForceRedaction(MagicConverter.convert(manualForceRedaction, ManualForceRedaction.class),
entityLogEntry,
getAnalysisNumber(dossierId, fileId));
response.add(ManualAddResponse.builder().annotationId(forceRedactionRequest.getAnnotationId()).commentId(commentId).entityLogEntry(entityLogEntry).build());
}
reprocess(dossierId, fileId);
@ -244,20 +271,25 @@ public class ManualRedactionService {
var response = new ArrayList<ManualAddResponse>();
dossierPersistenceService.getAndValidateDossier(dossierId);
List<LegalBasisChangeRequest> requests = manualRedactionMapper.toLegalBasisChangeRequestList(dossierId,
fileId,
legalBasisChangeRequests,
getEntityLogEntryConsumer(fileId));
List<RequestEntryPair<LegalBasisChangeRequest>> requests = manualRedactionMapper.toLegalBasisChangeRequestList(dossierId,
fileId,
legalBasisChangeRequests,
getEntityLogEntryConsumer(fileId));
for (var legalBasisChangeRequest : requests) {
legalBasisChangePersistenceService.insert(fileId, legalBasisChangeRequest);
for (RequestEntryPair<LegalBasisChangeRequest> legalBasisChangeRequestRequestEntryPair : requests) {
LegalBasisChangeRequest legalBasisChangeRequest = legalBasisChangeRequestRequestEntryPair.getRequest();
EntityLogEntry entityLogEntry = legalBasisChangeRequestRequestEntryPair.getEntityLogEntry();
ManualLegalBasisChangeEntity manualLegalBasisChange = legalBasisChangePersistenceService.insert(fileId, legalBasisChangeRequest);
Long commentId = commentService.addCommentAndGetId(fileId,
legalBasisChangeRequest.getAnnotationId(),
legalBasisChangeRequest.getComment(),
legalBasisChangeRequest.getUser());
response.add(ManualAddResponse.builder().annotationId(legalBasisChangeRequest.getAnnotationId()).commentId(commentId).build());
entityLogMergeService.mergeLegalBasisChange(MagicConverter.convert(manualLegalBasisChange, ManualLegalBasisChange.class),
entityLogEntry,
getAnalysisNumber(dossierId, fileId));
response.add(ManualAddResponse.builder().annotationId(legalBasisChangeRequest.getAnnotationId()).commentId(commentId).entityLogEntry(entityLogEntry).build());
}
reprocess(dossierId, fileId);
fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now());
@ -269,19 +301,22 @@ public class ManualRedactionService {
@Transactional
public List<ManualAddResponse> addRecategorization(String dossierId,
String fileId,
String dossierTemplateId,
Dossier dossier,
Set<RecategorizationRequestModel> recategorizationRequests,
boolean includeUnprocessed) {
var response = new ArrayList<ManualAddResponse>();
dossierPersistenceService.getAndValidateDossier(dossierId);
List<RecategorizationRequest> requests = manualRedactionMapper.toRecategorizationRequestList(dossierId,
fileId,
dossierTemplateId,
recategorizationRequests,
includeUnprocessed,
getEntityLogEntryConsumer(fileId));
for (var recategorizationRequest : requests) {
var dossierEntity = dossierPersistenceService.getAndValidateDossier(dossierId);
List<RequestEntryPair<RecategorizationRequest>> requests = manualRedactionMapper.toRecategorizationRequestList(dossierId,
fileId,
dossier.getDossierTemplateId(),
recategorizationRequests,
includeUnprocessed,
getEntityLogEntryConsumer(fileId));
for (RequestEntryPair<RecategorizationRequest> recategorizationRequestRequestEntryPair : requests) {
RecategorizationRequest recategorizationRequest = recategorizationRequestRequestEntryPair.getRequest();
EntityLogEntry entityLogEntry = recategorizationRequestRequestEntryPair.getEntityLogEntry();
manualRedactionDictionaryUpdateHandler.validateDictionariesForAdd(recategorizationRequest, recategorizationRequest.getValue());
manualRedactionDictionaryUpdateHandler.validateDictionariesForDelete(recategorizationRequest,
recategorizationRequest.getTypeToRemove(),
@ -298,13 +333,19 @@ public class ManualRedactionService {
recategorizationEntity.setTypeIdsOfDictionariesWithAdd(typeIdsOfDictionariesWithAdd);
recategorizationEntity.setTypeIdsOfDictionariesWithDelete(typeIdsOfDictionariesWithDelete);
Long commentId = commentService.addCommentAndGetId(fileId,
recategorizationRequest.getAnnotationId(),
recategorizationRequest.getComment(),
recategorizationRequest.getUser());
response.add(ManualAddResponse.builder().annotationId(recategorizationRequest.getAnnotationId()).commentId(commentId).build());
if (!recategorizationRequest.isAddToAllDossiers() && !recategorizationRequest.isAddToDictionary()) {
entityLogMergeService.mergeRecategorization(MagicConverter.convert(recategorizationEntity, ManualRecategorization.class, new ManualRecategorizationMapper()),
entityLogEntry,
dossierEntity,
getAnalysisNumber(dossierId, fileId));
}
response.add(ManualAddResponse.builder().annotationId(recategorizationRequest.getAnnotationId()).commentId(commentId).entityLogEntry(entityLogEntry).build());
recategorizationPersistenceService.saveAndFlush(recategorizationEntity);
}
@ -322,32 +363,38 @@ public class ManualRedactionService {
List<ManualAddResponse> response = new ArrayList<>();
List<ManualResizeRedactionEntity> manualResizeRedactionEntities = new ArrayList<>();
EntityLog entityLog = entityLogService.getEntityLog(dossierId, fileId, includeUnprocessed);
List<ResizeRedactionRequest> requests = manualRedactionMapper.toResizeRedactionRequestList(resizeRedactionRequests, getEntityLogEntryConsumer(fileId), entityLog);
List<RequestEntryPair<ResizeRedactionRequest>> requests = manualRedactionMapper.toResizeRedactionRequestList(dossierId,
fileId,
resizeRedactionRequests,
getEntityLogEntryConsumer(fileId));
for (ResizeRedactionRequest resizeRedactionRequest : requests) {
for (RequestEntryPair<ResizeRedactionRequest> resizeRedactionRequestRequestEntryPair : requests) {
ResizeRedactionRequest resizeRedactionRequest = resizeRedactionRequestRequestEntryPair.getRequest();
EntityLogEntry entityLogEntry = resizeRedactionRequestRequestEntryPair.getEntityLogEntry();
Long commentId = null;
var resizeRedaction = resizeRedactionPersistenceService.insert(fileId, resizeRedactionRequest);
manualResizeRedactionEntities.add(resizeRedaction);
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());
commentId = commentService.addCommentAndGetId(fileId,
resizeRedactionRequest.getAnnotationId(),
resizeRedactionRequest.getComment(),
resizeRedactionRequest.getUser());
}
Set<String> typeIdsOfModifiedDictionaries = manualRedactionDictionaryUpdateHandler.updateDictionaryForResizeRedactions(dossierId,
fileId,
resizeRedaction,
getEntityLogEntry(entityLog,
resizeRedaction.getId()
.getAnnotationId()));
entityLogEntry);
resizeRedactionPersistenceService.updateModifiedDictionaries(resizeRedaction.getId().getFileId(),
resizeRedaction.getId().getAnnotationId(),
typeIdsOfModifiedDictionaries);
if (!resizeRedactionRequest.isAddToAllDossiers() && !resizeRedactionRequest.getUpdateDictionary()) {
entityLogMergeService.mergeResizeRedaction(MagicConverter.convert(resizeRedaction, ManualResizeRedaction.class, new ManualResizeRedactionMapper()), entityLogEntry, getAnalysisNumber(dossierId, fileId));
}
response.add(ManualAddResponse.builder().annotationId(resizeRedactionRequest.getAnnotationId()).commentId(commentId).entityLogEntry(entityLogEntry).build());
}
manualResizeRedactionEntities = manualResizeRedactionEntities.stream()
@ -393,16 +440,6 @@ public class ManualRedactionService {
}
private EntityLogEntry getEntityLogEntry(EntityLog entityLog, String annotationId) {
return entityLog.getEntityLogEntry()
.stream()
.filter(entry -> entry.getId().equals(annotationId))
.findFirst()
.orElseThrow(() -> new NotFoundException("Annotation does not exist in entity log."));
}
public ManualRedactions getManualRedactions(String fileId, ManualChangesQueryOptions options) {
return manualRedactionProviderService.getManualRedactions(fileId, options);
@ -558,4 +595,11 @@ public class ManualRedactionService {
rabbitTemplate.convertAndSend(MessagingConfiguration.REDACTION_PRIORITY_QUEUE, analyseRequest);
}
private int getAnalysisNumber(String dossierId, String fileId) {
Optional<Integer> analysisNumber = entityLogMongoService.findLatestAnalysisNumber(dossierId, fileId);
return analysisNumber.orElseThrow(() -> new BadRequestException("Can't load latest analysis number"));
}
}

4
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

@ -28,13 +28,13 @@ public class ForceRedactionPersistenceService {
private final ForceRedactionRepository forceRedactionRepository;
public void insert(String fileId, ForceRedactionRequest forceRedactionRequest) {
public ManualForceRedactionEntity insert(String fileId, ForceRedactionRequest forceRedactionRequest) {
ManualForceRedactionEntity manualForceRedaction = new ManualForceRedactionEntity();
manualForceRedaction.setId(new AnnotationEntityId(forceRedactionRequest.getAnnotationId(), fileId));
BeanUtils.copyProperties(forceRedactionRequest, manualForceRedaction);
manualForceRedaction.setRequestDate(OffsetDateTime.now());
forceRedactionRepository.saveAndFlush(manualForceRedaction);
return forceRedactionRepository.saveAndFlush(manualForceRedaction);
}

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

@ -52,7 +52,9 @@ import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogLegalBasis;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryState;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ManualRedactionType;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Position;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.ManualAddResponse;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.Rectangle;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dictionary.Dictionary;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.file.FileType;
@ -121,8 +123,6 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
private ManualRedactionService manualRedactionService;
@Test
public void testRemoveToDossierTemplateWithDossierDictionaryOnlyTrue() {
@ -155,14 +155,14 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
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();
@ -1588,6 +1588,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
0);
fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
entityLogMongoService.upsertEntityLog(file.getDossierId(), file.getFileId(), entityLog);
manualRedactionClient.forceRedactionBulk(dossier.getId(),
file.getId(),
@ -1701,7 +1702,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
manualRedactionClient.recategorizeBulk(dossier.getId(),
file.getId(),
Set.of(RecategorizationRequestModel.builder().annotationId("dv").legalBasis("").section("section").build()),
Set.of(RecategorizationRequestModel.builder().annotationId("dv").legalBasis("").section("section").type(type.getType()).build()),
false);
var allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false, true);
@ -1728,7 +1729,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
manualRedactionClient.recategorizeBulk(dossier.getId(),
file.getId(),
Set.of(RecategorizationRequestModel.builder().annotationId("dv2").legalBasis("").section("section").build()),
Set.of(RecategorizationRequestModel.builder().annotationId("dv2").legalBasis("").section("section").type(type.getType()).build()),
false);
allManualRedactions = manualRedactionClient.getManualRedactions(dossier.getId(), file.getId(), false, true);
@ -2141,6 +2142,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
.build();
var entityLog = new EntityLog(1, 1, List.of(entityLogEntry), null, 0, 0, 0, 0);
fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
entityLogMongoService.upsertEntityLog(file.getDossierId(), file.getFileId(), entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
var recategorizationRequestModel = RecategorizationRequestModel.builder()
@ -2189,6 +2191,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
.build();
var entityLog = new EntityLog(1, 1, List.of(entityLogEntry), null, 0, 0, 0, 0);
fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
entityLogMongoService.upsertEntityLog(file.getDossierId(), file.getFileId(), entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
var legalBasisChangeRequestModel = LegalBasisChangeRequestModel.builder()
@ -2235,6 +2238,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
.build();
var entityLog = new EntityLog(1, 1, List.of(entityLogEntry), null, 0, 0, 0, 0);
fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
entityLogMongoService.upsertEntityLog(file.getDossierId(), file.getFileId(), entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
var resizeRedactionRequestModel = ResizeRedactionRequestModel.builder()
@ -2282,6 +2286,7 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
.build();
var entityLog = new EntityLog(1, 1, List.of(entityLogEntry), null, 0, 0, 0, 0);
fileManagementStorageService.storeJSONObject(dossier.getId(), file.getId(), FileType.ENTITY_LOG, entityLog);
entityLogMongoService.upsertEntityLog(file.getDossierId(), file.getFileId(), entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
var forceRedactionRequestModel = ForceRedactionRequestModel.builder().annotationId("annotationId").build();
@ -2479,4 +2484,302 @@ public class ManualRedactionTest extends AbstractPersistenceServerServiceTest {
}
@Test
public void testLocalAdd() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
var type = typeProvider.testAndProvideType(dossierTemplate, "test", 100);
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)
.positions(List.of(new Position(10f, 10f ,10f, 10f, 1)))
.build()),
null,
0,
0,
0,
0);
fileManagementStorageService.saveEntityLog(dossier.getId(), file.getId(), entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
ManualAddResponse response = manualRedactionClient.addRedactionBulk(dossier.getId(),
file.getId(),
Set.of(AddRedactionRequestModel.builder()
.sourceId("")
.reason("Reason")
.type(type.getType())
.addToAllDossiers(false)
.addToDictionary(false)
.dictionaryEntryType(DictionaryEntryType.ENTRY)
.forceAddToDictionary(false)
.legalBasis("legalBasis")
.positions(List.of(new Rectangle(10f, 10f ,10f, 10f, 1)))
.value("MyValue")
.build()))
.get(0);
assertEquals(response.getEntityLogEntry().getId(), response.getAnnotationId());
assertEquals(response.getEntityLogEntry().getValue(), "MyValue");
assertEquals(response.getEntityLogEntry().getLegalBasis(), "legalBasis");
assertEquals(response.getEntityLogEntry().getReason(), "Reason");
assertEquals(response.getEntityLogEntry().getType(), type.getType());
assertEquals(response.getEntityLogEntry().getEntryType(), EntryType.ENTITY);
assertEquals(response.getEntityLogEntry().getManualChanges()
.get(0).getManualRedactionType(), ManualRedactionType.ADD);
assertNull(response.getEntityLogEntry().getManualChanges()
.get(0).getProcessedDate());
}
@Test
public void testLocalForce() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
var type = typeProvider.testAndProvideType(dossierTemplate, "test", 100);
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.SKIPPED)
.dictionaryEntry(true)
.positions(List.of(new Position(10f, 10f ,10f, 10f, 1)))
.build()),
null,
0,
0,
0,
0);
fileManagementStorageService.saveEntityLog(dossier.getId(), file.getId(), entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
ManualAddResponse response = manualRedactionClient.forceRedactionBulk(dossier.getId(),
file.getId(),
Set.of(ForceRedactionRequestModel.builder()
.annotationId("AnnotationId")
.legalBasis("legalBasis")
.build()))
.get(0);
assertEquals(response.getEntityLogEntry().getId(), "AnnotationId");
assertEquals(response.getEntityLogEntry().getLegalBasis(), "legalBasis");
assertEquals(response.getEntityLogEntry().getState(), EntryState.APPLIED);
assertEquals(response.getEntityLogEntry().getManualChanges()
.get(0).getManualRedactionType(), ManualRedactionType.FORCE);
assertNull(response.getEntityLogEntry().getManualChanges()
.get(0).getProcessedDate());
}
@Test
public void testLocalLegalBasisChange() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
var type = typeProvider.testAndProvideType(dossierTemplate, "test", 100);
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);
fileManagementStorageService.saveEntityLog(dossier.getId(), file.getId(), entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
ManualAddResponse response = manualRedactionClient.legalBasisChangeBulk(dossier.getId(),
file.getId(),
Set.of(LegalBasisChangeRequestModel.builder()
.annotationId("AnnotationId")
.legalBasis("new legal basis")
.value("Luke Skywalker")
.section("")
.build()))
.get(0);
assertEquals(response.getEntityLogEntry().getId(), "AnnotationId");
assertEquals(response.getEntityLogEntry().getLegalBasis(), "new legal basis");
assertEquals(response.getEntityLogEntry().getManualChanges()
.get(0).getManualRedactionType(), ManualRedactionType.LEGAL_BASIS_CHANGE);
assertNull(response.getEntityLogEntry().getManualChanges()
.get(0).getProcessedDate());
}
@Test
public void testLocalResize() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
var type = typeProvider.testAndProvideType(dossierTemplate, "test", 100);
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)
.positions(List.of(new Position(10f, 10f ,10f, 10f, 1)))
.build()),
null,
0,
0,
0,
0);
fileManagementStorageService.saveEntityLog(dossier.getId(), file.getId(), entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
ManualAddResponse response = manualRedactionClient.resizeRedactionBulk(dossier.getId(),
file.getId(),
Set.of(ResizeRedactionRequestModel.builder()
.annotationId("AnnotationId")
.updateDictionary(false)
.addToAllDossiers(false)
.value("Luke")
.positions(List.of(new Rectangle(5f, 5f, 5f ,5f ,1)))
.build()),
false)
.get(0);
assertEquals(response.getEntityLogEntry().getId(), "AnnotationId");
assertEquals(response.getEntityLogEntry().getValue(), "Luke");
assertEquals(response.getEntityLogEntry().getPositions().get(0).getRectangle()[0], 5f);
assertEquals(response.getEntityLogEntry().getPositions().get(0).getRectangle()[1], 5f);
assertEquals(response.getEntityLogEntry().getPositions().get(0).getRectangle()[2], 5f);
assertEquals(response.getEntityLogEntry().getPositions().get(0).getRectangle()[3], 5f);
assertEquals(response.getEntityLogEntry().getManualChanges()
.get(0).getManualRedactionType(), ManualRedactionType.RESIZE);
assertNull(response.getEntityLogEntry().getManualChanges()
.get(0).getProcessedDate());
}
@Test
public void testLocalRecategorize() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
var type = typeProvider.testAndProvideType(dossierTemplate, "test", 100);
var type2 = typeProvider.testAndProvideType(dossierTemplate, "test2", 101);
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);
fileManagementStorageService.saveEntityLog(dossier.getId(), file.getId(), entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
ManualAddResponse response = manualRedactionClient.recategorizeBulk(dossier.getId(),
file.getId(),
Set.of(RecategorizationRequestModel.builder()
.type(type2.getType())
.annotationId("AnnotationId")
.addToDictionary(false)
.addToAllDossiers(false)
.legalBasis("")
.section("section")
.value("Luke Skywalker")
.build()),
false)
.get(0);
assertEquals(response.getEntityLogEntry().getId(), "AnnotationId");
assertEquals(response.getEntityLogEntry().getType(), type2.getType());
assertEquals(response.getEntityLogEntry().getManualChanges()
.get(0).getManualRedactionType(), ManualRedactionType.RECATEGORIZE);
assertNull(response.getEntityLogEntry().getManualChanges()
.get(0).getProcessedDate());
}
@Test
public void testLocalRemove() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
var type = typeProvider.testAndProvideType(dossierTemplate);
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);
fileManagementStorageService.saveEntityLog(dossier.getId(), file.getId(), entityLog);
when(entityLogService.getEntityLog(any(), any(), anyBoolean())).thenReturn(entityLog);
ManualAddResponse response = manualRedactionClient.removeRedactionBulk(dossier.getId(),
file.getId(),
Set.of(RemoveRedactionRequestModel.builder()
.annotationId("AnnotationId")
.removeFromDictionary(false)
.removeFromAllDossiers(false)
.build()),
false)
.get(0);
assertEquals(response.getEntityLogEntry().getId(), "AnnotationId");
assertEquals(response.getEntityLogEntry().getState(), EntryState.IGNORED);
assertEquals(response.getEntityLogEntry().getManualChanges()
.get(0).getManualRedactionType(), ManualRedactionType.REMOVE);
assertNull(response.getEntityLogEntry().getManualChanges()
.get(0).getProcessedDate());
}
}

19
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/RequestEntryPair.java Normal file
View File

@ -0,0 +1,19 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RequestEntryPair<T> {
private T request;
private EntityLogEntry entityLogEntry;
}

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

@ -1,5 +1,7 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.annotations;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntityLogEntry;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
@ -13,5 +15,6 @@ public class ManualAddResponse {
private String annotationId;
private Long commentId;
private EntityLogEntry entityLogEntry;
}

8
persistence-service-v1/persistence-service-shared-mongo-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/mongo/repository/EntityLogEntryDocumentRepository.java
View File

@ -2,6 +2,7 @@ package com.iqser.red.service.persistence.service.v1.api.shared.mongo.repository
import java.util.Collection;
import java.util.List;
import java.util.Optional;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.data.mongodb.repository.Query;
@ -43,13 +44,16 @@ public interface EntityLogEntryDocumentRepository extends MongoRepository<Entity
@Query("{'entityLogId' : ?0, 'positions': { $elemMatch: { 'pageNumber': { $in: ?1 } } } }")
List<EntityLogEntryDocument> findByEntityLogIdAndPositionsPageNumberIn(String entityLogId, List<Integer> pageNumbers);
@Query(value = "{ 'entityLogId': ?0, 'type': { '$nin': ?1 } }")
List<EntityLogEntryDocument> findEntityLogDocumentByIdAndExcludedTypes(String entityLogId, List<String> excludedTypes);
@Query(value = "{ 'entityLogId': ?0, 'entryId': ?1 }")
Optional<EntityLogEntryDocument> findEntityLogEntryDocumentByEntryId(String entityLogId, String entryId);
@Query(value = "{ 'entityLogId' : ?0}", delete = true)
void deleteByEntityLogId(String entityLogId);
}

7
persistence-service-v1/persistence-service-shared-mongo-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/mongo/service/EntityLogMongoService.java
View File

@ -181,6 +181,13 @@ public class EntityLogMongoService {
}
public Optional<EntityLogEntry> findEntityLogEntryById(String dossierId, String fileId, String annotationId) {
return entityLogEntryDocumentRepository.findEntityLogEntryDocumentByEntryId(mapper.getLogId(dossierId, fileId), annotationId)
.map(mapper::fromLogEntryDocument);
}
public boolean entityLogDocumentExists(String dossierId, String fileId) {
return entityLogDocumentRepository.existsById(mapper.getLogId(dossierId, fileId));