+ * Per ogni eccezione intercettata, effettua una putItem sulla tabella PaperTrackingsError + */ + public Mono handleInternalException(final PnPaperTrackerValidationException ex, Long messageReceiveCount) { + return handleError(ex.getError(), messageReceiveCount, ex); + } + + public Mono handleRetryError(PaperTrackingsErrors paperTrackingsErrors) { + return handleError(paperTrackingsErrors, null, null); + } + + public Mono handleError(PaperTrackingsErrors paperTrackingsErrors, Long messageReceiveCount, PnPaperTrackerValidationException ex) { + boolean isStatusCodeError = Objects.nonNull(paperTrackingsErrors.getDetails()) && ErrorCause.VALUES_NOT_FOUND.equals(paperTrackingsErrors.getDetails().getCause()); + + if (isStatusCodeError) { + if (messageReceiveCount < 5) { + // Retry SQS + return Mono.error(ex); + } + log.error("Max retries reached for status code error, inserting error and updating PaperTrackings state to KO for trackingId: {}", paperTrackingsErrors.getTrackingId()); + } + + // Salva l'errore + return insertErrorAndUpdateTrackingsEntity(paperTrackingsErrors); + } + + private Mono insertErrorAndUpdateTrackingsEntity(PaperTrackingsErrors paperTrackingsErrors){ + return paperTrackerErrorService.insertPaperTrackingsError(paperTrackingsErrors) + .filter(errors -> paperTrackingsErrors.getType().equals(ErrorType.ERROR)) + .doOnDiscard(PaperTrackingsErrors.class, errors -> log.info("Skipped updating PaperTrackings entity for error with type Warning")) + .map(unused -> { + PaperTrackings paperTrackingsToUpdate = new PaperTrackings(); + String statusCode = paperTrackingsErrors.getEventThrow(); + setNewStatus(paperTrackingsToUpdate,statusCode, BusinessState.KO, PaperTrackingsState.KO); + setDematValidationTimestampIfNeeded(paperTrackingsErrors, paperTrackingsToUpdate,statusCode); + return paperTrackingsToUpdate; + }) + .flatMap(paperTrackingsToUpdate -> paperTrackerTrackingService.updatePaperTrackingsStatus(paperTrackingsErrors.getTrackingId(), paperTrackingsToUpdate)) + .doOnError(throwable -> log.error("Error inserting entity into PaperTrackingsErrors: {}", throwable.getMessage(), throwable)); + } + + private static void setDematValidationTimestampIfNeeded(PaperTrackingsErrors paperTrackingsErrors, PaperTrackings paperTrackingsToUpdate, String statusCode) { + if (Objects.nonNull(paperTrackingsErrors.getDetails().getCause()) && paperTrackingsErrors.getDetails().getCause().equals(ErrorCause.OCR_KO)) { + setDematValidationTimestamp(paperTrackingsToUpdate, statusCode); + } + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerBadRequestException.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerBadRequestException.java new file mode 100644 index 000000000..eb8bc5657 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerBadRequestException.java @@ -0,0 +1,13 @@ +package it.pagopa.pn.papertracker.exception; + +import it.pagopa.pn.commons.exceptions.PnRuntimeException; +import org.springframework.http.HttpStatus; + +public class PnPaperTrackerBadRequestException extends PnRuntimeException { + + private static final String DEFAULT_ERROR_CODE = "PN_PAPER_TRACKER_BAD_REQUEST"; + + public PnPaperTrackerBadRequestException(String errorCode, String message) { + super(message, DEFAULT_ERROR_CODE, HttpStatus.BAD_REQUEST.value(), errorCode, null, message); + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerConflictException.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerConflictException.java new file mode 100644 index 000000000..1af7a3a81 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerConflictException.java @@ -0,0 +1,11 @@ +package it.pagopa.pn.papertracker.exception; + +import it.pagopa.pn.commons.exceptions.PnInternalException; +import org.springframework.http.HttpStatus; + +public class PnPaperTrackerConflictException extends PnInternalException { + + public PnPaperTrackerConflictException(String errorCode, String message) { + super(message, HttpStatus.CONFLICT.value(), errorCode); + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerNotFoundException.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerNotFoundException.java new file mode 100644 index 000000000..ad6eb1f6e --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerNotFoundException.java @@ -0,0 +1,11 @@ +package it.pagopa.pn.papertracker.exception; + +import it.pagopa.pn.commons.exceptions.PnInternalException; +import org.springframework.http.HttpStatus; + +public class PnPaperTrackerNotFoundException extends PnInternalException { + + public PnPaperTrackerNotFoundException(String errorCode, String message) { + super(message, HttpStatus.NOT_FOUND.value(), errorCode); + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerValidationException.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerValidationException.java new file mode 100644 index 000000000..def4fbb0b --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/exception/PnPaperTrackerValidationException.java @@ -0,0 +1,15 @@ +package it.pagopa.pn.papertracker.exception; + +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackingsErrors; +import lombok.Getter; + +@Getter +public class PnPaperTrackerValidationException extends RuntimeException { + + private final PaperTrackingsErrors error; + + public PnPaperTrackerValidationException(String message, PaperTrackingsErrors error) { + super(message); + this.error = error; + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperProgressStatusEventMapper.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperProgressStatusEventMapper.java new file mode 100644 index 000000000..57a8fdbaa --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperProgressStatusEventMapper.java @@ -0,0 +1,97 @@ +package it.pagopa.pn.papertracker.mapper; + +import it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.AttachmentDetails; +import it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.PaperProgressStatusEvent; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.*; +import lombok.AccessLevel; +import lombok.RequiredArgsConstructor; +import org.springframework.util.CollectionUtils; +import org.springframework.util.StringUtils; + +import java.time.Instant; +import java.util.ArrayList; +import java.util.List; + +@RequiredArgsConstructor(access = AccessLevel.NONE) +public class PaperProgressStatusEventMapper { + + /** + * Rimappa l'oggetto PaperProgressStatusEvent nell'entity PaperTrackings in modo da effettuare l'upsert + * + * @param paperProgressStatusEvent evento da rimappare + * @param anonymizedDiscoveredAddressId l'id dell'indirizzo anonimizzato + * @return PaperTrackings contenente il nuovo evento + */ + public static PaperTrackings toPaperTrackings(String reworkId, PaperProgressStatusEvent paperProgressStatusEvent, + String anonymizedDiscoveredAddressId, + String eventId, boolean dryRunEnabled, + boolean isFinalDemat, boolean isP000event, + boolean isInternalEvent, boolean isRecag012event) { + Instant now = Instant.now(); + PaperTrackings paperTrackings = new PaperTrackings(); + Event event = new Event(); + event.setId(eventId); + event.setIun(paperProgressStatusEvent.getIun()); + if (!CollectionUtils.isEmpty(paperProgressStatusEvent.getAttachments())) { + event.setAttachments(paperProgressStatusEvent.getAttachments().stream() + .map(PaperProgressStatusEventMapper::buildAttachmentFromAttachmentDetail) + .toList()); + }else{ + event.setAttachments(new ArrayList<>()); + } + + if(isFinalDemat) { + PaperStatus paperStatus = new PaperStatus(); + paperStatus.setFinalDematFound(true); + paperTrackings.setPaperStatus(paperStatus); + } + + if (isP000event) { + PaperStatus paperStatus = new PaperStatus(); + paperStatus.setPaperDeliveryTimestamp(paperProgressStatusEvent.getStatusDateTime().toInstant()); + paperTrackings.setPaperStatus(paperStatus); + } + + if (!isInternalEvent){ + event.setRequestTimestamp(paperProgressStatusEvent.getClientRequestTimeStamp().toInstant()); + } + + if(isRecag012event){ + ValidationFlow validationFlow = new ValidationFlow(); + validationFlow.setRecag012StatusTimestamp(now); + paperTrackings.setValidationFlow(validationFlow); + } + + event.setStatusCode(paperProgressStatusEvent.getStatusCode()); + event.setStatusTimestamp(paperProgressStatusEvent.getStatusDateTime().toInstant()); + + event.setDeliveryFailureCause(paperProgressStatusEvent.getDeliveryFailureCause()); + event.setRegisteredLetterCode(paperProgressStatusEvent.getRegisteredLetterCode()); + event.setNotificationReworkId(reworkId); + if(StringUtils.hasText(paperProgressStatusEvent.getProductType())) { + event.setProductType(paperProgressStatusEvent.getProductType()); + } + event.setAnonymizedDiscoveredAddressId(anonymizedDiscoveredAddressId); + event.setDryRun(dryRunEnabled); + event.setStatusDescription(paperProgressStatusEvent.getStatusDescription()); + event.setCreatedAt(now); + event.setPrinter(paperProgressStatusEvent.getPrinter()); + event.setDu(paperProgressStatusEvent.getDu()); + + paperTrackings.setEvents(List.of(event)); + return paperTrackings; + } + + public static Attachment buildAttachmentFromAttachmentDetail(AttachmentDetails attachmentDetails) { + Attachment attachment = new Attachment(); + attachment.setDate(attachmentDetails.getDate().toInstant()); + attachment.setId(attachmentDetails.getId()); + attachment.setDocumentType(attachmentDetails.getDocumentType()); + attachment.setUri(attachmentDetails.getUri()); + attachment.setSha256(attachmentDetails.getSha256()); + attachment.setSourceType(attachmentDetails.getSourceType()); + attachment.setOriginType(attachmentDetails.getOriginType()); + return attachment; + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackerDryRunOutputsMapper.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackerDryRunOutputsMapper.java new file mode 100644 index 000000000..6b3cd82be --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackerDryRunOutputsMapper.java @@ -0,0 +1,56 @@ +package it.pagopa.pn.papertracker.mapper; + +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.model.AttachmentDetails; +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.model.SendEvent; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.Attachment; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackerDryRunOutputs; +import lombok.AccessLevel; +import lombok.RequiredArgsConstructor; +import org.springframework.util.CollectionUtils; + +import java.time.Instant; +import java.util.Objects; + +@RequiredArgsConstructor(access = AccessLevel.NONE) +public class PaperTrackerDryRunOutputsMapper { + + public static PaperTrackerDryRunOutputs dtoToEntity(SendEvent event, String anonymizedDiscoveredAddressId) { + PaperTrackerDryRunOutputs dryRunOutput = new PaperTrackerDryRunOutputs(); + dryRunOutput.setTrackingId(event.getRequestId()); + dryRunOutput.setCreated(Instant.now()); + dryRunOutput.setRegisteredLetterCode(event.getRegisteredLetterCode()); + dryRunOutput.setStatusDetail(event.getStatusDetail()); + dryRunOutput.setStatusDescription(event.getStatusDescription()); + dryRunOutput.setDeliveryFailureCause(event.getDeliveryFailureCause()); + dryRunOutput.setAnonymizedDiscoveredAddressId(anonymizedDiscoveredAddressId); + + if(Objects.nonNull(event.getStatusCode())) { + dryRunOutput.setStatusCode(event.getStatusCode().name()); + } + + if(Objects.nonNull(event.getStatusDateTime())) { + dryRunOutput.setStatusDateTime(event.getStatusDateTime().toString()); + } + + if(!CollectionUtils.isEmpty(event.getAttachments())) { + dryRunOutput.setAttachments((event.getAttachments().stream() + .map(PaperTrackerDryRunOutputsMapper::buildAttachmentForExternalChannelOutputEvent) + .toList())); + } + + if(Objects.nonNull(event.getClientRequestTimeStamp())) { + dryRunOutput.setClientRequestTimestamp(event.getClientRequestTimeStamp().toString()); + } + + return dryRunOutput; + } + + private static Attachment buildAttachmentForExternalChannelOutputEvent(AttachmentDetails attachment) { + Attachment attachmentEntity = new Attachment(); + attachmentEntity.setId(attachment.getId()); + attachmentEntity.setDate(attachment.getDate().toInstant()); + attachmentEntity.setDocumentType(attachment.getDocumentType()); + attachmentEntity.setUri(attachment.getUrl()); + return attachmentEntity; + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackerMapStructMapper.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackerMapStructMapper.java new file mode 100644 index 000000000..4be8c1048 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackerMapStructMapper.java @@ -0,0 +1,75 @@ +package it.pagopa.pn.papertracker.mapper; + +import it.pagopa.pn.papertracker.generated.openapi.server.v1.dto.PaperTrackerOutput; +import it.pagopa.pn.papertracker.generated.openapi.server.v1.dto.Tracking; +import it.pagopa.pn.papertracker.generated.openapi.server.v1.dto.TrackingError; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.BusinessState; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.ErrorType; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackerDryRunOutputs; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackings; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackingsErrors; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackingsState; +import org.mapstruct.Mapper; +import org.mapstruct.Mapping; +import org.mapstruct.ReportingPolicy; +import java.time.Instant; + +@Mapper( + componentModel = "spring", + unmappedTargetPolicy = ReportingPolicy.ERROR, + unmappedSourcePolicy = ReportingPolicy.IGNORE +) +public interface PaperTrackerMapStructMapper { + + @Mapping(target = "notificationReworkTimestamp", source = "notificationReworkRequestTimestamp") + Tracking toTracking(PaperTrackings paperTrackings); + + TrackingError toTrackingError(PaperTrackingsErrors paperTrackingsErrors); + + PaperTrackerOutput toDtoPaperTrackerOutput(PaperTrackerDryRunOutputs entity); + + default String map(Instant instant) { + return instant != null ? instant.toString() : null; + } + + default Tracking.StateEnum map(PaperTrackingsState state) { + if (state == null) { + return null; + } + + return switch (state) { + case AWAITING_FINAL_STATUS_CODE, AWAITING_REFINEMENT -> Tracking.StateEnum.AWAITING_REFINEMENT; + case AWAITING_REWORK_EVENTS -> Tracking.StateEnum.AWAITING_REWORK_EVENTS; + case AWAITING_OCR -> Tracking.StateEnum.AWAITING_OCR; + case DONE -> Tracking.StateEnum.DONE; + case KO -> Tracking.StateEnum.KO; + }; + } + + default Tracking.BusinessStateEnum map(BusinessState businessState) { + if (businessState == null) { + return null; + } + + return switch (businessState) { + case AWAITING_FINAL_STATUS_CODE -> Tracking.BusinessStateEnum.AWAITING_FINAL_STATUS_CODE; + case AWAITING_REFINEMENT_OCR -> Tracking.BusinessStateEnum.AWAITING_OCR; + case AWAITING_REWORK_EVENTS -> Tracking.BusinessStateEnum.AWAITING_REWORK_EVENTS; + case AWAITING_OCR -> Tracking.BusinessStateEnum.AWAITING_REFINEMENT_OCR; + case DONE -> Tracking.BusinessStateEnum.DONE; + case KO -> Tracking.BusinessStateEnum.KO; + }; + } + + default TrackingError.TypeEnum map(ErrorType errorType) { + if (errorType == null) { + return null; + } + + return switch (errorType) { + case ERROR -> TrackingError.TypeEnum.ERROR; + case INFO, WARNING -> TrackingError.TypeEnum.WARNING; + }; + } +} + diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackingsErrorsMapper.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackingsErrorsMapper.java new file mode 100644 index 000000000..a7f24d6f3 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackingsErrorsMapper.java @@ -0,0 +1,44 @@ +package it.pagopa.pn.papertracker.mapper; + +import it.pagopa.pn.papertracker.generated.openapi.server.v1.dto.TrackingError; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.*; +import lombok.AccessLevel; +import lombok.RequiredArgsConstructor; + +import java.time.Instant; +import java.util.Map; + +@RequiredArgsConstructor(access = AccessLevel.NONE) +public class PaperTrackingsErrorsMapper { + + public static PaperTrackingsErrors buildPaperTrackingsError(PaperTrackings paperTrackings, + String statusCode, + ErrorCategory errorCategory, + ErrorCause errorCause, + String errorMessage, + Map additionalDetails, + FlowThrow flowThrow, + ErrorType errorType, + String eventIdThrow) { + return PaperTrackingsErrors.builder() + .trackingId(paperTrackings.getTrackingId()) + .created(Instant.now()) + .errorCategory(errorCategory) + .details(ErrorDetails.builder() + .cause(errorCause) + .message(errorMessage) + .additionalDetails(additionalDetails) + .build()) + .flowThrow(flowThrow) + .eventThrow(statusCode) + .productType(paperTrackings.getProductType()) + .unifiedDeliveryDriver(paperTrackings.getUnifiedDeliveryDriver()) + .registeredLetterCode(paperTrackings.getPaperStatus() != null + ? paperTrackings.getPaperStatus().getRegisteredLetterCode() + : null) + .type(errorType) + .eventIdThrow(eventIdThrow) + .build(); + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackingsMapper.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackingsMapper.java new file mode 100644 index 000000000..4f2e6f699 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/PaperTrackingsMapper.java @@ -0,0 +1,105 @@ +package it.pagopa.pn.papertracker.mapper; + +import it.pagopa.pn.papertracker.config.PnPaperTrackerConfigs; +import it.pagopa.pn.papertracker.config.TrackerConfigUtils; +import it.pagopa.pn.papertracker.generated.openapi.server.v1.dto.Tracking; +import it.pagopa.pn.papertracker.generated.openapi.server.v1.dto.TrackingCreationRequest; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.*; +import it.pagopa.pn.papertracker.model.FileType; +import it.pagopa.pn.papertracker.model.OcrStatusEnum; +import lombok.AccessLevel; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; + +import java.time.Instant; +import java.time.LocalDate; +import java.time.ZoneId; +import java.util.List; +import java.util.Objects; + +@Slf4j +@RequiredArgsConstructor(access = AccessLevel.NONE) +public class PaperTrackingsMapper { + + public static PaperTrackings toPaperTrackings(TrackingCreationRequest trackingCreationRequest, + TrackerConfigUtils trackerConfigUtils, + PnPaperTrackerConfigs pnPaperTrackerConfigs, + Instant now, + String xOriginClientId) { + ProductType productType = ProductType.fromValue(trackingCreationRequest.getProductType()); + LocalDate localDate = LocalDate.now(ZoneId.of("Europe/Rome")); + PaperTrackings paperTrackings = new PaperTrackings(); + paperTrackings.setTrackingId(String.join(".", trackingCreationRequest.getAttemptId(), trackingCreationRequest.getPcRetry())); + paperTrackings.setUnifiedDeliveryDriver(trackingCreationRequest.getUnifiedDeliveryDriver()); + paperTrackings.setProductType(trackingCreationRequest.getProductType()); + paperTrackings.setState(PaperTrackingsState.AWAITING_REFINEMENT); + paperTrackings.setBusinessState(BusinessState.AWAITING_FINAL_STATUS_CODE); + paperTrackings.setAttemptId(trackingCreationRequest.getAttemptId()); + paperTrackings.setPcRetry(trackingCreationRequest.getPcRetry()); + paperTrackings.setCreatedAt(now); + paperTrackings.setProcessingMode(trackerConfigUtils.getActualProductsProcessingModes(localDate).get(productType)); + paperTrackings.setAnalogRequestClientId(xOriginClientId); + PaperStatus paperStatus = new PaperStatus(); + paperTrackings.setPaperStatus(paperStatus); + ValidationFlow validationFlow = new ValidationFlow(); + validationFlow.setOcrRequests(List.of()); + paperTrackings.setValidationFlow(validationFlow); + ValidationConfig validationConfig = new ValidationConfig(); + validationConfig.setOcrFilterTemporal(pnPaperTrackerConfigs.getOcrFilterTemporal()); + validationConfig.setOcrFilterUnifiedDeliveryDriver(pnPaperTrackerConfigs.getOcrFilterUnifiedDeliveryDriver()); + validationConfig.setOcrEnabled(evaluateIfOcrIsEnabled(trackerConfigUtils, productType, now, trackingCreationRequest, localDate)); + validationConfig.setOcrFileTypes(pnPaperTrackerConfigs.getEnableOcrValidationForFile().stream().map(FileType::getValue).toList()); + validationConfig.setRequiredAttachmentsRefinementStock890(trackerConfigUtils.getActualRequiredAttachmentsRefinementStock890(localDate)); + validationConfig.setSendOcrAttachmentsRefinementStock890(trackerConfigUtils.getActualSendOcrAttachmentsRefinementStock890(localDate)); + validationConfig.setSendOcrAttachmentsFinalValidation(trackerConfigUtils.getActualSendOcrAttachmentsFinalValidation(localDate)); + validationConfig.setSendOcrAttachmentsFinalValidationStock890(trackerConfigUtils.getActualSendOcrAttachmentsFinalValidationStock890(localDate)); + validationConfig.setStrictFinalValidationStock890(trackerConfigUtils.getActualStrictFinalValidationStock890(localDate)); + validationConfig.setStrictDeliveryFailureCause(trackerConfigUtils.getActualStrictDeliveryFailureCause(localDate)); + paperTrackings.setValidationConfig(validationConfig); + return paperTrackings; + } + + private static OcrStatusEnum evaluateIfOcrIsEnabled(TrackerConfigUtils trackerConfigUtils, + ProductType productType, + Instant now, + TrackingCreationRequest trackingCreationRequest, + LocalDate localDate) { + + OcrStatusEnum ocrStatusEnum = trackerConfigUtils.getActualEnableOcrValidationFor(localDate).get(productType); + + if (Objects.isNull(ocrStatusEnum) || OcrStatusEnum.DISABLED.equals(ocrStatusEnum)) { + return OcrStatusEnum.DISABLED; + } + + if (OcrStatusEnum.DRY.equals(ocrStatusEnum)) { + return OcrStatusEnum.DRY; + } + + // Siamo in modalità OCR:RUN + + boolean isTemporalFilterConfigured = !trackerConfigUtils.isOcrFilterTemporalDisabled(); + boolean isUnifiedDeliveryDriverFilterConfigured = !trackerConfigUtils.isOcrFilterDriverDisabled(); + + // Caso 1: entrambi i filtri disattivi + if (!isTemporalFilterConfigured && !isUnifiedDeliveryDriverFilterConfigured) { + log.info("Both OCR filters are disabled. OCR will be enabled in RUN mode"); + return OcrStatusEnum.RUN; + } + + boolean isTemporalFilterActive = isTemporalFilterConfigured && trackerConfigUtils.isOcrFilterTemporalActive(now); + boolean isUnifiedDeliveryDriverFilterActive = isUnifiedDeliveryDriverFilterConfigured && + trackerConfigUtils.isOcrFilterDriverActive(trackingCreationRequest.getUnifiedDeliveryDriver()); + + log.info("Temporal filter is active: {}", isTemporalFilterActive); + log.info("UnifiedDeliveryDriver {} is filtered: {}", trackingCreationRequest.getUnifiedDeliveryDriver(), isUnifiedDeliveryDriverFilterActive); + + // Caso 2: entrambi i filtri sono configurati + if (isTemporalFilterConfigured && isUnifiedDeliveryDriverFilterConfigured) { + return (isTemporalFilterActive && isUnifiedDeliveryDriverFilterActive) ? OcrStatusEnum.RUN : OcrStatusEnum.DRY; + } + + // Caso 3: solo uno dei due filtri è configurato + return (isTemporalFilterActive || isUnifiedDeliveryDriverFilterActive) ? OcrStatusEnum.RUN : OcrStatusEnum.DRY; + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/SendEventMapper.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/SendEventMapper.java new file mode 100644 index 000000000..0c6df62f3 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/mapper/SendEventMapper.java @@ -0,0 +1,153 @@ +package it.pagopa.pn.papertracker.mapper; + +import it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.DiscoveredAddress; +import it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.PaperProgressStatusEvent; +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.model.AnalogAddress; +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.model.AttachmentDetails; +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.model.SendEvent; +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.model.StatusCodeEnum; +import it.pagopa.pn.papertracker.generated.openapi.msclient.pndatavault.model.PaperAddress; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.Attachment; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.Event; +import it.pagopa.pn.papertracker.model.EventStatusCodeEnum; +import it.pagopa.pn.papertracker.utils.TrackerUtility; +import lombok.AccessLevel; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.util.CollectionUtils; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +import java.time.OffsetDateTime; +import java.time.ZoneOffset; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +@RequiredArgsConstructor(access = AccessLevel.NONE) +@Slf4j +public class SendEventMapper { + + /** + * Crea l'evento dalla classe PaperProgressStatusEvent e lo inserisce dentro SendEvent per l'invio a delivery-push. + * Se si tratta di un evento intermedio senza allegati ed è un final demat, non viene inviato a delivery-push. + * + * @param paperProgressStatusEvent evento intermedio ricevuto + * @return SendEvent contenente l'evento rimappato da inviare a delivery-push + */ + public static Flux createSendEventsFromPaperProgressStatusEvent(PaperProgressStatusEvent paperProgressStatusEvent) { + boolean isFinalDemat = TrackerUtility.checkIfIsFinalDemat(paperProgressStatusEvent.getStatusCode()); + return Mono.just(paperProgressStatusEvent) + .flatMapMany(progressEvent -> { + if (!CollectionUtils.isEmpty(progressEvent.getAttachments())) { + return Flux.fromIterable(progressEvent.getAttachments().stream() + .map(attachmentDetails -> buildSendEvent(progressEvent, attachmentDetails)) + .collect(Collectors.toList())); + } else if(!isFinalDemat) + return Flux.just(buildSendEvent(progressEvent, null)); + + log.info("Event with statusCode {} is a final demat without attachments, skipping sending to delivery-push", progressEvent.getStatusCode()); + return Flux.empty(); + } + ); + } + + public static SendEvent buildSendEvent(PaperProgressStatusEvent progressEvent, it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.AttachmentDetails attachmentDetails) { + SendEvent.SendEventBuilder builder = SendEvent.builder() + .requestId(progressEvent.getRequestId()) + .statusCode(StatusCodeEnum.valueOf(EventStatusCodeEnum.valueOf(progressEvent.getStatusCode()).getStatus().name())) + .statusDetail(progressEvent.getStatusCode()) + .statusDescription(progressEvent.getProductType() + " - " + progressEvent.getStatusCode() + " - " + progressEvent.getStatusDescription()) + .deliveryFailureCause(progressEvent.getDeliveryFailureCause()) + .registeredLetterCode(progressEvent.getRegisteredLetterCode()) + .statusDateTime(progressEvent.getStatusDateTime()) + .clientRequestTimeStamp(progressEvent.getClientRequestTimeStamp()); + + if(Objects.nonNull(progressEvent.getDiscoveredAddress())){ + builder.discoveredAddress(toAnalogAddress(progressEvent.getDiscoveredAddress())); + } + if(Objects.nonNull(attachmentDetails)){ + builder.attachments(buildPaperAttachmentDetailsFromExternalChannels(List.of(attachmentDetails))); + } + + return builder.build(); + } + + public static Flux createSendEventsFromEventEntity(String requestId, Event event, StatusCodeEnum statusCode, String statusDetail, OffsetDateTime statusDateTime) { + return Mono.just(event) + .flatMapMany(progressEvent -> { + if (!CollectionUtils.isEmpty(progressEvent.getAttachments())) { + return Flux.fromIterable(progressEvent.getAttachments().stream() + .map(attachmentDetails -> toSendEvent(requestId, event, statusCode, statusDetail, statusDateTime, attachmentDetails)) + .collect(Collectors.toList())); + } + return Flux.just(toSendEvent(requestId, event, statusCode, statusDetail, statusDateTime, null)); + } + ); + } + + public static SendEvent toSendEvent(String requestId, Event event, StatusCodeEnum statusCode, String statusDetail, OffsetDateTime statusDateTime, Attachment attachmentDetails) { + SendEvent.SendEventBuilder builder = SendEvent.builder() + .requestId(requestId) + .statusCode(statusCode) + .statusDetail(statusDetail) + .statusDescription(event.getProductType() + " - " + statusDetail + " - " + event.getStatusDescription()) + .deliveryFailureCause(event.getDeliveryFailureCause()) + .registeredLetterCode(event.getRegisteredLetterCode()) + .statusDateTime(statusDateTime) + .clientRequestTimeStamp(event.getRequestTimestamp().atOffset(ZoneOffset.UTC)); + + if(Objects.nonNull(attachmentDetails)){ + builder.attachments(buildAttachmentDetails(event.getAttachments())); + } + + return builder.build(); + } + + private static List buildAttachmentDetails(List attachments) { + return attachments.stream().map(attachment -> AttachmentDetails.builder() + .documentType(attachment.getDocumentType()) + .date(attachment.getDate().atOffset(ZoneOffset.UTC)) + .id(attachment.getId()) + .url(attachment.getUri()) + .build()).toList(); + } + + private static List buildPaperAttachmentDetailsFromExternalChannels(List attachments) { + return attachments.stream().map(attachment -> AttachmentDetails.builder() + .documentType(attachment.getDocumentType()) + .date(attachment.getDate()) + .id(attachment.getId()) + .url(attachment.getUri()) + .build()).toList(); + } + + public static AnalogAddress toAnalogAddress(DiscoveredAddress discoveredAddress) { + return AnalogAddress.builder() + .address(discoveredAddress.getAddress()) + .addressRow2(discoveredAddress.getAddressRow2()) + .cap(discoveredAddress.getCap()) + .pr(discoveredAddress.getPr()) + .city(discoveredAddress.getCity()) + .city2(discoveredAddress.getCity2()) + .country(discoveredAddress.getCountry()) + .fullname(discoveredAddress.getName()) + .nameRow2(discoveredAddress.getNameRow2()) + .build(); + } + + public static AnalogAddress toAnalogAddress(PaperAddress paperAddress) { + return AnalogAddress.builder() + .address(paperAddress.getAddress()) + .addressRow2(paperAddress.getAddressRow2()) + .cap(paperAddress.getCap()) + .pr(paperAddress.getPr()) + .city(paperAddress.getCity()) + .city2(paperAddress.getCity2()) + .country(paperAddress.getCountry()) + .fullname(paperAddress.getName()) + .nameRow2(paperAddress.getNameRow2()) + .build(); + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/PaperTrackerDryRunOutputsDAO.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/PaperTrackerDryRunOutputsDAO.java new file mode 100644 index 000000000..4b91c4e08 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/PaperTrackerDryRunOutputsDAO.java @@ -0,0 +1,12 @@ +package it.pagopa.pn.papertracker.middleware.dao; + +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackerDryRunOutputs; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +public interface PaperTrackerDryRunOutputsDAO { + + Flux retrieveOutputEvents(String requestId); + + Mono insertOutputEvent(PaperTrackerDryRunOutputs paperTrackerDryRunOutputs); +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/PaperTrackingsDAO.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/PaperTrackingsDAO.java new file mode 100644 index 000000000..7b1fe580f --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/PaperTrackingsDAO.java @@ -0,0 +1,25 @@ +package it.pagopa.pn.papertracker.middleware.dao; + +import com.sngular.apigenerator.asyncapi.business_model.model.event.Data; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackings; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +import java.util.List; + +public interface PaperTrackingsDAO { + + Mono putIfAbsent(PaperTrackings entity); + + Mono retrieveEntityByTrackingId(String trackingId); + + Flux retrieveEntityByAttemptId(String attemptId, String pcRetry); + + Mono updateItem(String requestId, PaperTrackings paperTrackings); + + Mono updateItemForRework(String trackingId, PaperTrackings paperTrackings); + + Mono updateOcrRequests(Integer ocrRequestIndex, String trackingId, Data.ValidationStatus validationStatus); + + Flux retrieveAllByTrackingIds(List trackingIds); +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/PaperTrackingsErrorsDAO.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/PaperTrackingsErrorsDAO.java new file mode 100644 index 000000000..cf5bd2b19 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/PaperTrackingsErrorsDAO.java @@ -0,0 +1,13 @@ +package it.pagopa.pn.papertracker.middleware.dao; + +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackingsErrors; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + +public interface PaperTrackingsErrorsDAO { + + Mono insertError(PaperTrackingsErrors entity); + + Flux retrieveErrors(String requestId); + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/AdditionalDetailsConverter.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/AdditionalDetailsConverter.java new file mode 100644 index 000000000..ca73d2b7a --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/AdditionalDetailsConverter.java @@ -0,0 +1,95 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo; + +import software.amazon.awssdk.enhanced.dynamodb.AttributeConverter; +import software.amazon.awssdk.enhanced.dynamodb.AttributeValueType; +import software.amazon.awssdk.enhanced.dynamodb.EnhancedType; +import software.amazon.awssdk.services.dynamodb.model.AttributeValue; + +import java.util.List; +import java.util.Map; +import java.util.Objects; +import java.util.Optional; +import java.util.stream.Collectors; + +public class AdditionalDetailsConverter implements AttributeConverter> { + + @Override + public AttributeValue transformFrom(Map value) { + if (Objects.isNull(value)) { + return AttributeValue.builder().nul(true).build(); + } + return AttributeValue.builder().m(value.entrySet().stream() + .collect(java.util.stream.Collectors.toMap( + Map.Entry::getKey, + e -> toAttr(e.getValue()) + ))).build(); + } + + @Override + public Map transformTo(AttributeValue attributeValue) { + if (Boolean.TRUE.equals(attributeValue.nul())) { + return null; + } + if (Objects.isNull(attributeValue.m())) { + return Map.of(); + } + return attributeValue.m().entrySet().stream().collect(java.util.stream.Collectors.toMap( + Map.Entry::getKey, + e -> Optional.ofNullable(fromAttr(e.getValue())).orElse("") + )); + } + + @Override + public AttributeValueType attributeValueType() { + return AttributeValueType.M; + } + + @Override + public EnhancedType> type() { + return EnhancedType.mapOf(EnhancedType.of(String.class), EnhancedType.of(Object.class)); + } + + /* -------- conversioni -------- */ + + private AttributeValue toAttr(Object v) { + return switch (v) { + case String s -> AttributeValue.builder().s(s).build(); + case Number n -> AttributeValue.builder().n(n.toString()).build(); + case Boolean b -> AttributeValue.builder().bool(b).build(); + case Map m -> AttributeValue.builder().m(m.entrySet().stream() + .collect(Collectors.toMap(e -> e.getKey().toString(), e -> toAttr(e.getValue())))) + .build(); + case List l -> AttributeValue.builder().l(l.stream().map(this::toAttr).toList()).build(); + case null -> AttributeValue.builder().nul(true).build(); + default -> throw new IllegalArgumentException("Unsupported type in additionalDetails: " + v.getClass()); + }; + } + + private Object fromAttr(AttributeValue attributeValue) { + switch (attributeValue.type()) { + case S -> { + if (Objects.nonNull(attributeValue.s())) return attributeValue.s(); + } + case N -> { + if (Objects.nonNull(attributeValue.n())) return attributeValue.n(); + } + case BOOL -> { + if (Objects.nonNull(attributeValue.bool())) return attributeValue.bool(); + } + case M -> { + if (Objects.nonNull(attributeValue.m())) { + return attributeValue.m().entrySet().stream() + .collect(Collectors.toMap(Map.Entry::getKey, e -> Optional.ofNullable(fromAttr(e.getValue())).orElse(""))); + } + } + case L -> { + if (Objects.nonNull(attributeValue.l())) { + return attributeValue.l().stream() + .map(this::fromAttr) + .toList(); + } + } + } + return null; + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/BaseDao.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/BaseDao.java new file mode 100644 index 000000000..e9da3a8f6 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/BaseDao.java @@ -0,0 +1,184 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo; + +import lombok.extern.slf4j.Slf4j; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; +import software.amazon.awssdk.enhanced.dynamodb.*; +import software.amazon.awssdk.enhanced.dynamodb.model.*; +import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient; +import software.amazon.awssdk.services.dynamodb.model.AttributeValue; +import software.amazon.awssdk.services.dynamodb.model.UpdateItemRequest; +import software.amazon.awssdk.services.dynamodb.model.UpdateItemResponse; + +import java.util.*; +import java.util.concurrent.atomic.AtomicInteger; + +@Slf4j +public class BaseDao { + private final DynamoDbAsyncTable tableAsync; + private final Class tClass; + private final DynamoDbAsyncClient dynamoDbAsyncClient; + private final DynamoDbEnhancedAsyncClient dynamoDbEnhancedAsyncClient; + + protected BaseDao( + DynamoDbEnhancedAsyncClient dynamoDbEnhancedAsyncClient, + DynamoDbAsyncClient dynamoDbAsyncClient, + String tableName, + Class tClass + ) { + this.tableAsync = dynamoDbEnhancedAsyncClient.table(tableName, TableSchema.fromBean(tClass)); + this.tClass = tClass; + this.dynamoDbAsyncClient = dynamoDbAsyncClient; + this.dynamoDbEnhancedAsyncClient = dynamoDbEnhancedAsyncClient; + } + + protected Mono putItem(T entity) { + return Mono.fromFuture(this.tableAsync.putItem(entity)) + .thenReturn(entity); + } + + public Flux retrieveByRequestId(String pk) { + log.info("retrieve Items from [{}] table, for requestId={}", tableAsync.tableName(), pk); + return Flux.from(tableAsync.query(r -> r.queryConditional( + QueryConditional.keyEqualTo(Key.builder().partitionValue(pk).build())))) + .flatMap(page -> Flux.fromIterable(page.items())) + .doOnError(e -> log.error("Error retrieving items for requestId {}: {}", pk, e.getMessage())); + } + + public Mono getByKey(Key key) { + return Mono.fromFuture(tableAsync.getItem(key)); + } + + public Flux queryByIndex(Key build, String indexName) { + QueryEnhancedRequest request = QueryEnhancedRequest.builder() + .queryConditional(QueryConditional.keyEqualTo(build)) + .build(); + + return Mono.from(tableAsync.index(indexName).query(request)) + .map(Page::items) + .flatMapMany(Flux::fromIterable) + .doOnError(e -> log.error("Error querying index {}: {}", indexName, e.getMessage())); + } + + public Flux retrieveFromIndex(String indexName, QueryConditional queryConditional) { + return Mono.from(tableAsync.index(indexName) + .query(QueryEnhancedRequest.builder().queryConditional(queryConditional).build())) + .map(Page::items) + .flatMapMany(Flux::fromIterable); + } + + public Mono putIfAbsent(String expression, T entity) { + + Expression conditionExpressionPut = Expression.builder() + .expression(expression) + .build(); + + PutItemEnhancedRequest request = PutItemEnhancedRequest.builder(tClass) + .item(entity) + .conditionExpression(conditionExpressionPut) + .build(); + + return Mono.fromFuture(tableAsync.putItem(request)) + .thenReturn(entity); + } + + public Mono updateIfExists(Map key, String updateExpression, Map expressionValues, Map expressionNames, String conditionExpression) { + UpdateItemRequest updateItemRequest = UpdateItemRequest.builder() + .tableName(tableAsync.tableName()) + .key(key) + .updateExpression(updateExpression) + .expressionAttributeValues(expressionValues) + .expressionAttributeNames(expressionNames) + .conditionExpression(conditionExpression) + .returnValues("ALL_NEW") + .build(); + + return Mono.fromFuture(dynamoDbAsyncClient.updateItem(updateItemRequest)); + } + + protected Flux findAllByKeys(List partitionKeys) { + ReadBatch.Builder builder = ReadBatch.builder(tClass) + .mappedTableResource(this.tableAsync); + + partitionKeys.forEach(partitionKey -> + builder.addGetItem(Key.builder().partitionValue(partitionKey).build()) + ); + + BatchGetItemEnhancedRequest request = BatchGetItemEnhancedRequest.builder() + .readBatches(builder.build()) + .build(); + + return Flux.from(dynamoDbEnhancedAsyncClient.batchGetItem(request) + .map(result -> result.resultsForTable(tableAsync))) + .flatMap(Flux::fromIterable); + } + + /** + * Costruisce updateExpression per DynamoDB in base al tipo di attributo fornito. + * Per gli attributi di tipo lista, genera un'espressione per aggiungere alla lista utilizzando {@code list_append} e {@code if_not_exists}. + * Per gli attributi di tipo mappa (oggetto annidato), genera espressioni per aggiornare ciascuna coppia chiave-valore interna. + * Per altri tipi di attributo, genera una semplice espressione di assegnazione. + * + * @param key La chiave dell'attributo da aggiornare + * @param value Il valore dell'attributo da aggiornare + * @param counter Un contatore atomico utilizzato per generare indici univoci per i parametri + * @param names Mappa dei nomi degli attributi per l'espressione DynamoDB + * @param values Mappa dei valori degli attributi per l'espressione DynamoDB + * @return Una lista di espressioni di aggiornamento da utilizzare in una richiesta di update su DynamoDB + */ + protected List buildUpdateExpressions(String key, AttributeValue value, AtomicInteger counter, Map names, Map values) { + List expressions = new ArrayList<>(); + + if(key.equalsIgnoreCase("validationConfig")){ + return expressions; + } + + if (isListAttributeType(value)) { + int idx = counter.getAndIncrement(); + names.put("#k" + idx, key); + values.put(":v" + idx, AttributeValue.builder().l(value.l()).build()); + values.put(":empty" + idx, AttributeValue.builder().l(Collections.emptyList()).build()); + expressions.add("#k" + idx + " = list_append(if_not_exists(" + "#k" + idx + ", " + ":empty" + idx + "), " + ":v" + idx + ")"); + + } else if (isInnerObjectAttributeType(value)) { + value.m().forEach((innerKey, innerVal) -> { + int idx = counter.getAndIncrement(); + if(key.equalsIgnoreCase("paperStatus")){ + names.put("#paperStatus", key); + names.put("#paperStatus_" + idx + "_inner", innerKey); + values.put(":v" + idx, innerVal); + expressions.add("#paperStatus.#paperStatus_" + idx + "_inner" + " = " + ":v" + idx); + } + else if(key.equalsIgnoreCase("validationFlow")){ + names.put("#validationFlow" , key); + names.put("#validationFlow_" + idx + "_inner", innerKey); + values.put(":v" + idx, innerVal); + expressions.add("#validationFlow.#validationFlow_" + idx + "_inner" + " = " + ":v" + idx); + } + else { + names.put("#k" + idx, key); + names.put("#k" + idx + "_inner", innerKey); + values.put(":v" + idx, innerVal); + expressions.add("#k" + idx + "." + "#k" + idx + "_inner" + " = " + ":v" + idx); + } + }); + } else { + if(!key.equalsIgnoreCase("paperStatus") && !key.equalsIgnoreCase("validationFlow")){ + int idx = counter.getAndIncrement(); + names.put("#k" + idx, key); + values.put(":v" + idx, value); + expressions.add("#k" + idx + " = " + ":v" + idx); + } + } + return expressions; + } + + private static boolean isInnerObjectAttributeType(AttributeValue value) { + return value.m() != null && !value.m().isEmpty(); + } + + private boolean isListAttributeType(AttributeValue value) { + return value.l() != null && !value.l().isEmpty(); + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/PaperTrackerDryRunOutputsDAOImpl.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/PaperTrackerDryRunOutputsDAOImpl.java new file mode 100644 index 000000000..d4544c929 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/PaperTrackerDryRunOutputsDAOImpl.java @@ -0,0 +1,35 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo; + +import it.pagopa.pn.papertracker.config.PnPaperTrackerConfigs; +import it.pagopa.pn.papertracker.middleware.dao.PaperTrackerDryRunOutputsDAO; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackerDryRunOutputs; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Component; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; +import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedAsyncClient; +import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient; + +@Slf4j +@Component +public class PaperTrackerDryRunOutputsDAOImpl extends BaseDao implements PaperTrackerDryRunOutputsDAO { + + public PaperTrackerDryRunOutputsDAOImpl(DynamoDbEnhancedAsyncClient dynamoDbEnhancedClient, PnPaperTrackerConfigs cfg, DynamoDbAsyncClient dynamoDbAsyncClient) { + super(dynamoDbEnhancedClient, + dynamoDbAsyncClient, + cfg.getDao().getPaperTrackerDryRunOutputsTable(), + PaperTrackerDryRunOutputs.class + ); + } + + @Override + public Flux retrieveOutputEvents(String requestId) { + log.info("retrieving output events for requestId={}", requestId); + return retrieveByRequestId(requestId); + } + + @Override + public Mono insertOutputEvent(PaperTrackerDryRunOutputs paperTrackerDryRunOutputs) { + return putItem(paperTrackerDryRunOutputs); + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/PaperTrackingsDAOImpl.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/PaperTrackingsDAOImpl.java new file mode 100644 index 000000000..41bf94309 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/PaperTrackingsDAOImpl.java @@ -0,0 +1,206 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo; + +import com.sngular.apigenerator.asyncapi.business_model.model.event.Data; +import it.pagopa.pn.papertracker.config.PnPaperTrackerConfigs; +import it.pagopa.pn.papertracker.exception.PnPaperTrackerConflictException; +import it.pagopa.pn.papertracker.exception.PnPaperTrackerNotFoundException; +import it.pagopa.pn.papertracker.middleware.dao.PaperTrackingsDAO; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.*; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Component; +import org.springframework.util.CollectionUtils; +import org.springframework.util.StringUtils; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; +import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedAsyncClient; +import software.amazon.awssdk.enhanced.dynamodb.Key; +import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient; +import software.amazon.awssdk.services.dynamodb.model.AttributeValue; +import software.amazon.awssdk.services.dynamodb.model.ConditionalCheckFailedException; + +import java.time.Instant; +import java.util.*; +import java.util.concurrent.atomic.AtomicInteger; + +import static it.pagopa.pn.commons.abstractions.impl.AbstractDynamoKeyValueStore.ATTRIBUTE_NOT_EXISTS; +import static it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackings.ATTEMPT_ID_PCRETRY_INDEX; + +@Component +@Slf4j +public class PaperTrackingsDAOImpl extends BaseDao implements PaperTrackingsDAO { + + private final String ERROR_CODE_PAPER_TRACKER_DUPLICATED_ITEM = "PN_PAPER_TRACKER_DUPLICATED_ITEM"; + private final String ERROR_CODE_PAPER_TRACKER_NOT_FOUND = "PN_PAPER_TRACKER_NOT_FOUND"; + + private final PnPaperTrackerConfigs pnPaperTrackerConfigs; + + public PaperTrackingsDAOImpl(DynamoDbEnhancedAsyncClient dynamoDbEnhancedClient, PnPaperTrackerConfigs cfg, DynamoDbAsyncClient dynamoDbAsyncClient) { + super(dynamoDbEnhancedClient, + dynamoDbAsyncClient, + cfg.getDao().getPaperTrackingsTable(), + PaperTrackings.class + ); + this.pnPaperTrackerConfigs = cfg; + } + + @Override + public Mono retrieveEntityByTrackingId(String trackingId) { + return getByKey(Key.builder().partitionValue(trackingId).build()); + } + + @Override + public Flux retrieveEntityByAttemptId(String attemptId, String pcRetry) { + Key.Builder key = Key.builder().partitionValue(attemptId); + + if(StringUtils.hasText(pcRetry)){ + key.sortValue(pcRetry); + } + + return queryByIndex(key.build(), ATTEMPT_ID_PCRETRY_INDEX); + } + + @Override + public Mono putIfAbsent(PaperTrackings entity) { + String expression = String.format("%s(%s)", ATTRIBUTE_NOT_EXISTS, PaperTrackings.COL_TRACKING_ID); + entity.setTtl(Instant.now().plus(pnPaperTrackerConfigs.getPaperTrackingsTtlDuration()).getEpochSecond()); + + return putIfAbsent(expression, entity) + .onErrorMap(ConditionalCheckFailedException.class, ex -> { + log.error("Conditional check exception on PaperTrackingsDAOImpl putTrackings trackingId={} exmessage={}", entity.getTrackingId(), ex.getMessage()); + log.warn("Duplicate trackingId detected in putIfAbsent: {}", entity.getTrackingId()); + return new PnPaperTrackerConflictException(ERROR_CODE_PAPER_TRACKER_DUPLICATED_ITEM, String.format("RequestId %s already exists", entity.getTrackingId())); + }); + } + + public Mono updateOcrRequests(Integer ocrRequestIndex, String trackingId, Data.ValidationStatus validationStatus) { + log.debug("updateOcrRequests for item with trackingId: {}", trackingId); + Instant now = Instant.now(); + Map expressionAttributeNames = new HashMap<>(); + Map expressionAttributeValues = new HashMap<>(); + + String updateExpr = "SET #updatedAt = :updatedAt"; + + expressionAttributeNames.put("#updatedAt", PaperTrackings.COL_UPDATED_AT); + expressionAttributeNames.put("#validationFlow", PaperTrackings.COL_VALIDATION_FLOW); + expressionAttributeNames.put("#ocr", ValidationFlow.COL_OCR_REQUESTS); + + expressionAttributeValues.put(":updatedAt", AttributeValue.builder().s(now.toString()).build()); + + if (Objects.nonNull(ocrRequestIndex) && ocrRequestIndex >= 0) { + expressionAttributeNames.put("#responseTimestamp", OcrRequest.COL_RESPONSE_TIMESTAMP); + expressionAttributeValues.put(":responseTimestamp", AttributeValue.builder().s(now.toString()).build()); + expressionAttributeNames.put("#responseStatus", OcrRequest.COL_RESPONSE_STATUS); + expressionAttributeValues.put(":responseStatus", AttributeValue.builder().s(validationStatus.getValue()).build()); + updateExpr += ", #validationFlow.#ocr[" + ocrRequestIndex + "].#responseStatus = :responseStatus, " + + "#validationFlow.#ocr[" + ocrRequestIndex + "].#responseTimestamp = :responseTimestamp"; + } + + String conditionExpression = String.format("%s(%s)", "attribute_exists", PaperTrackings.COL_TRACKING_ID); + return updateIfExists(trackingId, updateExpr, expressionAttributeValues, expressionAttributeNames, conditionExpression); + + } + + @Override + public Mono updateItem(String trackingId, PaperTrackings paperTrackings) { + return updateItem(trackingId, paperTrackings, false); + } + + @Override + public Mono updateItemForRework(String trackingId, PaperTrackings paperTrackings) { + return updateItem(trackingId, paperTrackings, true); + } + + /** + * Aggiorna un elemento PaperTrackings nel database DynamoDB, identificato dal trackingId. + * L'aggiornamento viene eseguito solo se l'elemento esiste (condizione attribute_exists). + * Viene aggiornato anche il campo "updatedAt" con il timestamp corrente. + * + * @param trackingId pk dell'oggetto PaperTrackings da aggiornare + * @param paperTrackings l'oggetto PaperTrackings con i nuovi valori da aggiornare + * @return un Mono contenente l'oggetto PaperTrackings aggiornato + * @throws PnPaperTrackerNotFoundException se l'elemento con il trackingId specificato non esiste + */ + public Mono updateItem(String trackingId, PaperTrackings paperTrackings, boolean resetPaperStatus) { + log.debug("Updating item with trackingId: {}", trackingId); + + Map expressionAttributeNames = new HashMap<>(); + Map expressionAttributeValues = new HashMap<>(); + List updateExpressions = new ArrayList<>(); + + expressionAttributeNames.put("#updatedAt", PaperTrackings.COL_UPDATED_AT); + expressionAttributeValues.put(":updatedAt", AttributeValue.builder().s(Instant.now().toString()).build()); + updateExpressions.add("#updatedAt = :updatedAt"); + + String updateExpr = "SET "; + + Optional.ofNullable(paperTrackings.getValidationFlow()) + .ifPresent(flow -> { + List requests = flow.getOcrRequests(); + if (!CollectionUtils.isEmpty(requests)) { + expressionAttributeNames.put("#validationFlow", PaperTrackings.COL_VALIDATION_FLOW); + expressionAttributeNames.put("#ocr", ValidationFlow.COL_OCR_REQUESTS); + expressionAttributeValues.put(":requests", AttributeValue.builder() + .l(PaperTrackings.paperTrackingsToAttributeValueMap(paperTrackings).get("validationFlow").m().get("ocrRequests").l()).build()); + updateExpressions.add("#validationFlow.#ocr = list_append(#validationFlow.#ocr, :requests) "); + } + + flow.setOcrRequests(null); + }); + + + Map attributeValueMap = new HashMap<>(PaperTrackings.paperTrackingsToAttributeValueMap(paperTrackings)); + + /* + * Reset completo di paperStatus. + * In questo modo DynamoDB sovrascrive l'intero attributo paperStatus + * con una mappa vuota, eliminando tutti i campi precedenti. + */ + if (resetPaperStatus) { + expressionAttributeNames.put("#paperStatus", PaperTrackings.COL_PAPER_STATUS); + expressionAttributeValues.put(":emptyPaperStatus", AttributeValue.builder() + .m(Collections.emptyMap()) + .build()); + + updateExpressions.add("#paperStatus = :emptyPaperStatus"); + attributeValueMap.remove(PaperTrackings.COL_PAPER_STATUS); + } + + AtomicInteger counter = new AtomicInteger(0); + + attributeValueMap.forEach((key, value) -> { + List expressions = buildUpdateExpressions( + key, value, counter, expressionAttributeNames, expressionAttributeValues + ); + updateExpressions.addAll(expressions); + }); + + updateExpr += String.join(", ", updateExpressions); + + String conditionExpression = String.format("%s(%s)", "attribute_exists", PaperTrackings.COL_TRACKING_ID); + + log.debug("updateExpr {}", updateExpr); + log.debug("expressionAttributeValues {}", expressionAttributeValues); + log.debug("expressionAttributeNames {}", expressionAttributeNames); + + return updateIfExists(trackingId, updateExpr, expressionAttributeValues, expressionAttributeNames, conditionExpression); + } + + private Mono updateIfExists(String trackingId, String updateExpr, Map expressionAttributeValues, Map expressionAttributeNames, String conditionExpression) { + return updateIfExists(Map.of(PaperTrackings.COL_TRACKING_ID, AttributeValue.builder().s(trackingId).build()), updateExpr, expressionAttributeValues, expressionAttributeNames, conditionExpression) + .map(updateItemResponse -> PaperTrackings.attributeValueMapToPaperTrackings(updateItemResponse.attributes())) + .doOnError(e -> log.error("Error updating item with trackingId {}: {}", trackingId, e.getMessage())) + .onErrorMap(ConditionalCheckFailedException.class, e -> { + log.info("Item with trackingId {} not found — cannot update", trackingId); + return new PnPaperTrackerNotFoundException( + ERROR_CODE_PAPER_TRACKER_NOT_FOUND, + String.format("PaperTracking with trackingId %s not found", trackingId) + ); + }); + } + + @Override + public Flux retrieveAllByTrackingIds(List trackingIds) { + return findAllByKeys(trackingIds); + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/PaperTrackingsErrorsDAOImpl.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/PaperTrackingsErrorsDAOImpl.java new file mode 100644 index 000000000..8615538eb --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/PaperTrackingsErrorsDAOImpl.java @@ -0,0 +1,53 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo; + +import it.pagopa.pn.commons.log.dto.metrics.GeneralMetric; +import it.pagopa.pn.papertracker.config.PnPaperTrackerConfigs; +import it.pagopa.pn.papertracker.middleware.dao.PaperTrackingsErrorsDAO; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackingsErrors; +import it.pagopa.pn.papertracker.utils.MetricUtils; +import lombok.CustomLog; +import org.springframework.stereotype.Component; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; +import software.amazon.awssdk.enhanced.dynamodb.DynamoDbEnhancedAsyncClient; +import software.amazon.awssdk.services.dynamodb.DynamoDbAsyncClient; + +import java.time.Instant; +import java.util.List; + +@Component +@CustomLog +public class PaperTrackingsErrorsDAOImpl extends BaseDao implements PaperTrackingsErrorsDAO { + + private final PnPaperTrackerConfigs pnPaperTrackerConfigs; + + public PaperTrackingsErrorsDAOImpl(DynamoDbEnhancedAsyncClient dynamoDbEnhancedClient, PnPaperTrackerConfigs cfg, DynamoDbAsyncClient dynamoDbAsyncClient) { + super(dynamoDbEnhancedClient, + dynamoDbAsyncClient, + cfg.getDao().getPaperTrackingsErrorsTable(), + PaperTrackingsErrors.class + ); + this.pnPaperTrackerConfigs = cfg; + } + + public Mono insertError(PaperTrackingsErrors paperTrackingsErrors) { + String logMessage = "Logging metrics: " + MetricUtils.MetricName.ERROR_COUNT +"; Dimensions: " + MetricUtils.DimensionName.ERROR_CATEGORY.getValue() + ", " + MetricUtils.DimensionName.PRODUCT_TYPE.getValue(); + GeneralMetric errorCountMetric = MetricUtils.generateGeneralMetric( + MetricUtils.MetricName.ERROR_COUNT, + 1, + List.of( + MetricUtils.generateDimension(MetricUtils.DimensionName.ERROR_CATEGORY, paperTrackingsErrors.getErrorCategory().name()), + MetricUtils.generateDimension(MetricUtils.DimensionName.PRODUCT_TYPE, paperTrackingsErrors.getProductType()) + ) + ); + + log.logMetric(List.of(errorCountMetric), logMessage); + + paperTrackingsErrors.setTtl(Instant.now().plus(pnPaperTrackerConfigs.getPaperTrackingsErrorsTtlDuration()).getEpochSecond()); + return putItem(paperTrackingsErrors); + } + + public Flux retrieveErrors(String requestId) { + return retrieveByRequestId(requestId); + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/Attachment.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/Attachment.java new file mode 100644 index 000000000..82bc5b32e --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/Attachment.java @@ -0,0 +1,43 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.Data; +import lombok.Getter; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbAttribute; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean; + +import java.time.Instant; + +@DynamoDbBean +@Data +public class Attachment { + + public static final String COL_ID = "id"; + public static final String COL_DOCUMENT_TYPE = "documentType"; + public static final String COL_URI = "uri"; + public static final String COL_DATE = "date"; + public static final String COL_SHA256 = "sha256"; + public static final String COL_SOURCE_TYPE = "sourceType"; + public static final String COL_ORIGIN_TYPE = "originType"; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_ID)})) + private String id; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_DOCUMENT_TYPE)})) + private String documentType; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_URI)})) + private String uri; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_DATE)})) + private Instant date; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_SHA256)})) + private String sha256; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_SOURCE_TYPE)})) + private String sourceType; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_ORIGIN_TYPE)})) + private String originType; + +} \ No newline at end of file diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/BusinessState.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/BusinessState.java new file mode 100644 index 000000000..69258ae87 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/BusinessState.java @@ -0,0 +1,12 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +public enum BusinessState { + AWAITING_FINAL_STATUS_CODE, + AWAITING_REFINEMENT_OCR, + AWAITING_REWORK_EVENTS, + AWAITING_OCR, + DONE, + KO + +} + diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorCategory.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorCategory.java new file mode 100644 index 000000000..6a3b13fd4 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorCategory.java @@ -0,0 +1,36 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.Getter; + +@Getter +public enum ErrorCategory { + + TRACKING_ID_NOT_FOUND("TrackingId non trovato"), + NOT_RETRYABLE_EVENT_ERROR("Evento not retryable ricevuto"), + RENDICONTAZIONE_SCARTATA("Rendicontazione scartata"), + DATE_ERROR("Errore nella validazione delle date della sequenza."), + LAST_EVENT_EXTRACTION_ERROR("Errore nell'estrazione della sequenza dall'ultimo evento."), + REGISTERED_LETTER_CODE_ERROR("Errore nella validazione del registered letter code"), + DELIVERY_FAILURE_CAUSE_ERROR("Errore nella validazione del delivery Failure Cause"), + ATTACHMENTS_ERROR("Errore nella validazione degli allegati della sequenza"), + MAX_RETRY_REACHED_ERROR("Numero massimo di retry raggiunto"), + OCR_VALIDATION("Errore nella validazione OCR"), + DEMAT_EMPTY_EVENT("Errore evento per demat non trovato"), + DEMAT_ATTACHMENT_NUMBER_ERROR("Errore nel numero di attachment trovati per demat"), + DUPLICATED_EVENT("Errore nella validazione della presenza di eventi duplicati"), + INVALID_STATE_FOR_STOCK_890("Stato non valido per giacenza 890"), + INCONSISTENT_STATE("Tracking completato o in attesa validazione OCR"), + /** + * @deprecated Non utilizzare. Campo mantenuto solo per retrocompatibilità. + */ + @Deprecated + STATUS_CODE_ERROR("Errore nella validazione della presenza degli elementi della sequenza."), + REGISTERED_LETTER_CODE_NOT_FOUND("Registered letter code non trovato"); + + private final String value; + + ErrorCategory(String value) { + this.value = value; + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorCause.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorCause.java new file mode 100644 index 000000000..41cdd0c22 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorCause.java @@ -0,0 +1,25 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.AllArgsConstructor; +import lombok.Getter; + +@Getter +@AllArgsConstructor +public enum ErrorCause { + + GIACENZA_DATE_ERROR("Date di inizio e fine giacenza non coerenti"), + OCR_DUPLICATED_EVENT("Evento di risposta duplicato"), + OCR_DRY_RUN_MODE("Evento di risposta ignorato in quanto attiva la modalità dry-run per l'OCR"), + OCR_KO( "Errore nella validazione dell'OCR"), + OCR_UNSUPPORTED_PRODUCT("Prodotto non supportato per la validazione OCR"), + STOCK_890_REFINEMENT_MISSING("Spedizione 890 non perfezionata"), + STOCK_890_REFINEMENT_ERROR("Errore nel perfezionamento della spedizione 890"), + VALUE_AFTER_REFINEMENT("Evento arrivato dopo la conclusione della spedizione o mentre si stava aspettando l’OCR (DONE o AWAITING_OCR)"), + VALUES_NOT_MATCHING("Errore nella validazione degli allegati della sequenza: mancano degli allegati"), + INVALID_VALUES("Errore nella validazione"), + VALUES_NOT_FOUND("Errore nella validazione dei statusCode della sequenza: non sono presenti tutti gli statusCode previsti dalla macchina a stati"), + SOURCETYPE_FILETYPE_INCOHERENT("Il sourceType e il fileType dell'allegato non sono coerenti"); + + private final String description; + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorDetails.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorDetails.java new file mode 100644 index 000000000..88936d373 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorDetails.java @@ -0,0 +1,26 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import it.pagopa.pn.papertracker.middleware.dao.dynamo.AdditionalDetailsConverter; +import lombok.*; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbConvertedBy; + +import java.util.Map; + +@Setter +@Getter +@DynamoDbBean +@NoArgsConstructor +@AllArgsConstructor +@Builder +public class ErrorDetails { + + public static final String COL_CAUSE = "cause"; + public static final String COL_MESSAGE = "message"; + public static final String COL_ADDITIONAL_DETAILS = "additionalDetails"; + + private ErrorCause cause; + private String message; + @Getter(onMethod = @__({ @DynamoDbConvertedBy(AdditionalDetailsConverter.class) })) + private Map additionalDetails; +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorType.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorType.java new file mode 100644 index 000000000..375287ecc --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ErrorType.java @@ -0,0 +1,9 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +public enum ErrorType { + + ERROR, + INFO, + WARNING + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/Event.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/Event.java new file mode 100644 index 000000000..fa1eecbc2 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/Event.java @@ -0,0 +1,83 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.Data; +import lombok.Getter; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbAttribute; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbIgnoreNulls; + +import java.time.Instant; +import java.util.List; + +@DynamoDbBean +@Data +public class Event { + + public static final String COL_REQUEST_TIMESTAMP = "requestTimestamp"; + public static final String COL_STATUS_CODE = "statusCode"; + public static final String COL_STATUS_DESCRIPTION = "statusDescription"; + public static final String COL_STATUS_TIMESTAMP = "statusTimestamp"; + public static final String COL_PRODUCT_TYPE = "productType"; + public static final String COL_DELIVERY_FAILURE_CAUSE = "deliveryFailureCause"; + public static final String COL_DISCOVERED_ADDRESS = "discoveredAddress"; + public static final String COL_ANONYMIZED_DISCOVERED_ADDRESS_ID = "anonymizedDiscoveredAddressId"; + public static final String COL_ATTACHMENTS = "attachments"; + public static final String COL_REGISTERED_LETTER_CODE = "registeredLetterCode"; + public static final String COL_ID = "id"; + public static final String COL_DRY_RUN = "dryRun"; + public static final String COL_IUN = "iun"; + public static final String COL_CREATED_AT = "createdAt"; + public static final String COL_REWORK_ID = "reworkId"; + public static final String COL_PRINTER = "printer"; + public static final String COL_DU = "du"; + + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_ID)})) + private String id; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_IUN)})) + private String iun; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REQUEST_TIMESTAMP)})) + private Instant requestTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_STATUS_CODE)})) + private String statusCode; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_STATUS_DESCRIPTION)})) + private String statusDescription; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_STATUS_TIMESTAMP)})) + private Instant statusTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_PRODUCT_TYPE)})) + private String productType; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_DELIVERY_FAILURE_CAUSE)})) + private String deliveryFailureCause; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_ANONYMIZED_DISCOVERED_ADDRESS_ID)})) + private String anonymizedDiscoveredAddressId; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_ATTACHMENTS), @DynamoDbIgnoreNulls})) + private List attachments; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REGISTERED_LETTER_CODE)})) + private String registeredLetterCode; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_DRY_RUN)})) + private Boolean dryRun; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_CREATED_AT)})) + private Instant createdAt; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REWORK_ID)})) + private String notificationReworkId; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_PRINTER)})) + private String printer; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_DU)})) + private String du; + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/FlowThrow.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/FlowThrow.java new file mode 100644 index 000000000..8f7e3590f --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/FlowThrow.java @@ -0,0 +1,15 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +public enum FlowThrow { + + INIT_TRACKING, + NOT_RETRYABLE_EVENT_HANDLER, + DUPLICATED_EVENT_VALIDATION, + CHECK_TRACKING_PRODUCT, + SEQUENCE_VALIDATION, + DEMAT_VALIDATION, + FINAL_EVENT_BUILDING, + CHECK_TRACKING_STATE, + RETRY_PHASE; + +} \ No newline at end of file diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/OcrRequest.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/OcrRequest.java new file mode 100644 index 000000000..0bf976c34 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/OcrRequest.java @@ -0,0 +1,42 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.Data; +import lombok.Getter; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbAttribute; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean; + +import java.time.Instant; + +@DynamoDbBean +@Data +public class OcrRequest { + + public static final String COL_REQUEST_TIMESTAMP = "requestTimestamp"; + public static final String COL_RESPONSE_TIMESTAMP = "responseTimestamp"; + public static final String COL_DOCUMENT_TYPE = "documentType"; + public static final String COL_FINAL_EVENT_ID = "finalEventId"; + public static final String COL_ATTACHMENT_EVENT_ID = "attachmentEventId"; + public static final String COL_URI = "uri"; + public static final String COL_RESPONSE_STATUS = "responseStatus"; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_DOCUMENT_TYPE)})) + private String documentType; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_FINAL_EVENT_ID)})) + private String finalEventId; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_ATTACHMENT_EVENT_ID)})) + private String attachmentEventId; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_RESPONSE_TIMESTAMP)})) + private Instant responseTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REQUEST_TIMESTAMP)})) + private Instant requestTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_URI)})) + private String uri; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_RESPONSE_STATUS)})) + private String responseStatus; +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperStatus.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperStatus.java new file mode 100644 index 000000000..8b40f09fc --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperStatus.java @@ -0,0 +1,53 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.Data; +import lombok.Getter; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbAttribute; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbIgnoreNulls; + +import java.time.Instant; +import java.util.List; + +@DynamoDbBean +@Data +public class PaperStatus { + + public static final String COL_REGISTERED_LETTER_CODE = "registeredLetterCode"; + public static final String COL_DELIVERY_FAILURE_CAUSE = "deliveryFailureCause"; + public static final String COL_ANONYMIZED_DISCOVERED_ADDRESS = "anonymizedDiscoveredAddress"; + public static final String COL_FINAL_STATUS_CODE = "finalStatusCode"; + public static final String COL_VALIDATED_SEQUENCE_TIMESTAMP = "validatedSequenceTimestamp"; + public static final String COL_VALIDATED_EVENTS = "validatedEvents"; + public static final String COL_FINAL_DEMAT_FOUND = "finalDematFound"; + public static final String COL_PAPER_DELIVERY_TIMESTAMP = "paperDeliveryTimestamp"; + public static final String COL_PREDICTED_REFINEMENT_TYPE = "predictedRefinementType"; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REGISTERED_LETTER_CODE)})) + private String registeredLetterCode; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_DELIVERY_FAILURE_CAUSE)})) + private String deliveryFailureCause; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_ANONYMIZED_DISCOVERED_ADDRESS)})) + private String anonymizedDiscoveredAddress; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_FINAL_STATUS_CODE)})) + private String finalStatusCode; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_VALIDATED_SEQUENCE_TIMESTAMP)})) + private Instant validatedSequenceTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_VALIDATED_EVENTS), @DynamoDbIgnoreNulls})) + private List validatedEvents; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_FINAL_DEMAT_FOUND)})) + private Boolean finalDematFound; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_PAPER_DELIVERY_TIMESTAMP)})) + private Instant paperDeliveryTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_PREDICTED_REFINEMENT_TYPE)})) + private String predictedRefinementType; + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackerDryRunOutputs.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackerDryRunOutputs.java new file mode 100644 index 000000000..2a0df0c62 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackerDryRunOutputs.java @@ -0,0 +1,61 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.Data; +import lombok.Getter; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbAttribute; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey; + +import java.time.Instant; +import java.util.List; + +@DynamoDbBean +@Data +public class PaperTrackerDryRunOutputs { + public static final String COL_TRACKING_ID = "trackingId"; + public static final String COL_CREATED = "created"; + public static final String COL_REGISTERED_LETTER_CODE = "registeredLetterCode"; + public static final String COL_STATUS_CODE = "statusCode"; + public static final String COL_STATUS_DETAIL = "statusDetail"; + public static final String COL_STATUS_DESCRIPTION = "statusDescription"; + public static final String COL_STATUS_DATE_TIME = "statusDateTime"; + public static final String COL_DELIVERY_FAILURE_CAUSE = "deliveryFailureCause"; + public static final String COL_ATTACHMENTS = "attachments"; + public static final String COL_DISCOVERED_ADDRESS = "discoveredAddress"; + public static final String COL_CLIENT_REQUEST_TIMESTAMP = "clientRequestTimestamp"; + + @Getter(onMethod = @__({@DynamoDbPartitionKey, @DynamoDbAttribute(COL_TRACKING_ID)})) + private String trackingId; + + @Getter(onMethod = @__({@DynamoDbSortKey, @DynamoDbAttribute(COL_CREATED)})) + private Instant created; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REGISTERED_LETTER_CODE)})) + private String registeredLetterCode; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_STATUS_CODE)})) + private String statusCode; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_STATUS_DETAIL)})) + private String statusDetail; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_STATUS_DESCRIPTION)})) + private String statusDescription; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_STATUS_DATE_TIME)})) + private String statusDateTime; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_DELIVERY_FAILURE_CAUSE)})) + private String deliveryFailureCause; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_ATTACHMENTS)})) + private List attachments; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_DISCOVERED_ADDRESS)})) + private String anonymizedDiscoveredAddressId; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_CLIENT_REQUEST_TIMESTAMP)})) + private String clientRequestTimestamp; + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackings.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackings.java new file mode 100644 index 000000000..0e564239f --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackings.java @@ -0,0 +1,119 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.Data; +import lombok.Getter; +import software.amazon.awssdk.enhanced.dynamodb.TableSchema; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.*; +import software.amazon.awssdk.services.dynamodb.model.AttributeValue; + +import java.time.Instant; +import java.util.List; +import java.util.Map; + +@DynamoDbBean +@Data +public class PaperTrackings { + + public static final String COL_TRACKING_ID = "trackingId"; + public static final String COL_ATTEMPT_ID = "attemptId"; + public static final String COL_PC_RETRY = "pcRetry"; + public static final String COL_EVENTS = "events"; + public static final String COL_PAPER_STATUS = "paperStatus"; + public static final String COL_VALIDATION_FLOW = "validationFlow"; + public static final String COL_VALIDATION_CONFIG = "validationConfig"; + public static final String COL_PRODUCT_TYPE = "productType"; + public static final String COL_NEXT_REQUEST_ID_PC_RETRY = "nextRequestIdPcretry"; + public static final String COL_UNIFIED_DELIVERY_DRIVER = "unifiedDeliveryDriver"; + public static final String COL_CREATED_AT = "createdAt"; + public static final String COL_UPDATED_AT = "updatedAt"; + public static final String COL_STATE = "state"; + public static final String COL_BUSINESS_STATE = "businessState"; + public static final String COL_TTL = "ttl"; + public static final String COL_RECAG012_STATUS_TIMESTAMP = "recag012StatusTimestamp"; + public static final String COL_PENDING_FINAL_EVENT_ID = "pendingFinalEventId"; + public static final String ATTEMPT_ID_PCRETRY_INDEX = "attemptId-pcRetry-index"; + public static final String COL_REWORK_ID = "reworkId"; + public static final String COL_REWORK_REQUEST_TIMESTAMP = "reworkRequestTimestamp"; + public static final String COL_PROCESSING_MODE = "processingMode"; + public static final String COL_ANALOG_REQUEST_CLIENT_ID = "analogRequestClientId"; + + @Getter(onMethod = @__({@DynamoDbPartitionKey, @DynamoDbAttribute(COL_TRACKING_ID)})) + private String trackingId; + + @Getter(onMethod = @__({@DynamoDbSecondaryPartitionKey(indexNames = ATTEMPT_ID_PCRETRY_INDEX), @DynamoDbAttribute(COL_ATTEMPT_ID)})) + private String attemptId; + + @Getter(onMethod = @__({@DynamoDbSecondarySortKey(indexNames = ATTEMPT_ID_PCRETRY_INDEX), @DynamoDbAttribute(COL_PC_RETRY)})) + private String pcRetry; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_PRODUCT_TYPE)})) + private String productType; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_UNIFIED_DELIVERY_DRIVER)})) + private String unifiedDeliveryDriver; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_EVENTS), @DynamoDbIgnoreNulls})) + private List events; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_PAPER_STATUS), @DynamoDbIgnoreNulls})) + private PaperStatus paperStatus; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_VALIDATION_FLOW), @DynamoDbIgnoreNulls})) + private ValidationFlow validationFlow; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_VALIDATION_CONFIG), @DynamoDbIgnoreNulls})) + private ValidationConfig validationConfig; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_NEXT_REQUEST_ID_PC_RETRY)})) + private String nextRequestIdPcretry; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_STATE)})) + private PaperTrackingsState state; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_BUSINESS_STATE)})) + private BusinessState businessState; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_PENDING_FINAL_EVENT_ID)})) + private String pendingFinalEventId; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_CREATED_AT)})) + private Instant createdAt; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_UPDATED_AT)})) + private Instant updatedAt; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_TTL)})) + private Long ttl; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REWORK_REQUEST_TIMESTAMP)})) + private Instant notificationReworkRequestTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REWORK_ID)})) + private String notificationReworkId; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_PROCESSING_MODE)})) + private ProcessingMode processingMode; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_ANALOG_REQUEST_CLIENT_ID)})) + private String analogRequestClientId; + + // Costruito UNA volta sola + private static final TableSchema SCHEMA = + TableSchema.fromBean(PaperTrackings.class); + + /** + * Converte l'entity PaperTrackings in una mappa {@code Map} utilizzata da DynamoDB. + */ + public static Map paperTrackingsToAttributeValueMap(PaperTrackings p) { + return SCHEMA.itemToMap(p, true); + } + + /** + * Converte una mappa {@code Map} utilizzata da DynamoDB in una entity PaperTrackings. + */ + public static PaperTrackings attributeValueMapToPaperTrackings(Map item) { + if (item == null || item.isEmpty()) return null; + return SCHEMA.mapToItem(item); + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackingsErrors.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackingsErrors.java new file mode 100644 index 000000000..5392a5cfb --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackingsErrors.java @@ -0,0 +1,70 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.*; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbAttribute; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbPartitionKey; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbSortKey; + +import java.time.Instant; + +@Setter +@Getter +@ToString +@DynamoDbBean +@EqualsAndHashCode +@NoArgsConstructor +@AllArgsConstructor +@Builder +public class PaperTrackingsErrors { + + public static final String COL_TRACKING_ID = "trackingId"; + public static final String COL_CREATED = "created"; + public static final String COL_CATEGORY = "category"; + public static final String COL_DETAILS = "details"; + public static final String COL_FLOW_THROW = "flowThrow"; + public static final String COL_EVENT_THROW = "eventThrow"; + public static final String COL_EVENT_ID_THROW = "eventIdThrow"; + public static final String COL_PRODUCT_TYPE = "productType"; + public static final String COL_TYPE = "type"; + public static final String COL_TTL = "ttl"; + public static final String COL_UNIFIED_DELIVERY_DRIVER = "unifiedDeliveryDriver"; + public static final String COL_REGISTERED_LETTER_CODE = "registeredLetterCode"; + + @Getter(onMethod = @__({@DynamoDbPartitionKey, @DynamoDbAttribute(COL_TRACKING_ID)})) + private String trackingId; + + @Getter(onMethod = @__({@DynamoDbSortKey, @DynamoDbAttribute(COL_CREATED)})) + private Instant created; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_CATEGORY)})) + private ErrorCategory errorCategory; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_DETAILS)})) + private ErrorDetails details; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_FLOW_THROW)})) + private FlowThrow flowThrow; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_EVENT_THROW)})) + private String eventThrow; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_EVENT_ID_THROW)})) + private String eventIdThrow; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_PRODUCT_TYPE)})) + private String productType; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_TYPE)})) + private ErrorType type; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_TTL)})) + private Long ttl; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_UNIFIED_DELIVERY_DRIVER)})) + private String unifiedDeliveryDriver; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REGISTERED_LETTER_CODE)})) + private String registeredLetterCode; + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackingsState.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackingsState.java new file mode 100644 index 000000000..091593be5 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/PaperTrackingsState.java @@ -0,0 +1,10 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +public enum PaperTrackingsState { + AWAITING_FINAL_STATUS_CODE, //mantenuto per retrocompatibilità + AWAITING_REFINEMENT, + AWAITING_REWORK_EVENTS, + AWAITING_OCR, + DONE, + KO +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ProcessingMode.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ProcessingMode.java new file mode 100644 index 000000000..c33f34cd7 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ProcessingMode.java @@ -0,0 +1,6 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +public enum ProcessingMode { + DRY, + RUN +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ProductType.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ProductType.java new file mode 100644 index 000000000..e887d065d --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ProductType.java @@ -0,0 +1,37 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.Getter; + +@Getter +public enum ProductType { + + RS("RS"), + + AR("AR"), + + _890("890"), + + RIR("RIR"), + + RIS("RIS"), + + ALL("ALL"), + + UNKNOWN("UNKNOWN"); + + private final String value; + + ProductType(String value) { + this.value = value; + } + + public static ProductType fromValue(String value) { + for (ProductType type : ProductType.values()) { + if (type.getValue().equals(value)) { + return type; + } + } + throw new IllegalArgumentException("Unknown ProductType: " + value); + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ValidationConfig.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ValidationConfig.java new file mode 100644 index 000000000..b9aaedd04 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ValidationConfig.java @@ -0,0 +1,56 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import it.pagopa.pn.papertracker.model.FileType; +import it.pagopa.pn.papertracker.model.OcrStatusEnum; +import lombok.Data; +import lombok.Getter; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbAttribute; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean; + +import java.util.List; + +@DynamoDbBean +@Data +public class ValidationConfig { + + public static final String COL_OCR_ENABLED = "ocrEnabled"; + public static final String COL_OCR_FILE_TYPES = "ocrFileTypes"; + public static final String COL_REQUIRED_ATTACHMENTS_REFINEMENT_STOCK_890 = "requiredAttachmentsRefinementStock890"; + public static final String COL_SEND_OCR_REFINEMENT_STOCK_890 = "sendOcrAttachmentsRefinementStock890"; + public static final String COL_SEND_OCR_FINAL_VALIDATION_STOCK_890 = "sendOcrAttachmentsFinalValidationStock890"; + public static final String COL_SEND_OCR_FINAL_VALIDATION = "sendOcrAttachmentsFinalValidation"; + public static final String COL_STRICT_FINAL_VALIDATION_STOCK_890 = "strictFinalValidationStock890"; + public static final String COL_STRICT_DELIVERY_FAILURE_CAUSE = "strictDeliveryFailureCause"; + public static final String COL_OCR_FILTER_TEMPORAL = "ocrFilterTemporal"; + public static final String COL_OCR_FILTER_UNIFIED_DELIVERY_DRIVER = "ocrFilterUnifiedDeliveryDriver"; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_OCR_ENABLED)})) + private OcrStatusEnum ocrEnabled; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_OCR_FILE_TYPES)})) + private List ocrFileTypes; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REQUIRED_ATTACHMENTS_REFINEMENT_STOCK_890)})) + private List requiredAttachmentsRefinementStock890; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_SEND_OCR_REFINEMENT_STOCK_890)})) + private List sendOcrAttachmentsRefinementStock890; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_SEND_OCR_FINAL_VALIDATION_STOCK_890)})) + private List sendOcrAttachmentsFinalValidationStock890; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_SEND_OCR_FINAL_VALIDATION)})) + private List sendOcrAttachmentsFinalValidation; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_STRICT_FINAL_VALIDATION_STOCK_890)})) + private Boolean strictFinalValidationStock890; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_OCR_FILTER_TEMPORAL)})) + private String ocrFilterTemporal; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_OCR_FILTER_UNIFIED_DELIVERY_DRIVER)})) + private List ocrFilterUnifiedDeliveryDriver; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_STRICT_DELIVERY_FAILURE_CAUSE)})) + private Boolean strictDeliveryFailureCause; +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ValidationFlow.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ValidationFlow.java new file mode 100644 index 000000000..53c04778e --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/dao/dynamo/entity/ValidationFlow.java @@ -0,0 +1,40 @@ +package it.pagopa.pn.papertracker.middleware.dao.dynamo.entity; + +import lombok.Data; +import lombok.Getter; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbAttribute; +import software.amazon.awssdk.enhanced.dynamodb.mapper.annotations.DynamoDbBean; + +import java.time.Instant; +import java.util.List; + +@DynamoDbBean +@Data +public class ValidationFlow { + + public static final String COL_SEQUENCES_VALIDATION_TIMESTAMP = "sequencesValidationTimestamp"; + public static final String COL_FINAL_EVENT_DEMAT_VALIDATION_TIMESTAMP = "finalEventDematValidationTimestamp"; + public static final String COL_REFINEMENT_DEMAT_VALIDATION_TIMESTAMP = "refinementDematValidationTimestamp"; + public static final String COL_FINAL_EVENT_BUILDER_TIMESTAMP = "finalEventBuilderTimestamp"; + public static final String COL_RECAG012_STATUS_TIMESTAMP = "recag012StatusTimestamp"; + public static final String COL_OCR_REQUESTS = "ocrRequests"; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_SEQUENCES_VALIDATION_TIMESTAMP)})) + private Instant sequencesValidationTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_FINAL_EVENT_DEMAT_VALIDATION_TIMESTAMP)})) + private Instant finalEventDematValidationTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_REFINEMENT_DEMAT_VALIDATION_TIMESTAMP)})) + private Instant refinementDematValidationTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_FINAL_EVENT_BUILDER_TIMESTAMP)})) + private Instant finalEventBuilderTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_RECAG012_STATUS_TIMESTAMP)})) + private Instant recag012StatusTimestamp; + + @Getter(onMethod = @__({@DynamoDbAttribute(COL_OCR_REQUESTS)})) + private List ocrRequests; + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/eventBridge/EventBridgePublisher.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/eventBridge/EventBridgePublisher.java new file mode 100644 index 000000000..882a20466 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/eventBridge/EventBridgePublisher.java @@ -0,0 +1,45 @@ +package it.pagopa.pn.papertracker.middleware.eventBridge; + +import com.fasterxml.jackson.databind.ObjectMapper; +import it.pagopa.pn.papertracker.config.PnPaperTrackerConfigs; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.stereotype.Service; +import reactor.core.publisher.Mono; +import software.amazon.awssdk.services.eventbridge.EventBridgeAsyncClient; +import software.amazon.awssdk.services.eventbridge.model.PutEventsRequest; +import software.amazon.awssdk.services.eventbridge.model.PutEventsRequestEntry; +import software.amazon.awssdk.services.eventbridge.model.PutEventsResponse; + +@Service +@RequiredArgsConstructor +@Slf4j +public class EventBridgePublisher { + + private final EventBridgeAsyncClient client; + private final ObjectMapper objectMapper; + private final PnPaperTrackerConfigs configs; + + public Mono publish(Object event) { + log.info("Sending event to EventBridge"); + return Mono.fromCallable(() -> + objectMapper.writeValueAsString(event)) + .flatMap(detail -> Mono.fromFuture(client.putEvents(createRequest(detail)))) + .doOnError(e -> log.error("EventBridge publish error: {}", e.getMessage())) + .doOnNext(response -> log.info("EventBridge publish response: {}", response.entries())); + } + + private PutEventsRequest createRequest(String detail) { + PutEventsRequestEntry entry = PutEventsRequestEntry.builder() + .eventBusName(configs.getEventBus().getName()) + .source(configs.getEventBus().getSource()) + .detailType(configs.getEventBus().getDetailType()) + .detail(detail) + .build(); + + return PutEventsRequest.builder() + .entries(entry) + .build(); + } + +} \ No newline at end of file diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/DataVaultClient.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/DataVaultClient.java new file mode 100644 index 000000000..0ead3f9cd --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/DataVaultClient.java @@ -0,0 +1,12 @@ +package it.pagopa.pn.papertracker.middleware.msclient; + +import it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.DiscoveredAddress; +import it.pagopa.pn.papertracker.generated.openapi.msclient.pndatavault.model.PaperAddress; +import reactor.core.publisher.Mono; + +public interface DataVaultClient { + + Mono anonymizeDiscoveredAddress(String trackingId, DiscoveredAddress discoveredAddress); + + Mono deAnonymizeDiscoveredAddress(String trackingId, String anonymizeDiscoveredAddress); +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/PaperChannelClient.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/PaperChannelClient.java new file mode 100644 index 000000000..27f0df380 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/PaperChannelClient.java @@ -0,0 +1,10 @@ +package it.pagopa.pn.papertracker.middleware.msclient; + +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.model.PcRetryResponse; +import it.pagopa.pn.papertracker.model.HandlerContext; +import reactor.core.publisher.Mono; + +public interface PaperChannelClient { + + Mono getPcRetry(HandlerContext context, Boolean checkApplyRasterization); +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/SafeStorageClient.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/SafeStorageClient.java new file mode 100644 index 000000000..8e0ddea29 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/SafeStorageClient.java @@ -0,0 +1,8 @@ +package it.pagopa.pn.papertracker.middleware.msclient; + +import reactor.core.publisher.Mono; + +public interface SafeStorageClient { + + Mono getSafeStoragePresignedUrl(String safeStorageUri); +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/impl/DataVaultClientImpl.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/impl/DataVaultClientImpl.java new file mode 100644 index 000000000..101229cbd --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/impl/DataVaultClientImpl.java @@ -0,0 +1,46 @@ +package it.pagopa.pn.papertracker.middleware.msclient.impl; + +import it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.DiscoveredAddress; +import it.pagopa.pn.papertracker.generated.openapi.msclient.pndatavault.api.PaperAddressesApi; +import it.pagopa.pn.papertracker.generated.openapi.msclient.pndatavault.model.PaperAddress; +import it.pagopa.pn.papertracker.middleware.msclient.DataVaultClient; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Component; +import reactor.core.publisher.Mono; + +import java.util.UUID; + +@Component +@RequiredArgsConstructor +public class DataVaultClientImpl implements DataVaultClient { + + private final PaperAddressesApi paperAddressesApi; + + @Override + public Mono anonymizeDiscoveredAddress(String trackingId, DiscoveredAddress discoveredAddress) { + String uuid = UUID.randomUUID().toString(); + String PREFIX_ANONYMIZED_ADDRESS_ID = "anonymized_addr_"; + String anonymizedDiscoveredAddressId = PREFIX_ANONYMIZED_ADDRESS_ID + uuid; + return paperAddressesApi.updatePaperAddress(trackingId, anonymizedDiscoveredAddressId, toPaperAddress(discoveredAddress)) + .thenReturn(anonymizedDiscoveredAddressId); + } + + @Override + public Mono deAnonymizeDiscoveredAddress(String trackingId, String anonymizeDiscoveredAddress) { + return paperAddressesApi.getPaperAddressByIds(trackingId, anonymizeDiscoveredAddress) + .switchIfEmpty(Mono.error(new IllegalArgumentException("No address found for the given anonymized ID: " + anonymizeDiscoveredAddress))); + } + + private PaperAddress toPaperAddress(DiscoveredAddress discoveredAddress) { + return new PaperAddress() + .name(discoveredAddress.getName()) + .nameRow2(discoveredAddress.getNameRow2()) + .address(discoveredAddress.getAddress()) + .addressRow2(discoveredAddress.getAddressRow2()) + .cap(discoveredAddress.getCap()) + .city(discoveredAddress.getCity()) + .city2(discoveredAddress.getCity2()) + .pr(discoveredAddress.getPr()) + .country(discoveredAddress.getCountry()); + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/impl/PaperChannelClientImpl.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/impl/PaperChannelClientImpl.java new file mode 100644 index 000000000..bc1026405 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/impl/PaperChannelClientImpl.java @@ -0,0 +1,44 @@ +package it.pagopa.pn.papertracker.middleware.msclient.impl; + +import it.pagopa.pn.papertracker.config.PnPaperTrackerConfigs; +import it.pagopa.pn.papertracker.exception.PnPaperTrackerNotFoundException; +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.api.PcRetryApi; +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.model.PcRetryResponse; +import it.pagopa.pn.papertracker.middleware.msclient.PaperChannelClient; +import it.pagopa.pn.papertracker.model.HandlerContext; +import it.pagopa.pn.papertracker.utils.PcRetryUtilsMock; +import lombok.RequiredArgsConstructor; +import lombok.extern.slf4j.Slf4j; +import org.springframework.http.HttpStatus; +import org.springframework.stereotype.Component; +import org.springframework.web.reactive.function.client.WebClientResponseException; +import reactor.core.publisher.Mono; + +@Component +@RequiredArgsConstructor +@Slf4j +public class PaperChannelClientImpl implements PaperChannelClient { + + private final PcRetryApi pcRetryApi; + private final PnPaperTrackerConfigs config; + + @Override + public Mono getPcRetry(HandlerContext context, Boolean checkApplyRasterization) { + if(!context.isDryRunEnabled()){ + return getPcRetryPaperChannel(context.getPaperTrackings().getTrackingId(), checkApplyRasterization); + } + log.debug("giving mock response..."); + return PcRetryUtilsMock.getPcRetryPaperMock(context.getPaperTrackings(), config.getMaxPcRetryMock(), context.getPaperProgressStatusEvent().getStatusCode()); + } + + private Mono getPcRetryPaperChannel(String trackingId, Boolean checkApplyRasterization) { + return pcRetryApi.getPcRetry(trackingId, checkApplyRasterization) + .onErrorResume(throwable -> { + if (throwable instanceof WebClientResponseException webEx && webEx.getStatusCode() == HttpStatus.NOT_FOUND) { + return Mono.error(new PnPaperTrackerNotFoundException("RequestId not found", webEx.getMessage())); + } + return Mono.error(throwable); + }); + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/impl/SafeStorageClientImpl.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/impl/SafeStorageClientImpl.java new file mode 100644 index 000000000..7764f6596 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/msclient/impl/SafeStorageClientImpl.java @@ -0,0 +1,59 @@ +package it.pagopa.pn.papertracker.middleware.msclient.impl; + +import it.pagopa.pn.commons.log.PnLogger; +import it.pagopa.pn.papertracker.config.PnPaperTrackerConfigs; +import it.pagopa.pn.papertracker.exception.PaperTrackerException; +import it.pagopa.pn.papertracker.generated.openapi.msclient.safestorage.api.FileDownloadApi; +import it.pagopa.pn.papertracker.middleware.msclient.SafeStorageClient; +import it.pagopa.pn.papertracker.utils.AttachmentsConfigUtils; +import lombok.CustomLog; +import lombok.RequiredArgsConstructor; +import org.springframework.stereotype.Component; +import org.springframework.web.reactive.function.client.WebClientResponseException; +import reactor.core.publisher.Mono; +import reactor.util.retry.Retry; + +import java.net.ConnectException; +import java.time.Duration; +import java.util.concurrent.TimeoutException; + +@Component +@RequiredArgsConstructor +@CustomLog +public class SafeStorageClientImpl implements SafeStorageClient { + + private final FileDownloadApi fileDownloadApi; + private final PnPaperTrackerConfigs pnPaperTrackerConfigs; + + /** + * Retrieves the presigned download URL from the SafeStorage. + * + * @param fileKey the object key + * @return Mono containing the presigned URL + */ + public Mono getSafeStoragePresignedUrl(String fileKey) { + final String PN_SAFE_STORAGE_DESCRIPTION = "Safe Storage getFile"; + log.logInvokingAsyncExternalService(PnLogger.EXTERNAL_SERVICES.PN_SAFE_STORAGE, PN_SAFE_STORAGE_DESCRIPTION, null); + String reqFileKey = fileKey; + log.info("Getting file with {} key", fileKey); + fileKey = AttachmentsConfigUtils.cleanFileKey(fileKey); + log.debug("Req params : {}", fileKey); + + return fileDownloadApi.getFile(fileKey, this.pnPaperTrackerConfigs.getSafeStorageCxId(), false) + .retryWhen(Retry.backoff(2, Duration.ofMillis(500)).filter(throwable -> throwable instanceof TimeoutException || throwable instanceof ConnectException)) + .flatMap(response -> { + if(response.getDownload() != null && response.getDownload().getRetryAfter() != null) { + return Mono.error(new PaperTrackerException(String.valueOf(response.getDownload().getRetryAfter()))); + } + if (response.getDownload() == null || response.getDownload().getUrl() == null) { + log.error("File not found in Safe Storage for key: {}", reqFileKey); + return Mono.error(new PaperTrackerException("File not found in Safe Storage")); + } + return Mono.just(response.getDownload().getUrl()); + }) + .onErrorResume(WebClientResponseException.class, ex -> { + log.error(ex.getResponseBodyAsString()); + return Mono.error(ex); + }); + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/PnPaperTrackerMiddlewareConfigs.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/PnPaperTrackerMiddlewareConfigs.java new file mode 100644 index 000000000..c2bab40e1 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/PnPaperTrackerMiddlewareConfigs.java @@ -0,0 +1,58 @@ +package it.pagopa.pn.papertracker.middleware.queue; + +import com.fasterxml.jackson.databind.ObjectMapper; +import it.pagopa.pn.papertracker.config.PnPaperTrackerConfigs; +import it.pagopa.pn.papertracker.middleware.queue.model.DeliveryPushEvent; +import it.pagopa.pn.papertracker.middleware.queue.model.ExternalChannelEvent; +import it.pagopa.pn.papertracker.middleware.queue.model.OcrEvent; +import it.pagopa.pn.papertracker.middleware.queue.producer.ExternalChannelOutputsMomProducer; +import it.pagopa.pn.papertracker.middleware.queue.producer.ExternalChannelToPaperChannelDryRunMomProducer; +import it.pagopa.pn.papertracker.middleware.queue.producer.ExternalChannelToPaperTrackerMomProducer; +import it.pagopa.pn.papertracker.middleware.queue.producer.OcrMomProducer; +import lombok.AllArgsConstructor; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import software.amazon.awssdk.regions.Region; +import software.amazon.awssdk.services.sqs.SqsClient; + +@Configuration +@AllArgsConstructor +public class PnPaperTrackerMiddlewareConfigs { + private PnPaperTrackerConfigs pnPaperChannelConfigs; + + @Bean + public OcrMomProducer ocrMomProducer(ObjectMapper objMapper) { + SqsClient sqsClient = SqsClient.builder() + .region(Region.of(this.pnPaperChannelConfigs.getTopics().getQueueOcrInputsRegion())) + .build(); + return new OcrMomProducer(sqsClient, + this.pnPaperChannelConfigs.getTopics().getQueueOcrInputsUrl(), + this.pnPaperChannelConfigs.getTopics().getQueueOcrInputsUrl(), + objMapper, + OcrEvent.class); + } + + @Bean + public ExternalChannelOutputsMomProducer externalChannelOutputsMomProducer(SqsClient sqsClient, ObjectMapper objMapper) { + return new ExternalChannelOutputsMomProducer(sqsClient, + this.pnPaperChannelConfigs.getTopics().getExternalChannelOutputsQueue(), + objMapper, + DeliveryPushEvent.class); + } + + @Bean + public ExternalChannelToPaperTrackerMomProducer externalChannelToPaperTrackerMomProducer(SqsClient sqsClient, ObjectMapper objMapper) { + return new ExternalChannelToPaperTrackerMomProducer(sqsClient, + this.pnPaperChannelConfigs.getTopics().getExternalChannelToPaperTrackerQueue(), + objMapper, + ExternalChannelEvent.class); + } + + @Bean + public ExternalChannelToPaperChannelDryRunMomProducer externalChannelToPaperChannelDryRunMomProducer(SqsClient sqsClient, ObjectMapper objMapper) { + return new ExternalChannelToPaperChannelDryRunMomProducer(sqsClient, + this.pnPaperChannelConfigs.getTopics().getExternalChannelToPaperChannelDryRunQueue(), + objMapper, + ExternalChannelEvent.class); + } +} \ No newline at end of file diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/PnEventInboundService.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/PnEventInboundService.java new file mode 100644 index 000000000..8b405059a --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/PnEventInboundService.java @@ -0,0 +1,93 @@ +package it.pagopa.pn.papertracker.middleware.queue.consumer; + +import com.sngular.apigenerator.asyncapi.business_model.model.event.OcrDataResultPayload; +import io.awspring.cloud.sqs.annotation.SqsListener; +import io.awspring.cloud.sqs.listener.SqsHeaders; +import it.pagopa.pn.commons.utils.MDCUtils; +import it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.SingleStatusUpdate; +import it.pagopa.pn.papertracker.middleware.queue.consumer.internal.ExternalChannelHandler; +import it.pagopa.pn.papertracker.middleware.queue.consumer.internal.ExternalChannelSourceEventsHandler; +import it.pagopa.pn.papertracker.middleware.queue.consumer.internal.OcrEventHandler; +import it.pagopa.pn.papertracker.utils.LogUtility; +import lombok.CustomLog; +import lombok.RequiredArgsConstructor; +import org.slf4j.MDC; +import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty; +import org.springframework.messaging.Message; +import org.springframework.messaging.handler.annotation.Header; +import org.springframework.messaging.handler.annotation.Headers; +import org.springframework.messaging.handler.annotation.Payload; +import org.springframework.stereotype.Component; + +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +@CustomLog +@Component +@RequiredArgsConstructor +@ConditionalOnProperty( + prefix = "pn.paper-tracker.", + name = "disable-all-consumers", + havingValue = "false" +) +public class PnEventInboundService { + + private final ExternalChannelSourceEventsHandler externalChannelSourceEventsHandler; + private final ExternalChannelHandler externalChannelHandler; + private final OcrEventHandler ocrEventHandler; + private final LogUtility logUtility; + + @SqsListener("${pn.paper-tracker.topics.external-channel-to-paper-channel-queue}") + public void externalChannelSourceConsumer( + @Payload Message message, + @Headers Map headers, + @Header(name = SqsHeaders.SQS_SOURCE_DATA_HEADER) software.amazon.awssdk.services.sqs.model.Message sourceMessage + ) { + processMessage(() -> { + var messageAttributes = sourceMessage.messageAttributes(); + externalChannelSourceEventsHandler.handleExternalChannelMessage(message.getPayload(), messageAttributes); + }, "pn-external_channel_to_paper_channel", message, headers); + } + + @SqsListener("${pn.paper-tracker.topics.external-channel-to-paper-tracker-queue}") + public void externalChannelConsumer( + @Payload Message message, + @Header(name = "dryRun", required = false) Boolean dryRun, + @Header(name = "reworkId", required = false) String reworkId, + @Header(name = "id") String messageId, + @Header(name = SqsHeaders.MessageSystemAttributes.SQS_SENDER_ID, required = false) String senderId, + @Headers Map headers + ) { + processMessage(() -> externalChannelHandler.handleExternalChannelMessage( + message.getPayload(), Boolean.TRUE.equals(dryRun), reworkId, messageId, senderId), + "pn-external_channel_to_paper_tracker", message, headers); + } + + @SqsListener("${pn.paper-tracker.topics.pn-ocr-outputs-queue}") + public void ocrOutputsConsumer( + @Payload Message message, + @Headers Map headers + ) { + processMessage(() -> ocrEventHandler.handleOcrMessage(message.getPayload()), + "pn-ocr_outputs", message, headers); + } + + private void processMessage(Runnable handler, String source, Message message, Map headers) { + String anonymizedMessage = logUtility.messageToString(message, Set.of("discoveredAddress")); + try { + log.info("Handle message from {} with content {}", source, anonymizedMessage); + setMDCContext(headers); + handler.run(); + } catch (Exception ex) { + log.error("Error processing message from {}: {}", source, ex.getMessage(), ex); + throw ex; + } + } + + private void setMDCContext(Map headers) { + MDCUtils.clearMDCKeys(); + MDC.put(MDCUtils.MDC_PN_CTX_MESSAGE_ID, headers.getOrDefault("id", "").toString()); + MDC.put(MDCUtils.MDC_TRACE_ID_KEY, headers.getOrDefault("AWSTraceHeader", UUID.randomUUID().toString()).toString()); + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/internal/ExternalChannelHandler.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/internal/ExternalChannelHandler.java new file mode 100644 index 000000000..dbff4ee52 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/internal/ExternalChannelHandler.java @@ -0,0 +1,92 @@ +package it.pagopa.pn.papertracker.middleware.queue.consumer.internal; + +import it.pagopa.pn.commons.utils.MDCUtils; +import it.pagopa.pn.papertracker.config.PnPaperTrackerConfigs; +import it.pagopa.pn.papertracker.exception.PaperTrackerExceptionHandler; +import it.pagopa.pn.papertracker.exception.PnPaperTrackerValidationException; +import it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.SingleStatusUpdate; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.ProductType; +import it.pagopa.pn.papertracker.model.EventStatusCodeEnum; +import it.pagopa.pn.papertracker.model.EventTypeEnum; +import it.pagopa.pn.papertracker.model.HandlerContext; +import it.pagopa.pn.papertracker.service.handler_step.generic.HandlersRegistry; +import it.pagopa.pn.papertracker.utils.TrackerUtility; +import lombok.CustomLog; +import lombok.RequiredArgsConstructor; +import org.slf4j.MDC; +import org.springframework.stereotype.Component; +import org.springframework.util.StringUtils; + +import java.util.Objects; +import java.util.Optional; + +import static it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.ProductType.ALL; +import static it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.ProductType.UNKNOWN; + +@Component +@RequiredArgsConstructor +@CustomLog +public class ExternalChannelHandler { + + private final PaperTrackerExceptionHandler paperTrackerExceptionHandler; + private final HandlersRegistry handlersRegistry; // contiene HandlersFactoryAr, HandlersFactoryRir, ecc. + private final PnPaperTrackerConfigs pnPaperTrackerConfigs; + + private static final String HANDLING_EVENT_LOG = "Handling {} event for productType: [{}] and event: [{}]"; + + /** + * Riceve i messaggi provenienti dalla coda pn-external_channel_to_paper_tracker e gestisce, invia l'evento all'handlersRegistry per lo + * smistamento allo specifico handler in base a productType ed eventType + * + * @param payload il SingleStatusUpdate contenente le informazioni da processare + */ + public void handleExternalChannelMessage(SingleStatusUpdate payload, boolean dryRunEnabled, String reworkId, String messageId, String senderId) { + if (Objects.isNull(payload) || Objects.isNull(payload.getAnalogMail())) { + log.error("Received null payload or analogMail in ExternalChannelHandler"); + throw new IllegalArgumentException("Payload or analogMail cannot be null"); + } + + String processName = "processExternalChannelMessage"; + MDC.put(MDCUtils.MDC_PN_CTX_REQUEST_ID, payload.getAnalogMail().getRequestId()); + log.logStartingProcess(processName); + HandlerContext context = initializeContext(payload, dryRunEnabled, reworkId, messageId, senderId); + + var statusCode = payload.getAnalogMail().getStatusCode(); + var productType = resolveProductType(statusCode, payload.getAnalogMail().getProductType()); + var eventType = Optional.ofNullable(EventStatusCodeEnum.fromKey(statusCode)).map(EventStatusCodeEnum::getCodeType).orElse(null); + + logStatusEvent(eventType, productType, statusCode); + + MDCUtils.addMDCToContextAndExecute(handlersRegistry.handleEvent(productType, eventType, context) + .doOnSuccess(unused -> log.logEndingProcess(processName)) + .onErrorResume(PnPaperTrackerValidationException.class, ex -> paperTrackerExceptionHandler.handleInternalException(ex, context.getMessageReceiveCount()))) + .block(); + } + + private HandlerContext initializeContext(SingleStatusUpdate payload, boolean dryRunEnabled, String reworkId, String messageId, String senderId) { + HandlerContext context = new HandlerContext(); + context.setTrackingId(payload.getAnalogMail().getRequestId()); + context.setPaperProgressStatusEvent(payload.getAnalogMail()); + context.setEventId(messageId); + context.setDryRunEnabled(dryRunEnabled); + context.setReworkId(reworkId); + context.setRedrive(TrackerUtility.checkIfIsRedrive(senderId, pnPaperTrackerConfigs.getRedriveEnabledDomains())); + return context; + } + + private ProductType resolveProductType(String statusCode, String payloadProductType) { + ProductType eventProductType = Optional.ofNullable(EventStatusCodeEnum.fromKey(statusCode)) + .map(EventStatusCodeEnum::getProductType) + .orElse(UNKNOWN); + + if (ALL.equals(eventProductType) && StringUtils.hasText(payloadProductType)) { + return ProductType.fromValue(payloadProductType); + } + return eventProductType; + } + + private void logStatusEvent(EventTypeEnum statusEvent, ProductType productType, String statusCode) { + log.info(HANDLING_EVENT_LOG, statusEvent, productType, statusCode); + } + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/internal/ExternalChannelSourceEventsHandler.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/internal/ExternalChannelSourceEventsHandler.java new file mode 100644 index 000000000..bb48d77d7 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/internal/ExternalChannelSourceEventsHandler.java @@ -0,0 +1,70 @@ +package it.pagopa.pn.papertracker.middleware.queue.consumer.internal; + +import it.pagopa.pn.commons.utils.MDCUtils; +import it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.SingleStatusUpdate; +import it.pagopa.pn.papertracker.service.SourceQueueProxyService; +import lombok.CustomLog; +import lombok.RequiredArgsConstructor; +import org.slf4j.MDC; +import org.springframework.messaging.Message; +import org.springframework.stereotype.Component; +import software.amazon.awssdk.services.sqs.model.MessageAttributeValue; + +import java.util.Map; +import java.util.Objects; + +/** + * Handler responsabile della gestione degli eventi provenienti da pn-external-channel (pn-ec). + * + * In fase di inizializzazione di una spedizione su pn-paper-tracker, viene determinata e persistita + * la modalità operativa (DRY o RUN) sull'entità della tabella {pn-PaperTrackings. + * + * + * + * Conseguentemente, alla ricezione di un evento da pn-ec, pn-paper-tracker determina la modalità + * operativa recuperando le informazioni di tracking dalla tabella pn-PaperTrackings + * e gestisce ciascun evento in base alla logica definita. + * + * + * + * + * Spedizione non presente su pn-PaperTrackings + * L'evento viene inoltrato direttamente a pn-paper-channel. + * + * + * Spedizione presente su pn-PaperTrackings e modalità DRY + * L'evento viene inoltrato a pn-paper-channel (se non duplicato) e, in parallelo, processato internamente + * da pn-paper-tracker, con persistenza dell'output su tabella a fini di verifica. + * + * + * Spedizione presente su pn-PaperTrackings e modalità RUN + * L'evento viene processato internamente da pn-paper-tracker e l'output + * viene inviato a pn-delivery-push. + * + * + * + * La gestione del flusso operativo effettivo è demandata al {@link SourceQueueProxyService}. + */ +@Component +@RequiredArgsConstructor +@CustomLog +public class ExternalChannelSourceEventsHandler { + private final SourceQueueProxyService sourceQueueProxyService; + + public void handleExternalChannelMessage( + SingleStatusUpdate message, + Map messageAttributes) { + if (Objects.isNull(message) || Objects.isNull(message.getAnalogMail())) { + log.error("Received null payload or analogMail in ExternalChannelHandler"); + throw new IllegalArgumentException("Payload or analogMail cannot be null"); + } + + String processName = "processExternalChannelSourceMessage"; + MDC.put(MDCUtils.MDC_PN_CTX_REQUEST_ID, message.getAnalogMail().getRequestId()); + log.logStartingProcess(processName); + + MDCUtils.addMDCToContextAndExecute(sourceQueueProxyService.handleExternalChannelMessage(message, messageAttributes) + .doOnSuccess(unused -> log.logEndingProcess(processName))) + .block(); + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/internal/OcrEventHandler.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/internal/OcrEventHandler.java new file mode 100644 index 000000000..687361643 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/consumer/internal/OcrEventHandler.java @@ -0,0 +1,60 @@ +package it.pagopa.pn.papertracker.middleware.queue.consumer.internal; + +import com.sngular.apigenerator.asyncapi.business_model.model.event.OcrDataResultPayload; +import it.pagopa.pn.commons.utils.MDCUtils; +import it.pagopa.pn.papertracker.exception.PaperTrackerExceptionHandler; +import it.pagopa.pn.papertracker.exception.PnPaperTrackerValidationException; +import it.pagopa.pn.papertracker.middleware.dao.PaperTrackingsDAO; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.PaperTrackings; +import it.pagopa.pn.papertracker.middleware.dao.dynamo.entity.ProductType; +import it.pagopa.pn.papertracker.model.EventTypeEnum; +import it.pagopa.pn.papertracker.model.HandlerContext; +import it.pagopa.pn.papertracker.service.handler_step.generic.HandlersRegistry; +import it.pagopa.pn.papertracker.utils.TrackerUtility; +import lombok.CustomLog; +import lombok.RequiredArgsConstructor; +import org.slf4j.MDC; +import org.springframework.stereotype.Component; +import reactor.core.publisher.Mono; + +import java.util.Objects; + +@Component +@RequiredArgsConstructor +@CustomLog +public class OcrEventHandler { + + private final PaperTrackingsDAO paperTrackingsDAO; + private final PaperTrackerExceptionHandler paperTrackerExceptionHandler; + private final HandlersRegistry handlersRegistry; + + public void handleOcrMessage(OcrDataResultPayload ocrResultMessage) { + if (Objects.isNull(ocrResultMessage) || Objects.isNull(ocrResultMessage.getCommandId())) { + log.error("Received null payload or commandId in OcrResponse handler"); + throw new IllegalArgumentException("Payload or commandId cannot be null"); + } + + String processName = "processOcrResponseMessage"; + MDC.put(MDCUtils.MDC_PN_CTX_REQUEST_ID, ocrResultMessage.getCommandId()); + log.logStartingProcess(processName); + MDCUtils.addMDCToContextAndExecute(paperTrackingsDAO.retrieveEntityByTrackingId(TrackerUtility.getParsedOcrCommandId(ocrResultMessage.getCommandId())[0]) + .flatMap(paperTrackings -> callOcrResponseHandler(paperTrackings, ocrResultMessage)) + .onErrorResume(PnPaperTrackerValidationException.class, e -> paperTrackerExceptionHandler.handleInternalException(e, null)) + .then()) + .block(); + } + + private Mono callOcrResponseHandler(PaperTrackings paperTrackings, OcrDataResultPayload ocrResultMessage) { + HandlerContext context = buildContext(paperTrackings, ocrResultMessage); + return handlersRegistry.handleEvent(ProductType.fromValue(paperTrackings.getProductType()), EventTypeEnum.OCR_RESPONSE_EVENT, context); + } + + private HandlerContext buildContext(PaperTrackings paperTrackings, + OcrDataResultPayload ocrResultMessage) { + HandlerContext handlerContext = new HandlerContext(); + handlerContext.setTrackingId(paperTrackings.getTrackingId()); + handlerContext.setPaperTrackings(paperTrackings); + handlerContext.setOcrDataResultPayload(ocrResultMessage); + return handlerContext; + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/CustomEventHeader.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/CustomEventHeader.java new file mode 100644 index 000000000..7f0436d40 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/CustomEventHeader.java @@ -0,0 +1,22 @@ +package it.pagopa.pn.papertracker.middleware.queue.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import it.pagopa.pn.api.dto.events.GenericEventHeader; +import lombok.*; +import lombok.experimental.SuperBuilder; +import software.amazon.awssdk.services.sqs.model.MessageAttributeValue; + +import java.util.Map; + +@NoArgsConstructor +@AllArgsConstructor +@Getter +@EqualsAndHashCode(callSuper = true) +@ToString +@SuperBuilder +public class CustomEventHeader extends GenericEventHeader { + + @JsonProperty("messageAttributes") + private Map messageAttributes; + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/DeliveryPushEvent.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/DeliveryPushEvent.java new file mode 100644 index 000000000..3461506d4 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/DeliveryPushEvent.java @@ -0,0 +1,20 @@ +package it.pagopa.pn.papertracker.middleware.queue.model; + +import it.pagopa.pn.api.dto.events.GenericEvent; +import it.pagopa.pn.api.dto.events.GenericEventHeader; +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.model.PaperChannelUpdate; +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Getter; +import lombok.NoArgsConstructor; + +@NoArgsConstructor +@AllArgsConstructor +@Getter +@Builder(toBuilder = true) +public class DeliveryPushEvent implements GenericEvent { + + private GenericEventHeader header; + private PaperChannelUpdate payload; + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/ExternalChannelEvent.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/ExternalChannelEvent.java new file mode 100644 index 000000000..49d5fe473 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/ExternalChannelEvent.java @@ -0,0 +1,18 @@ +package it.pagopa.pn.papertracker.middleware.queue.model; + +import it.pagopa.pn.api.dto.events.GenericEvent; +import it.pagopa.pn.api.dto.events.GenericEventHeader; +import it.pagopa.pn.papertracker.generated.openapi.msclient.externalchannel.model.SingleStatusUpdate; +import it.pagopa.pn.papertracker.generated.openapi.msclient.paperchannel.model.PaperChannelUpdate; +import lombok.*; + +@NoArgsConstructor +@AllArgsConstructor +@Getter +@Builder(toBuilder = true) +public class ExternalChannelEvent implements GenericEvent { + + private CustomEventHeader header; + private SingleStatusUpdate payload; + +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/ExternalChannelEventHeader.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/ExternalChannelEventHeader.java new file mode 100644 index 000000000..ed02d376a --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/ExternalChannelEventHeader.java @@ -0,0 +1,20 @@ +package it.pagopa.pn.papertracker.middleware.queue.model; + +import com.fasterxml.jackson.annotation.JsonProperty; +import it.pagopa.pn.api.dto.events.GenericEventHeader; +import lombok.*; +import lombok.experimental.SuperBuilder; + +@NoArgsConstructor +@AllArgsConstructor +@Getter +@EqualsAndHashCode(callSuper = true) +@ToString +@SuperBuilder +public class ExternalChannelEventHeader extends GenericEventHeader { + + public static final String PN_EVENT_HEADER_DRYRUN = "dryRun"; + @JsonProperty("dryRun") + private Boolean dryRun; + +} \ No newline at end of file diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/OcrEvent.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/OcrEvent.java new file mode 100644 index 000000000..3de4fbaaf --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/model/OcrEvent.java @@ -0,0 +1,23 @@ +package it.pagopa.pn.papertracker.middleware.queue.model; + +import com.sngular.apigenerator.asyncapi.business_model.model.event.OcrDataPayloadDTO; +import it.pagopa.pn.api.dto.events.GenericEvent; +import it.pagopa.pn.api.dto.events.GenericEventHeader; +import lombok.AllArgsConstructor; + +@AllArgsConstructor +public class OcrEvent implements GenericEvent { + + private GenericEventHeader header; + private OcrDataPayloadDTO payload; + + @Override + public GenericEventHeader getHeader() { + return header; + } + + @Override + public OcrDataPayloadDTO getPayload() { + return payload; + } +} diff --git a/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/producer/ExternalChannelOutputsMomProducer.java b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/producer/ExternalChannelOutputsMomProducer.java new file mode 100644 index 000000000..cd2118744 --- /dev/null +++ b/jdk_21_maven/cs/rest/pn-paper-tracker/src/main/java/it/pagopa/pn/papertracker/middleware/queue/producer/ExternalChannelOutputsMomProducer.java @@ -0,0 +1,16 @@ +package it.pagopa.pn.papertracker.middleware.queue.producer; + +import com.fasterxml.jackson.databind.ObjectMapper; +import it.pagopa.pn.api.dto.events.AbstractSqsMomProducer; +import it.pagopa.pn.papertracker.middleware.queue.model.DeliveryPushEvent; +import lombok.extern.slf4j.Slf4j; +import software.amazon.awssdk.services.sqs.SqsClient; + +@Slf4j +public class ExternalChannelOutputsMomProducer extends AbstractSqsMomProducer
+ * In fase di inizializzazione di una spedizione su pn-paper-tracker, viene determinata e persistita + * la modalità operativa (DRY o RUN) sull'entità della tabella {pn-PaperTrackings. + *
+ * Conseguentemente, alla ricezione di un evento da pn-ec, pn-paper-tracker determina la modalità + * operativa recuperando le informazioni di tracking dalla tabella pn-PaperTrackings + * e gestisce ciascun evento in base alla logica definita. + *