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

Pull request #190: RED-3239 Implemented feature to archive dossiers

Browse Source 
Merge in RED/persistence-service from RED-3239 to master

* commit '2e992c3f31af2b0d388d9b0d6a47cc21723369df':
  RED-3239 Implemented feature to archive dossiers
This commit is contained in:
Philipp Schramm 2022-01-25 09:48:50 +01:00 committed by Dominique Eiflaender
commit 9430096f87
20 changed files with 336 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
persistence-service-v1/persistence-service-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/model/dossiertemplate/dossier/Dossier.java
View File

@ -34,6 +34,7 @@ public class Dossier {
private OffsetDateTime hardDeletedTime;
private OffsetDateTime startDate;
private OffsetDateTime dueDate;
private OffsetDateTime archivedTime;
private String dossierTemplateId;
}

1
persistence-service-v1/persistence-service-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/model/dossiertemplate/dossier/DossierInformation.java
View File

@ -6,6 +6,7 @@ import lombok.Data;
public class DossierInformation {
private int numberOfActiveDossiers;
private int numberOfArchivedDossiers;
private int numberOfSoftDeletedDossiers;
private int numberOfHardDeletedDossiers;

2
persistence-service-v1/persistence-service-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/model/dossiertemplate/dossier/DossierStatus.java
View File

@ -1,5 +1,5 @@
package com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.dossier;
public enum DossierStatus {
ACTIVE, DELETED
ACTIVE, ARCHIVED, DELETED
}

18
persistence-service-v1/persistence-service-api-v1/src/main/java/com/iqser/red/service/persistence/service/v1/api/resources/DossierResource.java
View File

@ -22,10 +22,15 @@ public interface DossierResource {
String HARD_DELETE_PATH = "/hardDelete";
String UNDELETE_PATH = "/undelete";
String ARCHIVE_DOSSIERS_PATH = "/archivedDossiers";
String ARCHIVE_PATH = "/archive";
String UNARCHIVE_PATH = "/unarchive";
String DOSSIER_ID_PARAM = "dossierId";
String DOSSIER_ID_PATH_PARAM = "/{" + DOSSIER_ID_PARAM + "}";
String INCLUDE_DELETED_PARAM = "includeDeleted";
String INCLUDE_ARCHIVED_PARAM = "includeArchived";
String CHANGES_PATH = "/changes";
@ -44,15 +49,20 @@ public interface DossierResource {
void delete(@PathVariable(DOSSIER_ID_PARAM) String dossierId);
@GetMapping(value = REST_PATH, produces = MediaType.APPLICATION_JSON_VALUE)
List<Dossier> getAllDossiers();
List<Dossier> getAllDossiers(@RequestParam(name = INCLUDE_ARCHIVED_PARAM, defaultValue = "false", required = false) boolean includeArchived,
@RequestParam(name = INCLUDE_DELETED_PARAM, defaultValue = "false", required = false) boolean includeDeleted);
@GetMapping(value = REST_PATH + INFO_PATH, produces = MediaType.APPLICATION_JSON_VALUE)
DossierInformation getDossierInformation();
@GetMapping(value = REST_PATH + DOSSIER_ID_PATH_PARAM, produces = MediaType.APPLICATION_JSON_VALUE)
Dossier getDossierById(@PathVariable(DOSSIER_ID_PARAM) String dossierId,
@RequestParam(name = INCLUDE_ARCHIVED_PARAM, defaultValue = "false", required = false) boolean includeArchived,
@RequestParam(name = INCLUDE_DELETED_PARAM, defaultValue = "false", required = false) boolean includeDeleted);
@GetMapping(value = ARCHIVE_DOSSIERS_PATH, produces = MediaType.APPLICATION_JSON_VALUE)
List<Dossier> getArchivedDossiers();
@GetMapping(value = DELETED_DOSSIERS_PATH, produces = MediaType.APPLICATION_JSON_VALUE)
List<Dossier> getSoftDeletedDossiers();
@ -62,4 +72,10 @@ public interface DossierResource {
@PostMapping(value = DELETED_DOSSIERS_PATH + UNDELETE_PATH)
void undeleteDossiers(@RequestBody Set<String> dossierIds);
@PostMapping(value = ARCHIVE_DOSSIERS_PATH + ARCHIVE_PATH)
void archiveDossiers(@RequestBody Set<String> dossierIds);
@PostMapping(value = ARCHIVE_DOSSIERS_PATH + UNARCHIVE_PATH)
void unarchiveDossiers(@RequestBody Set<String> dossierIds);
}

3
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/entity/dossier/DossierEntity.java
View File

@ -70,6 +70,9 @@ public class DossierEntity {
@Column
private OffsetDateTime hardDeletedTime;
@Column
private OffsetDateTime archivedTime;
@Column
private OffsetDateTime startDate;

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

@ -79,7 +79,7 @@ public class DossierPersistenceService {
public DossierEntity getAndValidateDossier(String dossierId) {
// check whether the dossierId exists and is not deleted
var dossier = findByDossierId(dossierId);
if (dossier == null || dossier.getStatus().equals(DossierStatus.DELETED)) {
if (dossier == null || dossier.getStatus().equals(DossierStatus.DELETED) || dossier.getStatus().equals(DossierStatus.ARCHIVED)) {
throw new DossierNotFoundException(String.format(DOSSIER_NOT_FOUND_MESSAGE, dossierId));
}
return dossier;
@ -136,4 +136,19 @@ public class DossierPersistenceService {
return dossierChanges;
}
@Transactional
public void archiveDossier(String dossierId) {
dossierRepository.archiveDossier(dossierId, DossierStatus.ARCHIVED, OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS));
}
@Transactional
public void unarchiveDossier(String dossierId) {
int updateCount = dossierRepository.unarchiveDossier(dossierId, DossierStatus.ACTIVE, OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS));
if (updateCount == 0) {
throw new BadRequestException("Cannot unarchive dossier!");
}
}
}

38
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/service/persistence/repository/DossierRepository.java
View File

@ -15,16 +15,6 @@ public interface DossierRepository extends JpaRepository<DossierEntity, String>
@Query("select d.id from DossierEntity d where d.lastUpdated > :since")
List<String> findDossierChangeByLastUpdatedIsAfter(OffsetDateTime since);
@Modifying
@Query("update DossierEntity d set d.status = :dossierStatus, d.hardDeletedTime = :hardDeletedTime, d.lastUpdated = :lastUpdated," +
" d.softDeletedTime = " +
"case " +
"when d.softDeletedTime is null then :hardDeletedTime " +
"when d.softDeletedTime is not null then d.softDeletedTime " +
"end " +
"where d.id = :dossierId")
void hardDelete(String dossierId, DossierStatus dossierStatus, OffsetDateTime hardDeletedTime, OffsetDateTime lastUpdated);
@Modifying
@Query("update DossierEntity d set d.status = :dossierStatus, d.softDeletedTime = null, d.lastUpdated = :lastUpdated where d.id = :dossierId" +
" and d.hardDeletedTime is null")
@ -34,5 +24,33 @@ public interface DossierRepository extends JpaRepository<DossierEntity, String>
@Query("update DossierEntity d set d.status = :dossierStatus, d.softDeletedTime = :softDeletedTime, d.lastUpdated = :lastUpdated where d.id = :dossierId")
void markDossierAsDeleted(String dossierId, DossierStatus dossierStatus, OffsetDateTime softDeletedTime, OffsetDateTime lastUpdated);
@Modifying
@Query("update DossierEntity d set d.status = :dossierStatus, d.hardDeletedTime = :hardDeletedTime, d.lastUpdated = :lastUpdated, " +
"d.softDeletedTime = " +
"case " +
"when d.softDeletedTime is null then :hardDeletedTime " +
"else d.softDeletedTime " +
"end " +
"where d.id = :dossierId")
void hardDelete(String dossierId, DossierStatus dossierStatus, OffsetDateTime hardDeletedTime, OffsetDateTime lastUpdated);
@Modifying
@Query("update DossierEntity d set d.archivedTime = :archiveTime, d.lastUpdated = :archiveTime, " +
"d.status = " +
"case " +
"when d.softDeletedTime is null then :dossierStatus " +
"else d.status " +
"end " +
"where d.id = :dossierId")
void archiveDossier(String dossierId, DossierStatus dossierStatus, OffsetDateTime archiveTime);
@Modifying
@Query("update DossierEntity d set d.lastUpdated = :lastUpdated, d.archivedTime = null, " +
"d.status = " +
"case " +
"when d.softDeletedTime is null then :dossierStatus " +
"else d.status " +
"end " +
"where d.id = :dossierId")
int unarchiveDossier(String dossierId, DossierStatus dossierStatus, OffsetDateTime lastUpdated);
}

78
persistence-service-v1/persistence-service-server-v1/src/main/java/com/iqser/red/service/peristence/v1/server/controller/DossierController.java
View File

@ -3,6 +3,7 @@ package com.iqser.red.service.peristence.v1.server.controller;
import com.iqser.red.service.peristence.v1.server.service.DossierService;
import com.iqser.red.service.peristence.v1.server.service.FileService;
import com.iqser.red.service.peristence.v1.server.service.FileStatusService;
import com.iqser.red.service.peristence.v1.server.service.IndexingService;
import com.iqser.red.service.peristence.v1.server.utils.DossierMapper;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.DossierEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.FileEntity;
@ -10,8 +11,10 @@ import com.iqser.red.service.persistence.management.v1.processor.exception.Dossi
import com.iqser.red.service.persistence.service.v1.api.model.common.JSONPrimitive;
import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.dossier.*;
import com.iqser.red.service.persistence.service.v1.api.resources.DossierResource;
import com.iqser.red.service.search.v1.model.IndexMessageType;
import feign.Param;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
@ -26,6 +29,7 @@ import java.util.stream.Collectors;
import static com.iqser.red.service.persistence.management.v1.processor.exception.DossierNotFoundException.DOSSIER_NOT_FOUND_MESSAGE;
import static com.iqser.red.service.persistence.management.v1.processor.utils.MagicConverter.convert;
@Slf4j
@RestController
@RequiredArgsConstructor
public class DossierController implements DossierResource {
@ -33,6 +37,7 @@ public class DossierController implements DossierResource {
private final DossierService dossierService;
private final FileStatusService fileStatusService;
private final FileService fileService;
private final IndexingService indexingService;
@Override
@ -76,16 +81,22 @@ public class DossierController implements DossierResource {
});
dossierService.softDeleteDossier(dossierId, now);
}
@Override
@Transactional
public List<Dossier> getAllDossiers() {
public List<Dossier> getAllDossiers(@RequestParam(name = INCLUDE_ARCHIVED_PARAM, defaultValue = "false", required = false) boolean includeArchived,
@RequestParam(name = INCLUDE_DELETED_PARAM, defaultValue = "false", required = false) boolean includeDeleted) {
if (includeDeleted && includeArchived) {
return convert(dossierService.getAllDossiers(), Dossier.class, new DossierMapper());
}
return convert(dossierService.getAllDossiers()
.stream()
.filter(p -> p.getStatus().equals(DossierStatus.ACTIVE))
.filter(p -> p.getStatus().equals(DossierStatus.ACTIVE) || includeDeleted && p.getStatus().equals(DossierStatus.DELETED) || includeArchived && p.getStatus().equals(DossierStatus.ARCHIVED))
.collect(Collectors.toList()), Dossier.class, new DossierMapper());
}
@ -98,6 +109,8 @@ public class DossierController implements DossierResource {
dossierInformation.setNumberOfHardDeletedDossiers(dossierInformation.getNumberOfHardDeletedDossiers() + 1);
} else if (d.getSoftDeletedTime() != null) {
dossierInformation.setNumberOfSoftDeletedDossiers(dossierInformation.getNumberOfSoftDeletedDossiers() + 1);
} else if (d.getArchivedTime() != null) {
dossierInformation.setNumberOfArchivedDossiers(dossierInformation.getNumberOfArchivedDossiers() + 1);
} else {
dossierInformation.setNumberOfActiveDossiers(dossierInformation.getNumberOfActiveDossiers() + 1);
}
@ -110,9 +123,13 @@ public class DossierController implements DossierResource {
@Override
@Transactional
public Dossier getDossierById(@Param(DOSSIER_ID_PARAM) @PathVariable(DOSSIER_ID_PARAM) String dossierId,
@RequestParam(name = INCLUDE_ARCHIVED_PARAM, defaultValue = "false", required = false) boolean includeArchived,
@RequestParam(name = INCLUDE_DELETED_PARAM, defaultValue = "false", required = false) boolean includeDeleted) {
DossierEntity dossier = dossierService.getDossierById(dossierId);
if (dossier.getStatus().equals(DossierStatus.ARCHIVED) && !includeArchived) {
throw new DossierNotFoundException(String.format(DOSSIER_NOT_FOUND_MESSAGE, dossierId));
}
if (dossier.getStatus().equals(DossierStatus.DELETED) && !includeDeleted) {
throw new DossierNotFoundException(String.format(DOSSIER_NOT_FOUND_MESSAGE, dossierId));
}
@ -120,6 +137,20 @@ public class DossierController implements DossierResource {
}
@Override
@Transactional
public List<Dossier> getArchivedDossiers() {
var archivedDossiers = convert(dossierService.getAllDossiers()
.stream()
.filter(p -> p.getStatus().equals(DossierStatus.ARCHIVED) && p.getHardDeletedTime() == null)
.collect(Collectors.toList()), Dossier.class, new DossierMapper());
archivedDossiers.sort((dossier1, dossier2) -> dossier2.getArchivedTime().compareTo(dossier1.getArchivedTime()));
return archivedDossiers;
}
@Override
@Transactional
public List<Dossier> getSoftDeletedDossiers() {
@ -157,8 +188,8 @@ public class DossierController implements DossierResource {
var dossier = dossierService.getDossierById(dossierId);
List<FileEntity> fileStatuses = fileStatusService.getDossierStatus(dossierId);
fileStatuses.forEach(fileStatus -> {
if (fileStatus.getDeleted().equals(dossier.getSoftDeletedTime()) || fileStatus.getDeleted()
.isAfter(dossier.getSoftDeletedTime())) {
if (fileStatus.getDeleted() != null && (fileStatus.getDeleted().equals(dossier.getSoftDeletedTime()) || fileStatus.getDeleted()
.isAfter(dossier.getSoftDeletedTime()))) {
fileService.undeleteFile(dossier.getDossierTemplateId(), dossierId, fileStatus.getId(), dossier.getSoftDeletedTime());
fileStatusService.setFileStatusUndeleted(fileStatus.getId());
}
@ -169,4 +200,43 @@ public class DossierController implements DossierResource {
}
@Override
public void archiveDossiers(@RequestBody Set<String> dossierIds) {
for (String dossierId : dossierIds) {
DossierEntity dossier = dossierService.getDossierById(dossierId);
if (dossier.getHardDeletedTime() == null) {
dossierService.archiveDossier(dossier.getId());
List<FileEntity> fileStatuses = fileStatusService.getDossierStatus(dossier.getId());
addToIndexingQueue(dossierId, fileStatuses);
} else {
log.error("Could not archive Dossier {}, because it is already deleted.", dossierId);
}
}
}
@Override
public void unarchiveDossiers(@RequestBody Set<String> dossierIds) {
for (String dossierId : dossierIds) {
DossierEntity dossier = dossierService.getDossierById(dossierId);
if (dossier.getHardDeletedTime() == null) {
dossierService.unarchiveDossier(dossier.getId());
List<FileEntity> fileStatuses = fileStatusService.getDossierStatus(dossier.getId());
addToIndexingQueue(dossierId, fileStatuses);
} else {
log.error("Could not unarchive Dossier {}, because it is deleted.", dossierId);
}
}
}
private void addToIndexingQueue(String dossierId, List<FileEntity> fileStatuses) {
fileStatuses.forEach(f -> indexingService.addToIndexingQueue(IndexMessageType.UPDATE, null, dossierId, f.getId(), 2));
}
}

2
persistence-service-v1/persistence-service-server-v1/src/main/java/com/iqser/red/service/peristence/v1/server/controller/ReanalysisController.java
View File

@ -98,6 +98,8 @@ public class ReanalysisController implements ReanalysisResource {
public void ocrFile(@PathVariable(DOSSIER_ID_PARAM) String dossierId, @PathVariable(FILE_ID_PARAM) String fileId, @RequestParam(value = "force", required = false, defaultValue = FALSE) boolean force) {
dossierPersistenceService.getAndValidateDossier(dossierId);
if (force) {
fileStatusService.setStatusOcrProcessing(dossierId, fileId);
} else {

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

@ -42,7 +42,7 @@ public class DossierService {
}
var dossierTemplate = dossierTemplatePersistenceService.getDossierTemplate(createOrUpdateDossierRequest.getDossierTemplateId());
if(!dossierTemplate.getDossierTemplateStatus().equals(DossierTemplateStatus.ACTIVE)) {
if (!dossierTemplate.getDossierTemplateStatus().equals(DossierTemplateStatus.ACTIVE)) {
throw new BadRequestException("Dossier template is not active.");
}
@ -54,7 +54,7 @@ public class DossierService {
public DossierEntity updateDossier(CreateOrUpdateDossierRequest dossierRequest, String dossierId) {
var dossierTemplate = dossierTemplatePersistenceService.getDossierTemplate(dossierRequest.getDossierTemplateId());
if(!dossierTemplate.getDossierTemplateStatus().equals(DossierTemplateStatus.ACTIVE)) {
if (!dossierTemplate.getDossierTemplateStatus().equals(DossierTemplateStatus.ACTIVE)) {
throw new BadRequestException("Dossier template is not active.");
}
@ -110,7 +110,22 @@ public class DossierService {
return dossierPersistenceService.findAllDossiers();
}
public Set<DossierChange> changesSince(OffsetDateTime since) {
return dossierPersistenceService.hasChangesSince(since);
}
public void archiveDossier(String dossierId) {
dossierPersistenceService.archiveDossier(dossierId);
}
public void unarchiveDossier(String dossierId) {
dossierPersistenceService.unarchiveDossier(dossierId);
}
}

1
persistence-service-v1/persistence-service-server-v1/src/main/java/com/iqser/red/service/peristence/v1/server/service/DossierStatsService.java
View File

@ -11,7 +11,6 @@ import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import static com.iqser.red.service.persistence.management.v1.processor.exception.DossierNotFoundException.DOSSIER_NOT_FOUND_MESSAGE;

5
persistence-service-v1/persistence-service-server-v1/src/main/java/com/iqser/red/service/peristence/v1/server/service/FileService.java
View File

@ -151,7 +151,7 @@ public class FileService {
});
viewedPagesPersistenceService.deleteForFile(fileId);
indexingService.addToDeleteFromIndexQueue(dossierId, fileId, 2);
indexingService.addToIndexingQueue(IndexMessageType.UPDATE, null, dossierId, fileId, 2);
}
public void hardDeleteFile(String dossierId, String fileId) {
@ -193,6 +193,7 @@ public class FileService {
commentPersistenceService.hardDelete(comment.getId());
});
});
indexingService.addToDeleteFromIndexQueue(dossierId, fileId, 2);
}
@ -252,7 +253,7 @@ public class FileService {
}
});
indexingService.addToIndexingQueue(IndexMessageType.INSERT, dossierTemplateId, dossierId, fileId, 2);
indexingService.addToIndexingQueue(IndexMessageType.UPDATE, dossierTemplateId, dossierId, fileId, 2);
}

10
persistence-service-v1/persistence-service-server-v1/src/main/java/com/iqser/red/service/peristence/v1/server/service/ReanalysisRequiredStatusService.java
View File

@ -1,6 +1,7 @@
package com.iqser.red.service.peristence.v1.server.service;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.DossierEntity;
import com.iqser.red.service.persistence.management.v1.processor.exception.DossierNotFoundException;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DictionaryPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.DossierPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.LegalBasisMappingPersistenceService;
@ -86,8 +87,13 @@ public class ReanalysisRequiredStatusService {
Map<String, DossierEntity> dossierMap) {
// enhance with dossierTemplateId
DossierEntity dossier = dossierMap.computeIfAbsent(fileStatus.getDossierId(), k -> dossierPersistenceService.getAndValidateDossier(fileStatus.getDossierId()));
fileStatus.setDossierTemplateId(dossier.getDossierTemplateId());
try {
DossierEntity dossier = dossierMap.computeIfAbsent(fileStatus.getDossierId(), k -> dossierPersistenceService.getAndValidateDossier(fileStatus.getDossierId()));
fileStatus.setDossierTemplateId(dossier.getDossierTemplateId());
} catch (DossierNotFoundException e) {
log.info("Dossier {} was not found, thus analysis is not required", fileStatus.getDossierId());
return new AnalysisRequiredResult(false, false);
}
// get relevant versions
var dossierTemplateVersions = dossierTemplateVersionMap.computeIfAbsent(fileStatus.getDossierTemplateId(),

3
persistence-service-v1/persistence-service-server-v1/src/main/java/com/iqser/red/service/peristence/v1/server/service/scheduler/AutomaticAnalysisScheduler.java
View File

@ -5,7 +5,6 @@ import com.iqser.red.service.peristence.v1.server.service.FileStatusService;
import com.iqser.red.service.peristence.v1.server.service.ReanalysisRequiredStatusService;
import com.iqser.red.service.peristence.v1.server.utils.FileModelMapper;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.FileEntity;
import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.dossier.DossierStatus;
import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.dossier.file.FileModel;
import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.dossier.file.ProcessingStatus;
import com.iqser.red.service.persistence.service.v1.api.model.dossiertemplate.dossier.file.WorkflowStatus;
@ -88,7 +87,7 @@ public class AutomaticAnalysisScheduler {
.filter(f -> !f.getProcessingStatus().equals(ProcessingStatus.DELETED))
.filter(f -> !f.getWorkflowStatus().equals(WorkflowStatus.APPROVED))
.filter(f -> !isProcessing(f))
.filter(f -> f.getDossier().getSoftDeletedTime() == null && f.getDossier().getHardDeletedTime() == null)
.filter(f -> f.getDossier().getSoftDeletedTime() == null && f.getDossier().getHardDeletedTime() == null && f.getDossier().getArchivedTime() == null)
.collect(Collectors.toList()), FileModel.class, new FileModelMapper()))
.stream()
.filter(FileModel::isAnalysisRequired)

11
persistence-service-v1/persistence-service-server-v1/src/main/resources/db/changelog/4-archived-dossier.changelog.yaml Normal file
View File

@ -0,0 +1,11 @@
databaseChangeLog:
- changeSet:
id: archived-dossier
author: philipp
changes:
- addColumn:
columns:
- column:
name: archived_time
type: TIMESTAMP WITHOUT TIME ZONE
tableName: dossier

2
persistence-service-v1/persistence-service-server-v1/src/main/resources/db/changelog/db.changelog-master.yaml
View File

@ -5,3 +5,5 @@ databaseChangeLog:
file: db/changelog/2-ignored-hint-color.changelog.yaml
- include:
file: db/changelog/3-added-annotation-modification-date.changelog.yaml
- include:
file: db/changelog/4-archived-dossier.changelog.yaml

29
persistence-service-v1/persistence-service-server-v1/src/test/java/com/iqser/red/service/peristence/v1/server/integration/service/DossierTesterAndProvider.java
View File

@ -29,6 +29,31 @@ public class DossierTesterAndProvider {
return provideTestDossier(testTemplate, "Dossier1");
}
public Dossier provideTestDossier(String testTemplateId, String dossierName) {
CreateOrUpdateDossierRequest cru = new CreateOrUpdateDossierRequest();
cru.setDownloadFileTypes(Sets.newHashSet(DownloadFileType.ORIGINAL));
cru.setDossierName(dossierName);
cru.setDescription(dossierName);
cru.setWatermarkEnabled(true);
cru.setMemberIds(Sets.newHashSet("1"));
cru.setOwnerId("1");
cru.setApproverIds(Sets.newHashSet("1"));
cru.setRequestingUser("1");
cru.setDueDate(OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS));
cru.setDossierTemplateId(testTemplateId);
cru.setReportTemplateIds(List.of("reportTemplate1", "reportTemplate2"));
Dossier result = dossierClient.addDossier(cru);
assertThat(result.getDossierName()).isEqualTo(dossierName);
Dossier loadedDossier = dossierClient.getDossierById(result.getId(),false, false);
assertThat(loadedDossier).isEqualTo(result);
return loadedDossier;
}
public Dossier provideTestDossier(DossierTemplate testTemplate, String dossierName) {
CreateOrUpdateDossierRequest cru = new CreateOrUpdateDossierRequest();
cru.setDownloadFileTypes(Sets.newHashSet(DownloadFileType.ORIGINAL));
@ -47,7 +72,7 @@ public class DossierTesterAndProvider {
assertThat(result.getDossierName()).isEqualTo(dossierName);
Dossier loadedDossier = dossierClient.getDossierById(result.getId(),false);
Dossier loadedDossier = dossierClient.getDossierById(result.getId(),false, false);
assertThat(loadedDossier).isEqualTo(result);
@ -68,6 +93,4 @@ public class DossierTesterAndProvider {
return provideTestDossier(testTemplate, filename);
}
}

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

@ -5,6 +5,7 @@ import static org.assertj.core.api.Assertions.assertThatThrownBy;
import java.time.OffsetDateTime;
import java.util.List;
import java.util.Set;
import com.iqser.red.service.persistence.service.v1.api.model.common.JSONPrimitive;
import org.junit.Test;
@ -41,7 +42,7 @@ public class DossierTest extends AbstractPersistenceServerServiceTest {
var dossier = dossierTesterAndProvider.provideTestDossier();
var allDossiers = dossierClient.getAllDossiers();
var allDossiers = dossierClient.getAllDossiers(false, false);
assertThat(allDossiers.size()).isEqualTo(1);
assertThat(allDossiers.get(0)).isEqualTo(dossier);
@ -61,23 +62,27 @@ public class DossierTest extends AbstractPersistenceServerServiceTest {
assertThat(updated.isWatermarkPreviewEnabled()).isEqualTo(true);
var loadedTemplate = dossierClient.getDossierById(updated.getId(),false);
var loadedTemplate = dossierClient.getDossierById(updated.getId(),false, false);
assertThat(loadedTemplate).isEqualTo(updated);
dossierClient.getAllDossiers().forEach(ld -> dossierClient.delete(ld.getId()));
dossierClient.getAllDossiers(false, false).forEach(ld -> dossierClient.delete(ld.getId()));
assertThat(dossierClient.getAllDossiers()).isEmpty();
assertThat(dossierClient.getAllDossiers(false, false)).isEmpty();
assertThat(dossierClient.getSoftDeletedDossiers().size()).isEqualTo(1);
assertThat(dossierClient.getAllDossiers(false, true)).hasSize(1);
dossierClient.undeleteDossiers(Sets.newHashSet(dossier.getId()));
assertThat(dossierClient.getAllDossiers()).isNotEmpty();
assertThat(dossierClient.getAllDossiers(false, false)).isNotEmpty();
assertThat(dossierClient.getSoftDeletedDossiers()).isEmpty();
dossierClient.hardDeleteDossiers(Sets.newHashSet(dossier.getId()));
assertThat(dossierClient.getAllDossiers()).isEmpty();
assertThat(dossierClient.getAllDossiers(false, false)).isEmpty();
assertThat(dossierClient.getAllDossiers(true, false)).isEmpty();
assertThat(dossierClient.getAllDossiers(false, true)).hasSize(1);
assertThat(dossierClient.getAllDossiers(true, true)).hasSize(1);
assertThat(dossierClient.getSoftDeletedDossiers()).isEmpty();
assertThatThrownBy(() -> dossierClient.undeleteDossiers(Sets.newHashSet(dossier.getId()))).isInstanceOf(FeignException.class);
@ -87,15 +92,119 @@ public class DossierTest extends AbstractPersistenceServerServiceTest {
assertThat(dossierInformation.getNumberOfActiveDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfSoftDeletedDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfHardDeletedDossiers()).isEqualTo(1);
assertThat(dossierInformation.getNumberOfArchivedDossiers()).isEqualTo(0);
}
@Test
public void testArchiveDossier() {
// Arrange
var dossier1 = dossierTesterAndProvider.provideTestDossier("dossier1");
var dossier2 = dossierTesterAndProvider.provideTestDossier(dossier1.getDossierTemplateId(), "dossier2");
// Act & Assert 1
assertThat(dossierClient.getAllDossiers(false, false)).hasSize(2);
assertThat(dossierClient.getAllDossiers(true, false)).hasSize(2);
assertThat(dossierClient.getAllDossiers(false, true)).hasSize(2);
assertThat(dossierClient.getAllDossiers(true, true)).hasSize(2);
assertThat(dossierClient.getArchivedDossiers()).hasSize(0);
assertThat(dossierClient.getSoftDeletedDossiers()).hasSize(0);
// Act & Assert 2
dossierClient.archiveDossiers(Set.of(dossier1.getId()));
assertThat(dossierClient.getAllDossiers(false, false)).hasSize(1);
assertThat(dossierClient.getAllDossiers(true, false)).hasSize(2);
assertThat(dossierClient.getAllDossiers(false, true)).hasSize(1);
assertThat(dossierClient.getAllDossiers(true, true)).hasSize(2);
assertThat(dossierClient.getArchivedDossiers()).hasSize(1);
assertThat(dossierClient.getSoftDeletedDossiers()).hasSize(0);
var dossierInformation = dossierClient.getDossierInformation();
assertThat(dossierInformation.getNumberOfActiveDossiers()).isEqualTo(1);
assertThat(dossierInformation.getNumberOfSoftDeletedDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfHardDeletedDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfArchivedDossiers()).isEqualTo(1);
// Act & Assert 3
dossierClient.unarchiveDossiers(Set.of(dossier1.getId()));
assertThat(dossierClient.getAllDossiers(false, false)).hasSize(2);
assertThat(dossierClient.getArchivedDossiers()).hasSize(0);
dossierInformation = dossierClient.getDossierInformation();
assertThat(dossierInformation.getNumberOfActiveDossiers()).isEqualTo(2);
assertThat(dossierInformation.getNumberOfSoftDeletedDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfHardDeletedDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfArchivedDossiers()).isEqualTo(0);
// Act & Assert 4
dossierClient.archiveDossiers(Set.of(dossier1.getId(), dossier2.getId()));
assertThat(dossierClient.getAllDossiers(false, false)).hasSize(0);
assertThat(dossierClient.getAllDossiers(true, false)).hasSize(2);
assertThat(dossierClient.getArchivedDossiers()).hasSize(2);
assertThat(dossierClient.getSoftDeletedDossiers()).hasSize(0);
dossierInformation = dossierClient.getDossierInformation();
assertThat(dossierInformation.getNumberOfActiveDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfSoftDeletedDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfHardDeletedDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfArchivedDossiers()).isEqualTo(2);
// Act & Assert 5
dossierClient.delete(dossier1.getId());
dossierClient.archiveDossiers(Set.of(dossier1.getId(), dossier2.getId()));
assertThat(dossierClient.getAllDossiers(false, false)).hasSize(0);
assertThat(dossierClient.getAllDossiers(true, false)).hasSize(1);
assertThat(dossierClient.getAllDossiers(false, true)).hasSize(1);
assertThat(dossierClient.getAllDossiers(true, true)).hasSize(2);
assertThat(dossierClient.getArchivedDossiers()).hasSize(1);
assertThat(dossierClient.getSoftDeletedDossiers()).hasSize(1);
dossierInformation = dossierClient.getDossierInformation();
assertThat(dossierInformation.getNumberOfActiveDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfSoftDeletedDossiers()).isEqualTo(1);
assertThat(dossierInformation.getNumberOfHardDeletedDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfArchivedDossiers()).isEqualTo(1);
// Act & Assert 6
dossierClient.unarchiveDossiers(Set.of(dossier1.getId(), dossier2.getId()));
assertThat(dossierClient.getAllDossiers(false, false)).hasSize(1);
assertThat(dossierClient.getAllDossiers(true, false)).hasSize(1);
assertThat(dossierClient.getAllDossiers(false, true)).hasSize(2);
assertThat(dossierClient.getArchivedDossiers()).hasSize(0);
assertThat(dossierClient.getSoftDeletedDossiers()).hasSize(1);
dossierInformation = dossierClient.getDossierInformation();
assertThat(dossierInformation.getNumberOfActiveDossiers()).isEqualTo(1);
assertThat(dossierInformation.getNumberOfSoftDeletedDossiers()).isEqualTo(1);
assertThat(dossierInformation.getNumberOfHardDeletedDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfArchivedDossiers()).isEqualTo(0);
// Act & Assert 7
dossierClient.hardDeleteDossiers(Set.of(dossier1.getId()));
dossierClient.archiveDossiers(Set.of(dossier1.getId(), dossier2.getId()));
assertThat(dossierClient.getAllDossiers(false, false)).hasSize(0);
assertThat(dossierClient.getAllDossiers(true, false)).hasSize(1);
assertThat(dossierClient.getAllDossiers(false, true)).hasSize(1);
assertThat(dossierClient.getAllDossiers(true, true)).hasSize(2);
assertThat(dossierClient.getArchivedDossiers()).hasSize(1);
assertThat(dossierClient.getSoftDeletedDossiers()).hasSize(0);
dossierInformation = dossierClient.getDossierInformation();
assertThat(dossierInformation.getNumberOfActiveDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfSoftDeletedDossiers()).isEqualTo(0);
assertThat(dossierInformation.getNumberOfHardDeletedDossiers()).isEqualTo(1);
assertThat(dossierInformation.getNumberOfArchivedDossiers()).isEqualTo(1);
}
@Test
public void testDossierWithReportTemplates() {
var dossier = dossierTesterAndProvider.provideTestDossier();
String dossierName = "Dossier 1 Update";
var allDossiers = dossierClient.getAllDossiers();
var allDossiers = dossierClient.getAllDossiers(false, false);
assertThat(allDossiers.size()).isEqualTo(1);
assertThat(allDossiers.get(0)).isEqualTo(dossier);
@ -115,13 +224,13 @@ public class DossierTest extends AbstractPersistenceServerServiceTest {
assertThat(updated.getReportTemplateIds().size()).isEqualTo(1);
assertThat(updated.getReportTemplateIds()).contains(availableTemplates.get(0).getTemplateId());
var loadedTemplate = dossierClient.getDossierById(dossier.getId(),false);
var loadedTemplate = dossierClient.getDossierById(dossier.getId(),false, false);
assertThat(loadedTemplate).isEqualTo(updated);
assertThat(loadedTemplate.getReportTemplateIds().size()).isEqualTo(1);
assertThat(loadedTemplate.getReportTemplateIds()).contains(availableTemplates.get(0).getTemplateId());
allDossiers = dossierClient.getAllDossiers();
allDossiers = dossierClient.getAllDossiers(false, false);
assertThat(allDossiers.size()).isEqualTo(1);
assertThat(allDossiers.get(0).getReportTemplateIds().size()).isEqualTo(1);
@ -139,7 +248,7 @@ public class DossierTest extends AbstractPersistenceServerServiceTest {
assertThat(updated.getReportTemplateIds().size()).isEqualTo(2);
assertThat(updated.getReportTemplateIds()).contains(availableTemplates.get(0).getTemplateId(), availableTemplates.get(1).getTemplateId());
loadedTemplate = dossierClient.getDossierById(dossier.getId(),false);
loadedTemplate = dossierClient.getDossierById(dossier.getId(),false, false);
assertThat(loadedTemplate).isEqualTo(updated);
assertThat(loadedTemplate.getReportTemplateIds().size()).isEqualTo(2);
@ -159,7 +268,7 @@ public class DossierTest extends AbstractPersistenceServerServiceTest {
assertThat(updated.getReportTemplateIds().size()).isEqualTo(2);
assertThat(updated.getReportTemplateIds()).contains(availableTemplates.get(1).getTemplateId(), availableTemplates.get(2).getTemplateId());
loadedTemplate = dossierClient.getDossierById(dossier.getId(),false);
loadedTemplate = dossierClient.getDossierById(dossier.getId(),false, false);
assertThat(loadedTemplate).isEqualTo(updated);
assertThat(loadedTemplate.getReportTemplateIds().size()).isEqualTo(2);
@ -179,7 +288,7 @@ public class DossierTest extends AbstractPersistenceServerServiceTest {
assertThat(updated.getReportTemplateIds().size()).isEqualTo(1);
assertThat(updated.getReportTemplateIds()).contains(availableTemplates.get(0).getTemplateId());
loadedTemplate = dossierClient.getDossierById(dossier.getId(),false);
loadedTemplate = dossierClient.getDossierById(dossier.getId(),false, false);
assertThat(loadedTemplate).isEqualTo(updated);
assertThat(loadedTemplate.getReportTemplateIds().size()).isEqualTo(1);
@ -187,9 +296,9 @@ public class DossierTest extends AbstractPersistenceServerServiceTest {
// Remove dossier
dossierClient.getAllDossiers().forEach(ld -> dossierClient.delete(ld.getId()));
dossierClient.getAllDossiers(false, false).forEach(ld -> dossierClient.delete(ld.getId()));
dossierClient.hardDeleteDossiers(Sets.newHashSet(dossier.getId()));
assertThat(dossierClient.getAllDossiers()).isEmpty();
assertThat(dossierClient.getAllDossiers(false, false)).isEmpty();
assertThat(dossierClient.getSoftDeletedDossiers()).isEmpty();
}

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

@ -97,7 +97,7 @@ public class DownloadPreparationTest extends AbstractPersistenceServerServiceTes
.reportTemplateIds(availableTemplates.stream().map(a -> a.getTemplateId()).collect(Collectors.toList()))
.build(), dossier.getId());
var updatedDossier = dossierClient.getDossierById(dossier.getId(),false);
var updatedDossier = dossierClient.getDossierById(dossier.getId(),false, false);
assertThat(updatedDossier.getReportTemplateIds()).isNotEmpty();
downloadClient.prepareDownload(DownloadRequest.builder()

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

@ -274,7 +274,7 @@ public class MigrationTest extends AbstractPersistenceServerServiceTest {
assertThat(rulesVersion).isGreaterThan(0);
});
var dossiers = dossierClient.getAllDossiers();
var dossiers = dossierClient.getAllDossiers(false, false);
assertThat(dossiers.size()).isEqualTo(3);
dossiers.forEach(dossier -> {
var dossierTypes = dictionaryClient.getAllTypesForDossier(dossier.getId());