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

Merge branch 'REVERT-RED-7237' into 'master'

Browse Source 
Revert "RED-7237 - Change to group annotation"

Closes RED-7237

See merge request redactmanager/persistence-service!708
This commit is contained in:
Maverick Studer 2024-08-29 09:24:00 +02:00
commit 0cc48f8dfd
63 changed files with 38 additions and 3007 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,298 +0,0 @@
package com.iqser.red.persistence.service.v1.external.api.impl.controller;
import java.util.List;
import java.util.Map;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import com.iqser.red.service.persistence.management.v1.processor.service.AccessControlService;
import com.iqser.red.service.persistence.management.v1.processor.service.group.GroupAnnotationService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.AuditPersistenceService;
import com.iqser.red.service.persistence.service.v1.api.external.resource.GroupAnnotationResource;
import com.iqser.red.service.persistence.service.v1.api.shared.model.AuditCategory;
import com.iqser.red.service.persistence.service.v1.api.shared.model.audit.AuditRequest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.AddAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.AddTextGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ChangePageRangeAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ChangeValueAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotation;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationResponse;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.RecategorizeGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ResizeAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.UpdateLegalBasisRequestModel;
import com.knecon.fforesight.keycloakcommons.security.KeycloakSecurity;
import jakarta.validation.Valid;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import lombok.experimental.FieldDefaults;
@RestController
@RequiredArgsConstructor
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
public class GroupAnnotationController implements GroupAnnotationResource {
static String GROUP_IDS = "groupIds";
AuditPersistenceService auditPersistenceService;
AccessControlService accessControlService;
GroupAnnotationService groupAnnotationService;
@Override
public GroupAnnotationResponse addTextGroupAnnotation(String dossierId, String fileId, @Valid @RequestBody List<AddTextGroupAnnotationRequestModel> addTextGroupAnnotationRequestModels) {
accessControlService.checkAccessPermissionsToDossier(dossierId);
accessControlService.verifyFileIsNotApproved(dossierId, fileId);
accessControlService.verifyUserIsMemberOrApprover(dossierId);
GroupAnnotationResponse groupAnnotationResponse = groupAnnotationService.addTextGroupAnnotation(dossierId, fileId, addTextGroupAnnotationRequestModels);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(fileId)
.category(AuditCategory.DOCUMENT.name())
.message("Group annotations were added")
.details(Map.of(DOSSIER_ID,
dossierId,
FILE_ID,
fileId,
GROUP_IDS,
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getGroupId)
.toList()))
.build());
return groupAnnotationResponse;
}
@Override
public GroupAnnotationResponse addAreaGroupAnnotation(String dossierId, String fileId, List<AddAreaGroupAnnotationRequestModel> addAreaGroupAnnotationRequestModels) {
accessControlService.checkAccessPermissionsToDossier(dossierId);
accessControlService.verifyFileIsNotApproved(dossierId, fileId);
accessControlService.verifyUserIsMemberOrApprover(dossierId);
GroupAnnotationResponse groupAnnotationResponse = groupAnnotationService.addAreaGroupAnnotation(dossierId, fileId, addAreaGroupAnnotationRequestModels);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(fileId)
.category(AuditCategory.DOCUMENT.name())
.message("Group annotations were added")
.details(Map.of(DOSSIER_ID,
dossierId,
FILE_ID,
fileId,
GROUP_IDS,
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getGroupId)
.toList()))
.build());
return groupAnnotationResponse;
}
@Override
public GroupAnnotationResponse getGroupAnnotations(String dossierId, String fileId, boolean includeSoftDeleted) {
return groupAnnotationService.getAllGroupAnnotations(fileId, includeSoftDeleted);
}
@Override
public GroupAnnotation getGroupAnnotation(String dossierId, String fileId, String groupId) {
return groupAnnotationService.getGroupAnnotation(groupId);
}
@Override
public GroupAnnotationResponse updateLegalBasis(String dossierId, String fileId, List<UpdateLegalBasisRequestModel> annotationRequestModels) {
GroupAnnotationResponse groupAnnotationResponse = groupAnnotationService.updateLegalBasis(dossierId, fileId, annotationRequestModels);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(fileId)
.category(AuditCategory.DOCUMENT.name())
.message("Group annotations legal basis was modified.")
.details(Map.of(DOSSIER_ID,
dossierId,
FILE_ID,
fileId,
GROUP_IDS,
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getGroupId)
.toList(),
"legalBasis",
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getLegalBasis)
.toList()))
.build());
return groupAnnotationResponse;
}
@Override
public GroupAnnotationResponse recategorizeGroupAnnotation(String dossierId,
String fileId,
List<RecategorizeGroupAnnotationRequestModel> annotationRequestModels) {
GroupAnnotationResponse groupAnnotationResponse = groupAnnotationService.recategorizeGroupAnnotation(dossierId, fileId, annotationRequestModels);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(fileId)
.category(AuditCategory.DOCUMENT.name())
.message("Group annotations type was modified.")
.details(Map.of(DOSSIER_ID,
dossierId,
FILE_ID,
fileId,
GROUP_IDS,
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getGroupId)
.toList(),
"type",
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getTypeId)
.toList()))
.build());
return groupAnnotationResponse;
}
@Override
public GroupAnnotationResponse forceGroupAnnotation(String dossierId, String fileId, List<GroupAnnotationRequestModel> groupAnnotationRequestModels) {
GroupAnnotationResponse groupAnnotationResponse = groupAnnotationService.forceGroupAnnotation(dossierId, fileId, groupAnnotationRequestModels);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(fileId)
.category(AuditCategory.DOCUMENT.name())
.message("Group annotations forced.")
.details(Map.of(DOSSIER_ID,
dossierId,
FILE_ID,
fileId,
GROUP_IDS,
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getGroupId)
.toList()))
.build());
return groupAnnotationResponse;
}
@Override
public GroupAnnotationResponse resizeGroupAnnotation(String dossierId, String fileId, List<ResizeAreaGroupAnnotationRequestModel> resizeAreaGroupAnnotationRequestModels) {
GroupAnnotationResponse groupAnnotationResponse = groupAnnotationService.resizeAreaGroupAnnotation(dossierId, fileId, resizeAreaGroupAnnotationRequestModels);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(fileId)
.category(AuditCategory.DOCUMENT.name())
.message("Area Group annotations positions were modified.")
.details(Map.of(DOSSIER_ID,
dossierId,
FILE_ID,
fileId,
GROUP_IDS,
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getGroupId)
.toList()))
.build());
return groupAnnotationResponse;
}
@Override
public GroupAnnotationResponse changeValueGroupAnnotation(String dossierId, String fileId, List<ChangeValueAreaGroupAnnotationRequestModel> changeValueAreaGroupAnnotationRequestModels) {
GroupAnnotationResponse groupAnnotationResponse = groupAnnotationService.changeValueGroupAnnotation(dossierId, fileId, changeValueAreaGroupAnnotationRequestModels);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(fileId)
.category(AuditCategory.DOCUMENT.name())
.message("Area Group annotations value was modified.")
.details(Map.of(DOSSIER_ID,
dossierId,
FILE_ID,
fileId,
GROUP_IDS,
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getGroupId)
.toList()))
.build());
return groupAnnotationResponse;
}
@Override
public GroupAnnotationResponse changePageRangeGroupAnnotation(String dossierId, String fileId, List<ChangePageRangeAreaGroupAnnotationRequestModel> changePageRangeAreaGroupAnnotationRequestModels) {
GroupAnnotationResponse groupAnnotationResponse = groupAnnotationService.changePageRangesGroupAnnotation(dossierId, fileId, changePageRangeAreaGroupAnnotationRequestModels);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(fileId)
.category(AuditCategory.DOCUMENT.name())
.message("Area Group annotations page ranges were modified.")
.details(Map.of(DOSSIER_ID,
dossierId,
FILE_ID,
fileId,
GROUP_IDS,
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getGroupId)
.toList()))
.build());
return groupAnnotationResponse;
}
@Override
public void removeGroupAnnotation(String dossierId, String fileId, List<GroupAnnotationRequestModel> groupAnnotationRequestModelList) {
GroupAnnotationResponse groupAnnotationResponse = groupAnnotationService.removeGroupAnnotation(dossierId, fileId, groupAnnotationRequestModelList);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(fileId)
.category(AuditCategory.DOCUMENT.name())
.message("Group annotations were removed.")
.details(Map.of(DOSSIER_ID,
dossierId,
FILE_ID,
fileId,
GROUP_IDS,
groupAnnotationResponse.getGroupAnnotations()
.stream()
.map(GroupAnnotation::getGroupId)
.toList()))
.build());
}
}

174
persistence-service-v1/persistence-service-external-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/external/resource/GroupAnnotationResource.java vendored
View File

@ -1,174 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.external.resource;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.AddAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.AddTextGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ChangePageRangeAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ChangeValueAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotation;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationResponse;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.RecategorizeGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ResizeAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.UpdateLegalBasisRequestModel;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.responses.ApiResponse;
import io.swagger.v3.oas.annotations.responses.ApiResponses;
import jakarta.validation.Valid;
public interface GroupAnnotationResource {
String GROUP_ANNOTATION_REST_PATH = ExternalApi.BASE_PATH + "/group";
String TEXT_GROUP_ANNOTATION_REST_PATH = GROUP_ANNOTATION_REST_PATH + "/text";
String AREA_GROUP_ANNOTATION_REST_PATH = GROUP_ANNOTATION_REST_PATH + "/area";
String DOSSIER_ID = "dossierId";
String DOSSIER_ID_PATH_PARAM = "/{" + DOSSIER_ID + "}";
String FILE_ID = "fileId";
String FILE_ID_PATH_VARIABLE = "/{" + FILE_ID + "}";
String INCLUDE_SOFT_DELETED_PARAM = "includeSoftDeleted";
String GROUP_ID = "groupId";
String GROUP_ID_PATH_VARIABLE = "/{" + GROUP_ID + "}";
@ResponseStatus(value = HttpStatus.OK)
@PostMapping(value = TEXT_GROUP_ANNOTATION_REST_PATH
+ "/add"
+ DOSSIER_ID_PATH_PARAM
+ FILE_ID_PATH_VARIABLE, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Adds a list of text group annotations", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found"), @ApiResponse(responseCode = "403", description = "Forbidden")})
GroupAnnotationResponse addTextGroupAnnotation(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@Valid @RequestBody List<AddTextGroupAnnotationRequestModel> addTextGroupAnnotationRequestModels);
@ResponseStatus(value = HttpStatus.OK)
@PostMapping(value = AREA_GROUP_ANNOTATION_REST_PATH
+ "/add"
+ DOSSIER_ID_PATH_PARAM
+ FILE_ID_PATH_VARIABLE, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Adds a list of area group annotations", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found"), @ApiResponse(responseCode = "403", description = "Forbidden")})
GroupAnnotationResponse addAreaGroupAnnotation(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@Valid @RequestBody List<AddAreaGroupAnnotationRequestModel> addAreaGroupAnnotationRequestModels);
@ResponseStatus(value = HttpStatus.OK)
@GetMapping(value = GROUP_ANNOTATION_REST_PATH + DOSSIER_ID_PATH_PARAM + FILE_ID_PATH_VARIABLE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Returns all the group annotations", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found")})
GroupAnnotationResponse getGroupAnnotations(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@RequestParam(name = INCLUDE_SOFT_DELETED_PARAM, defaultValue = "false", required = false) boolean includeSoftDeleted);
@ResponseStatus(value = HttpStatus.OK)
@GetMapping(value = GROUP_ANNOTATION_REST_PATH + DOSSIER_ID_PATH_PARAM + FILE_ID_PATH_VARIABLE + GROUP_ID_PATH_VARIABLE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Returns a specific group annotation", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found")})
GroupAnnotation getGroupAnnotation(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@PathVariable(GROUP_ID) String groupId);
@ResponseStatus(value = HttpStatus.OK)
@PostMapping(value = GROUP_ANNOTATION_REST_PATH
+ "/updateLegalBasis"
+ DOSSIER_ID_PATH_PARAM
+ FILE_ID_PATH_VARIABLE, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Update the legal basis of a list of group annotations", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found"), @ApiResponse(responseCode = "403", description = "Forbidden")})
GroupAnnotationResponse updateLegalBasis(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@RequestBody List<UpdateLegalBasisRequestModel> updateLegalBasisRequestModels);
@ResponseStatus(value = HttpStatus.OK)
@PostMapping(value = GROUP_ANNOTATION_REST_PATH
+ "/recategorize"
+ DOSSIER_ID_PATH_PARAM
+ FILE_ID_PATH_VARIABLE, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Update the type of a list of group annotations", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found"), @ApiResponse(responseCode = "403", description = "Forbidden")})
GroupAnnotationResponse recategorizeGroupAnnotation(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@RequestBody List<RecategorizeGroupAnnotationRequestModel> recategorizeGroupAnnotationRequestModels);
@ResponseStatus(value = HttpStatus.OK)
@PostMapping(value = GROUP_ANNOTATION_REST_PATH
+ "/force"
+ DOSSIER_ID_PATH_PARAM
+ FILE_ID_PATH_VARIABLE, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Force of a list of group annotations", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found"), @ApiResponse(responseCode = "403", description = "Forbidden")})
GroupAnnotationResponse forceGroupAnnotation(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@RequestBody List<GroupAnnotationRequestModel> groupAnnotationRequestModels);
@ResponseStatus(value = HttpStatus.OK)
@PostMapping(value = AREA_GROUP_ANNOTATION_REST_PATH
+ "/resize"
+ DOSSIER_ID_PATH_PARAM
+ FILE_ID_PATH_VARIABLE, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Resize a list of area group annotations", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found"), @ApiResponse(responseCode = "403", description = "Forbidden")})
GroupAnnotationResponse resizeGroupAnnotation(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@RequestBody List<ResizeAreaGroupAnnotationRequestModel> resizeAreaGroupAnnotationRequestModels);
@ResponseStatus(value = HttpStatus.OK)
@PostMapping(value = AREA_GROUP_ANNOTATION_REST_PATH
+ "/change/value"
+ DOSSIER_ID_PATH_PARAM
+ FILE_ID_PATH_VARIABLE, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Change the value for a list of area group annotations", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found"), @ApiResponse(responseCode = "403", description = "Forbidden")})
GroupAnnotationResponse changeValueGroupAnnotation(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@RequestBody List<ChangeValueAreaGroupAnnotationRequestModel> changeValueAreaGroupAnnotationRequestModels);
@ResponseStatus(value = HttpStatus.OK)
@PostMapping(value = AREA_GROUP_ANNOTATION_REST_PATH
+ "/change/pageRange"
+ DOSSIER_ID_PATH_PARAM
+ FILE_ID_PATH_VARIABLE, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Change the page range for a list of area group annotations", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found"), @ApiResponse(responseCode = "403", description = "Forbidden")})
GroupAnnotationResponse changePageRangeGroupAnnotation(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@RequestBody List<ChangePageRangeAreaGroupAnnotationRequestModel> changePageRangeAreaGroupAnnotationRequestModels);
@ResponseStatus(value = HttpStatus.OK)
@PostMapping(value = GROUP_ANNOTATION_REST_PATH
+ "/remove"
+ DOSSIER_ID_PATH_PARAM
+ FILE_ID_PATH_VARIABLE, consumes = MediaType.APPLICATION_JSON_VALUE, produces = MediaType.APPLICATION_JSON_VALUE)
@Operation(summary = "Remove of a list of group annotations", description = "None")
@ApiResponses(value = {@ApiResponse(responseCode = "200", description = "OK"), @ApiResponse(responseCode = "404", description = "Dossier or file not found"), @ApiResponse(responseCode = "403", description = "Forbidden")})
void removeGroupAnnotation(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@RequestBody List<GroupAnnotationRequestModel> groupAnnotationRequestModelList);
}

32
persistence-service-v1/persistence-service-internal-api-impl-v1/src/main/java/com/iqser/red/service/persistence/v1/internal/api/controller/DictionaryInternalController.java
View File

@ -52,6 +52,22 @@ public class DictionaryInternalController implements DictionaryResource {
}
private void setEntriesForTypes(Long fromVersion, List<Type> targets) {
targets.forEach(target -> {
setEntriesForType(target.getTypeId(), target, fromVersion != null ? fromVersion : -1);
});
}
private void setEntriesForType(String typeId, Type target, Long fromVersion) {
target.setEntries(convert(entryPersistenceService.getEntries(typeId, DictionaryEntryType.ENTRY, fromVersion), DictionaryEntry.class));
target.setFalsePositiveEntries(convert(entryPersistenceService.getEntries(typeId, DictionaryEntryType.FALSE_POSITIVE, fromVersion), DictionaryEntry.class));
target.setFalseRecommendationEntries(convert(entryPersistenceService.getEntries(typeId, DictionaryEntryType.FALSE_RECOMMENDATION, fromVersion), DictionaryEntry.class));
}
@Override
public Type getDictionaryForType(@PathVariable(TYPE_PARAMETER_NAME) String typeId, @RequestParam(value = FROM_VERSION_PARAM, required = false) Long fromVersion) {
@ -82,20 +98,4 @@ public class DictionaryInternalController implements DictionaryResource {
return convert(colorsService.getColors(dossierTemplateId), Colors.class);
}
private void setEntriesForTypes(Long fromVersion, List<Type> targets) {
targets.forEach(target -> {
setEntriesForType(target.getTypeId(), target, fromVersion != null ? fromVersion : -1);
});
}
private void setEntriesForType(String typeId, Type target, Long fromVersion) {
target.setEntries(convert(entryPersistenceService.getEntries(typeId, DictionaryEntryType.ENTRY, fromVersion), DictionaryEntry.class));
target.setFalsePositiveEntries(convert(entryPersistenceService.getEntries(typeId, DictionaryEntryType.FALSE_POSITIVE, fromVersion), DictionaryEntry.class));
target.setFalseRecommendationEntries(convert(entryPersistenceService.getEntries(typeId, DictionaryEntryType.FALSE_RECOMMENDATION, fromVersion), DictionaryEntry.class));
}
}

29
persistence-service-v1/persistence-service-internal-api-impl-v1/src/main/java/com/iqser/red/service/persistence/v1/internal/api/controller/GroupAnnotationInternalController.java
View File

@ -1,29 +0,0 @@
package com.iqser.red.service.persistence.v1.internal.api.controller;
import org.springframework.web.bind.annotation.RestController;
import com.iqser.red.service.persistence.management.v1.processor.service.group.GroupAnnotationService;
import com.iqser.red.service.persistence.service.v1.api.internal.resources.GroupAnnotationResource;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationInternalResponse;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import lombok.experimental.FieldDefaults;
import lombok.extern.slf4j.Slf4j;
@RestController
@RequiredArgsConstructor
@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
@Slf4j
public class GroupAnnotationInternalController implements GroupAnnotationResource {
GroupAnnotationService groupAnnotationService;
@Override
public GroupAnnotationInternalResponse getGroupAnnotations(String dossierId, String fileId, boolean includeSoftDeleted) {
return groupAnnotationService.getAllGroupAnnotationsInternal(fileId, includeSoftDeleted);
}
}

11
persistence-service-v1/persistence-service-internal-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/internal/resources/DictionaryResource.java
View File

@ -1,7 +1,5 @@
package com.iqser.red.service.persistence.service.v1.api.internal.resources;
import static com.iqser.red.service.persistence.service.v1.api.internal.resources.GroupAnnotationResource.INCLUDE_SOFT_DELETED_PARAM;
import java.util.List;
import org.springframework.http.HttpStatus;
@ -14,7 +12,6 @@ import org.springframework.web.bind.annotation.ResponseStatus;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.configuration.Colors;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.type.Type;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationResponse;
@ResponseStatus(value = HttpStatus.OK)
public interface DictionaryResource {
@ -38,14 +35,6 @@ public interface DictionaryResource {
String COLOR_PATH = "/color";
String VERSION_PATH = "/version";
String GROUP_REDACTION_REST_PATH = "/group";
String DOSSIER_ID = "dossierId";
String DOSSIER_ID_PATH_PARAM = "/{" + DOSSIER_ID + "}";
String FILE_ID = "fileId";
String FILE_ID_PATH_VARIABLE = "/{" + FILE_ID + "}";
@GetMapping(value = InternalApi.BASE_PATH + TYPE_PATH + DOSSIER_TEMPLATE_PATH_VARIABLE, produces = MediaType.APPLICATION_JSON_VALUE)
List<Type> getAllTypesForDossierTemplate(@PathVariable(DOSSIER_TEMPLATE_PARAMETER_NAME) String dossierTemplateId,

31
persistence-service-v1/persistence-service-internal-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/internal/resources/GroupAnnotationResource.java
View File

@ -1,31 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.internal.resources;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseStatus;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationInternalResponse;
@ResponseStatus(value = HttpStatus.OK)
public interface GroupAnnotationResource {
String GROUP_ANNOTATION_REST_PATH = "/group";
String DOSSIER_ID = "dossierId";
String DOSSIER_ID_PATH_PARAM = "/{" + DOSSIER_ID + "}";
String FILE_ID = "fileId";
String FILE_ID_PATH_VARIABLE = "/{" + FILE_ID + "}";
String INCLUDE_SOFT_DELETED_PARAM = "includeSoftDeleted";
@GetMapping(value = InternalApi.BASE_PATH + GROUP_ANNOTATION_REST_PATH + DOSSIER_ID_PATH_PARAM + FILE_ID_PATH_VARIABLE, produces = MediaType.APPLICATION_JSON_VALUE)
GroupAnnotationInternalResponse getGroupAnnotations(@PathVariable(DOSSIER_ID) String dossierId,
@PathVariable(FILE_ID) String fileId,
@RequestParam(name = INCLUDE_SOFT_DELETED_PARAM, defaultValue = "false", required = false) boolean includeSoftDeleted);
}

2
persistence-service-v1/persistence-service-processor-v1/build.gradle.kts
View File

@ -69,8 +69,6 @@ dependencies {
api("org.springframework.cloud:spring-cloud-starter-openfeign:${springCloudVersion}")
api("commons-validator:commons-validator:1.7")
api("com.opencsv:opencsv:5.9")
api("com.vladmihalcea:hibernate-types-60:2.21.1")
api("org.hibernate.orm:hibernate-core:6.5.2.Final")
implementation("org.mapstruct:mapstruct:1.5.5.Final")
annotationProcessor("org.mapstruct:mapstruct-processor:1.5.5.Final")

33
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/group/AreaGroupEntity.java
View File

@ -1,33 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.entity.group;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonManagedReference;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.OneToMany;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
@Data
@Entity
@DiscriminatorValue("area")
@AllArgsConstructor
@NoArgsConstructor
@SuperBuilder
public class AreaGroupEntity extends GroupAnnotationEntity {
@OneToMany(mappedBy = "areaGroup", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
@JsonManagedReference
private List<PageRangeEntity> pageRanges;
@Column(name = "section")
private String section;
}

8
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/group/ChangeType.java
View File

@ -1,8 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.entity.group;
public enum ChangeType {
REMOVE,
RECATEGORIZE,
LEGAL_BASIS_CHANGE
}

80
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/group/GroupAnnotationEntity.java
View File

@ -1,80 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.entity.group;
import java.time.OffsetDateTime;
import java.util.ArrayList;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonManagedReference;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.DiscriminatorColumn;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.Inheritance;
import jakarta.persistence.InheritanceType;
import jakarta.persistence.OneToMany;
import jakarta.persistence.OneToOne;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
@Data
@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "group_type")
@Table(name = "group_redaction")
@NoArgsConstructor
@AllArgsConstructor
@SuperBuilder
public class GroupAnnotationEntity {
@Id
@Column(name = "group_id", nullable = false, length = 36)
private String groupId;
@Column(name = "file_id")
private String fileId;
@Column(name = "type_id")
private String typeId;
@Column(name = "value", length = 4000)
private String value;
@Column(name = "legal_basis")
private String legalBasis;
@Enumerated(EnumType.STRING)
@Column(name = "entry_type")
private EntryType entryType;
@Column(name = "user_id")
private String userId;
@Column(name = "request_date")
private OffsetDateTime requestDate;
@Column(name = "processed_date")
private OffsetDateTime processedDate;
@Column(name = "soft_deleted_time")
private OffsetDateTime softDeletedTime;
@Builder.Default
@OneToMany(mappedBy = "group", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
@JsonManagedReference
private List<GroupChangeEntity> groupChanges = new ArrayList<>();
@OneToOne(mappedBy = "groupAnnotation", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
@JsonManagedReference
private PositionOnPageEntity positionsOnPage;
}

59
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/group/GroupChangeEntity.java
View File

@ -1,59 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.entity.group;
import java.time.OffsetDateTime;
import java.util.ArrayList;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonBackReference;
import com.fasterxml.jackson.annotation.JsonManagedReference;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupChangeType;
import jakarta.persistence.CascadeType;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Entity
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "group_change")
public class GroupChangeEntity {
@Id
@Column(name = "change_id", nullable = false, length = 36)
private String changeId;
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "group_id", nullable = false)
@JsonBackReference
private GroupAnnotationEntity group;
@Column(name = "user_id", nullable = false)
private String userId;
@Column(name = "change_date", nullable = false)
private OffsetDateTime changeDate;
@Column(name = "change_type", nullable = false)
@Enumerated(EnumType.STRING)
private GroupChangeType changeType;
@Builder.Default
@OneToMany(mappedBy = "groupChange", cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
@JsonManagedReference
private List<PropertyChangeEntity> propertyChanges = new ArrayList<>();
}

52
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/group/PageRangeEntity.java
View File

@ -1,52 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.entity.group;
import java.util.UUID;
import com.fasterxml.jackson.annotation.JsonBackReference;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.PrePersist;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Entity
@Builder
@NoArgsConstructor
@AllArgsConstructor
@Table(name = "area_group_page_range")
public class PageRangeEntity {
@Id
@Column(name = "page_range_id", nullable = false, length = 36)
private String pageRangeId;
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "group_id", nullable = false)
@JsonBackReference
private AreaGroupEntity areaGroup;
@Column(name = "start_page", nullable = false)
private int startPage;
@Column(name = "end_page", nullable = false)
private int endPage;
@PrePersist
public void initializeUUID() {
if (this.pageRangeId == null) {
this.pageRangeId = UUID.randomUUID().toString();
}
}
}

60
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/group/PositionOnPageEntity.java
View File

@ -1,60 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.entity.group;
import java.util.UUID;
import com.fasterxml.jackson.annotation.JsonBackReference;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.OneToOne;
import jakarta.persistence.PrePersist;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Entity
@Builder
@AllArgsConstructor
@NoArgsConstructor
@Table(name = "area_group_position")
public class PositionOnPageEntity {
@Id
@Column(name = "position_id", nullable = false, length = 36)
private String positionId;
@OneToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "group_id", nullable = false)
@JsonBackReference
private GroupAnnotationEntity groupAnnotation;
@Column(name = "x", nullable = false)
private float x;
@Column(name = "y", nullable = false)
private float y;
@Column(name = "width", nullable = false)
private float width;
@Column(name = "height", nullable = false)
private float height;
@Column(name = "page_number", nullable = false)
private int pageNumber;
@PrePersist
public void initializeUUID() {
if (this.positionId == null) {
this.positionId = UUID.randomUUID().toString();
}
}
}

44
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/group/PropertyChangeEntity.java
View File

@ -1,44 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.entity.group;
import com.fasterxml.jackson.annotation.JsonBackReference;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.FetchType;
import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.Table;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Entity
@Table(name = "property_change")
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class PropertyChangeEntity {
@Id
@Column(name = "property_change_id", nullable = false, length = 36)
private String propertyChangeId;
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "change_id", nullable = false)
@JsonBackReference
private GroupChangeEntity groupChange;
@Column(name = "property_name", nullable = false)
private String propertyName;
@Column(name = "property_old_value", nullable = false)
private String propertyOldValue;
@Column(name = "property_new_value", nullable = false)
private String propertyNewValue;
}

16
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/group/TextGroupEntity.java
View File

@ -1,16 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.entity.group;
import jakarta.persistence.DiscriminatorValue;
import jakarta.persistence.Entity;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.experimental.SuperBuilder;
@Data
@Entity
@DiscriminatorValue("text")
@AllArgsConstructor
@SuperBuilder
public class TextGroupEntity extends GroupAnnotationEntity {
}

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

@ -24,11 +24,9 @@ import org.springframework.stereotype.Service;
import com.iqser.red.service.persistence.management.v1.processor.entity.configuration.TypeEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.DossierEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupAnnotationEntity;
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.manualredactions.PendingDictionaryEntryFactory;
import com.iqser.red.service.persistence.management.v1.processor.service.manualredactions.PendingGroupAnnotationFactory;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DictionaryPersistenceService;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.Change;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.ChangeType;
@ -71,11 +69,10 @@ public class EntityLogMergeService {
DictionaryPersistenceService dictionaryPersistenceService;
PendingDictionaryEntryFactory pendingDictionaryEntryFactory;
EntityLogMongoService entityLogMongoService;
PendingGroupAnnotationFactory pendingGroupAnnotationFactory;
@Observed(name = "EntityLogMergeService", contextualName = "merge-entity-log")
public EntityLog mergeEntityLog(ManualRedactions unprocessedManualRedactions, EntityLog entityLog, DossierEntity dossier, List<GroupAnnotationEntity> unprocessedGroupAnnotations) {
public EntityLog mergeEntityLog(ManualRedactions unprocessedManualRedactions, EntityLog entityLog, DossierEntity dossier) {
final int analysisNumber = entityLog.getAnalysisNumber();
@ -83,7 +80,7 @@ public class EntityLogMergeService {
List<EntityLogEntry> entityLogEntries = new LinkedList<>(entityLog.getEntityLogEntry());
merge(unprocessedManualRedactions, entityLog.getEntityLogEntry(), dossier, analysisNumber, entityLogEntries, allManualChanges, unprocessedGroupAnnotations);
merge(unprocessedManualRedactions, entityLog.getEntityLogEntry(), dossier, analysisNumber, entityLogEntries, allManualChanges);
entityLog.setEntityLogEntry(entityLogEntries);
return entityLog;
@ -100,7 +97,7 @@ public class EntityLogMergeService {
List<EntityLogEntry> entityLogEntries = entityLogMongoService.findEntityLogEntriesByIds(dossier.getId(), fileId, entityLogEntryIds);
merge(unprocessedManualRedactions, entityLogEntries, dossier, analysisNumber, entityLogEntries, allManualChanges, Collections.emptyList());
merge(unprocessedManualRedactions, entityLogEntries, dossier, analysisNumber, entityLogEntries, allManualChanges);
return entityLogEntries;
}
@ -111,28 +108,19 @@ public class EntityLogMergeService {
DossierEntity dossier,
int analysisNumber,
List<EntityLogEntry> entityLogEntries,
Map<String, List<BaseAnnotation>> allManualChanges,
List<GroupAnnotationEntity> unprocessedGroupAnnotations) {
Map<String, List<BaseAnnotation>> allManualChanges) {
Map<String, String> trackLocalChangesBasedOnDictEntriesMap = new HashMap<>();
Map<String, EntityLogEntry> addedLocalManualEntries = buildUnprocessedLocalManualRedactions(unprocessedManualRedactions, entityLog, dossier, analysisNumber)//
.collect(Collectors.toMap(EntityLogEntry::getId, Function.identity()));
entityLogEntries.addAll(addedLocalManualEntries.values());
buildPendingDictionaryChanges(unprocessedManualRedactions).forEach(entityLogEntries::add);
buildGroupAnnotations(unprocessedGroupAnnotations).forEach(entityLogEntries::add);
processEntityLogEntries(dossier, entityLogEntries, addedLocalManualEntries, analysisNumber, allManualChanges, trackLocalChangesBasedOnDictEntriesMap);
adjustEntityLogEntriesAfterLocalChangesBasedOnDict(entityLogEntries, trackLocalChangesBasedOnDictEntriesMap, analysisNumber);
}
private Stream<EntityLogEntry> buildGroupAnnotations(List<GroupAnnotationEntity> unprocessedGroupAnnotations) {
return unprocessedGroupAnnotations.stream()
.map(pendingGroupAnnotationFactory::buildGroupAnnotationEntry);
}
private void adjustEntityLogEntriesAfterLocalChangesBasedOnDict(List<EntityLogEntry> entityLogEntries,
Map<String, String> trackLocalChangesBasedOnDictEntriesMap,
int analysisNumber) {

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

@ -37,12 +37,7 @@ public class EntityLogMongoWrapperService {
if (includeUnprocessed) {
DossierEntity dossier = dossierService.getDossierById(dossierId);
ManualRedactions unprocessedManualRedactions = manualRedactionProviderService.getManualRedactions(fileId, ManualChangesQueryOptions.unprocessedOnlyForIds(ids));
entityLogEntries = entityLogMergeService.mergeEntityLogEntries(unprocessedManualRedactions,
entityLogEntries.stream()
.map(EntityLogEntry::getId)
.toList(),
dossier,
fileId);
entityLogEntries = entityLogMergeService.mergeEntityLogEntries(unprocessedManualRedactions, entityLogEntries.stream().map(EntityLogEntry::getId).toList(), dossier, fileId);
}
return entityLogEntries;
}
@ -52,5 +47,4 @@ public class EntityLogMongoWrapperService {
return String.format("EntityLogEntry does not exist for annotationId ID \"%s\"!", annotationId);
}
}

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

@ -9,10 +9,8 @@ import java.util.Map;
import org.springframework.stereotype.Service;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.DossierEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupAnnotationEntity;
import com.iqser.red.service.persistence.management.v1.processor.model.ManualChangesQueryOptions;
import com.iqser.red.service.persistence.management.v1.processor.service.manualredactions.ManualRedactionProviderService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.group.GroupAnnotationRepository;
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;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.FilteredEntityLogRequest;
@ -37,7 +35,6 @@ public class EntityLogService {
DossierService dossierService;
CommentService commentService;
EntityLogMergeService entityLogMergeService;
GroupAnnotationRepository groupAnnotationRepository;
@Observed(name = "EntityLogService", contextualName = "get-entity-log")
@ -77,8 +74,7 @@ public class EntityLogService {
if (includeUnprocessed) {
DossierEntity dossier = dossierService.getDossierById(dossierId);
ManualRedactions unprocessedManualRedactions = manualRedactionProviderService.getManualRedactions(fileId, ManualChangesQueryOptions.unprocessedOnly());
List<GroupAnnotationEntity> unprocessedGroupAnnotations = groupAnnotationRepository.findAllUnprocessedGroupAnnotations(fileId);
processedEntityLog = entityLogMergeService.mergeEntityLog(unprocessedManualRedactions, processedEntityLog, dossier, unprocessedGroupAnnotations);
processedEntityLog = entityLogMergeService.mergeEntityLog(unprocessedManualRedactions, processedEntityLog, dossier);
}
if (fileStatus.getExcludedPages() != null && !fileStatus.getExcludedPages().isEmpty()) {

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

@ -1,11 +1,12 @@
package com.iqser.red.service.persistence.management.v1.processor.service;
import org.apache.commons.lang3.StringUtils;
import org.springframework.retry.support.RetryTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.web.bind.annotation.RestController;
import com.iqser.red.service.persistence.management.v1.processor.exception.ConflictException;
import com.iqser.red.service.persistence.management.v1.processor.service.group.GroupAnnotationService;
import com.iqser.red.service.persistence.management.v1.processor.service.manualredactions.ManualRedactionService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DossierPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.FileStatusPersistenceService;
@ -32,7 +33,6 @@ public class FileStatusProcessingUpdateService {
private final ManualRedactionService manualRedactionService;
private final FileManagementServiceSettings settings;
private final FileStatusPersistenceService fileStatusPersistenceService;
private final GroupAnnotationService groupAnnotationService;
public void analysisSuccessful(String dossierId, String fileId, AnalyzeResult analyzeResult) {
@ -54,7 +54,6 @@ public class FileStatusProcessingUpdateService {
}
manualRedactionService.updateProcessedDate(analyzeResult.getManualRedactions());
groupAnnotationService.updateProcessedDate(analyzeResult.getGroupAnnotations());
if (analyzeResult.getAddedFileAttributes() != null && !analyzeResult.getAddedFileAttributes().isEmpty()) {
fileStatusPersistenceService.addFileAttributes(dossierId, fileId, analyzeResult.getAddedFileAttributes());

160
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/group/GroupAnnotationMapper.java
View File

@ -1,160 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.service.group;
import java.util.ArrayList;
import java.util.List;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.AreaGroupEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupChangeEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupAnnotationEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.PageRangeEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.PositionOnPageEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.PropertyChangeEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.TextGroupEntity;
import com.iqser.red.service.persistence.service.v1.api.shared.model.PageRange;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.AreaGroupAnnotation;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupChange;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupPropertyChange;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotation;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationType;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.PositionOnPage;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.TextGroupAnnotation;
import lombok.experimental.UtilityClass;
@UtilityClass
public class GroupAnnotationMapper {
public static GroupAnnotation toGroupAnnotation(GroupAnnotationEntity groupAnnotationEntity) {
if (groupAnnotationEntity instanceof TextGroupEntity textGroupEntity) {
return toTextGroupAnnotation(textGroupEntity);
} else if (groupAnnotationEntity instanceof AreaGroupEntity areaGroupEntity) {
return toAreaGroupAnnotation(areaGroupEntity);
} else {
return null;
}
}
public static AreaGroupAnnotation toAreaGroupAnnotation(AreaGroupEntity areaGroupEntity) {
List<PageRange> pageRanges = new ArrayList<>();
areaGroupEntity.getPageRanges()
.forEach(pageRangeEntity -> pageRanges.add(toPageRange(pageRangeEntity)));
return AreaGroupAnnotation.builder()
.groupAnnotationType(GroupAnnotationType.AREA)
.groupId(areaGroupEntity.getGroupId())
.legalBasis(areaGroupEntity.getLegalBasis())
.value(areaGroupEntity.getValue())
.entryType(areaGroupEntity.getEntryType())
.processedDate(areaGroupEntity.getProcessedDate())
.requestDate(areaGroupEntity.getRequestDate())
.softDeletedTime(areaGroupEntity.getSoftDeletedTime())
.typeId(areaGroupEntity.getTypeId())
.userId(areaGroupEntity.getUserId())
.fileId(areaGroupEntity.getFileId())
.groupChanges(toGroupChanges(areaGroupEntity.getGroupChanges()))
.positionOnPage(toPositionOnPage(areaGroupEntity.getPositionsOnPage()))
.pageRanges(pageRanges)
.section(areaGroupEntity.getSection())
.build();
}
public static PositionOnPage toPositionOnPage(PositionOnPageEntity positionOnPageEntity) {
return PositionOnPage.builder()
.x(positionOnPageEntity.getX())
.y(positionOnPageEntity.getY())
.width(positionOnPageEntity.getWidth())
.height(positionOnPageEntity.getHeight())
.pageNumber(positionOnPageEntity.getPageNumber())
.build();
}
public static PositionOnPageEntity toPositionOnPageEntity(PositionOnPage positionOnPage) {
return PositionOnPageEntity.builder()
.x(positionOnPage.getX())
.y(positionOnPage.getY())
.width(positionOnPage.getWidth())
.height(positionOnPage.getHeight())
.pageNumber(positionOnPage.getPageNumber())
.build();
}
public static PageRange toPageRange(PageRangeEntity pageRangeEntity) {
return PageRange.builder().startPage(pageRangeEntity.getStartPage()).endPage(pageRangeEntity.getEndPage()).build();
}
public static PageRangeEntity toPageRangeEntity(PageRange pageRangeEntity) {
return PageRangeEntity.builder().startPage(pageRangeEntity.getStartPage()).endPage(pageRangeEntity.getEndPage()).build();
}
public static TextGroupAnnotation toTextGroupAnnotation(TextGroupEntity textGroupEntity) {
return TextGroupAnnotation.builder()
.groupAnnotationType(GroupAnnotationType.TEXT)
.groupId(textGroupEntity.getGroupId())
.legalBasis(textGroupEntity.getLegalBasis())
.value(textGroupEntity.getValue())
.entryType(textGroupEntity.getEntryType())
.processedDate(textGroupEntity.getProcessedDate())
.requestDate(textGroupEntity.getRequestDate())
.softDeletedTime(textGroupEntity.getSoftDeletedTime())
.typeId(textGroupEntity.getTypeId())
.userId(textGroupEntity.getUserId())
.fileId(textGroupEntity.getFileId())
.positionOnPage(toPositionOnPage(textGroupEntity.getPositionsOnPage()))
.groupChanges(toGroupChanges(textGroupEntity.getGroupChanges()))
.build();
}
public static List<GroupChange> toGroupChanges(List<GroupChangeEntity> groupChangeEntities) {
List<GroupChange> groupChanges = new ArrayList<>();
if (groupChangeEntities == null || groupChangeEntities.isEmpty()) {
return groupChanges;
}
groupChangeEntities.forEach(groupChangeEntity -> groupChanges.add(GroupChange.builder()
.changeDate(groupChangeEntity.getChangeDate())
.changeId(groupChangeEntity.getChangeId())
.changeType(groupChangeEntity.getChangeType())
.userId(groupChangeEntity.getUserId())
.propertyChanges(toGroupPropertyChanges(groupChangeEntity.getPropertyChanges()))
.build()));
return groupChanges;
}
public static List<GroupPropertyChange> toGroupPropertyChanges(List<PropertyChangeEntity> propertyChangeEntities) {
List<GroupPropertyChange> groupPropertyChanges = new ArrayList<>();
if (propertyChangeEntities == null || propertyChangeEntities.isEmpty()) {
return groupPropertyChanges;
}
propertyChangeEntities.forEach(propertyChangeEntity -> groupPropertyChanges.add(GroupPropertyChange.builder()
.propertyChangeId(propertyChangeEntity.getPropertyChangeId())
.propertyName(propertyChangeEntity.getPropertyName())
.propertyOldValue(propertyChangeEntity.getPropertyOldValue())
.propertyNewValue(propertyChangeEntity.getPropertyNewValue())
.build()));
return groupPropertyChanges;
}
}

179
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/group/GroupAnnotationPersistenceService.java
View File

@ -1,179 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.service.group;
import java.time.OffsetDateTime;
import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.springframework.stereotype.Service;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.AreaGroupEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupAnnotationEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.PageRangeEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.PositionOnPageEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.TextGroupEntity;
import com.iqser.red.service.persistence.management.v1.processor.exception.NotFoundException;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.group.GroupAnnotationRepository;
import com.iqser.red.service.persistence.service.v1.api.shared.model.PageRange;
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.group.AddAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.AddGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.PositionOnPage;
import com.knecon.fforesight.keycloakcommons.security.KeycloakSecurity;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import lombok.experimental.FieldDefaults;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Service
@RequiredArgsConstructor
@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
public class GroupAnnotationPersistenceService {
GroupAnnotationRepository groupAnnotationRepository;
public TextGroupEntity addTextGroupEntity(String fileId, AddGroupAnnotationRequestModel addGroupAnnotationRequestModel) {
PositionOnPageEntity positionOnPageEntity = GroupAnnotationMapper.toPositionOnPageEntity(addGroupAnnotationRequestModel.getPositionOnPage());
TextGroupEntity textGroupEntity = TextGroupEntity.builder()
.groupId(UUID.randomUUID().toString())
.entryType(addGroupAnnotationRequestModel.getEntryType())
.fileId(fileId)
.legalBasis(addGroupAnnotationRequestModel.getLegalBasis())
.typeId(addGroupAnnotationRequestModel.getType())
.value(addGroupAnnotationRequestModel.getValue())
.positionsOnPage(positionOnPageEntity)
.requestDate(OffsetDateTime.now())
.userId(KeycloakSecurity.getUserId())
.build();
positionOnPageEntity.setGroupAnnotation(textGroupEntity);
return groupAnnotationRepository.saveAndFlush(textGroupEntity);
}
public AreaGroupEntity addAreaGroupEntity(String fileId, AddAreaGroupAnnotationRequestModel addAreaGroupAnnotationRequestModel) {
PositionOnPageEntity positionOnPageEntity = GroupAnnotationMapper.toPositionOnPageEntity(addAreaGroupAnnotationRequestModel.getPositionOnPage());
AreaGroupEntity areaGroupEntity = AreaGroupEntity.builder()
.groupId(UUID.randomUUID().toString())
.entryType(addAreaGroupAnnotationRequestModel.getEntryType())
.fileId(fileId)
.legalBasis(addAreaGroupAnnotationRequestModel.getLegalBasis())
.typeId(addAreaGroupAnnotationRequestModel.getType())
.value(addAreaGroupAnnotationRequestModel.getValue())
.positionsOnPage(positionOnPageEntity)
.requestDate(OffsetDateTime.now())
.userId(KeycloakSecurity.getUserId())
.section(addAreaGroupAnnotationRequestModel.getSection())
.build();
positionOnPageEntity.setGroupAnnotation(areaGroupEntity);
List<PageRangeEntity> pageRanges = new ArrayList<>();
addAreaGroupAnnotationRequestModel.getPageRanges().forEach(pageRange -> {
PageRangeEntity pageRangeEntity = GroupAnnotationMapper.toPageRangeEntity(pageRange);
pageRangeEntity.setAreaGroup(areaGroupEntity);
pageRanges.add(pageRangeEntity);
});
areaGroupEntity.setPageRanges(pageRanges);
return groupAnnotationRepository.saveAndFlush(areaGroupEntity);
}
public List<GroupAnnotationEntity> findAllGroupEntitiesForFile(String fileId, boolean includeSoftDeleted) {
if (includeSoftDeleted) {
return groupAnnotationRepository.findAllByFileId(fileId);
}
else {
return groupAnnotationRepository.findAllByFileIdAndNotSoftDeleted(fileId);
}
}
public GroupAnnotationEntity findGroupAnnotation(String groupId) {
return groupAnnotationRepository.findById(groupId)
.orElseThrow(() -> new NotFoundException(String.format("Group annotation with id %s not found.", groupId)));
}
public void markAsProcessed(String groupId) {
groupAnnotationRepository.markAsProcessed(groupId, OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS));
}
public GroupAnnotationEntity updateLegalBasis(GroupAnnotationEntity groupAnnotation, String legalBasis) {
groupAnnotation.setLegalBasis(legalBasis);
return groupAnnotationRepository.saveAndFlush(groupAnnotation);
}
public GroupAnnotationEntity forceGroupAnnotation(GroupAnnotationEntity groupAnnotation) {
groupAnnotation.setEntryType(EntryType.ENTITY);
return groupAnnotationRepository.saveAndFlush(groupAnnotation);
}
public GroupAnnotationEntity recategorizeGroupAnnotation(GroupAnnotationEntity groupAnnotation, String typeId) {
groupAnnotation.setTypeId(typeId);
return groupAnnotationRepository.saveAndFlush(groupAnnotation);
}
public AreaGroupEntity resizeAreaGroupAnnotation(AreaGroupEntity areaGroupEntity, PositionOnPage positionOnPage) {
PositionOnPageEntity positionEntity = GroupAnnotationMapper.toPositionOnPageEntity(positionOnPage);
positionEntity.setGroupAnnotation(areaGroupEntity);
areaGroupEntity.setPositionsOnPage(positionEntity);
return groupAnnotationRepository.saveAndFlush(areaGroupEntity);
}
public AreaGroupEntity changeValueAreaGroupAnnotation(AreaGroupEntity areaGroupEntity, String value) {
areaGroupEntity.setValue(value);
return groupAnnotationRepository.saveAndFlush(areaGroupEntity);
}
public AreaGroupEntity changePageRangesAreaGroupAnnotation(AreaGroupEntity areaGroupEntity, List<PageRange> pageRanges) {
List<PageRangeEntity> existingPageRanges = areaGroupEntity.getPageRanges();
existingPageRanges.clear();
pageRanges.forEach(pageRange -> {
PageRangeEntity pageRangeEntity = GroupAnnotationMapper.toPageRangeEntity(pageRange);
pageRangeEntity.setAreaGroup(areaGroupEntity);
existingPageRanges.add(pageRangeEntity);
});
areaGroupEntity.setPageRanges(existingPageRanges);
return groupAnnotationRepository.saveAndFlush(areaGroupEntity);
}
public GroupAnnotationEntity removeGroupAnnotation(GroupAnnotationEntity groupAnnotation) {
groupAnnotation.setSoftDeletedTime(OffsetDateTime.now());
return groupAnnotationRepository.saveAndFlush(groupAnnotation);
}
}

438
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/group/GroupAnnotationService.java
View File

@ -1,438 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.service.group;
import java.time.OffsetDateTime;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.AreaGroupEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupAnnotationEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupChangeEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.PageRangeEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.PositionOnPageEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.PropertyChangeEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.TextGroupEntity;
import com.iqser.red.service.persistence.management.v1.processor.exception.BadRequestException;
import com.iqser.red.service.persistence.management.v1.processor.service.FileStatusService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.FileStatusPersistenceService;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.AddAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.AddTextGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.AreaGroupAnnotation;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ChangePageRangeAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ChangeValueAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotation;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationInternalResponse;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationResponse;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationType;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupChange;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupChangeType;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.RecategorizeGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ResizeAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.TextGroupAnnotation;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.UpdateLegalBasisRequestModel;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import lombok.experimental.FieldDefaults;
import lombok.extern.slf4j.Slf4j;
@Service
@RequiredArgsConstructor
@Slf4j
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
public class GroupAnnotationService {
GroupAnnotationPersistenceService groupAnnotationPersistenceService;
GroupChangePersistenceService groupChangePersistenceService;
FileStatusPersistenceService fileStatusPersistenceService;
FileStatusService fileStatusService;
@Transactional
public GroupAnnotationResponse addTextGroupAnnotation(String dossierId, String fileId, List<AddTextGroupAnnotationRequestModel> addTextGroupAnnotationRequestModels) {
List<GroupAnnotation> groupAnnotations = new ArrayList<>();
addTextGroupAnnotationRequestModels.forEach(addTextGroupAnnotationRequestModel -> {
validateAddTextGroupRequest(addTextGroupAnnotationRequestModel);
TextGroupEntity textGroupEntity = groupAnnotationPersistenceService.addTextGroupEntity(fileId, addTextGroupAnnotationRequestModel);
GroupAnnotation groupAnnotation = GroupAnnotationMapper.toGroupAnnotation(textGroupEntity);
groupAnnotations.add(groupAnnotation);
});
reprocess(dossierId, fileId);
fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now());
return GroupAnnotationResponse.builder().groupAnnotations(groupAnnotations).build();
}
@Transactional
public GroupAnnotationResponse addAreaGroupAnnotation(String dossierId, String fileId, List<AddAreaGroupAnnotationRequestModel> addAreaGroupAnnotationRequestModels) {
List<GroupAnnotation> groupAnnotations = new ArrayList<>();
addAreaGroupAnnotationRequestModels.forEach(areaGroupAnnotationRequestModel -> {
validateAddAreaGroupAnnotationRequest(areaGroupAnnotationRequestModel);
AreaGroupEntity areaGroupEntity = groupAnnotationPersistenceService.addAreaGroupEntity(fileId, areaGroupAnnotationRequestModel);
AreaGroupAnnotation areaGroupAnnotation = GroupAnnotationMapper.toAreaGroupAnnotation(areaGroupEntity);
groupAnnotations.add(areaGroupAnnotation);
});
reprocess(dossierId, fileId);
fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now());
return GroupAnnotationResponse.builder().groupAnnotations(groupAnnotations).build();
}
private void validateAddAreaGroupAnnotationRequest(AddAreaGroupAnnotationRequestModel addAreaGroupAnnotationRequestModel) {
if (!addAreaGroupAnnotationRequestModel.getGroupAnnotationType().equals(GroupAnnotationType.AREA)) {
throw new BadRequestException("Area group annotation needs group annotation type to be AREA!");
}
if (addAreaGroupAnnotationRequestModel.getPositionOnPage() == null) {
throw new BadRequestException("Area group annotation requires positions on page!");
}
if (addAreaGroupAnnotationRequestModel.getValue().length() > 4000) {
throw new BadRequestException("Group annotation value can not exceed 4000 characters!");
}
}
private void validateAddTextGroupRequest(AddTextGroupAnnotationRequestModel addTextGroupAnnotationRequestModel) {
if (!addTextGroupAnnotationRequestModel.getGroupAnnotationType().equals(GroupAnnotationType.TEXT)) {
throw new BadRequestException("Text group annotation needs group annotation type to be TEXT!");
}
if (addTextGroupAnnotationRequestModel.getValue().length() > 4000) {
throw new BadRequestException("Group annotation value can not exceed 4000 characters!");
}
}
private void reprocess(String dossierId, String fileId) {
fileStatusService.setStatusReprocessForManual(dossierId, fileId, true);
}
@Transactional(readOnly = true)
public GroupAnnotationResponse getAllGroupAnnotations(String fileId, boolean includeSoftDeleted) {
GroupAnnotationResponse groupAnnotationResponse = new GroupAnnotationResponse();
List<GroupAnnotationEntity> groupAnnotationEntities = groupAnnotationPersistenceService.findAllGroupEntitiesForFile(fileId, includeSoftDeleted);
groupAnnotationResponse.setGroupAnnotations(groupAnnotationEntities.stream()
.map(GroupAnnotationMapper::toGroupAnnotation)
.collect(Collectors.toList()));
return groupAnnotationResponse;
}
@Transactional(readOnly = true)
public GroupAnnotationInternalResponse getAllGroupAnnotationsInternal(String fileId, boolean includeSoftDeleted) {
List<TextGroupAnnotation> textGroupAnnotations = new ArrayList<>();
List<AreaGroupAnnotation> areaGroupAnnotations = new ArrayList<>();
List<GroupAnnotationEntity> groupAnnotationEntities = groupAnnotationPersistenceService.findAllGroupEntitiesForFile(fileId, includeSoftDeleted);
groupAnnotationEntities.forEach(groupAnnotation -> {
if (groupAnnotation instanceof TextGroupEntity textGroupEntity) {
textGroupAnnotations.add(GroupAnnotationMapper.toTextGroupAnnotation(textGroupEntity));
} else if (groupAnnotation instanceof AreaGroupEntity areaGroupEntity) {
areaGroupAnnotations.add(GroupAnnotationMapper.toAreaGroupAnnotation(areaGroupEntity));
}
});
return GroupAnnotationInternalResponse.builder().areaGroupAnnotations(areaGroupAnnotations).textGroupAnnotations(textGroupAnnotations).build();
}
@Transactional(readOnly = true)
public GroupAnnotation getGroupAnnotation(String groupId) {
GroupAnnotationEntity groupAnnotation = groupAnnotationPersistenceService.findGroupAnnotation(groupId);
return GroupAnnotationMapper.toGroupAnnotation(groupAnnotation);
}
@Transactional
public void updateProcessedDate(Set<GroupAnnotation> groupAnnotations) {
if (groupAnnotations != null) {
groupAnnotations.forEach(groupAnnotation -> {
if (groupAnnotation.getProcessedDate() == null || groupAnnotation.getGroupChanges()
.stream()
.anyMatch(change -> change.getChangeDate().isAfter(groupAnnotation.getProcessedDate()))) {
groupAnnotationPersistenceService.markAsProcessed(groupAnnotation.getGroupId());
}
});
}
}
@Transactional
public GroupAnnotationResponse updateLegalBasis(String dossierId, String fileId, List<UpdateLegalBasisRequestModel> updateLegalBasisRequestModels) {
List<GroupAnnotation> groupAnnotations = new ArrayList<>();
updateLegalBasisRequestModels.forEach(updateLegalBasisRequestModel -> {
GroupAnnotationEntity oldGroupEntity = groupAnnotationPersistenceService.findGroupAnnotation(updateLegalBasisRequestModel.getGroupId());
String oldLegalBasis = oldGroupEntity.getLegalBasis();
GroupAnnotationEntity newGroupEntity = groupAnnotationPersistenceService.updateLegalBasis(oldGroupEntity, updateLegalBasisRequestModel.getLegalBasis());
GroupAnnotation groupAnnotation = GroupAnnotationMapper.toGroupAnnotation(newGroupEntity);
List<PropertyChangeEntity> propertyChangeEntities = new ArrayList<>();
propertyChangeEntities.add(PropertyChangeEntity.builder()
.propertyName("legalBasis")
.propertyOldValue(oldLegalBasis)
.propertyNewValue(newGroupEntity.getLegalBasis())
.build());
addChange(newGroupEntity, GroupChangeType.LEGAL_BASIS_CHANGE, propertyChangeEntities, groupAnnotation);
groupAnnotations.add(groupAnnotation);
});
reprocess(dossierId, fileId);
fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now());
return GroupAnnotationResponse.builder().groupAnnotations(groupAnnotations).build();
}
@Transactional
public GroupAnnotationResponse recategorizeGroupAnnotation(String dossierId, String fileId, List<RecategorizeGroupAnnotationRequestModel> groupAnnotationRequestModels) {
List<GroupAnnotation> groupAnnotations = new ArrayList<>();
groupAnnotationRequestModels.forEach(groupAnnotationRequestModel -> {
GroupAnnotationEntity oldGroupEntity = groupAnnotationPersistenceService.findGroupAnnotation(groupAnnotationRequestModel.getGroupId());
String oldType = oldGroupEntity.getTypeId();
GroupAnnotationEntity newGroupEntity = groupAnnotationPersistenceService.recategorizeGroupAnnotation(oldGroupEntity, groupAnnotationRequestModel.getTypeId());
GroupAnnotation groupAnnotation = GroupAnnotationMapper.toGroupAnnotation(newGroupEntity);
List<PropertyChangeEntity> propertyChangeEntities = new ArrayList<>();
propertyChangeEntities.add(PropertyChangeEntity.builder().propertyName("type_id").propertyOldValue(oldType).propertyNewValue(newGroupEntity.getTypeId()).build());
addChange(newGroupEntity, GroupChangeType.RECATEGORIZE, propertyChangeEntities, groupAnnotation);
groupAnnotations.add(groupAnnotation);
});
reprocess(dossierId, fileId);
fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now());
return GroupAnnotationResponse.builder().groupAnnotations(groupAnnotations).build();
}
@Transactional
public GroupAnnotationResponse forceGroupAnnotation(String dossierId, String fileId, List<GroupAnnotationRequestModel> groupAnnotationRequestModels) {
List<GroupAnnotation> groupAnnotations = new ArrayList<>();
groupAnnotationRequestModels.forEach(groupAnnotationRequestModel -> {
GroupAnnotationEntity oldGroupEntity = groupAnnotationPersistenceService.findGroupAnnotation(groupAnnotationRequestModel.getGroupId());
String oldEntryType = oldGroupEntity.getEntryType().name();
GroupAnnotationEntity newGroupEntity = groupAnnotationPersistenceService.forceGroupAnnotation(oldGroupEntity);
GroupAnnotation groupAnnotation = GroupAnnotationMapper.toGroupAnnotation(newGroupEntity);
List<PropertyChangeEntity> propertyChangeEntities = new ArrayList<>();
propertyChangeEntities.add(PropertyChangeEntity.builder()
.propertyName("entryType")
.propertyOldValue(oldEntryType)
.propertyNewValue(newGroupEntity.getEntryType().name())
.build());
addChange(newGroupEntity, GroupChangeType.FORCE, propertyChangeEntities, groupAnnotation);
groupAnnotations.add(groupAnnotation);
});
reprocess(dossierId, fileId);
fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now());
return GroupAnnotationResponse.builder().groupAnnotations(groupAnnotations).build();
}
@Transactional
public GroupAnnotationResponse resizeAreaGroupAnnotation(String dossierId, String fileId, List<ResizeAreaGroupAnnotationRequestModel> areaGroupAnnotationRequestModels) {
List<GroupAnnotation> groupAnnotations = new ArrayList<>();
areaGroupAnnotationRequestModels.forEach(resizeAreaGroupAnnotationRequestModel -> {
GroupAnnotationEntity oldGroupEntity = groupAnnotationPersistenceService.findGroupAnnotation(resizeAreaGroupAnnotationRequestModel.getGroupId());
if (oldGroupEntity instanceof AreaGroupEntity oldAreaGroupEntity) {
PositionOnPageEntity oldPositionOnPage = oldAreaGroupEntity.getPositionsOnPage();
AreaGroupEntity newAreaGroupEntity = groupAnnotationPersistenceService.resizeAreaGroupAnnotation(oldAreaGroupEntity,
resizeAreaGroupAnnotationRequestModel.getPositionOnPage());
GroupAnnotation groupAnnotation = GroupAnnotationMapper.toAreaGroupAnnotation(newAreaGroupEntity);
List<PropertyChangeEntity> propertyChangeEntities = new ArrayList<>();
propertyChangeEntities.add(PropertyChangeEntity.builder()
.propertyName("positions")
.propertyOldValue(buildPositionOnPageString(oldPositionOnPage))
.propertyNewValue(buildPositionOnPageString(newAreaGroupEntity.getPositionsOnPage()))
.build());
addChange(newAreaGroupEntity, GroupChangeType.RESIZE, propertyChangeEntities, groupAnnotation);
groupAnnotations.add(groupAnnotation);
} else {
throw new BadRequestException("Can not resize TEXT group annotations!");
}
});
reprocess(dossierId, fileId);
fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now());
return GroupAnnotationResponse.builder().groupAnnotations(groupAnnotations).build();
}
private String buildPositionOnPageString(PositionOnPageEntity positionOnPageEntity) {
return "["
+ positionOnPageEntity.getX()
+ ", "
+ positionOnPageEntity.getY()
+ ", "
+ positionOnPageEntity.getWidth()
+ ", "
+ positionOnPageEntity.getHeight()
+ ", "
+ positionOnPageEntity.getPageNumber()
+ "]";
}
@Transactional
public GroupAnnotationResponse removeGroupAnnotation(String dossierId, String fileId, List<GroupAnnotationRequestModel> groupAnnotationRequestModels) {
List<GroupAnnotation> groupAnnotations = new ArrayList<>();
groupAnnotationRequestModels.forEach(groupAnnotationRequestModel -> {
GroupAnnotationEntity oldGroupEntity = groupAnnotationPersistenceService.findGroupAnnotation(groupAnnotationRequestModel.getGroupId());
GroupAnnotationEntity newGroupEntity = groupAnnotationPersistenceService.removeGroupAnnotation(oldGroupEntity);
GroupAnnotation groupAnnotation = GroupAnnotationMapper.toGroupAnnotation(newGroupEntity);
List<PropertyChangeEntity> propertyChangeEntities = new ArrayList<>();
propertyChangeEntities.add(PropertyChangeEntity.builder()
.propertyName("softDeletedTime")
.propertyOldValue(null)
.propertyNewValue(newGroupEntity.getSoftDeletedTime().toString())
.build());
addChange(newGroupEntity, GroupChangeType.REMOVE, propertyChangeEntities, groupAnnotation);
groupAnnotations.add(groupAnnotation);
});
reprocess(dossierId, fileId);
fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now());
return GroupAnnotationResponse.builder().groupAnnotations(groupAnnotations).build();
}
@Transactional
public GroupAnnotationResponse changeValueGroupAnnotation(String dossierId, String fileId, List<ChangeValueAreaGroupAnnotationRequestModel> annotationRequestModels) {
List<GroupAnnotation> groupAnnotations = new ArrayList<>();
annotationRequestModels.forEach(changeValueAreaGroupAnnotationRequestModel -> {
GroupAnnotationEntity oldGroupEntity = groupAnnotationPersistenceService.findGroupAnnotation(changeValueAreaGroupAnnotationRequestModel.getGroupId());
if (oldGroupEntity instanceof AreaGroupEntity oldAreaGroupEntity) {
String oldValue = oldAreaGroupEntity.getValue();
AreaGroupEntity newAreaGroupEntity = groupAnnotationPersistenceService.changeValueAreaGroupAnnotation(oldAreaGroupEntity,
changeValueAreaGroupAnnotationRequestModel.getValue());
GroupAnnotation groupAnnotation = GroupAnnotationMapper.toAreaGroupAnnotation(newAreaGroupEntity);
List<PropertyChangeEntity> propertyChangeEntities = new ArrayList<>();
propertyChangeEntities.add(PropertyChangeEntity.builder().propertyName("value").propertyOldValue(oldValue).propertyNewValue(newAreaGroupEntity.getValue()).build());
addChange(newAreaGroupEntity, GroupChangeType.VALUE_CHANGE, propertyChangeEntities, groupAnnotation);
groupAnnotations.add(groupAnnotation);
} else {
throw new BadRequestException("Can not change value for TEXT group annotations!");
}
});
reprocess(dossierId, fileId);
fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now());
return GroupAnnotationResponse.builder().groupAnnotations(groupAnnotations).build();
}
@Transactional
public GroupAnnotationResponse changePageRangesGroupAnnotation(String dossierId,
String fileId,
List<ChangePageRangeAreaGroupAnnotationRequestModel> changePageRangeAreaGroupAnnotationRequestModels) {
List<GroupAnnotation> groupAnnotations = new ArrayList<>();
changePageRangeAreaGroupAnnotationRequestModels.forEach(changePageRangeAreaGroupAnnotationRequestModel -> {
GroupAnnotationEntity oldGroupEntity = groupAnnotationPersistenceService.findGroupAnnotation(changePageRangeAreaGroupAnnotationRequestModel.getGroupId());
if (oldGroupEntity instanceof AreaGroupEntity oldAreaGroupEntity) {
List<PageRangeEntity> oldPageRanges = oldAreaGroupEntity.getPageRanges();
validateChangePageRangeRequest(changePageRangeAreaGroupAnnotationRequestModel);
AreaGroupEntity newAreaGroupEntity = groupAnnotationPersistenceService.changePageRangesAreaGroupAnnotation(oldAreaGroupEntity,
changePageRangeAreaGroupAnnotationRequestModel.getPageRanges());
AreaGroupAnnotation groupareaGroupAnnotation = GroupAnnotationMapper.toAreaGroupAnnotation(newAreaGroupEntity);
List<PropertyChangeEntity> propertyChangeEntities = new ArrayList<>();
propertyChangeEntities.add(PropertyChangeEntity.builder()
.propertyName("pageRanges")
.propertyOldValue(buildPageRangeString(oldPageRanges))
.propertyNewValue(buildPageRangeString(newAreaGroupEntity.getPageRanges()))
.build());
addChange(newAreaGroupEntity, GroupChangeType.PAGE_RANGE_CHANGE, propertyChangeEntities, groupareaGroupAnnotation);
groupAnnotations.add(groupareaGroupAnnotation);
} else {
throw new BadRequestException("Can not change page range for TEXT group annotations!");
}
});
reprocess(dossierId, fileId);
fileStatusPersistenceService.setLastManualChangeDate(fileId, OffsetDateTime.now());
return GroupAnnotationResponse.builder().groupAnnotations(groupAnnotations).build();
}
private String buildPageRangeString(List<PageRangeEntity> pageRangeEntities) {
StringBuilder sb = new StringBuilder();
int pageRangeSize = pageRangeEntities.size();
if (pageRangeSize > 1) {
sb.append("[");
}
pageRangeEntities.forEach(pageRangeEntity -> {
sb.append("[");
sb.append(pageRangeEntity.getStartPage());
sb.append(", ");
sb.append(pageRangeEntity.getEndPage());
sb.append("]");
});
if (pageRangeSize > 1) {
sb.append("[");
}
return sb.toString();
}
private void validateChangePageRangeRequest(ChangePageRangeAreaGroupAnnotationRequestModel changePageRangeAreaGroupAnnotationRequestModel) {
if (changePageRangeAreaGroupAnnotationRequestModel.getPageRanges()
.stream()
.anyMatch(pageRange -> pageRange.getStartPage() > pageRange.getEndPage())) {
throw new BadRequestException("Page range start can not be higher than page range end!");
}
}
@Transactional
private void addChange(GroupAnnotationEntity groupAnnotationEntity,
GroupChangeType groupChangeType,
List<PropertyChangeEntity> propertyChangeEntities,
GroupAnnotation groupAnnotation) {
GroupChangeEntity groupChangeEntity = groupChangePersistenceService.addGroupChange(groupChangeType, groupAnnotationEntity, propertyChangeEntities);
List<GroupChange> groupChanges = GroupAnnotationMapper.toGroupChanges(List.of(groupChangeEntity));
groupAnnotation.getGroupChanges().addAll(groupChanges);
}
}

50
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/group/GroupChangePersistenceService.java
View File

@ -1,50 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.service.group;
import java.time.OffsetDateTime;
import java.util.List;
import java.util.UUID;
import org.springframework.stereotype.Service;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupChangeEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupAnnotationEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.PropertyChangeEntity;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.group.GroupChangeRepository;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupChangeType;
import com.knecon.fforesight.keycloakcommons.security.KeycloakSecurity;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import lombok.experimental.FieldDefaults;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Service
@RequiredArgsConstructor
@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
public class GroupChangePersistenceService {
GroupChangeRepository groupChangeRepository;
public GroupChangeEntity addGroupChange(GroupChangeType changeType, GroupAnnotationEntity groupAnnotation, List<PropertyChangeEntity> propertyChangeEntities) {
GroupChangeEntity groupChange = GroupChangeEntity.builder()
.userId(KeycloakSecurity.getUserId())
.changeDate(OffsetDateTime.now())
.changeId(UUID.randomUUID().toString())
.changeType(changeType)
.group(groupAnnotation)
.build();
List<PropertyChangeEntity> initializedPropertyChanges = propertyChangeEntities.stream().peek(propertyChange -> {
propertyChange.setPropertyChangeId(UUID.randomUUID().toString());
propertyChange.setGroupChange(groupChange);
}).toList();
groupChange.setPropertyChanges(initializedPropertyChanges);
return groupChangeRepository.saveAndFlush(groupChange);
}
}

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

@ -96,13 +96,13 @@ public class ManualRedactionMapper {
.toList(),
includeUnprocessed);
Map<String, EntityLogEntry> idToEntityLogEntryMap = entityLogEntries.stream()
Map<String, EntityLogEntry> iddToEntityLogEntryMap = entityLogEntries.stream()
.collect(Collectors.toMap(EntityLogEntry::getId, Function.identity()));
List<RequestEntryPair<RemoveRedactionRequest>> requests = new ArrayList<>();
for (var removeRedactionRequest : removeRedactionRequests) {
EntityLogEntry entityLogEntry = idToEntityLogEntryMap.get(removeRedactionRequest.getAnnotationId());
EntityLogEntry entityLogEntry = iddToEntityLogEntryMap.get(removeRedactionRequest.getAnnotationId());
if (entityLogEntry != null) {
var request = RemoveRedactionRequest.builder()

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

@ -1,131 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.service.manualredactions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import org.springframework.stereotype.Service;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.AreaGroupEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupAnnotationEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.PositionOnPageEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.TextGroupEntity;
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.EntityLogEntry;
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.Position;
@Service
public class PendingGroupAnnotationFactory {
public EntityLogEntry buildGroupAnnotationEntry(GroupAnnotationEntity groupAnnotationEntity) {
String reason = String.format("%s has been added as a group annotation", shortenValueIfNecessary(groupAnnotationEntity.getValue()));
if (groupAnnotationEntity instanceof TextGroupEntity textGroupEntity) {
return buildTextGroupAnnotationEntry(textGroupEntity, reason);
} else if (groupAnnotationEntity instanceof AreaGroupEntity areaGroupEntity) {
return buildAreaGroupAnnotationEntry(areaGroupEntity, reason);
} else {
return null;
}
}
private EntityLogEntry buildAreaGroupAnnotationEntry(AreaGroupEntity areaGroupEntity, String reason) {
return EntityLogEntry.builder()
.id(UUID.randomUUID().toString())
.value(areaGroupEntity.getValue())
.type(areaGroupEntity.getTypeId())
.entryType(areaGroupEntity.getEntryType())
.state(EntryState.PENDING)
.dictionaryEntry(false)
.dossierDictionaryEntry(false)
.reason(reason)
.legalBasis(reason)
.matchedRule("")
.containingNodeId(Collections.emptyList())
.closestHeadline("")
.section(areaGroupEntity.getSection())
.positions(convertPositions(areaGroupEntity.getPositionsOnPage()))
.textAfter("")
.textBefore("")
.startOffset(-1)
.endOffset(-1)
.changes(Collections.emptyList())
.manualChanges(Collections.emptyList())
.engines(Set.of(Engine.DICTIONARY))
.reference(Collections.emptySet())
.importedRedactionIntersections(Collections.emptySet())
.build();
}
private EntityLogEntry buildTextGroupAnnotationEntry(TextGroupEntity textGroupEntity, String reason) {
return EntityLogEntry.builder()
.id(UUID.randomUUID().toString())
.value(textGroupEntity.getValue())
.type(textGroupEntity.getTypeId())
.entryType(textGroupEntity.getEntryType())
.state(EntryState.PENDING)
.dictionaryEntry(false)
.dossierDictionaryEntry(false)
.reason(reason)
.legalBasis(reason)
.matchedRule("")
.containingNodeId(Collections.emptyList())
.closestHeadline("")
.section("")
.positions(convertPositions(textGroupEntity.getPositionsOnPage()))
.textAfter("")
.textBefore("")
.startOffset(-1)
.endOffset(-1)
.changes(Collections.emptyList())
.manualChanges(Collections.emptyList())
.engines(Set.of(Engine.DICTIONARY))
.reference(Collections.emptySet())
.importedRedactionIntersections(Collections.emptySet())
.build();
}
private String shortenValueIfNecessary(String value) {
final int MAX_LENGTH = 100;
if (value.length() <= MAX_LENGTH) {
return value;
}
String[] words = value.split(" ");
if (words.length == 1) {
return value.substring(0, MAX_LENGTH) + "...";
}
int bound = Math.min(words.length, 2);
List<String> list = new ArrayList<>(Arrays.asList(words).subList(0, bound));
return String.join(" ", list) + "...";
}
private List<Position> convertPositions(PositionOnPageEntity positionOnPageEntity) {
List<Position> positions = new ArrayList<>();
positions.add(new Position(positionOnPageEntity.getX(),
positionOnPageEntity.getY(),
positionOnPageEntity.getWidth(),
positionOnPageEntity.getHeight(),
positionOnPageEntity.getPageNumber()));
return positions;
}
}

34
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/repository/group/GroupAnnotationRepository.java
View File

@ -1,34 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.group;
import java.time.OffsetDateTime;
import java.util.List;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupAnnotationEntity;
public interface GroupAnnotationRepository extends JpaRepository<GroupAnnotationEntity, String> {
List<GroupAnnotationEntity> findAllByFileId(String fileId);
@Query("select g from GroupAnnotationEntity g where g.fileId = :fileId and g.softDeletedTime is null")
List<GroupAnnotationEntity> findAllByFileIdAndNotSoftDeleted(@Param("fileId") String fileId);
@Modifying
@Query("update GroupAnnotationEntity t set t.processedDate = :processedDate where t.id = :groupId")
void markAsProcessed(@Param("groupId") String groupId, @Param("processedDate") OffsetDateTime processedDate);
@Query("select g from GroupAnnotationEntity g "
+ "where g.fileId = :fileId "
+ "and g.softDeletedTime is null "
+ "and (g.processedDate is null "
+ "or exists (select gc from g.groupChanges gc where gc.changeDate > g.processedDate))")
List<GroupAnnotationEntity> findAllUnprocessedGroupAnnotations(@Param("fileId") String fileId);
}

9
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/repository/group/GroupChangeRepository.java
View File

@ -1,9 +0,0 @@
package com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.group;
import org.springframework.data.jpa.repository.JpaRepository;
import com.iqser.red.service.persistence.management.v1.processor.entity.group.GroupChangeEntity;
public interface GroupChangeRepository extends JpaRepository<GroupChangeEntity, String> {
}

12
persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/db.changelog-tenant.yaml
View File

@ -218,14 +218,4 @@ databaseChangeLog:
- include:
file: db/changelog/tenant/132-add-based-on-dict-annotation-id-to-manual_changes.yaml
- include:
file: db/changelog/tenant/133-add-technical-name-to-legal_basis.yaml
- include:
file: db/changelog/tenant/134-add-group-entity-table.yaml
- include:
file: db/changelog/tenant/135-add-group-changes-table.yaml
- include:
file: db/changelog/tenant/136-add-property-changes-table.yaml
- include:
file: db/changelog/tenant/137-add-area-position-table.yaml
- include:
file: db/changelog/tenant/138-add-page-range-table.yaml
file: db/changelog/tenant/133-add-technical-name-to-legal_basis.yaml

71
persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/tenant/134-add-group-entity-table.yaml
View File

@ -1,71 +0,0 @@
databaseChangeLog:
- changeSet:
id: 134-add-group-entity-table
author: aisvoran
changes:
- createTable:
tableName: group_redaction
columns:
- column:
name: group_id
type: VARCHAR(36)
constraints:
nullable: false
primaryKey: true
primaryKeyName: group_entity_pkey
- column:
name: group_type
type: VARCHAR(50)
constraints:
nullable: false
- column:
name: file_id
type: VARCHAR(255)
constraints:
nullable: false
- column:
name: type_id
type: VARCHAR(255)
constraints:
nullable: false
- column:
name: value
type: VARCHAR(4000)
constraints:
nullable: true
- column:
name: legal_basis
type: VARCHAR(255)
constraints:
nullable: false
- column:
name: entry_type
type: VARCHAR(255)
defaultValue: ENTITY
constraints:
nullable: false
- column:
name: user_id
type: VARCHAR(255)
constraints:
nullable: false
- column:
name: section
type: VARCHAR(255)
constraints:
nullable: true
- column:
name: request_date
type: TIMESTAMP WITH TIME ZONE
constraints:
nullable: true
- column:
name: processed_date
type: TIMESTAMP WITH TIME ZONE
constraints:
nullable: true
- column:
name: soft_deleted_time
type: TIMESTAMP WITH TIME ZONE
constraints:
nullable: true

41
persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/tenant/135-add-group-changes-table.yaml
View File

@ -1,41 +0,0 @@
databaseChangeLog:
- changeSet:
id: 135-create-group-changes-table
author: aisvoran
changes:
- createTable:
tableName: group_change
columns:
- column:
name: change_id
type: VARCHAR(36)
constraints:
nullable: false
primaryKey: true
primaryKeyName: group_change_pkey
- column:
name: group_id
type: VARCHAR(255)
constraints:
nullable: false
- column:
name: user_id
type: VARCHAR(255)
constraints:
nullable: false
- column:
name: change_date
type: TIMESTAMP WITH TIME ZONE
constraints:
nullable: false
- column:
name: change_type
type: VARCHAR(50)
constraints:
nullable: false
- addForeignKeyConstraint:
baseTableName: group_change
baseColumnNames: group_id
referencedTableName: group_redaction
referencedColumnNames: group_id
constraintName: fk_group_change_change_id

37
persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/tenant/136-add-property-changes-table.yaml
View File

@ -1,37 +0,0 @@
databaseChangeLog:
- changeSet:
id: 136-create-property-change-table
author: aisvoran
changes:
- createTable:
tableName: property_change
columns:
- column:
name: property_change_id
type: VARCHAR(36)
constraints:
nullable: false
primaryKey: true
primaryKeyName: property_change_pkey
- column:
name: change_id
type: VARCHAR(255)
constraints:
nullable: false
- column:
name: property_name
type: VARCHAR(255)
constraints:
nullable: false
- column:
name: property_old_value
type: VARCHAR(255)
- column:
name: property_new_value
type: VARCHAR(255)
- addForeignKeyConstraint:
baseTableName: property_change
baseColumnNames: change_id
referencedTableName: group_change
referencedColumnNames: change_id
constraintName: fk_property_change_change_id

51
persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/tenant/137-add-area-position-table.yaml
View File

@ -1,51 +0,0 @@
databaseChangeLog:
- changeSet:
id: 137-add-area-position-table
author: aisvoran
changes:
- createTable:
tableName: area_group_position
columns:
- column:
name: position_id
type: VARCHAR(36)
constraints:
nullable: false
primaryKey: true
primaryKeyName: area_group_positions_pkey
- column:
name: group_id
type: VARCHAR(36)
constraints:
nullable: false
- column:
name: x
type: FLOAT
constraints:
nullable: false
- column:
name: y
type: FLOAT
constraints:
nullable: false
- column:
name: width
type: FLOAT
constraints:
nullable: false
- column:
name: height
type: FLOAT
constraints:
nullable: false
- column:
name: page_number
type: INTEGER
constraints:
nullable: false
- addForeignKeyConstraint:
baseTableName: area_group_position
baseColumnNames: group_id
referencedTableName: group_redaction
referencedColumnNames: group_id
constraintName: fk_area_group_positions_group_id

36
persistence-service-v1/persistence-service-processor-v1/src/main/resources/db/changelog/tenant/138-add-page-range-table.yaml
View File

@ -1,36 +0,0 @@
databaseChangeLog:
- changeSet:
id: 138-add-page-range-table
author: aisvoran
changes:
- createTable:
tableName: area_group_page_range
columns:
- column:
name: page_range_id
type: VARCHAR(36)
constraints:
nullable: false
primaryKey: true
primaryKeyName: area_group_page_range_pkey
- column:
name: group_id
type: VARCHAR(36)
constraints:
nullable: false
- column:
name: start_page
type: INTEGER
constraints:
nullable: false
- column:
name: end_page
type: INTEGER
constraints:
nullable: false
- addForeignKeyConstraint:
baseTableName: area_group_page_range
baseColumnNames: group_id
referencedTableName: group_redaction
referencedColumnNames: group_id
constraintName: fk_area_group_page_ranges_group_id

1
persistence-service-v1/persistence-service-processor-v1/src/main/resources/mongo/changelog/mongo.changelog-tenant.xml
View File

@ -7,5 +7,4 @@
<include file="/mongo/changelog/tenant/3-add-page-paragraph-idx.xml"/>
<include file="/mongo/changelog/tenant/4-create-component-entities.xml"/>
<include file="/mongo/changelog/tenant/5-add-duplicate-text-ranges.xml"/>
<include file="/mongo/changelog/tenant/6-add-group-id.xml"/>
</databaseChangeLog>

25
persistence-service-v1/persistence-service-processor-v1/src/main/resources/mongo/changelog/tenant/6-add-group-id.xml
View File

@ -1,25 +0,0 @@
<databaseChangeLog
xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:ext="http://www.liquibase.org/xml/ns/dbchangelog-ext"
xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-4.20.xsd
http://www.liquibase.org/xml/ns/dbchangelog-ext http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-ext.xsd">
<changeSet id="6" author="aisvoran">
<ext:runCommand>
<ext:command>
{
update: "entity-log-entries",
updates: [
{
q: {},
u: { $set: { "groupId": null } },
multi: true
}
]
}
</ext:command>
</ext:runCommand>
</changeSet>
</databaseChangeLog>

10
persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/client/GroupAnnotationExternalClient.java
View File

@ -1,10 +0,0 @@
package com.iqser.red.service.peristence.v1.server.integration.client;
import org.springframework.cloud.openfeign.FeignClient;
import com.iqser.red.service.persistence.service.v1.api.external.resource.GroupAnnotationResource;
@FeignClient(name = "GroupAnnotationExternalClient", url = "http://localhost:${server.port}", configuration = FeignSupportConfig.class)
public interface GroupAnnotationExternalClient extends GroupAnnotationResource {
}

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

@ -33,10 +33,8 @@ import com.iqser.red.service.persistence.management.v1.processor.service.Dossier
import com.iqser.red.service.persistence.management.v1.processor.service.EntityLogMergeService;
import com.iqser.red.service.persistence.management.v1.processor.service.FileManagementStorageService;
import com.iqser.red.service.persistence.management.v1.processor.service.FileStatusService;
import com.iqser.red.service.persistence.management.v1.processor.service.group.GroupAnnotationPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.manualredactions.ManualRedactionProviderService;
import com.iqser.red.service.persistence.management.v1.processor.service.manualredactions.PendingDictionaryEntryFactory;
import com.iqser.red.service.persistence.management.v1.processor.service.manualredactions.PendingGroupAnnotationFactory;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DictionaryPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DossierTemplatePersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.FileStatusPersistenceService;
@ -96,9 +94,6 @@ public class EntityLogMergeTest {
@MockBean
private EntityLogMongoService entityLogMongoService;
@MockBean
private GroupAnnotationPersistenceService groupAnnotationPersistenceService;
@Captor
private ArgumentCaptor<AnalyzeRequest> captor;
@ -108,7 +103,7 @@ public class EntityLogMergeTest {
@BeforeEach
public void setUp() {
entityLogMergeService = new EntityLogMergeService(dictionaryPersistenceService, new PendingDictionaryEntryFactory(), entityLogMongoService, new PendingGroupAnnotationFactory());
entityLogMergeService = new EntityLogMergeService(dictionaryPersistenceService, new PendingDictionaryEntryFactory(), entityLogMongoService);
}
@ -146,7 +141,7 @@ public class EntityLogMergeTest {
when(fileStatusPersistenceService.getStatus(fileId)).thenReturn(FileEntity.builder().id(fileId).fileAttributes(Collections.emptyList()).build());
when(fileStatusService.convertAttributes(any(), anyString())).thenReturn(Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build(), Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build());
assertNotNull(response);
assertFalse(response.getEntityLogEntry().isEmpty());
@ -320,7 +315,7 @@ public class EntityLogMergeTest {
when(fileStatusPersistenceService.getStatus(fileId)).thenReturn(FileEntity.builder().id(fileId).fileAttributes(Collections.emptyList()).build());
when(fileStatusService.convertAttributes(any(), anyString())).thenReturn(Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build(), Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build());
assertNotNull(response);
assertFalse(response.getEntityLogEntry().isEmpty());
@ -393,7 +388,7 @@ public class EntityLogMergeTest {
when(fileStatusPersistenceService.getStatus(fileId)).thenReturn(FileEntity.builder().id(fileId).fileAttributes(Collections.emptyList()).build());
when(fileStatusService.convertAttributes(any(), anyString())).thenReturn(Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build(), Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build());
var resizedEntry = response.getEntityLogEntry()
.stream()
@ -438,7 +433,7 @@ public class EntityLogMergeTest {
when(fileStatusPersistenceService.getStatus(FILE_ID)).thenReturn(FileEntity.builder().id(FILE_ID).fileAttributes(Collections.emptyList()).build());
when(fileStatusService.convertAttributes(any(), anyString())).thenReturn(Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build(), Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build());
assertNotNull(response);
assertFalse(response.getEntityLogEntry().isEmpty());
@ -493,7 +488,7 @@ public class EntityLogMergeTest {
when(fileStatusPersistenceService.getStatus(FILE_ID)).thenReturn(FileEntity.builder().id(FILE_ID).fileAttributes(Collections.emptyList()).build());
when(fileStatusService.convertAttributes(any(), anyString())).thenReturn(Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build(), Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build());
assertNotNull(response);
assertFalse(response.getEntityLogEntry().isEmpty());
@ -547,7 +542,7 @@ public class EntityLogMergeTest {
when(fileStatusPersistenceService.getStatus(FILE_ID)).thenReturn(FileEntity.builder().id(FILE_ID).fileAttributes(Collections.emptyList()).build());
when(fileStatusService.convertAttributes(any(), anyString())).thenReturn(Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build(), Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build());
assertNotNull(response);
assertFalse(response.getEntityLogEntry().isEmpty());
@ -593,7 +588,7 @@ public class EntityLogMergeTest {
when(fileStatusPersistenceService.getStatus(FILE_ID)).thenReturn(FileEntity.builder().id(FILE_ID).fileAttributes(Collections.emptyList()).build());
when(fileStatusService.convertAttributes(any(), anyString())).thenReturn(Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build(), Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build());
assertNotNull(response);
assertFalse(response.getEntityLogEntry().isEmpty());
@ -662,7 +657,7 @@ public class EntityLogMergeTest {
when(fileStatusPersistenceService.getStatus(FILE_ID)).thenReturn(FileEntity.builder().id(FILE_ID).fileAttributes(Collections.emptyList()).build());
when(fileStatusService.convertAttributes(any(), anyString())).thenReturn(Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build(), Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build());
assertNotNull(response);
assertFalse(response.getEntityLogEntry().isEmpty());
@ -719,7 +714,7 @@ public class EntityLogMergeTest {
when(fileStatusPersistenceService.getStatus(FILE_ID)).thenReturn(FileEntity.builder().id(FILE_ID).fileAttributes(Collections.emptyList()).build());
when(fileStatusService.convertAttributes(any(), anyString())).thenReturn(Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build(), Collections.emptyList());
EntityLog response = entityLogMergeService.mergeEntityLog(manualRedactions, entityLog, DossierEntity.builder().dossierTemplateId(dossierTemplateId).build());
assertNotNull(response);
assertFalse(response.getEntityLogEntry().isEmpty());

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

@ -1,318 +0,0 @@
package com.iqser.red.service.peristence.v1.server.integration.tests;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.List;
import org.jetbrains.annotations.NotNull;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import com.iqser.red.service.peristence.v1.server.integration.client.GroupAnnotationExternalClient;
import com.iqser.red.service.peristence.v1.server.integration.service.DossierTemplateTesterAndProvider;
import com.iqser.red.service.peristence.v1.server.integration.service.DossierTesterAndProvider;
import com.iqser.red.service.peristence.v1.server.integration.service.FileTesterAndProvider;
import com.iqser.red.service.peristence.v1.server.integration.utils.AbstractPersistenceServerServiceTest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.PageRange;
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.group.AddAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.AddTextGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ChangePageRangeAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ChangeValueAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotationType;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.PositionOnPage;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.RecategorizeGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.ResizeAreaGroupAnnotationRequestModel;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.UpdateLegalBasisRequestModel;
import feign.FeignException;
public class GroupAnnotationTest extends AbstractPersistenceServerServiceTest {
@Autowired
private DossierTemplateTesterAndProvider dossierTemplateTesterAndProvider;
@Autowired
private DossierTesterAndProvider dossierTesterAndProvider;
@Autowired
private FileTesterAndProvider fileTesterAndProvider;
@Autowired
private GroupAnnotationExternalClient groupRedactionExternalClient;
@Test
public void testCreateTextGroupRedaction() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
List<AddTextGroupAnnotationRequestModel> addTextGroupRedactionRequestModels = getAddTextGroupRedactionRequestModels();
var response = groupRedactionExternalClient.addTextGroupAnnotation(dossier.getId(), file.getFileId(), addTextGroupRedactionRequestModels);
assertNotNull(response);
assertEquals(response.getGroupAnnotations().size(), 1);
assertEquals(response.getGroupAnnotations()
.get(0).getValue(), "value");
}
private static @NotNull List<AddTextGroupAnnotationRequestModel> getAddTextGroupRedactionRequestModels() {
List<AddTextGroupAnnotationRequestModel> addTextGroupRedactionRequestModels = new ArrayList<>();
addTextGroupRedactionRequestModels.add(new AddTextGroupAnnotationRequestModel("CBI_author",
"value",
"legalBasis",
EntryType.ENTITY,
PositionOnPage.builder().height(1).width(1).x(1).y(1).build(),
GroupAnnotationType.TEXT));
return addTextGroupRedactionRequestModels;
}
@Test
public void testCreateAreaGroupRedaction() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
List<AddAreaGroupAnnotationRequestModel> addAreaGroupRedactionRequestModels = getAddAreaGroupRedactionRequestModels();
var response = groupRedactionExternalClient.addAreaGroupAnnotation(dossier.getId(), file.getFileId(), addAreaGroupRedactionRequestModels);
assertNotNull(response);
assertEquals(response.getGroupAnnotations().size(), 1);
assertEquals(response.getGroupAnnotations()
.get(0).getValue(), "value");
}
@Test
public void testGetAllGroupRedaction() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
List<AddTextGroupAnnotationRequestModel> addTextGroupRedactionRequestModels = getAddTextGroupRedactionRequestModels();
groupRedactionExternalClient.addTextGroupAnnotation(dossier.getId(), file.getFileId(), addTextGroupRedactionRequestModels);
List<AddAreaGroupAnnotationRequestModel> addAreaGroupRedactionRequestModels = getAddAreaGroupRedactionRequestModels();
var area = groupRedactionExternalClient.addAreaGroupAnnotation(dossier.getId(), file.getFileId(), addAreaGroupRedactionRequestModels);
var response = groupRedactionExternalClient.getGroupAnnotations(dossier.getId(), file.getFileId(), false);
assertEquals(response.getGroupAnnotations().size(), 2);
groupRedactionExternalClient.removeGroupAnnotation(dossier.getId(),
file.getFileId(),
List.of(GroupAnnotationRequestModel.builder()
.groupId(area.getGroupAnnotations()
.get(0).getGroupId())
.build()));
response = groupRedactionExternalClient.getGroupAnnotations(dossier.getId(), file.getFileId(), false);
assertEquals(response.getGroupAnnotations().size(), 1);
response = groupRedactionExternalClient.getGroupAnnotations(dossier.getId(), file.getFileId(), true);
assertEquals(response.getGroupAnnotations().size(), 2);
}
private static @NotNull List<AddAreaGroupAnnotationRequestModel> getAddAreaGroupRedactionRequestModels() {
List<AddAreaGroupAnnotationRequestModel> addAreaGroupRedactionRequestModels = new ArrayList<>();
addAreaGroupRedactionRequestModels.add(new AddAreaGroupAnnotationRequestModel("CBI_author",
"value",
"legalBasis",
EntryType.ENTITY,
GroupAnnotationType.AREA,
PositionOnPage.builder().height(1).width(1).x(1).y(1).build(),
List.of(PageRange.builder().startPage(1).endPage(2).build()),
"section"));
return addAreaGroupRedactionRequestModels;
}
@Test
public void testUpdateLegalBasis() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
List<AddTextGroupAnnotationRequestModel> addTextGroupRedactionRequestModels = getAddTextGroupRedactionRequestModels();
var text = groupRedactionExternalClient.addTextGroupAnnotation(dossier.getId(), file.getFileId(), addTextGroupRedactionRequestModels);
var response = groupRedactionExternalClient.updateLegalBasis(dossier.getId(),
file.getFileId(),
List.of(UpdateLegalBasisRequestModel.builder()
.groupId(text.getGroupAnnotations()
.get(0).getGroupId())
.legalBasis("new legal basis")
.build()));
assertEquals(response.getGroupAnnotations()
.get(0).getLegalBasis(), "new legal basis");
}
@Test
public void testRecategorize() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
List<AddTextGroupAnnotationRequestModel> addTextGroupRedactionRequestModels = getAddTextGroupRedactionRequestModels();
var text = groupRedactionExternalClient.addTextGroupAnnotation(dossier.getId(), file.getFileId(), addTextGroupRedactionRequestModels);
var response = groupRedactionExternalClient.recategorizeGroupAnnotation(dossier.getId(),
file.getFileId(),
List.of(RecategorizeGroupAnnotationRequestModel.builder()
.groupId(text.getGroupAnnotations()
.get(0).getGroupId())
.typeId("PII")
.build()));
assertEquals(response.getGroupAnnotations()
.get(0).getTypeId(), "PII");
}
@Test
public void testResize() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
List<AddAreaGroupAnnotationRequestModel> addAreaGroupRedactionRequestModels = getAddAreaGroupRedactionRequestModels();
var area = groupRedactionExternalClient.addAreaGroupAnnotation(dossier.getId(), file.getFileId(), addAreaGroupRedactionRequestModels);
var response = groupRedactionExternalClient.resizeGroupAnnotation(dossier.getId(),
file.getFileId(),
List.of(ResizeAreaGroupAnnotationRequestModel.builder()
.groupId(area.getGroupAnnotations()
.get(0).getGroupId())
.positionOnPage(PositionOnPage.builder()
.pageNumber(1)
.width(2)
.height(3)
.x(4)
.y(5)
.build())
.build()));
assertEquals(response.getGroupAnnotations()
.get(0).getPositionOnPage().getPageNumber(), 1);
assertEquals(response.getGroupAnnotations()
.get(0).getPositionOnPage().getHeight(), 3);
assertEquals(response.getGroupAnnotations()
.get(0).getPositionOnPage().getWidth(), 2);
assertEquals(response.getGroupAnnotations()
.get(0).getPositionOnPage().getX(), 4);
assertEquals(response.getGroupAnnotations()
.get(0).getPositionOnPage().getY(), 5);
}
@Test
public void testForce() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
List<AddTextGroupAnnotationRequestModel> addTextGroupRedactionRequestModels = new ArrayList<>();
addTextGroupRedactionRequestModels.add(new AddTextGroupAnnotationRequestModel("CBI_author",
"value",
"legalBasis",
EntryType.HINT,
PositionOnPage.builder().height(1).width(1).x(1).y(1).build(),
GroupAnnotationType.TEXT));
var text = groupRedactionExternalClient.addTextGroupAnnotation(dossier.getId(), file.getFileId(), addTextGroupRedactionRequestModels);
var response = groupRedactionExternalClient.forceGroupAnnotation(dossier.getId(),
file.getFileId(),
List.of(GroupAnnotationRequestModel.builder()
.groupId(text.getGroupAnnotations()
.get(0).getGroupId())
.build()));
assertEquals(response.getGroupAnnotations()
.get(0).getEntryType(), EntryType.ENTITY);
}
@Test
public void testChangeValue() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
List<AddAreaGroupAnnotationRequestModel> addAreaGroupRedactionRequestModels = getAddAreaGroupRedactionRequestModels();
var area = groupRedactionExternalClient.addAreaGroupAnnotation(dossier.getId(), file.getFileId(), addAreaGroupRedactionRequestModels);
var response = groupRedactionExternalClient.changeValueGroupAnnotation(dossier.getId(),
file.getFileId(),
List.of(ChangeValueAreaGroupAnnotationRequestModel.builder()
.groupId(area.getGroupAnnotations()
.get(0).getGroupId())
.value("new value")
.build()));
assertEquals(response.getGroupAnnotations()
.get(0).getValue(), "new value");
}
@Test
public void testChangePageRanges() {
var dossierTemplate = dossierTemplateTesterAndProvider.provideTestTemplate();
var dossier = dossierTesterAndProvider.provideTestDossier(dossierTemplate);
var file = fileTesterAndProvider.testAndProvideFile(dossier);
List<AddAreaGroupAnnotationRequestModel> addAreaGroupRedactionRequestModels = getAddAreaGroupRedactionRequestModels();
var area = groupRedactionExternalClient.addAreaGroupAnnotation(dossier.getId(), file.getFileId(), addAreaGroupRedactionRequestModels);
var error = assertThrows(FeignException.class,
() -> groupRedactionExternalClient.changePageRangeGroupAnnotation(dossier.getId(),
file.getFileId(),
List.of(ChangePageRangeAreaGroupAnnotationRequestModel.builder()
.groupId(area.getGroupAnnotations()
.get(0).getGroupId())
.pageRanges(List.of(PageRange.builder()
.startPage(20)
.endPage(10)
.build()))
.build())));
assertTrue(error.getMessage().contains("Page range start can not be higher than page range end!"));
var response = groupRedactionExternalClient.changePageRangeGroupAnnotation(dossier.getId(),
file.getFileId(),
List.of(ChangePageRangeAreaGroupAnnotationRequestModel.builder()
.groupId(area.getGroupAnnotations()
.get(0).getGroupId())
.pageRanges(List.of(PageRange.builder().startPage(10).endPage(20).build()))
.build()));
assertEquals("[10, 20]",
response.getGroupAnnotations()
.get(0).getGroupChanges()
.get(0).getPropertyChanges()
.get(0).getPropertyNewValue());
}
}

6
persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/utils/AbstractPersistenceServerServiceTest.java
View File

@ -72,7 +72,6 @@ import com.iqser.red.service.persistence.management.v1.processor.roles.Applicati
import com.iqser.red.service.persistence.management.v1.processor.service.ApplicationConfigService;
import com.iqser.red.service.persistence.management.v1.processor.service.EntityLogService;
import com.iqser.red.service.persistence.management.v1.processor.service.FileManagementStorageService;
import com.iqser.red.service.persistence.management.v1.processor.service.group.GroupAnnotationService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.ApplicationConfigRepository;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.AuditRepository;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.CommentRepository;
@ -105,7 +104,6 @@ import com.iqser.red.service.persistence.management.v1.processor.service.persist
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.dictionaryentry.EntryRepository;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.dictionaryentry.FalsePositiveEntryRepository;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.dictionaryentry.FalseRecommendationEntryRepository;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.group.GroupAnnotationRepository;
import com.iqser.red.service.persistence.management.v1.processor.service.users.UserService;
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.dossiertemplate.configuration.ApplicationConfig;
@ -240,8 +238,6 @@ public abstract class AbstractPersistenceServerServiceTest {
protected FalseRecommendationEntryRepository falseRecommendationEntryRepository;
@Autowired
protected ApplicationConfigRepository applicationConfigRepository;
@Autowired
protected GroupAnnotationRepository groupAnnotationRepository;
@MockBean
protected RedactionClient redactionClient;
@Autowired
@ -276,8 +272,6 @@ public abstract class AbstractPersistenceServerServiceTest {
protected CommentRepository commentRepository;
@Autowired
protected ResizeRedactionRepository resizeRedactionRepository;
@Autowired
protected GroupAnnotationService groupAnnotationService;
@MockBean
protected TenantAuthenticationManagerResolver tenantAuthenticationManagerResolver;

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

@ -5,7 +5,6 @@ import java.util.Set;
import com.iqser.red.service.persistence.service.v1.api.shared.model.annotations.ManualRedactions;
import com.iqser.red.service.persistence.service.v1.api.shared.model.component.ComponentMappingMetadata;
import com.iqser.red.service.persistence.service.v1.api.shared.model.group.GroupAnnotation;
import lombok.AllArgsConstructor;
import lombok.Builder;
@ -38,8 +37,6 @@ public class AnalyzeResult {
private ManualRedactions manualRedactions;
private Set<GroupAnnotation> groupAnnotations;
private Set<FileAttribute> addedFileAttributes;
private List<ComponentMappingMetadata> usedComponentMappings;

3
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/analysislog/entitylog/Engine.java
View File

@ -6,6 +6,5 @@ public enum Engine {
RULE,
MANUAL,
IMPORTED,
DOSSIER_DICTIONARY,
GROUP
DOSSIER_DICTIONARY
}

2
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/analysislog/entitylog/EntityLogEntry.java
View File

@ -79,6 +79,4 @@ public class EntityLogEntry {
List<DuplicatedTextRange> duplicatedTextRanges;
String groupId;
}

1
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/analysislog/entitylog/EntityLogEntryResponse.java
View File

@ -75,6 +75,5 @@ public class EntityLogEntryResponse {
int numberOfComments;
int paragraphPageIdx;
String groupId;
}

41
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/AddAreaGroupAnnotationRequestModel.java
View File

@ -1,41 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import java.util.List;
import com.iqser.red.service.persistence.service.v1.api.shared.model.PageRange;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
import jakarta.validation.constraints.NotEmpty;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
@Data
@EqualsAndHashCode(callSuper = true)
@NoArgsConstructor
@AllArgsConstructor
public class AddAreaGroupAnnotationRequestModel extends AddGroupAnnotationRequestModel {
public AddAreaGroupAnnotationRequestModel(String type,
String value,
String legalBasis,
EntryType entryType,
@NotNull(message = "GroupAnnotationType is required") GroupAnnotationType groupAnnotationType,
PositionOnPage positionsOnPage,
List<PageRange> pageRanges,
String section) {
super(type, value, legalBasis, entryType, positionsOnPage, groupAnnotationType);
this.pageRanges = pageRanges;
this.section = section;
}
@NotEmpty(message = "Page ranges are required for AREA group annotation")
private List<PageRange> pageRanges;
private String section;
}

34
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/AddGroupAnnotationRequestModel.java
View File

@ -1,34 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import com.fasterxml.jackson.annotation.JsonSubTypes;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, property = "groupAnnotationType", visible = true)
@JsonSubTypes({@JsonSubTypes.Type(value = AddTextGroupAnnotationRequestModel.class, name = "TEXT"), @JsonSubTypes.Type(value = AddAreaGroupAnnotationRequestModel.class, name = "AREA")})
public class AddGroupAnnotationRequestModel {
private String type;
private String value;
private String legalBasis;
private EntryType entryType;
private PositionOnPage positionOnPage;
@NotNull(message = "GroupAnnotationType is required")
private GroupAnnotationType groupAnnotationType;
}

27
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/AddTextGroupAnnotationRequestModel.java
View File

@ -1,27 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
import jakarta.validation.constraints.NotNull;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.ToString;
@Data
@EqualsAndHashCode(callSuper = true)
@AllArgsConstructor
@ToString(callSuper = true)
public class AddTextGroupAnnotationRequestModel extends AddGroupAnnotationRequestModel {
public AddTextGroupAnnotationRequestModel(String type,
String value,
String legalBasis,
EntryType entryType,
PositionOnPage positionOnPage,
@NotNull(message = "GroupAnnotationType is required") GroupAnnotationType groupAnnotationType) {
super(type, value, legalBasis, entryType, positionOnPage, groupAnnotationType);
}
}

24
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/AreaGroupAnnotation.java
View File

@ -1,24 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import java.util.List;
import com.iqser.red.service.persistence.service.v1.api.shared.model.PageRange;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
@Data
@SuperBuilder
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = true)
public class AreaGroupAnnotation extends GroupAnnotation {
private List<PageRange> pageRanges;
private String section;
}

21
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/ChangePageRangeAreaGroupAnnotationRequestModel.java
View File

@ -1,21 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import java.util.List;
import com.iqser.red.service.persistence.service.v1.api.shared.model.PageRange;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ChangePageRangeAreaGroupAnnotationRequestModel {
private String groupId;
private List<PageRange> pageRanges;
}

18
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/ChangeValueAreaGroupAnnotationRequestModel.java
View File

@ -1,18 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ChangeValueAreaGroupAnnotationRequestModel {
private String groupId;
private String value;
}

50
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/GroupAnnotation.java
View File

@ -1,50 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import java.time.OffsetDateTime;
import java.util.ArrayList;
import java.util.List;
import com.iqser.red.service.persistence.service.v1.api.shared.model.analysislog.entitylog.EntryType;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
@Data
@SuperBuilder
@NoArgsConstructor
@AllArgsConstructor
@EqualsAndHashCode
public class GroupAnnotation {
private String groupId;
private String value;
private String fileId;
private String typeId;
private String userId;
private String legalBasis;
private EntryType entryType;
private GroupAnnotationType groupAnnotationType;
private OffsetDateTime requestDate;
private OffsetDateTime processedDate;
private OffsetDateTime softDeletedTime;
@Builder.Default
private List<GroupChange> groupChanges = new ArrayList<>();
private PositionOnPage positionOnPage;
}

20
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/GroupAnnotationInternalResponse.java
View File

@ -1,20 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import java.util.ArrayList;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GroupAnnotationInternalResponse {
List<TextGroupAnnotation> textGroupAnnotations = new ArrayList<>();
List<AreaGroupAnnotation> areaGroupAnnotations = new ArrayList<>();
}

15
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/GroupAnnotationRequestModel.java
View File

@ -1,15 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GroupAnnotationRequestModel {
private String groupId;
}

19
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/GroupAnnotationResponse.java
View File

@ -1,19 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import java.util.ArrayList;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class GroupAnnotationResponse {
List<GroupAnnotation> groupAnnotations = new ArrayList<>();
}

8
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/GroupAnnotationType.java
View File

@ -1,8 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
public enum GroupAnnotationType {
TEXT,
AREA
}

29
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/GroupChange.java
View File

@ -1,29 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import java.time.OffsetDateTime;
import java.util.ArrayList;
import java.util.List;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class GroupChange {
private String changeId;
private String userId;
private OffsetDateTime changeDate;
private GroupChangeType changeType;
@Builder.Default
private List<GroupPropertyChange> propertyChanges = new ArrayList<>();
}

12
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/GroupChangeType.java
View File

@ -1,12 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
public enum GroupChangeType {
REMOVE,
RECATEGORIZE,
LEGAL_BASIS_CHANGE,
FORCE,
RESIZE,
VALUE_CHANGE,
PAGE_RANGE_CHANGE
}

22
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/GroupPropertyChange.java
View File

@ -1,22 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class GroupPropertyChange {
private String propertyChangeId;
private String propertyName;
private String propertyOldValue;
private String propertyNewValue;
}

22
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/PositionOnPage.java
View File

@ -1,22 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
@Data
@Builder
@AllArgsConstructor
public class PositionOnPage {
private float x;
private float y;
private float width;
private float height;
private int pageNumber;
}

17
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/RecategorizeGroupAnnotationRequestModel.java
View File

@ -1,17 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class RecategorizeGroupAnnotationRequestModel {
private String groupId;
private String typeId;
}

18
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/ResizeAreaGroupAnnotationRequestModel.java
View File

@ -1,18 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ResizeAreaGroupAnnotationRequestModel {
private String groupId;
private PositionOnPage positionOnPage;
}

14
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/TextGroupAnnotation.java
View File

@ -1,14 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.SuperBuilder;
@Data
@SuperBuilder
@AllArgsConstructor
@EqualsAndHashCode(callSuper = true)
public class TextGroupAnnotation extends GroupAnnotation {
}

17
persistence-service-v1/persistence-service-shared-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/model/group/UpdateLegalBasisRequestModel.java
View File

@ -1,17 +0,0 @@
package com.iqser.red.service.persistence.service.v1.api.shared.model.group;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UpdateLegalBasisRequestModel {
private String groupId;
private String legalBasis;
}

2
persistence-service-v1/persistence-service-shared-mongo-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/shared/mongo/document/EntityLogEntryDocument.java
View File

@ -77,6 +77,4 @@ public class EntityLogEntryDocument {
List<DuplicatedTextRange> duplicatedTextRanges;
String groupId;
}