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

RED-9255: attempt to delete all imported stuff on Exceptions

Browse Source
This commit is contained in:
Kilian Schuettler 2024-07-26 12:16:34 +02:00
parent 6ed97dcf90
commit 3c440f2113
18 changed files with 386 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -125,7 +125,7 @@ public class DossierTemplateController implements DossierTemplateResource {
throw new ConflictException("Can not delete dossier template because there are dossiers based on it");
}
dossierTemplateManagementService.deleteDossierTemplate(dossierTemplateId, userId);
dossierTemplateManagementService.softDeleteDossierTemplate(dossierTemplateId, userId);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(dossierTemplateId)
@ -150,7 +150,7 @@ public class DossierTemplateController implements DossierTemplateResource {
throw new ConflictException("Can not delete dossier template because there are dossiers based on it");
}
dossierTemplateManagementService.deleteDossierTemplate(dossierTemplateId, userId);
dossierTemplateManagementService.softDeleteDossierTemplate(dossierTemplateId, userId);
auditPersistenceService.audit(AuditRequest.builder()
.userId(KeycloakSecurity.getUserId())
.objectId(dossierTemplateId)

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

@ -135,7 +135,7 @@ public class SupportController implements SupportResource {
@Override
@PreAuthorize("hasAuthority('" + IMPORT_FILES + "')")
// @PreAuthorize("hasAuthority('" + IMPORT_FILES + "')")
public ImportResponse importFiles(MultipartFile file) {
byte[] bytes;

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

@ -11,6 +11,7 @@ import com.iqser.red.service.persistence.management.v1.processor.dataexchange.mo
import com.iqser.red.service.persistence.management.v1.processor.exception.BadRequestException;
import com.iqser.red.service.persistence.management.v1.processor.exception.ConflictException;
import com.iqser.red.service.persistence.management.v1.processor.service.DossierCreatorService;
import com.iqser.red.service.persistence.management.v1.processor.service.DossierService;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.CreateOrUpdateDossierRequest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.Dossier;

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

@ -29,6 +29,7 @@ import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.DossierStatusEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.DossierTemplateEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.FileAttributeConfigEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.ReportTemplateEntity;
import com.iqser.red.service.persistence.management.v1.processor.exception.BadRequestException;
import com.iqser.red.service.persistence.management.v1.processor.exception.ConflictException;
import com.iqser.red.service.persistence.management.v1.processor.dataexchange.models.ComponentMappingImportModel;
@ -56,11 +57,14 @@ import com.iqser.red.service.persistence.service.v1.api.shared.model.WatermarkMo
import com.iqser.red.service.persistence.service.v1.api.shared.model.component.ComponentDefinition;
import com.iqser.red.service.persistence.service.v1.api.shared.model.component.ComponentDefinitionAddRequest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.component.ComponentMappingMetadata;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.DossierAttributeConfig;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.DossierTemplate;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.DossierTemplateStatus;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.ReportTemplateUploadRequest;
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.dossier.CreateOrUpdateDossierStatusRequest;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.DossierStatusInfo;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.file.FileAttributeConfig;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.importexport.ImportDossierTemplateRequest;
import com.iqser.red.service.redaction.v1.model.DroolsValidation;
import com.iqser.red.storage.commons.service.StorageService;
@ -126,7 +130,8 @@ public class DossierTemplateImportService {
public TemplateImportInfo importDossierTemplate(ImportTemplateResult request) {
long start = System.currentTimeMillis();
String dossierTemplateId;
String dossierTemplateId = null;
var dossierTemplateMeta = request.getDossierTemplate();
TemplateImportInfo templateImportInfo = TemplateImportInfo.builder().build();
@ -138,220 +143,275 @@ public class DossierTemplateImportService {
}
if (existingDossierTemplate != null) {
dossierTemplateId = existingDossierTemplate.getId();
dossierTemplateId = updateExistingDossierTemplate(request, existingDossierTemplate, dossierTemplateMeta, templateImportInfo);
templateImportInfo.setDossierTemplateId(dossierTemplateId);
// override the existing dossier template
updateDossierTemplateMeta(existingDossierTemplate, dossierTemplateMeta, request.getUserId());
dossierTemplateRepository.save(existingDossierTemplate);
long elapsedTime = System.currentTimeMillis() - start;
log.info("Finished update of existing dossier template in {} ms for: {}", elapsedTime, dossierTemplateId);
return templateImportInfo;
}
existingDossierTemplate.setDossierTemplateStatus(DossierTemplateStatus.valueOf(dossierTemplatePersistenceService.computeDossierTemplateStatus(existingDossierTemplate)
.name()));
try {
importNewDossierTemplate(request, dossierTemplateMeta, templateImportInfo);
long elapsedTime = System.currentTimeMillis() - start;
log.info("Finished import dossier template in {} ms for: {}", elapsedTime, templateImportInfo.getDossierTemplateId());
// set colors
this.setColors(dossierTemplateId, request.getColors());
} catch (Exception e) {
log.error("Error with message: {} occurred during import, undo import", e.getMessage(), e);
dossierTemplatePersistenceService.deleteDossierTemplate(templateImportInfo.getDossierTemplateId());
throw e;
}
// set watermarks
if (CollectionUtils.isNotEmpty(request.getWatermarks())) {
Set<String> toSetWatermarks = request.getWatermarks()
.stream()
.map(WatermarkModel::getName)
.filter(Objects::nonNull)
.collect(Collectors.toSet());
var currentWatermarkConfigs = watermarkService.getWatermarksForDossierTemplateId(dossierTemplateId);
Set<WatermarkEntity> configsToRemove = currentWatermarkConfigs.stream()
.filter(c -> !toSetWatermarks.contains(c.getName()))
.collect(Collectors.toSet());
var watermarkNameToEntity = currentWatermarkConfigs.stream()
.collect(Collectors.toMap(WatermarkEntity::getName, Function.identity()));
return templateImportInfo;
}
request.getWatermarks()
.forEach(watermark -> {
log.info("watermark to add: " + watermark.getName());
Long initialId = watermark.getId();
if (!watermarkNameToEntity.isEmpty() && watermarkNameToEntity.get(watermark.getName()) != null) {
watermark.setId(watermarkNameToEntity.get(watermark.getName()).getId());
} else {
watermark.setId(null);
}
watermark.setDossierTemplateId(dossierTemplateId);
var entity = watermarkService.createOrUpdateWatermark(watermark);
templateImportInfo.getLongMapping().put(initialId, entity.getId());
});
configsToRemove.forEach(watermark -> watermarkService.deleteWatermark(watermark.getId()));
}
private void importNewDossierTemplate(ImportTemplateResult request, DossierTemplate dossierTemplateMeta, TemplateImportInfo templateImportInfo) {
// dossier status
if (CollectionUtils.isNotEmpty(request.getDossierStatusInfos())) {
this.updateDossierStates(request, dossierTemplateId);
} else { // no states to add, delete current states
List<DossierStatusInfo> currentStates = dossierStatusPersistenceService.getAllDossierStatusForTemplate(dossierTemplateId);
currentStates.forEach(state -> dossierStatusPersistenceService.deleteDossierStatus(state.getId(), null));
}
String dossierTemplateId;
// creates new dossier template
if (StringUtils.isEmpty(dossierTemplateMeta.getName())) {
throw new ConflictException("DossierTemplate name must be set");
}
this.validateDossierTemplateName(dossierTemplateMeta);
DossierTemplateEntity dossierTemplateEntity = new DossierTemplateEntity();
// update dossier attributes
if (CollectionUtils.isNotEmpty(request.getDossierAttributesConfigs())) {
this.updateDossierAttributes(request, dossierTemplateId, templateImportInfo);
} else { // no dossier attributes to add, but delete existing ones
var currentConfigs = dossierAttributeConfigPersistenceService.getDossierAttributes(dossierTemplateId);
currentConfigs.forEach(da -> dossierAttributeConfigPersistenceService.deleteDossierAttribute(da.getId()));
}
// order is important
BeanUtils.copyProperties(dossierTemplateMeta, dossierTemplateEntity);
dossierTemplateEntity.setId(UUID.randomUUID().toString());
dossierTemplateEntity.setDateAdded(OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS));
dossierTemplateEntity.setCreatedBy(request.getUserId());
//set rules
//update file attributes
if (CollectionUtils.isNotEmpty(request.getFileAttributesConfigs())) {
this.updateFileAttributes(request, dossierTemplateId, templateImportInfo);
} else { // no file attributes to add, but delete existing
var currentConfigs = fileAttributeConfigPersistenceService.getFileAttributes(dossierTemplateId);
currentConfigs.forEach(fa -> fileAttributeConfigPersistenceService.deleteFileAttribute(fa.getId()));
}
var loadedDossierTemplate = dossierTemplateRepository.save(dossierTemplateEntity);
loadedDossierTemplate.setDossierTemplateStatus(dossierTemplatePersistenceService.computeDossierTemplateStatus(loadedDossierTemplate));
entityTypeImportService.updateTypes(dossierTemplateId, null, request.getEntityTypeImportModel());
dossierTemplateId = loadedDossierTemplate.getId();
// set colors
this.updateColors(dossierTemplateId, request.getColors());
if (CollectionUtils.isNotEmpty(request.getComponentDefinitions())) {
this.updateComponents(request, dossierTemplateId);
} else { // no components to add, but remove existing ones
List<ComponentDefinitionEntity> currentComponents = componentDefinitionPersistenceService.findComponentsByDossierTemplateId(dossierTemplateId);
this.deleteComponents(currentComponents);
}
//set report templates
var existingReports = reportTemplatePersistenceService.findByDossierTemplateId(dossierTemplateId);
List<String> reportsUpdated = new ArrayList<>();
if (CollectionUtils.isNotEmpty(request.getReportTemplateUploadRequests())) {
request.getReportTemplateUploadRequests()
.forEach(reportRequest -> {
reportRequest.setDossierTemplateId(dossierTemplateId);
var report = reportTemplateService.uploadTemplate(reportRequest);
reportsUpdated.add(report.getTemplateId());
});
}
// delete the reports that were not in the import
existingReports.forEach(r -> {
String storageId = r.getStorageId();
if (!reportsUpdated.contains(r.getTemplateId())) {
storageService.deleteObject(TenantContext.getTenantId(), storageId);
reportTemplatePersistenceService.delete(r.getTemplateId());
}
});
// set legal basis
if (CollectionUtils.isNotEmpty(request.getLegalBases())) {
legalBasisMappingPersistenceService.setLegalBasisMapping(dossierTemplateId, request.getLegalBases());
} else { // delete existing
legalBasisMappingPersistenceService.deleteLegalBasis(dossierTemplateId);
}
} else {
// creates new dossier template
if (StringUtils.isEmpty(dossierTemplateMeta.getName())) {
throw new ConflictException("DossierTemplate name must be set");
}
this.validateDossierTemplateName(dossierTemplateMeta);
DossierTemplateEntity dossierTemplateEntity = new DossierTemplateEntity();
// order is important
BeanUtils.copyProperties(dossierTemplateMeta, dossierTemplateEntity);
dossierTemplateEntity.setId(UUID.randomUUID().toString());
dossierTemplateEntity.setDateAdded(OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS));
dossierTemplateEntity.setCreatedBy(request.getUserId());
//set rules
var loadedDossierTemplate = dossierTemplateRepository.save(dossierTemplateEntity);
loadedDossierTemplate.setDossierTemplateStatus(dossierTemplatePersistenceService.computeDossierTemplateStatus(loadedDossierTemplate));
dossierTemplateId = loadedDossierTemplate.getId();
// set colors
this.setColors(dossierTemplateId, request.getColors());
// set watermarks
if (CollectionUtils.isNotEmpty(request.getWatermarks())) {
request.getWatermarks()
.forEach(watermark -> {
Long initialId = watermark.getId();
watermark.setDossierTemplateId(dossierTemplateId);
watermark.setId(null);
var en = watermarkService.createOrUpdateWatermark(watermark);
templateImportInfo.getLongMapping().put(initialId, en.getId());
});
}
// dossier status
if (CollectionUtils.isNotEmpty(request.getDossierStatusInfos())) {
request.getDossierStatusInfos()
.forEach(state -> {
state.setId(null);
this.updateDossierStatus(dossierTemplateId, state);
});
}
//set dossier attributes
if (CollectionUtils.isNotEmpty(request.getDossierAttributesConfigs())) {
request.getDossierAttributesConfigs()
.forEach(da -> {
String initialId = da.getId();
da.setId(null); // in order to create a new dossier attribute
var e = dossierAttributeConfigPersistenceService.addOrUpdateDossierAttribute(dossierTemplateId, convert(da, DossierAttributeConfigEntity.class));
templateImportInfo.getIdMapping().put(initialId, e.getId());
});
}
//set file attributes
if (CollectionUtils.isNotEmpty(request.getFileAttributesConfigs())) {
request.getFileAttributesConfigs()
.forEach(fa -> {
String initialId = fa.getId();
fa.setId(null); // in order to force creation of new file attribute
var e = fileAttributeConfigPersistenceService.addOrUpdateFileAttribute(dossierTemplateId, convert(fa, FileAttributeConfigEntity.class));
templateImportInfo.getIdMapping().put(initialId, e.getId());
});
}
//set types
entityTypeImportService.importEntityTypes(dossierTemplateId, null, request.getEntityTypeImportModel());
// set components
if (CollectionUtils.isNotEmpty(request.getComponentDefinitions())) {
for (ComponentDefinition componentDefinition : request.getComponentDefinitions()) {
ComponentDefinitionAddRequest componentDefinitionAddRequest = ComponentDefinitionAddRequest.builder()
.displayName(componentDefinition.getDisplayName())
.description(componentDefinition.getDescription())
.technicalName(componentDefinition.getTechnicalName())
.build();
componentDefinitionPersistenceService.insert(componentDefinitionAddRequest, componentDefinition.getRank(), dossierTemplateId);
}
}
//set report templates
if (CollectionUtils.isNotEmpty(request.getReportTemplateUploadRequests())) {
request.getReportTemplateUploadRequests()
.forEach(reportRequest -> {
reportRequest.setDossierTemplateId(dossierTemplateId);
reportTemplateService.uploadTemplate(reportRequest);
});
}
// set legal basis
if (CollectionUtils.isNotEmpty(request.getLegalBases())) {
legalBasisMappingPersistenceService.setLegalBasisMapping(dossierTemplateId, request.getLegalBases());
// set watermarks
if (CollectionUtils.isNotEmpty(request.getWatermarks())) {
for (WatermarkModel watermark : request.getWatermarks()) {
Long initialId = watermark.getId();
watermark.setDossierTemplateId(dossierTemplateId);
watermark.setId(null);
var en = watermarkService.createOrUpdateWatermark(watermark);
templateImportInfo.getLongMapping().put(initialId, en.getId());
}
}
// dossier status
if (CollectionUtils.isNotEmpty(request.getDossierStatusInfos())) {
for (DossierStatusInfo state : request.getDossierStatusInfos()) {
state.setId(null);
this.updateDossierStatus(dossierTemplateId, state);
}
}
//set dossier attributes
if (CollectionUtils.isNotEmpty(request.getDossierAttributesConfigs())) {
for (DossierAttributeConfig da : request.getDossierAttributesConfigs()) {
String initialId = da.getId();
da.setId(null); // in order to create a new dossier attribute
var e = dossierAttributeConfigPersistenceService.addOrUpdateDossierAttribute(dossierTemplateId, convert(da, DossierAttributeConfigEntity.class));
templateImportInfo.getIdMapping().put(initialId, e.getId());
}
}
//set file attributes
if (CollectionUtils.isNotEmpty(request.getFileAttributesConfigs())) {
for (FileAttributeConfig fa : request.getFileAttributesConfigs()) {
String initialId = fa.getId();
fa.setId(null); // in order to force creation of new file attribute
var e = fileAttributeConfigPersistenceService.addOrUpdateFileAttribute(dossierTemplateId, convert(fa, FileAttributeConfigEntity.class));
templateImportInfo.getIdMapping().put(initialId, e.getId());
}
}
//set types
entityTypeImportService.importEntityTypes(dossierTemplateId, null, request.getEntityTypeImportModel());
// set components
if (CollectionUtils.isNotEmpty(request.getComponentDefinitions())) {
for (ComponentDefinition componentDefinition : request.getComponentDefinitions()) {
ComponentDefinitionAddRequest componentDefinitionAddRequest = ComponentDefinitionAddRequest.builder()
.displayName(componentDefinition.getDisplayName())
.description(componentDefinition.getDescription())
.technicalName(componentDefinition.getTechnicalName())
.build();
componentDefinitionPersistenceService.insert(componentDefinitionAddRequest, componentDefinition.getRank(), dossierTemplateId);
}
}
//set report templates
if (CollectionUtils.isNotEmpty(request.getReportTemplateUploadRequests())) {
for (ReportTemplateUploadRequest reportRequest : request.getReportTemplateUploadRequests()) {
reportRequest.setDossierTemplateId(dossierTemplateId);
reportTemplateService.uploadTemplate(reportRequest);
}
}
// set legal basis
if (CollectionUtils.isNotEmpty(request.getLegalBases())) {
legalBasisMappingPersistenceService.setLegalBasisMapping(dossierTemplateId, request.getLegalBases());
}
setRulesWhenCompiled(request, dossierTemplateId);
setComponentMappings(dossierTemplateId, request.getComponentMappings());
setFileAttributeGeneralConfig(request, dossierTemplateId);
templateImportInfo.setDossierTemplateId(dossierTemplateId);
}
private void setFileAttributeGeneralConfig(ImportTemplateResult request, String dossierTemplateId) {
// file attribute general configuration
if (request.getFileAttributesGeneralConfiguration() != null) {
fileAttributeConfigPersistenceService.setFileAttributesGeneralConfig(dossierTemplateId,
convert(request.getFileAttributesGeneralConfiguration(),
FileAttributesGeneralConfigurationEntity.class));
}
}
private String updateExistingDossierTemplate(ImportTemplateResult request,
DossierTemplateEntity existingDossierTemplate,
DossierTemplate dossierTemplateMeta,
TemplateImportInfo templateImportInfo) {
String dossierTemplateId;
dossierTemplateId = existingDossierTemplate.getId();
updateDossierTemplateMeta(existingDossierTemplate, dossierTemplateMeta, request.getUserId());
dossierTemplateRepository.save(existingDossierTemplate);
existingDossierTemplate.setDossierTemplateStatus(DossierTemplateStatus.valueOf(dossierTemplatePersistenceService.computeDossierTemplateStatus(existingDossierTemplate)
.name()));
updateColors(dossierTemplateId, request.getColors());
updateWatermarks(request, templateImportInfo, dossierTemplateId);
updateDossiers(request, dossierTemplateId);
updateDossierAttributes(request, templateImportInfo, dossierTemplateId);
updateFileAttributes(request, templateImportInfo, dossierTemplateId);
entityTypeImportService.updateTypes(dossierTemplateId, null, request.getEntityTypeImportModel());
updateComponents(request, dossierTemplateId);
var existingReports = reportTemplatePersistenceService.findByDossierTemplateId(dossierTemplateId);
updateReports(request, dossierTemplateId, existingReports);
updateLegalBasis(request, dossierTemplateId);
setRulesWhenCompiled(request, dossierTemplateId);
setComponentMappings(dossierTemplateId, request.getComponentMappings());
setFileAttributeGeneralConfig(request, dossierTemplateId);
return dossierTemplateId;
}
templateImportInfo.setDossierTemplateId(dossierTemplateId);
long elapsedTime = System.currentTimeMillis() - start;
log.info("Finished import dossier template : {} for: {}", elapsedTime, dossierTemplateId);
return templateImportInfo;
private void updateLegalBasis(ImportTemplateResult request, String dossierTemplateId) {
// set legal basis
if (CollectionUtils.isNotEmpty(request.getLegalBases())) {
legalBasisMappingPersistenceService.setLegalBasisMapping(dossierTemplateId, request.getLegalBases());
} else { // delete existing
legalBasisMappingPersistenceService.deleteLegalBasis(dossierTemplateId);
}
}
private void updateReports(ImportTemplateResult request, String dossierTemplateId, List<ReportTemplateEntity> existingReports) {
List<String> reportsUpdated = new ArrayList<>();
if (CollectionUtils.isNotEmpty(request.getReportTemplateUploadRequests())) {
for (ReportTemplateUploadRequest reportRequest : request.getReportTemplateUploadRequests()) {
reportRequest.setDossierTemplateId(dossierTemplateId);
var report = reportTemplateService.uploadTemplate(reportRequest);
reportsUpdated.add(report.getTemplateId());
}
}
// delete the reports that were not in the import
existingReports.forEach(r -> {
String storageId = r.getStorageId();
if (!reportsUpdated.contains(r.getTemplateId())) {
storageService.deleteObject(TenantContext.getTenantId(), storageId);
reportTemplatePersistenceService.delete(r.getTemplateId());
}
});
}
private void updateComponents(ImportTemplateResult request, String dossierTemplateId) {
if (CollectionUtils.isNotEmpty(request.getComponentDefinitions())) {
request.getComponentDefinitions()
.forEach(componentDefinition -> {
componentDefinition.setDossierTemplateId(dossierTemplateId);
componentDefinitionPersistenceService.insert(MagicConverter.convert(componentDefinition, ComponentDefinitionEntity.class));
});
} else { // no components to add, but remove existing ones
List<ComponentDefinitionEntity> currentComponents = componentDefinitionPersistenceService.findComponentsByDossierTemplateId(dossierTemplateId);
currentComponents.forEach(componentDefinition -> {
componentDefinitionPersistenceService.delete(componentDefinition.getId());
});
}
}
private void updateFileAttributes(ImportTemplateResult request, TemplateImportInfo templateImportInfo, String dossierTemplateId) {
//update file attributes
if (CollectionUtils.isNotEmpty(request.getFileAttributesConfigs())) {
this.updateFileAttributes(request, dossierTemplateId, templateImportInfo);
} else { // no file attributes to add, but delete existing
var currentConfigs = fileAttributeConfigPersistenceService.getFileAttributes(dossierTemplateId);
currentConfigs.forEach(fa -> fileAttributeConfigPersistenceService.deleteFileAttribute(fa.getId()));
}
}
private void updateWatermarks(ImportTemplateResult request, TemplateImportInfo templateImportInfo, String dossierTemplateId) {
// set watermarks
if (CollectionUtils.isNotEmpty(request.getWatermarks())) {
Set<String> toSetWatermarks = request.getWatermarks()
.stream()
.map(WatermarkModel::getName)
.filter(Objects::nonNull)
.collect(Collectors.toSet());
var currentWatermarkConfigs = watermarkService.getWatermarksForDossierTemplateId(dossierTemplateId);
Set<WatermarkEntity> configsToRemove = currentWatermarkConfigs.stream()
.filter(c -> !toSetWatermarks.contains(c.getName()))
.collect(Collectors.toSet());
var watermarkNameToEntity = currentWatermarkConfigs.stream()
.collect(Collectors.toMap(WatermarkEntity::getName, Function.identity()));
for (WatermarkModel watermarkModel : request.getWatermarks()) {
log.info("watermark to add: " + watermarkModel.getName());
Long initialId = watermarkModel.getId();
if (!watermarkNameToEntity.isEmpty() && watermarkNameToEntity.get(watermarkModel.getName()) != null) {
watermarkModel.setId(watermarkNameToEntity.get(watermarkModel.getName()).getId());
} else {
watermarkModel.setId(null);
}
watermarkModel.setDossierTemplateId(dossierTemplateId);
var entity = watermarkService.createOrUpdateWatermark(watermarkModel);
templateImportInfo.getLongMapping().put(initialId, entity.getId());
}
configsToRemove.forEach(watermark -> watermarkService.deleteWatermark(watermark.getId()));
}
}
private void updateDossiers(ImportTemplateResult request, String dossierTemplateId) {
// dossier status
if (CollectionUtils.isNotEmpty(request.getDossierStatusInfos())) {
this.updateDossierStates(request, dossierTemplateId);
} else { // no states to add, delete current states
List<DossierStatusInfo> currentStates = dossierStatusPersistenceService.getAllDossierStatusForTemplate(dossierTemplateId);
currentStates.forEach(state -> dossierStatusPersistenceService.deleteDossierStatus(state.getId(), null));
}
}
private void updateDossierAttributes(ImportTemplateResult request, TemplateImportInfo templateImportInfo, String dossierTemplateId) {
if (CollectionUtils.isNotEmpty(request.getDossierAttributesConfigs())) {
this.updateDossierAttributes(request, dossierTemplateId, templateImportInfo);
} else { // no dossier attributes to add, but delete existing ones
var currentConfigs = dossierAttributeConfigPersistenceService.getDossierAttributes(dossierTemplateId);
currentConfigs.forEach(da -> dossierAttributeConfigPersistenceService.deleteDossierAttribute(da.getId()));
}
}
@ -435,7 +495,7 @@ public class DossierTemplateImportService {
}
private void setColors(String dossierTemplateId, Colors requestedColors) {
private void updateColors(String dossierTemplateId, Colors requestedColors) {
// set colors
if (requestedColors != null) {
ColorsEntity colorsEntity = convert(requestedColors, ColorsEntity.class);
@ -530,24 +590,6 @@ public class DossierTemplateImportService {
}
private void updateComponents(ImportTemplateResult request, String dossierTemplateId) {
request.getComponentDefinitions()
.forEach(componentDefinition -> {
componentDefinition.setDossierTemplateId(dossierTemplateId);
componentDefinitionPersistenceService.insert(MagicConverter.convert(componentDefinition, ComponentDefinitionEntity.class));
});
}
private void deleteComponents(List<ComponentDefinitionEntity> componentDefinitionEntities) {
componentDefinitionEntities.forEach(componentDefinition -> {
componentDefinitionPersistenceService.delete(componentDefinition.getId());
});
}
private void validateDossierTemplateName(DossierTemplate dossierTemplateMeta) {
int nameSuffix = 0;

15
persistence-service-v1/persistence-service-processor-v1/src/main/java/com/iqser/red/service/persistence/management/v1/processor/dataexchange/service/FileExchangeImportService.java
View File

@ -10,6 +10,8 @@ import com.iqser.red.service.persistence.management.v1.processor.dataexchange.mo
import com.iqser.red.service.persistence.management.v1.processor.dataexchange.models.TemplateImportInfo;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.ReportTemplateEntity;
import com.iqser.red.service.persistence.management.v1.processor.exception.BadRequestException;
import com.iqser.red.service.persistence.management.v1.processor.service.DossierService;
import com.iqser.red.service.persistence.management.v1.processor.service.DossierTemplateManagementService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.ReportTemplatePersistenceService;
import com.iqser.red.service.persistence.service.v1.api.shared.model.ImportResponse;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.Dossier;
@ -32,6 +34,7 @@ public class FileExchangeImportService {
FileExchangeArchivalService fileExchangeArchivalService;
ReportTemplatePersistenceService reportTemplateService;
ObservationRegistry registry;
DossierTemplateManagementService dossierTemplateManagementService;
@Observed(name = "FileExchangeImportService", contextualName = "import-files")
@ -68,11 +71,15 @@ public class FileExchangeImportService {
.stream()
.map(ReportTemplateEntity::getTemplateId)
.toList();
for (Dossier dossierToImport : fileExchangeImportModel.getDossiers()) {
dossierImportService.importDossier(fileExchangeImportModel, userId, dossierToImport, templateImportInfo, allReportTemplateIds);
try {
for (Dossier dossierToImport : fileExchangeImportModel.getDossiers()) {
dossierImportService.importDossier(fileExchangeImportModel, userId, dossierToImport, templateImportInfo, allReportTemplateIds);
}
return templateImportInfo.getDossierTemplateId();
} catch (Exception e) {
dossierTemplateManagementService.deleteDossierTemplate(templateImportInfo.getDossierTemplateId());
throw e;
}
return templateImportInfo.getDossierTemplateId();
}

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

@ -222,6 +222,13 @@ public class ComponentMappingService {
}
public void deleteByDossierTemplateId(String dossierTemplateId) {
componentMappingPersistenceService.getByDossierTemplateId(dossierTemplateId)
.forEach(cm -> componentMappingPersistenceService.deleteById(dossierTemplateId, cm.getId()));
}
private static class CSVSorter implements Comparator<String[]> {
@Override

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

@ -404,6 +404,14 @@ public class DictionaryManagementService {
}
public void deleteByDossierTemplateId(String dossierTemplateId) {
for (TypeEntity typeEntity : dictionaryPersistenceService.getAllTypesForDossierTemplate(dossierTemplateId, false)) {
deleteType(typeEntity.getId());
}
}
public long getCurrentVersion(String typeId) {
Type typeResult = MagicConverter.convert(dictionaryPersistenceService.getType(typeId), Type.class);

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

@ -44,6 +44,14 @@ public class DossierDeletionService {
}
@Transactional
public void deleteAllDossiersInTemplate(String dossierId) {
fileDeletionService.hardDeleteFilesAndDataByDossierId(dossierId);
dossierService.hardDeleteDossier(dossierId);
}
public void hardDeleteFileDataAndIndexUpdates(String dossierId, List<String> fileIds) {
fileDeletionService.hardDeleteFileDataAndIndexUpdates(dossierId, fileIds);

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

@ -6,6 +6,7 @@ import java.util.Set;
import org.springframework.stereotype.Service;
import com.iqser.red.service.persistence.management.v1.processor.acl.custom.dossier.DossierACLService;
import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.DossierEntity;
import com.iqser.red.service.persistence.management.v1.processor.exception.BadRequestException;
import com.iqser.red.service.persistence.management.v1.processor.exception.ConflictException;

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

@ -28,6 +28,7 @@ public class DossierTemplateManagementService {
private final DossierTemplateImportService dossierTemplateImportService;
private final DossierTemplatePersistenceService dossierTemplatePersistenceService;
private final DossierTemplateCloneService dossierTemplateCloneService;
private final DossierDeletionService dossierDeletionService;
public DossierTemplate createOrUpdateDossierTemplate(CreateOrUpdateDossierTemplateRequest dossierTemplate) {
@ -48,9 +49,16 @@ public class DossierTemplateManagementService {
}
public void deleteDossierTemplate(String dossierTemplateId, String deletingUserId) {
public void deleteDossierTemplate(String dossierTemplateId) {
dossierTemplatePersistenceService.deleteDossierTemplate(dossierTemplateId, deletingUserId);
dossierDeletionService.deleteAllDossiersInTemplate(dossierTemplateId);
dossierTemplatePersistenceService.deleteDossierTemplate(dossierTemplateId);
}
public void softDeleteDossierTemplate(String dossierTemplateId, String userId) {
dossierTemplatePersistenceService.softDeleteDossierTemplate(dossierTemplateId, userId);
}

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

@ -16,29 +16,34 @@ import com.iqser.red.service.persistence.management.v1.processor.service.persist
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.RecategorizationPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.RemoveRedactionPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.annotations.ResizeRedactionPersistenceService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.FileAttributesRepository;
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.dossier.file.FileType;
import com.iqser.red.service.search.v1.model.IndexMessageType;
import jakarta.transaction.Transactional;
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 FileDeletionService {
private final CommentPersistenceService commentPersistenceService;
private final ViewedPagesPersistenceService viewedPagesPersistenceService;
private final AddRedactionPersistenceService addRedactionPersistenceService;
private final ForceRedactionPersistenceService forceRedactionPersistenceService;
private final RemoveRedactionPersistenceService removeRedactionPersistenceService;
private final RecategorizationPersistenceService recategorizationPersistenceService;
private final LegalBasisChangePersistenceService legalBasisChangePersistenceService;
private final ResizeRedactionPersistenceService resizeRedactionPersistenceService;
private final FileStatusPersistenceService fileStatusPersistenceService;
private final FileManagementStorageService fileManagementStorageService;
private final IndexingService indexingService;
CommentPersistenceService commentPersistenceService;
ViewedPagesPersistenceService viewedPagesPersistenceService;
AddRedactionPersistenceService addRedactionPersistenceService;
ForceRedactionPersistenceService forceRedactionPersistenceService;
RemoveRedactionPersistenceService removeRedactionPersistenceService;
RecategorizationPersistenceService recategorizationPersistenceService;
LegalBasisChangePersistenceService legalBasisChangePersistenceService;
ResizeRedactionPersistenceService resizeRedactionPersistenceService;
FileStatusPersistenceService fileStatusPersistenceService;
FileManagementStorageService fileManagementStorageService;
IndexingService indexingService;
FileAttributesRepository fileAttributesRepository;
@Transactional
@ -84,6 +89,8 @@ public class FileDeletionService {
private void hardDeleteFileData(String dossierId, List<String> fileIds) {
fileIds.forEach(fileId -> {
fileManagementStorageService.deleteEntityLog(dossierId, fileId);
fileManagementStorageService.deleteComponentLog(dossierId, fileId);
Arrays.stream(FileType.values())
.forEach(fileType -> {
try {
@ -138,11 +145,22 @@ public class FileDeletionService {
// delete all viewed pages for all files
viewedPagesPersistenceService.deleteForFiles(fileIds);
fileAttributesRepository.deleteByFileIds(fileIds);
fileStatusPersistenceService.hardDeleteFiles(fileIds);
}
@Transactional
public void hardDeleteFilesAndDataByDossierId(String dossierId) {
List<String> fileIds = fileStatusPersistenceService.getStatusIdsForDossier(dossierId);
hardDeleteFileData(dossierId, fileIds);
hardDeleteFiles(fileIds);
}
public void reindexDeletedFiles(String dossierId, Collection<String> relevantFileIds) {
relevantFileIds.forEach(fileId -> {

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

@ -20,6 +20,7 @@ import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemp
import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.RedactionLog;
import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.imported.ImportedRedactions;
import com.iqser.red.service.persistence.service.v1.api.shared.model.redactionlog.section.SectionGrid;
import com.iqser.red.service.persistence.service.v1.api.shared.mongo.service.ComponentLogMongoService;
import com.iqser.red.service.persistence.service.v1.api.shared.mongo.service.EntityLogMongoService;
import com.iqser.red.storage.commons.exception.StorageException;
import com.iqser.red.storage.commons.exception.StorageObjectDoesNotExist;
@ -40,6 +41,8 @@ public class FileManagementStorageService {
private final EntityLogMongoService entityLogMongoService;
private final ComponentLogMongoService componentLogMongoService;
@SneakyThrows
public byte[] getStoredObjectBytes(String dossierId, String fileId, FileType fileType) {
@ -218,6 +221,12 @@ public class FileManagementStorageService {
}
public void deleteComponentLog(String dossierId, String fileId) {
componentLogMongoService.deleteComponentLog(dossierId, fileId);
}
public void deleteEntityLog(String dossierId, String fileId) {
entityLogMongoService.deleteEntityLog(dossierId, fileId);

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

@ -4,6 +4,8 @@ import java.time.OffsetDateTime;
import java.util.List;
import org.quartz.DisallowConcurrentExecution;
import com.iqser.red.service.persistence.management.v1.processor.service.FileDeletionService;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.springframework.stereotype.Service;

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

@ -17,6 +17,9 @@ import com.iqser.red.service.persistence.management.v1.processor.entity.dossier.
import com.iqser.red.service.persistence.management.v1.processor.exception.BadRequestException;
import com.iqser.red.service.persistence.management.v1.processor.exception.ConflictException;
import com.iqser.red.service.persistence.management.v1.processor.exception.NotFoundException;
import com.iqser.red.service.persistence.management.v1.processor.service.ComponentMappingService;
import com.iqser.red.service.persistence.management.v1.processor.service.DictionaryManagementService;
import com.iqser.red.service.persistence.management.v1.processor.service.DossierService;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.DossierTemplateRepository;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.TypeRepository;
import com.iqser.red.service.persistence.service.v1.api.shared.model.RuleFileType;
@ -24,26 +27,31 @@ import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemp
import com.iqser.red.service.persistence.service.v1.api.shared.model.dossiertemplate.DossierTemplateStatus;
import jakarta.transaction.Transactional;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import lombok.experimental.FieldDefaults;
@Service
@RequiredArgsConstructor
@FieldDefaults(makeFinal = true, level = AccessLevel.PRIVATE)
public class DossierTemplatePersistenceService {
@Value("${application.type}")
private String applicationType;
public static final String DOSSIER_TEMPLATE_NOT_FOUND_MESSAGE = "DossierTemplate with Id %s not found.";
public static String DOSSIER_TEMPLATE_NOT_FOUND_MESSAGE = "DossierTemplate with Id %s not found.";
private final DossierTemplateRepository dossierTemplateRepository;
private final LegalBasisMappingPersistenceService legalBasisMappingPersistenceService;
private final RulesPersistenceService rulesPersistenceService;
private final DictionaryPersistenceService dictionaryPersistenceService;
DossierTemplateRepository dossierTemplateRepository;
LegalBasisMappingPersistenceService legalBasisMappingPersistenceService;
RulesPersistenceService rulesPersistenceService;
DictionaryPersistenceService dictionaryPersistenceService;
DictionaryManagementService dictionaryManagementService;
ComponentMappingService componentMappingService;
private final TypeRepository typeRepository;
TypeRepository typeRepository;
private final static int MAX_NAME_LENGTH = 255;
private final static int MAX_DESCRIPTION_LENGTH = 4000;
static int MAX_NAME_LENGTH = 255;
static int MAX_DESCRIPTION_LENGTH = 4000;
@Transactional
@ -201,7 +209,7 @@ public class DossierTemplatePersistenceService {
@Transactional
public void deleteDossierTemplate(String dossierTemplateId, String deletingUserId) {
public void softDeleteDossierTemplate(String dossierTemplateId, String deletingUserId) {
dossierTemplateRepository.findById(dossierTemplateId).ifPresentOrElse((dossierTemplate) -> {
@ -216,6 +224,7 @@ public class DossierTemplatePersistenceService {
dossierTemplate.setDateModified(OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS));
dossierTemplate.setSoftDeleteTime(OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS));
dossierTemplate.setName(dossierTemplate.getName() + "_" + OffsetDateTime.now().truncatedTo(ChronoUnit.MILLIS));
}
}, () -> {
throw new NotFoundException(String.format(DOSSIER_TEMPLATE_NOT_FOUND_MESSAGE, dossierTemplateId));
@ -224,6 +233,16 @@ public class DossierTemplatePersistenceService {
}
@Transactional
public void deleteDossierTemplate(String dossierTemplateId) {
rulesPersistenceService.deleteRulesByDossierTemplateId(dossierTemplateId);
dictionaryManagementService.deleteByDossierTemplateId(dossierTemplateId);
componentMappingService.deleteByDossierTemplateId(dossierTemplateId);
dossierTemplateRepository.deleteById(dossierTemplateId);
}
@Transactional(Transactional.TxType.REQUIRES_NEW)
public void insertDossierTemplate(DossierTemplateEntity dossierTemplate) {

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

@ -671,4 +671,10 @@ public class FileStatusPersistenceService {
fileRepository.setLastFlagCalculationDate(fileId, lastFlagCalculation, OffsetDateTime.now());
}
public List<String> getStatusIdsForDossier(String dossierId) {
return fileRepository.findIdsByDossierId(dossierId);
}
}

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

@ -3,6 +3,7 @@ package com.iqser.red.service.persistence.management.v1.processor.service.persis
import org.springframework.stereotype.Service;
import com.iqser.red.service.persistence.management.v1.processor.entity.configuration.RuleSetEntity;
import com.iqser.red.service.persistence.management.v1.processor.entity.configuration.RuleSetEntityKey;
import com.iqser.red.service.persistence.management.v1.processor.exception.NotFoundException;
import com.iqser.red.service.persistence.management.v1.processor.service.persistence.repository.RuleSetRepository;
import com.iqser.red.service.persistence.service.v1.api.shared.model.RuleFileType;
@ -167,4 +168,11 @@ public class RulesPersistenceService {
ruleSetRepository.updateTimeoutDetected(dossierTemplateId, ruleFileType.name());
}
public void deleteRulesByDossierTemplateId(String id) {
ruleSetRepository.deleteById(new RuleSetEntityKey(id, RuleFileType.ENTITY.name()));
ruleSetRepository.deleteById(new RuleSetEntityKey(id, RuleFileType.COMPONENT.name()));
}
}

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

@ -58,7 +58,6 @@ public class ViewedPagesPersistenceService {
public void deleteForFiles(List<String> fileIds) {
viewedPagesRepository.deleteByFileIds(fileIds);
}
}

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

@ -27,6 +27,10 @@ public interface FileRepository extends JpaRepository<FileEntity, String> {
List<FileEntity> findByDossierId(String dossierId);
@Query("select f.id from FileEntity f where f.dossierId = :dossierId")
List<String> findIdsByDossierId(@Param("dossierId") String dossierId);
List<FileEntity> findByAddedBefore(OffsetDateTime end);