index int64 0 0 | repo_id stringlengths 9 205 | file_path stringlengths 31 246 | content stringlengths 1 12.2M | __index_level_0__ int64 0 10k |
|---|---|---|---|---|
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/evaluators | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/evaluators/predicates/IsDuplicated.java | package com.paypal.notifications.incoming.services.evaluators.predicates;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import com.paypal.notifications.storage.services.NotificationStorageService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.function.Predicate;
/**
* Predicate for checking if a {@link NotificationEntity} is duplicated.
*/
@Slf4j
@Service
public class IsDuplicated extends AbstractNotificationPredicate implements Predicate<NotificationEntity> {
public IsDuplicated(final NotificationStorageService notificationStorageService) {
super(notificationStorageService);
}
/**
* Checks if there are more than one {@link NotificationEntity} in the database with
* the same token.
* @param notificationEntity {@link NotificationEntity} to be checked.
* @return true if there are more than one notification in the database with the same
* token, false otherwise.
*/
@Override
public boolean test(final NotificationEntity notificationEntity) {
final boolean isDuplicated = super.notificationStorageService
.getNotificationsByWebHookToken(notificationEntity.getWebHookToken()).size() > 1;
if (isDuplicated) {
log.warn("Duplicated notification: [{}]", notificationEntity.getWebHookToken());
}
return isDuplicated;
}
}
| 5,100 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/evaluators | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/evaluators/predicates/IsOutdated.java | package com.paypal.notifications.incoming.services.evaluators.predicates;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import com.paypal.notifications.storage.services.NotificationStorageService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.function.Predicate;
/**
* Predicate for checking if a {@link NotificationEntity} is outdated.
*/
@Slf4j
@Service
public class IsOutdated extends AbstractNotificationPredicate implements Predicate<NotificationEntity> {
public IsOutdated(final NotificationStorageService notificationStorageService) {
super(notificationStorageService);
}
/**
* Checks if there is any {@link NotificationEntity} in the database with the same
* object token and a later creation date.
* @param notificationEntity {@link NotificationEntity} to be checked.
* @return true if there are notifications in the database with the same object token
* and a later creation date, false otherwise.
*/
@Override
public boolean test(final NotificationEntity notificationEntity) {
final boolean isOutdated = !CollectionUtils
.isEmpty(super.notificationStorageService.getNotificationsByObjectTokenAndAndCreationDateAfter(
notificationEntity.getObjectToken(), notificationEntity.getCreationDate()));
if (isOutdated) {
log.warn("Outdated notification: [{}]", notificationEntity.getWebHookToken());
}
return isOutdated;
}
}
| 5,101 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/evaluators | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/evaluators/predicates/AbstractNotificationPredicate.java | package com.paypal.notifications.incoming.services.evaluators.predicates;
import com.paypal.notifications.storage.services.NotificationStorageService;
/**
* Abstract notification predicate for handling common functionality.
*/
public abstract class AbstractNotificationPredicate {
protected final NotificationStorageService notificationStorageService;
protected AbstractNotificationPredicate(final NotificationStorageService notificationStorageService) {
this.notificationStorageService = notificationStorageService;
}
}
| 5,102 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/support/AbstractNotificationListener.java | package com.paypal.notifications.events.support;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.notifications.events.model.HMCEvent;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.notifications.storage.repositories.entities.NotificationInfoEntity;
import com.paypal.notifications.failures.repositories.FailedNotificationInformationRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.ApplicationListener;
/**
* Abstract notification listener that encapsulates the logic to store failed
* notifications and reprocess them if need be
*
* @param <T> Type of the event to be processed
*/
@Slf4j
public abstract class AbstractNotificationListener<T extends HMCEvent> implements ApplicationListener<T> {
private static final String MSG_NOTIFICATION_RESTARTED = "Notification [{}] failed previously and will be restarted";
private static final String MSG_FAILED_NOTIFICATION_STORED_FOR_RETRY = "Failed notification with token [{}] will be stored to be restarted in the future.";
private static final String MSG_OUTDATED_NOTIFICATION = "Received outdated notification [{}] targeting the same type and token target as a more up-to-date, stored notification [{}]. The outdated notification will be skipped";
private static final String MSG_MORE_RECENT_NOTIFICATION = "Received notification [{}] targets the same type and token target as an outdated stored notification [{}]. Since it is more recent, the latter will be removed from the database";
private static final String MSG_EXCEEDED_NUM_OF_RETRIES = "Failed notification with token [{}] exceeded its max amount of retries and could not be processed by the HMC - It will be removed from the database. This incident will be notified via email";
private static final String EMAIL_SUBJECT = "[HMC] Technical error occurred when processing the notification %s";
private static final String EMAIL_BODY = "There was an error processing the notification %s and the operation could not be completed. The maximum number of attempts (%d) has been reached, therefore it will not try to re-process the notification anymore."
+ "\nPlease check the logs for further information.";
@Value("#{'${hmc.webhooks.retries.enabled}'}")
private boolean retryNotifications;
@Value("${hmc.webhooks.retries.max-retries}")
private int maxRetries;
private final MailNotificationUtil mailNotificationUtil;
private final FailedNotificationInformationRepository failedNotificationInformationRepository;
private final Converter<HyperwalletWebhookNotification, NotificationInfoEntity> notificationInfoEntityToNotificationConverter;
protected AbstractNotificationListener(final MailNotificationUtil mailNotificationUtil,
final FailedNotificationInformationRepository failedNotificationInformationRepository,
final Converter<HyperwalletWebhookNotification, NotificationInfoEntity> notificationInfoEntityToNotificationConverter) {
this.mailNotificationUtil = mailNotificationUtil;
this.failedNotificationInformationRepository = failedNotificationInformationRepository;
this.notificationInfoEntityToNotificationConverter = notificationInfoEntityToNotificationConverter;
}
/**
* Processes recently received notifications from Hyperwallet or the HMC notification
* retry job. It attempts to find any notification that failed in the past by checking
* in the database in case there's any notification with...
* <ul>
* <li>The same token - In which case it retries a failed notification Failed
* notifications can be retried up to X amount of times (can be configured for each
* listener) before they are discarded and a mail is sent to notify any integrator of
* the issue that has happened.</li>
* <li>The same type and target token, but a different notification token - In which
* case it treats the recently received notification as an update of the one that was
* stored</li>
* </ul>
* If such a notification is found, the HMC will remove it from the database. If none
* is found, the HMC will process any newly received notification as usual.
* <p>
* If a notification fails during its process, it will be stored in the database to be
* retried in the future, such as by running the notification retry job.
* @param event Event that is being processed
*/
@Override
public final void onApplicationEvent(final T event) {
final HyperwalletWebhookNotification notification = event.getNotification();
log.info("Processing incoming {} notification [{}] ", getNotificationType(), notification.getToken());
final NotificationInfoEntity notificationInfoEntity = notificationInfoEntityToNotificationConverter
.convert(notification);
final Integer retryCount = getRetryCountForNotification(notificationInfoEntity);
if (retryCount != null) {
try {
processNotification(notification);
}
catch (final RuntimeException ex) {
handleNotificationFailure(notificationInfoEntity, retryCount, ex);
}
}
}
/**
* Gets the retry counter of the notification that is being processed To do so, it
* checks for any notifications that are stored it the database like so:
* <ul>
* <li>The received notification has the same token as a failed notification If one is
* found, it implies that the received notification and the stored one are the same.
* The system will retry that notification in hopes that it can be processed correctly
* this time around.
* <p>
* (Returns the number of retries left in the stored notification)</li>
* <li>The received notification has the same type and target token as a failed
* notification If one is found, it implies that the notification that is received
* serves the same purpose as the one that was stored, but has different data. We can
* tell if it's an <b>update</b> or is <b>outdated</b> based on its creation date.
* <ul>
* <li>The received notification is an update if was created after the one that was
* stored in the HMC. In that case, the stored notification is removed and the update
* is processed
* <p>
* (Returns 0, stating that the notification is being processed for the first
* time)</li>
* <li>The received notification is outdated if was created before the one that was
* stored in the HMC. In that case, the stored notification is kept in the system for
* retry. Since the one that was received is outdated, it can be skipped
* <p>
* (Returns null, stating that it'll be skipped)</li>
* </ul>
*
* </li>
* </ul>
* If no notifications are found, it returns a zero by default.
* <p>
* @param notification The notification used to check if there are any coincidences in
* the DB
*/
private Integer getRetryCountForNotification(final NotificationInfoEntity notification) {
final String notificationToken = notification.getNotificationToken();
final NotificationInfoEntity notificationWithSameToken = failedNotificationInformationRepository
.findByNotificationToken(notificationToken);
if (notificationWithSameToken != null) {
log.info(MSG_NOTIFICATION_RESTARTED, notificationToken);
failedNotificationInformationRepository.delete(notificationWithSameToken);
return notificationWithSameToken.getRetryCounter();
}
final NotificationInfoEntity notificationWithSamePurpose = failedNotificationInformationRepository
.findByTypeAndTarget(notification.getType(), notification.getTarget());
if (notificationWithSamePurpose != null) {
final String storedNotificationToken = notificationWithSamePurpose.getNotificationToken();
if (notificationWithSamePurpose.getCreationDate().after(notification.getCreationDate())) {
log.info(MSG_OUTDATED_NOTIFICATION, notification.getNotificationToken(), storedNotificationToken);
return null;
}
else {
log.info(MSG_MORE_RECENT_NOTIFICATION, notification.getNotificationToken(), storedNotificationToken);
failedNotificationInformationRepository.delete(notificationWithSamePurpose);
}
}
return 0;
}
private void handleNotificationFailure(final NotificationInfoEntity notificationInfoEntity, final int retries,
final RuntimeException ex) {
final String token = notificationInfoEntity.getNotificationToken();
log.error("Notification [{}] could not be processed. Reason: [{}]", token, ex.getMessage());
if (hasEnabledNotificationRetries()) {
if (retries + 1 < getMaxRetries()) {
log.error(MSG_FAILED_NOTIFICATION_STORED_FOR_RETRY, token);
notificationInfoEntity.setRetryCounter(retries + 1);
failedNotificationInformationRepository.save(notificationInfoEntity);
}
else {
log.error(MSG_EXCEEDED_NUM_OF_RETRIES, token);
mailNotificationUtil.sendPlainTextEmail(EMAIL_SUBJECT.formatted(token),
EMAIL_BODY.formatted(token, getMaxRetries()));
}
}
}
protected boolean hasEnabledNotificationRetries() {
return retryNotifications;
}
protected int getMaxRetries() {
return maxRetries;
}
protected abstract void processNotification(final HyperwalletWebhookNotification notification);
protected abstract String getNotificationType();
}
| 5,103 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/support | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/support/converters/NotificationToNotificationInfoConverter.java | package com.paypal.notifications.events.support.converters;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.notifications.storage.repositories.entities.NotificationInfoEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import java.util.Map;
import java.util.Optional;
@Slf4j
@Component
public class NotificationToNotificationInfoConverter
implements Converter<HyperwalletWebhookNotification, NotificationInfoEntity> {
/**
* Method that retrieves a {@link HyperwalletWebhookNotification} and returns a
* {@link NotificationInfoEntity}
* @param source the source object {@link HyperwalletWebhookNotification}
* @return the returned object {@link NotificationInfoEntity}
*/
@Override
public NotificationInfoEntity convert(final HyperwalletWebhookNotification source) {
final NotificationInfoEntity notificationInfoEntityNotification = new NotificationInfoEntity();
notificationInfoEntityNotification.setNotificationToken(source.getToken());
notificationInfoEntityNotification.setType(source.getType());
notificationInfoEntityNotification.setCreationDate(source.getCreatedOn());
final Object notificationBody = source.getObject();
if (notificationBody instanceof Map) {
final Map<String, String> notificationDetails = (Map<String, String>) notificationBody;
Optional.ofNullable(notificationDetails.get("token"))
.ifPresent(notificationInfoEntityNotification::setTarget);
Optional.ofNullable(notificationDetails.get("programToken"))
.ifPresent(notificationInfoEntityNotification::setProgram);
}
else {
log.error("Notification [{}] has an empty body", source.getToken());
}
return notificationInfoEntityNotification;
}
}
| 5,104 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/model/KycUserEvent.java | package com.paypal.notifications.events.model;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
/**
* Event for KyC user notifications
*/
public class KycUserEvent extends HMCEvent {
public KycUserEvent(final Object source, final HyperwalletWebhookNotification notification) {
super(source, notification);
}
}
| 5,105 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/model/HMCEvent.java | package com.paypal.notifications.events.model;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import lombok.Getter;
import org.springframework.context.ApplicationEvent;
/**
* Event base for HMC events
*/
@Getter
public abstract class HMCEvent extends ApplicationEvent {
private final transient HyperwalletWebhookNotification notification;
protected HMCEvent(final Object source, final HyperwalletWebhookNotification notification) {
super(source);
this.notification = notification;
}
}
| 5,106 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/model/KycBusinessStakeholderEvent.java | package com.paypal.notifications.events.model;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
/**
* Event for KyC business stakeholder notifications
*/
public class KycBusinessStakeholderEvent extends HMCEvent {
public KycBusinessStakeholderEvent(final Object source, final HyperwalletWebhookNotification notification) {
super(source, notification);
}
}
| 5,107 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/model/PaymentEvent.java | package com.paypal.notifications.events.model;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
/**
* Event for payment notifications
*/
public class PaymentEvent extends HMCEvent {
public PaymentEvent(final Object source, final HyperwalletWebhookNotification notification) {
super(source, notification);
}
}
| 5,108 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services/EventSenderExecutor.java | package com.paypal.notifications.events.services;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.strategy.SingleAbstractStrategyExecutor;
import com.paypal.infrastructure.support.strategy.Strategy;
import org.springframework.stereotype.Service;
import java.util.Set;
@Service
public class EventSenderExecutor extends SingleAbstractStrategyExecutor<HyperwalletWebhookNotification, Void> {
private final Set<Strategy<HyperwalletWebhookNotification, Void>> strategies;
public EventSenderExecutor(final Set<Strategy<HyperwalletWebhookNotification, Void>> strategies) {
this.strategies = strategies;
}
@Override
protected Set<Strategy<HyperwalletWebhookNotification, Void>> getStrategies() {
return strategies;
}
}
| 5,109 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services/eventpublishers/AbstractHMCEventSender.java | package com.paypal.notifications.events.services.eventpublishers;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.notifications.events.model.HMCEvent;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationEventPublisher;
/**
* Abstract class that defines the publication of events
*/
@Slf4j
public abstract class AbstractHMCEventSender {
@Resource
private ApplicationEventPublisher applicationEventPublisher;
public Void execute(final HyperwalletWebhookNotification notification) {
log.info("Notification sent to [{}]", notification.getType());
applicationEventPublisher.publishEvent(getEvent(notification));
return null;
}
protected abstract HMCEvent getEvent(final HyperwalletWebhookNotification notification);
}
| 5,110 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services/eventpublishers/KycBusinessStakeHolderSender.java | package com.paypal.notifications.events.services.eventpublishers;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.notifications.events.model.HMCEvent;
import com.paypal.notifications.events.model.KycBusinessStakeholderEvent;
import com.paypal.infrastructure.support.strategy.Strategy;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
/**
* Strategy class for sending Kyc business stakeholder notifications
*/
@Slf4j
@Getter
@Service
public class KycBusinessStakeHolderSender extends AbstractHMCEventSender
implements Strategy<HyperwalletWebhookNotification, Void> {
@Value("${hmc.webhooks.routing-keys.kyc-bstk}")
private String notificationType;
@Override
public HMCEvent getEvent(final HyperwalletWebhookNotification notification) {
return new KycBusinessStakeholderEvent(this, notification);
}
@Override
public boolean isApplicable(final HyperwalletWebhookNotification source) {
final String type = source.getType();
return type != null && type.startsWith(getNotificationType());
}
}
| 5,111 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services/eventpublishers/PaymentSender.java | package com.paypal.notifications.events.services.eventpublishers;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.notifications.events.model.HMCEvent;
import com.paypal.notifications.events.model.PaymentEvent;
import com.paypal.infrastructure.support.strategy.Strategy;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
/**
* Strategy class for sending payment notifications
*/
@Slf4j
@Getter
@Service
public class PaymentSender extends AbstractHMCEventSender implements Strategy<HyperwalletWebhookNotification, Void> {
@Value("${hmc.webhooks.routing-keys.payments}")
private String notificationType;
@Override
public HMCEvent getEvent(final HyperwalletWebhookNotification notification) {
return new PaymentEvent(this, notification);
}
@Override
public boolean isApplicable(final HyperwalletWebhookNotification source) {
final String type = source.getType();
return type != null && type.startsWith(getNotificationType());
}
}
| 5,112 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services/eventpublishers/UnknownEventSender.java | package com.paypal.notifications.events.services.eventpublishers;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.strategy.Strategy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Set;
/**
* Strategy class for unknown notifications Receives notifications, but does not process
* them
*/
@Slf4j
@Service
public class UnknownEventSender implements Strategy<HyperwalletWebhookNotification, Void> {
private final Set<Strategy<HyperwalletWebhookNotification, Void>> allRegisteredNotifications;
public UnknownEventSender(final Set<Strategy<HyperwalletWebhookNotification, Void>> allRegisteredNotifications) {
this.allRegisteredNotifications = allRegisteredNotifications;
}
@Override
public Void execute(final HyperwalletWebhookNotification notification) {
log.info("Skip processing notification [{}]", notification.getType());
return null;
}
@Override
public boolean isApplicable(final HyperwalletWebhookNotification source) {
return allRegisteredNotifications.stream()
.noneMatch(notificationStrategy -> notificationStrategy.isApplicable(source));
}
}
| 5,113 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/events/services/eventpublishers/KycUserEventSender.java | package com.paypal.notifications.events.services.eventpublishers;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.notifications.events.model.HMCEvent;
import com.paypal.notifications.events.model.KycUserEvent;
import com.paypal.infrastructure.support.strategy.Strategy;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
/**
* Strategy class for sending Kyc user notifications
*/
@Slf4j
@Getter
@Service
public class KycUserEventSender extends AbstractHMCEventSender
implements Strategy<HyperwalletWebhookNotification, Void> {
@Value("${hmc.webhooks.routing-keys.kyc-users}")
private String notificationType;
@Override
public HMCEvent getEvent(final HyperwalletWebhookNotification notification) {
return new KycUserEvent(this, notification);
}
@Override
public boolean isApplicable(final HyperwalletWebhookNotification source) {
final String type = source.getType();
return type != null && type.startsWith(getNotificationType());
}
}
| 5,114 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/InvoicesArchTest.java | package com.paypal.invoices;
import com.paypal.testsupport.archrules.SliceLayeredModulePackageStructureRules;
import com.paypal.testsupport.archrules.SliceLayeredModuleWeakenedLayerProtectionRules;
import com.tngtech.archunit.core.importer.ImportOption;
import com.tngtech.archunit.junit.AnalyzeClasses;
import com.tngtech.archunit.junit.ArchTest;
import com.tngtech.archunit.junit.ArchTests;
@AnalyzeClasses(packages = "com.paypal.invoices", importOptions = ImportOption.DoNotIncludeTests.class)
public class InvoicesArchTest {
@ArchTest
public static final ArchTests packageRules = ArchTests.in(SliceLayeredModulePackageStructureRules.class);
@ArchTest
public static final ArchTests layerRules = ArchTests.in(SliceLayeredModuleWeakenedLayerProtectionRules.class);
}
| 5,115 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/connectors/PaymentHyperwalletApiClientTest.java | package com.paypal.invoices.extractioncommons.connectors;
import com.hyperwallet.clientsdk.Hyperwallet;
import com.hyperwallet.clientsdk.model.HyperwalletPayment;
import com.hyperwallet.clientsdk.model.HyperwalletPaymentListOptions;
import com.paypal.infrastructure.hyperwallet.services.PaymentHyperwalletSDKService;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PaymentHyperwalletApiClientTest {
public static final String PROGRAM_TOKEN = "programToken";
public static final String CLIENT_PAYMENT_ID = "clientPaymentId";
@Mock
private PaymentHyperwalletSDKService sdkService;
private PaymentHyperwalletApiClient client;
@BeforeEach
void setUp() {
client = new PaymentHyperwalletApiClient(sdkService);
}
@Test
void createPayment() {
final Hyperwallet hyperwalletMock = Mockito.mock(Hyperwallet.class);
when(sdkService.getHyperwalletInstanceByProgramToken(PROGRAM_TOKEN)).thenReturn(hyperwalletMock);
final HyperwalletPayment payment = new HyperwalletPayment().programToken(PROGRAM_TOKEN);
client.createPayment(payment);
verify(hyperwalletMock).createPayment(payment);
}
@Test
void listPayments() {
final Hyperwallet hyperwalletMock = Mockito.mock(Hyperwallet.class);
when(sdkService.getHyperwalletInstanceByProgramToken(PROGRAM_TOKEN)).thenReturn(hyperwalletMock);
client.listPayments(PROGRAM_TOKEN, CLIENT_PAYMENT_ID);
final ArgumentCaptor<HyperwalletPaymentListOptions> captor = ArgumentCaptor
.forClass(HyperwalletPaymentListOptions.class);
verify(hyperwalletMock).listPayments(captor.capture());
Assertions.assertEquals(CLIENT_PAYMENT_ID, captor.getValue().getClientPaymentId());
}
}
| 5,116 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/batchjobs/AccountingDocumentBatchJobItemValidatorTest.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.infrastructure.mirakl.services.IgnoreProgramsService;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.jobsystem.batchjob.model.BatchJobItemValidationResult;
import com.paypal.jobsystem.batchjob.model.BatchJobItemValidationStatus;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class AccountingDocumentBatchJobItemValidatorTest extends AccountingDocumentBatchJobHandlersTestSupport {
@InjectMocks
private AccountingDocumentBatchJobItemValidator testObj;
@Mock
private IgnoreProgramsService ignoreProgramsService;
@Mock
private BatchJobContext batchJobContextMock;
@Mock
private InvoiceModel invoiceModelMock;
@Mock
private TestAccountingDocumentBatchJobItem testAccountingDocumentBatchJobItemMock;
@Test
void validateItem_shouldReturnValidIfBankAccountAndProgramAreSet_andProgramIgnoredProgramsIsEmpty() {
when(testAccountingDocumentBatchJobItemMock.getItem()).thenReturn(invoiceModelMock);
when(invoiceModelMock.getHyperwalletProgram()).thenReturn("SOMETHING");
when(invoiceModelMock.getDestinationToken()).thenReturn("SOMETHING");
when(ignoreProgramsService.isIgnored("SOMETHING")).thenReturn(false);
final BatchJobItemValidationResult result = testObj.validateItem(batchJobContextMock,
testAccountingDocumentBatchJobItemMock);
assertThat(result.getStatus()).isEqualTo(BatchJobItemValidationStatus.VALID);
}
@Test
void validateItem_shouldReturnInvalidIfProgramIsIgnored() {
when(testAccountingDocumentBatchJobItemMock.getItem()).thenReturn(invoiceModelMock);
when(testAccountingDocumentBatchJobItemMock.getItemId()).thenReturn("ITEMID-1");
when(invoiceModelMock.getHyperwalletProgram()).thenReturn("SOMETHING");
when(ignoreProgramsService.isIgnored("SOMETHING")).thenReturn(true);
final BatchJobItemValidationResult result = testObj.validateItem(batchJobContextMock,
testAccountingDocumentBatchJobItemMock);
assertThat(result.getStatus()).isEqualTo(BatchJobItemValidationStatus.INVALID);
assertThat(result.getReason()).contains(
"Invoice documents with id [ITEMID-1] should be skipped because it belongs to an ignored program");
}
@Test
void validateItem_shouldReturnInvalidIfBankAccountIsNotSet_andProgramIsNotIgnored() {
when(testAccountingDocumentBatchJobItemMock.getItem()).thenReturn(invoiceModelMock);
when(testAccountingDocumentBatchJobItemMock.getItemId()).thenReturn("ITEMID-1");
when(invoiceModelMock.getHyperwalletProgram()).thenReturn("SOMETHING");
when(ignoreProgramsService.isIgnored("SOMETHING")).thenReturn(false);
final BatchJobItemValidationResult result = testObj.validateItem(batchJobContextMock,
testAccountingDocumentBatchJobItemMock);
assertThat(result.getStatus()).isEqualTo(BatchJobItemValidationStatus.INVALID);
assertThat(result.getReason()).contains(
"Invoice documents with id [ITEMID-1] should be skipped because are lacking hw-program or bank account token");
}
@Test
void validateItem_shouldReturnInvalidIfProgramIsNotSet() {
when(testAccountingDocumentBatchJobItemMock.getItem()).thenReturn(invoiceModelMock);
when(testAccountingDocumentBatchJobItemMock.getItemId()).thenReturn("ITEMID-1");
final BatchJobItemValidationResult result = testObj.validateItem(batchJobContextMock,
testAccountingDocumentBatchJobItemMock);
assertThat(result.getStatus()).isEqualTo(BatchJobItemValidationStatus.INVALID);
assertThat(result.getReason()).contains(
"Invoice documents with id [ITEMID-1] should be skipped because are lacking hw-program or bank account token");
}
}
| 5,117 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/batchjobs/AccountingDocumentBatchJobHandlersTestSupport.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.invoices.extractioncommons.batchjobs.AbstractAccountingDocumentBatchJobItem;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
public abstract class AccountingDocumentBatchJobHandlersTestSupport {
static class TestAccountingDocumentBatchJobItem extends AbstractAccountingDocumentBatchJobItem<InvoiceModel> {
public static final String ITEM_TYPE = "Invoice";
public TestAccountingDocumentBatchJobItem(final InvoiceModel item) {
super(item);
}
@Override
public String getItemId() {
return getItem().getInvoiceNumber();
}
@Override
public String getItemType() {
return ITEM_TYPE;
}
@Override
protected TestAccountingDocumentBatchJobItem from(final InvoiceModel item) {
return new TestAccountingDocumentBatchJobItem(item);
}
}
}
| 5,118 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/batchjobs/AbstractAccountingDocumentBatchJobTest.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.invoices.extractioncommons.batchjobs.AbstractAccountingDocumentBatchJob;
import com.paypal.invoices.extractioncommons.batchjobs.AccountingDocumentBatchJobItemEnricher;
import com.paypal.invoices.extractioncommons.batchjobs.AccountingDocumentBatchJobItemValidator;
import com.paypal.invoices.extractioncommons.batchjobs.AccountingDocumentBatchJobPreProcessor;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.jobsystem.batchjob.model.BatchJobType;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoiceExtractJobItem;
import com.paypal.jobsystem.batchjobsupport.model.*;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.InjectMocks;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class AbstractAccountingDocumentBatchJobTest {
@InjectMocks
private MyAccountingDocumentBatchJob testObj;
@Mock
private AccountingDocumentBatchJobItemEnricher accountingDocumentBatchJobItemEnricherMock;
@Mock
private AccountingDocumentBatchJobPreProcessor accountingDocumentBatchJobPreProcessorMock;
@Mock
private AccountingDocumentBatchJobItemValidator accountingDocumentBatchJobItemValidatorMock;
@SuppressWarnings("unchecked")
@Test
void getBatchJobItemValidator_shouldReturnAccountingDocumenHandler() {
assertThat(testObj.getBatchJobItemValidator())
.contains((BatchJobItemValidator) accountingDocumentBatchJobItemValidatorMock);
}
@SuppressWarnings("unchecked")
@Test
void getBatchJobPreProcessor_shouldReturnAccountingDocumenHandler() {
assertThat(testObj.getBatchJobPreProcessor())
.contains((BatchJobPreProcessor) accountingDocumentBatchJobPreProcessorMock);
}
@SuppressWarnings("unchecked")
@Test
void getBatchJobItemEnricher_shouldReturnAccountingDocumenHandler() {
assertThat(testObj.getBatchJobItemEnricher())
.contains((BatchJobItemEnricher) accountingDocumentBatchJobItemEnricherMock);
}
static class MyAccountingDocumentBatchJob extends AbstractAccountingDocumentBatchJob<InvoiceExtractJobItem> {
protected MyAccountingDocumentBatchJob(
final AccountingDocumentBatchJobItemEnricher accountingDocumentBatchJobItemEnricher,
final AccountingDocumentBatchJobPreProcessor accountingDocumentBatchJobPreProcessor,
final AccountingDocumentBatchJobItemValidator accountingDocumentBatchJobItemValidator) {
super(accountingDocumentBatchJobItemEnricher, accountingDocumentBatchJobPreProcessor,
accountingDocumentBatchJobItemValidator);
}
@Override
protected BatchJobItemProcessor<BatchJobContext, InvoiceExtractJobItem> getBatchJobItemProcessor() {
return null;
}
@Override
protected BatchJobItemsExtractor<BatchJobContext, InvoiceExtractJobItem> getBatchJobItemsExtractor() {
return null;
}
@Override
public BatchJobType getType() {
return null;
}
}
}
| 5,119 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/batchjobs/AbstractAccountingDocumentBatchJobExtractorTest.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.jobsystem.batchjob.model.BatchJobItem;
import com.paypal.jobsystem.batchjobaudit.services.BatchJobTrackingService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Answers;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collection;
import java.util.Date;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class AbstractAccountingDocumentBatchJobExtractorTest {
private static final String INCLUDE_PAID_KEY = "includePaid";
private static final Date DELTA = new Date();
@InjectMocks
@Spy
private MyAbstractAccountingDocumentBatchJobExtractor testObj;
@Mock
private BatchJobTrackingService batchJobTrackingServiceMock;
@Mock(answer = Answers.RETURNS_DEEP_STUBS)
private BatchJobContext batchJobContextMock;
@Test
void getItems_shouldCallGetItemsWithParamIncludePaidFalse_whenIncludePaidIsFalse() {
when(batchJobContextMock.getJobExecutionContext().getJobDetail().getJobDataMap().get(INCLUDE_PAID_KEY))
.thenReturn(false);
testObj.getItems(batchJobContextMock, DELTA);
verify(testObj).getItems(batchJobContextMock, DELTA, false);
}
@Test
void getItems_shouldCallGetItemsWithParamIncludePaidTrue_whenIncludePaidIsTrue() {
when(batchJobContextMock.getJobExecutionContext().getJobDetail().getJobDataMap().get(INCLUDE_PAID_KEY))
.thenReturn(true);
testObj.getItems(batchJobContextMock, DELTA);
verify(testObj).getItems(batchJobContextMock, DELTA, true);
}
@Test
void getItems_shouldCallGetItemsWithParamIncludePaidTrue_whenIncludePaidIsNull() {
when(batchJobContextMock.getJobExecutionContext().getJobDetail().getJobDataMap().get(INCLUDE_PAID_KEY))
.thenReturn(null);
testObj.getItems(batchJobContextMock, DELTA);
verify(testObj).getItems(batchJobContextMock, DELTA, false);
}
private static class MyAbstractAccountingDocumentBatchJobExtractor
extends AbstractAccountingDocumentBatchJobExtractor<BatchJobContext, BatchJobItem<Object>> {
protected MyAbstractAccountingDocumentBatchJobExtractor(final BatchJobTrackingService batchJobTrackingService) {
super(batchJobTrackingService);
}
@Override
protected Collection getItems(final BatchJobContext ctx, final Date delta, final boolean includePaid) {
return null;
}
}
}
| 5,120 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/batchjobs/AccountingDocumentBatchJobPreProcessorTest.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.invoices.extractioncommons.services.AccountingDocumentsLinksService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class AccountingDocumentBatchJobPreProcessorTest extends AccountingDocumentBatchJobHandlersTestSupport {
@InjectMocks
private AccountingDocumentBatchJobPreProcessor testObj;
@Mock
private AccountingDocumentsLinksService accountingDocumentsLinksServiceMock;
@Mock
private BatchJobContext batchJobContextMock;
@Mock
private InvoiceModel invoiceModel1Mock, invoiceModel2Mock;
@Mock
private TestAccountingDocumentBatchJobItem testAccountingDocumentBatchJobItem1Mock,
testAccountingDocumentBatchJobItem2Mock;
@Test
void prepareForProcessing_shouldStoreAllLinks() {
when(testAccountingDocumentBatchJobItem1Mock.getItem()).thenReturn(invoiceModel1Mock);
when(testAccountingDocumentBatchJobItem2Mock.getItem()).thenReturn(invoiceModel2Mock);
testObj.prepareForProcessing(batchJobContextMock,
List.of(testAccountingDocumentBatchJobItem1Mock, testAccountingDocumentBatchJobItem2Mock));
verify(accountingDocumentsLinksServiceMock)
.storeRequiredLinks(argThat(x -> x.containsAll(List.of(invoiceModel1Mock, invoiceModel2Mock))));
}
}
| 5,121 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/batchjobs/AccountingDocumentBatchJobItemEnricherTest.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemLinkLocator;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemTypes;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.invoices.extractioncommons.services.AccountingDocumentsLinksService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class AccountingDocumentBatchJobItemEnricherTest extends AccountingDocumentBatchJobHandlersTestSupport {
@InjectMocks
@Spy
private AccountingDocumentBatchJobItemEnricher testObj;
@Mock
private AccountingDocumentsLinksService accountingDocumentsLinksServiceMock;
@Mock
private BatchJobContext batchJobContextMock;
@Mock
private InvoiceModel invoiceModelMock, enrichedInvoiceModelMock;
@Mock
private TestAccountingDocumentBatchJobItem testAccountingDocumentBatchJobItemMock,
enrichedTestAccountingDocumentBatchJobItemMock;
@Mock
private HyperwalletItemLinkLocator hyperwalletItemLinkLocator1Mock, hyperwalletItemLinkLocator2Mock;
@Test
void enrichItem_shouldAddBankAccountAndProgramToken() {
when(testAccountingDocumentBatchJobItemMock.getItem()).thenReturn(invoiceModelMock);
when(accountingDocumentsLinksServiceMock.findRequiredLinks(invoiceModelMock))
.thenReturn(List.of(hyperwalletItemLinkLocator1Mock, hyperwalletItemLinkLocator2Mock));
when(hyperwalletItemLinkLocator1Mock.getType()).thenReturn(HyperwalletItemTypes.BANK_ACCOUNT);
when(hyperwalletItemLinkLocator1Mock.getId()).thenReturn("B");
when(hyperwalletItemLinkLocator2Mock.getType()).thenReturn(HyperwalletItemTypes.PROGRAM);
when(hyperwalletItemLinkLocator2Mock.getId()).thenReturn("P");
when(testAccountingDocumentBatchJobItemMock.from(enrichedInvoiceModelMock))
.thenReturn(enrichedTestAccountingDocumentBatchJobItemMock);
doReturn(enrichedInvoiceModelMock).when(testObj).buildEnriched(invoiceModelMock, "B", "P");
final TestAccountingDocumentBatchJobItem result = (TestAccountingDocumentBatchJobItem) testObj
.enrichItem(batchJobContextMock, testAccountingDocumentBatchJobItemMock);
assertThat(result).isEqualTo(enrichedTestAccountingDocumentBatchJobItemMock);
}
}
| 5,122 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/model/AccountingDocumentModelTest.java | package com.paypal.invoices.extractioncommons.model;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel.Builder;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
import static com.mirakl.client.mmp.domain.common.MiraklAdditionalFieldValue.MiraklStringAdditionalFieldValue;
import static com.mirakl.client.mmp.domain.common.MiraklAdditionalFieldValue.MiraklValueListAdditionalFieldValue;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
@ExtendWith(MockitoExtension.class)
class AccountingDocumentModelTest {
public static Stream<Arguments> provideValuesForTextAreaCustomFieldValues() {
return Stream
.of(Arguments.of(AccountingDocumentModel.builder().destinationToken(List.of(
populateStringCustomFieldValue("hw-bankaccount-token", "destinationTokenValue"))),
"destinationToken", "destinationTokenValue"),
Arguments.of(
AccountingDocumentModel.builder()
.hyperwalletProgram(List.of(populateMiraklValueListCustomFieldValue(
"hw-program", "hyperwalletProgramValue"))),
"hyperwalletProgram", "hyperwalletProgramValue"),
Arguments.of(AccountingDocumentModel.builder().destinationToken(Collections.emptyList()),
"destinationToken", null));
}
private static MiraklStringAdditionalFieldValue populateStringCustomFieldValue(final String code,
final String value) {
final MiraklStringAdditionalFieldValue miraklStringAdditionalFieldValue = new MiraklStringAdditionalFieldValue();
miraklStringAdditionalFieldValue.setCode(code);
miraklStringAdditionalFieldValue.setValue(value);
return miraklStringAdditionalFieldValue;
}
private static MiraklValueListAdditionalFieldValue populateMiraklValueListCustomFieldValue(final String code,
final String value) {
final MiraklValueListAdditionalFieldValue miraklValueListAdditionalFieldValue = new MiraklValueListAdditionalFieldValue();
miraklValueListAdditionalFieldValue.setCode(code);
miraklValueListAdditionalFieldValue.setValue(value);
return miraklValueListAdditionalFieldValue;
}
@ParameterizedTest
@MethodSource("provideValuesForTextAreaCustomFieldValues")
void destinationToken_ShouldSetStringValuesFromTextAreaCustomFieldValues(final Builder invoiceModelBuilder,
final String property, final String expectedValue) {
final AccountingDocumentModel result = invoiceModelBuilder.build();
assertThat(result).hasFieldOrPropertyWithValue(property, expectedValue);
}
@Test
void destinationToken_shouldSetAttributeValueInPlainText() {
final Builder result = AccountingDocumentModel.builder().destinationToken("destinationTokenValue");
assertThat(result).hasFieldOrPropertyWithValue("destinationToken", "destinationTokenValue");
}
@Test
void hyperwalletProgram_shouldSetAttributeValueInPlainText() {
final Builder result = AccountingDocumentModel.builder().hyperwalletProgram("hyperwalletProgramValue");
assertThat(result).hasFieldOrPropertyWithValue("hyperwalletProgram", "hyperwalletProgramValue");
}
}
| 5,123 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/jobs/InvoicesExtractJobTest.java | package com.paypal.invoices.extractioncommons.jobs;
import com.callibrity.logging.test.LogTracker;
import com.callibrity.logging.test.LogTrackerStub;
import com.paypal.jobsystem.batchjob.model.BatchJob;
import com.paypal.jobsystem.quartzadapter.job.QuartzBatchJobAdapterFactory;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesExtractBatchJob;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesExtractBatchJob;
import com.paypal.invoices.extractioncreditnotes.configuration.CreditNotesConfig;
import com.paypal.invoices.extractioninvoices.configuration.InvoicesOperatorCommissionsConfig;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class InvoicesExtractJobTest {
@InjectMocks
@Spy
private MyInvoicesExtractJob testObj;
@Mock
private InvoicesExtractBatchJob invoicesExtractBatchJobMock;
@Mock
private CreditNotesExtractBatchJob creditNotesExtractBatchJobMock;
@Mock
private InvoicesOperatorCommissionsConfig invoicesOperatorCommissionsConfigMock;
@RegisterExtension
final LogTrackerStub logTrackerStub = LogTrackerStub.create().recordForLevel(LogTracker.LogLevel.INFO)
.recordForType(InvoicesExtractJob.class);
@Mock
private CreditNotesConfig creditNotesConfigMock;
@Mock
private JobExecutionContext jobExecutionContextMock;
@Test
void execute_ShouldExecuteInvoicesExtractBatchJobAndExecuteCreditNotesExtractBatchJob_WhenCreditConfigIsEnabled()
throws JobExecutionException {
doNothing().when(testObj).executeBatchJob(invoicesExtractBatchJobMock, jobExecutionContextMock);
doNothing().when(testObj).executeBatchJob(creditNotesExtractBatchJobMock, jobExecutionContextMock);
when(creditNotesConfigMock.isEnabled()).thenReturn(Boolean.TRUE);
testObj.execute(jobExecutionContextMock);
verify(testObj).executeBatchJob(invoicesExtractBatchJobMock, jobExecutionContextMock);
verify(testObj).executeBatchJob(creditNotesExtractBatchJobMock, jobExecutionContextMock);
}
@Test
void execute_ShouldExecuteInvoicesExtractBatchJobAndNotExecuteCreditNotesExtractBatchJob_WhenCreditConfigIsNotEnabled()
throws JobExecutionException {
doNothing().when(testObj).executeBatchJob(invoicesExtractBatchJobMock, jobExecutionContextMock);
when(creditNotesConfigMock.isEnabled()).thenReturn(Boolean.FALSE);
testObj.execute(jobExecutionContextMock);
verify(testObj).executeBatchJob(invoicesExtractBatchJobMock, jobExecutionContextMock);
verify(testObj, never()).executeBatchJob(creditNotesExtractBatchJobMock, jobExecutionContextMock);
}
@Test
void beforeItemExtraction_ShouldLogPaymentOfCommissionsEnabledStatus_WhenJobIsAnInvoicesExtractJobAndInvoicesOperatorCommissionsConfigIsNotEnabled()
throws JobExecutionException {
doNothing().when(testObj).executeBatchJob(invoicesExtractBatchJobMock, jobExecutionContextMock);
when(invoicesOperatorCommissionsConfigMock.isEnabled()).thenReturn(Boolean.FALSE);
testObj.execute(jobExecutionContextMock);
assertThat(
logTrackerStub.contains("Payment of commissions is disabled, skipping processing payments to operator"))
.isTrue();
}
@Test
void beforeItemExtraction_ShouldLogPaymentOfCommissionsDisabledStatus_WhenJobIsAnInvoicesExtractJobAndInvoicesOperatorCommissionsConfigIsEnabled()
throws JobExecutionException {
doNothing().when(testObj).executeBatchJob(invoicesExtractBatchJobMock, jobExecutionContextMock);
when(invoicesOperatorCommissionsConfigMock.isEnabled()).thenReturn(Boolean.TRUE);
testObj.execute(jobExecutionContextMock);
assertThat(logTrackerStub.contains("Payment of commissions is enabled, retrieving payments for the operator"))
.isTrue();
}
static class MyInvoicesExtractJob extends InvoicesExtractJob {
public MyInvoicesExtractJob(final QuartzBatchJobAdapterFactory quartzBatchJobAdapterFactory,
final InvoicesExtractBatchJob invoicesExtractBatchJob,
final CreditNotesExtractBatchJob creditNotesExtractBatchJob, final CreditNotesConfig creditNotesConfig,
final InvoicesOperatorCommissionsConfig invoicesOperatorCommissionsConfig) {
super(quartzBatchJobAdapterFactory, invoicesExtractBatchJob, creditNotesExtractBatchJob, creditNotesConfig,
invoicesOperatorCommissionsConfig);
}
@Override
protected void executeBatchJob(final BatchJob batchJob, final JobExecutionContext context)
throws JobExecutionException {
super.executeBatchJob(batchJob, context);
}
}
}
| 5,124 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/controllers/InvoicesExtractJobControllerTest.java | package com.paypal.invoices.extractioncommons.controllers;
import com.paypal.jobsystem.quartzintegration.support.AbstractDeltaInfoJob;
import com.paypal.jobsystem.quartzintegration.services.JobService;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.infrastructure.support.date.TimeMachine;
import com.paypal.invoices.extractioncommons.jobs.InvoicesExtractJob;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.quartz.SchedulerException;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.Map;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
class InvoicesExtractJobControllerTest {
private static final String JOB_NAME = "jobName";
private static final String INCLUDE_PAID = "includePaid";
@InjectMocks
private InvoiceExtractJobController testObj;
@Mock
private JobService jobService;
@Test
void runJob_shouldCallCreateAndRunSingleExecutionJobAndTestingInvoiceSessionDataAndIncludePaidFalseWithTheTransformedValues()
throws SchedulerException {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 45));
final LocalDateTime now = TimeMachine.now();
final Date delta = DateUtil.convertToDate(now, ZoneId.systemDefault());
testObj.runJob(delta, "jobName", false);
verify(jobService).createAndRunSingleExecutionJob(JOB_NAME, InvoicesExtractJob.class,
AbstractDeltaInfoJob.createJobDataMap(delta, Map.of(INCLUDE_PAID, false)), null);
}
@Test
void runJob_shouldCallCreateAndRunSingleExecutionJobAndTestingInvoiceSessionDataAndIncludePaidTrueWithTheTransformedValues()
throws SchedulerException {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 45));
final LocalDateTime now = TimeMachine.now();
final Date delta = DateUtil.convertToDate(now, ZoneId.systemDefault());
testObj.runJob(delta, "jobName", true);
verify(jobService).createAndRunSingleExecutionJob(JOB_NAME, InvoicesExtractJob.class,
AbstractDeltaInfoJob.createJobDataMap(delta, Map.of(INCLUDE_PAID, true)), null);
}
@Test
void runJob_shouldCallCreateAndRunSingleExecutionJobAndTestingInvoiceSessionDataWithTheTransformedValues()
throws SchedulerException {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 45));
final LocalDateTime now = TimeMachine.now();
final Date delta = DateUtil.convertToDate(now, ZoneId.systemDefault());
testObj.runJob(delta, "jobName", null);
verify(jobService).createAndRunSingleExecutionJob(JOB_NAME, InvoicesExtractJob.class,
AbstractDeltaInfoJob.createJobDataMap(delta, Map.of()), null);
}
}
| 5,125 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/aspects/UpdateStoredItemLinksAspectTest.java | package com.paypal.invoices.extractioncommons.aspects;
import com.mirakl.client.mmp.domain.shop.MiraklShop;
import com.mirakl.client.mmp.domain.shop.MiraklShops;
import com.paypal.invoices.extractioncommons.services.AccountingDocumentsLinksService;
import org.aspectj.lang.ProceedingJoinPoint;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.InjectMocks;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class UpdateStoredItemLinksAspectTest {
@InjectMocks
private UpdateStoredItemLinksAspect testObj;
@Mock
private AccountingDocumentsLinksService accountingDocumentsLinksServiceMock;
@Test
void interceptNotificationsMethod_shouldUpdateStoredItemLinks() throws Throwable {
// given
final ProceedingJoinPoint proceedingJoinPointMock = mock(ProceedingJoinPoint.class);
final MiraklShops miraklShopsMock = mock(MiraklShops.class);
final List<MiraklShop> miraklShopsList = List.of(mock(MiraklShop.class));
when(miraklShopsMock.getShops()).thenReturn(miraklShopsList);
when(proceedingJoinPointMock.proceed()).thenReturn(miraklShopsMock);
// when
final MiraklShops result = testObj.interceptNotificationMethod(proceedingJoinPointMock);
// then
verify(accountingDocumentsLinksServiceMock).updateLinksFromShops(miraklShopsList);
assertThat(result).isEqualTo(miraklShopsMock);
}
@Test
void interceptNotificationsMethod_shouldUpdateStoredItemLinks_andPassEmptyListIfNoShops() throws Throwable {
// given
final ProceedingJoinPoint proceedingJoinPointMock = mock(ProceedingJoinPoint.class);
final MiraklShops miraklShopsMock = mock(MiraklShops.class);
when(proceedingJoinPointMock.proceed()).thenReturn(miraklShopsMock);
// when
final MiraklShops result = testObj.interceptNotificationMethod(proceedingJoinPointMock);
// then
verify(accountingDocumentsLinksServiceMock).updateLinksFromShops(List.of());
assertThat(result).isEqualTo(miraklShopsMock);
}
@Test
void interceptNotificationsMethod_shouldNotDoAnything_ifPjpReturnIsNull() throws Throwable {
// given
final ProceedingJoinPoint proceedingJoinPointMock = mock(ProceedingJoinPoint.class);
when(proceedingJoinPointMock.proceed()).thenReturn(null);
// when
final MiraklShops result = testObj.interceptNotificationMethod(proceedingJoinPointMock);
// then
verify(accountingDocumentsLinksServiceMock, never()).updateLinksFromShops(any());
assertThat(result).isNull();
}
@Test
void interceptNotificationsMethod_shouldNotThrowExceptions_whenUpdateStoreFails() throws Throwable {
// given
final ProceedingJoinPoint proceedingJoinPointMock = mock(ProceedingJoinPoint.class);
final MiraklShops miraklShopsMock = mock(MiraklShops.class);
final List<MiraklShop> miraklShopsList = List.of(mock(MiraklShop.class));
when(miraklShopsMock.getShops()).thenReturn(miraklShopsList);
when(proceedingJoinPointMock.proceed()).thenReturn(miraklShopsMock);
doThrow(new RuntimeException()).when(accountingDocumentsLinksServiceMock).updateLinksFromShops(miraklShopsList);
// when
final MiraklShops result = testObj.interceptNotificationMethod(proceedingJoinPointMock);
// then
assertThat(result).isEqualTo(miraklShopsMock);
}
}
| 5,126 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/services/AbstractAccountingDocumentsExtractServiceImplTest.java | package com.paypal.invoices.extractioncommons.services;
import com.mirakl.client.mmp.domain.invoice.MiraklInvoice;
import com.mirakl.client.mmp.domain.invoice.MiraklInvoices;
import com.mirakl.client.mmp.domain.shop.MiraklShop;
import com.mirakl.client.mmp.operator.request.payment.invoice.MiraklGetInvoicesRequest;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.infrastructure.mirakl.client.MiraklClient;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.infrastructure.support.date.TimeMachine;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import com.paypal.invoices.extractioncommons.model.InvoiceTypeEnum;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.*;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.beans.factory.annotation.Value;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;
import static com.mirakl.client.mmp.domain.accounting.document.MiraklAccountingDocumentPaymentStatus.PENDING;
import static com.mirakl.client.mmp.domain.accounting.document.MiraklAccountingDocumentType.MANUAL_CREDIT;
import static com.mirakl.client.mmp.request.payment.invoice.MiraklAccountingDocumentState.COMPLETE;
import static com.paypal.infrastructure.hyperwallet.constants.HyperWalletConstants.MIRAKL_MAX_RESULTS_PER_PAGE;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class AbstractAccountingDocumentsExtractServiceImplTest {
private static final String ACCOUNTDOCUMENT_ID_1 = "ACCOUNTDOCUMENT_ID_1";
private static final String ACCOUNTDOCUMENT_ID_2 = "ACCOUNTDOCUMENT_ID_2";
private static final String ACCOUNTDOCUMENT_ID_3 = "ACCOUNTDOCUMENT_ID_3";
@Value("${hmc.jobs.settings.search-invoices-maxdays}")
protected int maxNumberOfDaysForInvoiceIdSearch;
@InjectMocks
@Spy
private MyAccountingDocumentsExtractServiceImplTest testObj;
@Mock
protected MiraklClient miraklMarketplacePlatformOperatorApiClient;
@Mock
private Converter<MiraklInvoice, MyAccountingDocumentModel> invoiceConverterMock;
@Mock
private MyAccountingDocumentModel myAccountingDocumentModel1Mock, myAccountingDocumentModel2Mock;
@Mock
private MiraklInvoice miraklInvoice1Mock, miraklInvoice2Mock, miraklInvoice3Mock;
@Mock
private MiraklInvoices miraklInvoicesMock, miraklInvoices2Mock;
@Captor
private ArgumentCaptor<MiraklGetInvoicesRequest> miraklGetInvoicesRequestArgumentCaptor;
@Test
void extractAccountingDocumentsById_shouldReturnDocuments_whenTheyAreInsideSearchWindow() {
TimeMachine.useFixedClockAt(LocalDateTime.now());
when(miraklMarketplacePlatformOperatorApiClient.getInvoices(any())).thenReturn(miraklInvoicesMock);
when(miraklInvoicesMock.getInvoices())
.thenReturn(List.of(miraklInvoice1Mock, miraklInvoice2Mock, miraklInvoice3Mock));
when(miraklInvoice1Mock.getId()).thenReturn(ACCOUNTDOCUMENT_ID_1);
when(miraklInvoice2Mock.getId()).thenReturn(ACCOUNTDOCUMENT_ID_2);
when(miraklInvoice3Mock.getId()).thenReturn(ACCOUNTDOCUMENT_ID_3);
when(invoiceConverterMock.convert(miraklInvoice1Mock)).thenReturn(myAccountingDocumentModel1Mock);
when(invoiceConverterMock.convert(miraklInvoice2Mock)).thenReturn(myAccountingDocumentModel2Mock);
final Collection<MyAccountingDocumentModel> result = testObj
.extractAccountingDocuments(List.of(ACCOUNTDOCUMENT_ID_1, ACCOUNTDOCUMENT_ID_2));
assertThat(result).containsExactlyInAnyOrder(myAccountingDocumentModel1Mock, myAccountingDocumentModel2Mock);
verify(miraklMarketplacePlatformOperatorApiClient)
.getInvoices(miraklGetInvoicesRequestArgumentCaptor.capture());
assertThat(miraklGetInvoicesRequestArgumentCaptor.getValue().getStartDate()).isAfterOrEqualTo(searchWindow());
assertThat(miraklGetInvoicesRequestArgumentCaptor.getValue().getType())
.hasToString(testObj.getInvoiceType().toString());
}
@Test
void extractAccountingDocument_whenNoInvoicesAreReturned_shouldReturnEmptyList() {
final LocalDateTime now = LocalDateTime.now();
TimeMachine.useFixedClockAt(now);
final Date nowAsDate = DateUtil.convertToDate(now, ZoneId.systemDefault());
doReturn(Collections.emptyList()).when(testObj).extractAccountingDocuments(nowAsDate);
final List<MyAccountingDocumentModel> result = testObj.extractAccountingDocuments(nowAsDate);
assertThat(result).isEmpty();
}
@Test
void extractAccountingDocuments_shouldReturnListOfAccountingDocuments_notIncludingPaidInvoices() {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 0, 55));
final Date now = DateUtil.convertToDate(TimeMachine.now(), ZoneId.systemDefault());
when(miraklMarketplacePlatformOperatorApiClient.getInvoices(any())).thenReturn(miraklInvoicesMock);
when(miraklInvoicesMock.getInvoices()).thenReturn(List.of(miraklInvoice1Mock, miraklInvoice2Mock));
when(invoiceConverterMock.convert(miraklInvoice1Mock)).thenReturn(myAccountingDocumentModel1Mock);
when(invoiceConverterMock.convert(miraklInvoice2Mock)).thenReturn(myAccountingDocumentModel2Mock);
final List<MyAccountingDocumentModel> creditNoteList = testObj.extractAccountingDocuments(now);
verify(miraklMarketplacePlatformOperatorApiClient)
.getInvoices(miraklGetInvoicesRequestArgumentCaptor.capture());
verify(testObj).extractAccountingDocuments(now, false);
final MiraklGetInvoicesRequest miraklGetInvoicesRequest = miraklGetInvoicesRequestArgumentCaptor.getValue();
assertThat(miraklGetInvoicesRequest.getStartDate()).isEqualTo(now);
assertThat(miraklGetInvoicesRequest.getStates()).isEqualTo(List.of(COMPLETE));
assertThat(miraklGetInvoicesRequest.getPaymentStatus()).isEqualTo(PENDING);
assertThat(creditNoteList).containsExactlyInAnyOrder(myAccountingDocumentModel1Mock,
myAccountingDocumentModel2Mock);
}
@Test
void extractAccountingDocuments_shouldReturnListOfAccountingDocuments_includingPaidInvoices() {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 0, 55));
final Date now = DateUtil.convertToDate(TimeMachine.now(), ZoneId.systemDefault());
when(miraklMarketplacePlatformOperatorApiClient.getInvoices(any())).thenReturn(miraklInvoicesMock);
when(miraklInvoicesMock.getInvoices()).thenReturn(List.of(miraklInvoice1Mock, miraklInvoice2Mock));
when(invoiceConverterMock.convert(miraklInvoice1Mock)).thenReturn(myAccountingDocumentModel1Mock);
when(invoiceConverterMock.convert(miraklInvoice2Mock)).thenReturn(myAccountingDocumentModel2Mock);
final List<MyAccountingDocumentModel> creditNoteList = testObj.extractAccountingDocuments(now, true);
verify(miraklMarketplacePlatformOperatorApiClient)
.getInvoices(miraklGetInvoicesRequestArgumentCaptor.capture());
final MiraklGetInvoicesRequest miraklGetInvoicesRequest = miraklGetInvoicesRequestArgumentCaptor.getValue();
assertThat(miraklGetInvoicesRequest.getStartDate()).isEqualTo(now);
assertThat(miraklGetInvoicesRequest.getStates()).isEqualTo(List.of(COMPLETE));
assertThat(miraklGetInvoicesRequest.getPaymentStatus()).isNull();
assertThat(creditNoteList).containsExactlyInAnyOrder(myAccountingDocumentModel1Mock,
myAccountingDocumentModel2Mock);
}
@Test
void createAccountingDocumentRequest_shouldReturnRequestWithTargetInvoiceType() {
final Date date = new Date();
final MiraklGetInvoicesRequest result = testObj.createAccountingDocumentRequest(date,
InvoiceTypeEnum.MANUAL_CREDIT);
assertThat(result.getMax()).isEqualTo(100);
assertThat(result.getStartDate()).isEqualTo(date);
assertThat(result.getType()).isEqualTo(MANUAL_CREDIT);
assertThat(result.getPaymentStatus()).isEqualTo(PENDING);
assertThat(result.getStates()).containsExactly(COMPLETE);
}
@Test
void getAccountingDocuments_whenRequestNeedsPagination_shouldRepeatRequestAndReturnAllInvoices() {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 0, 55));
final Date now = DateUtil.convertToDate(TimeMachine.now(), ZoneId.systemDefault());
final List<MiraklInvoice> firstPageResponseInvoices = getListOfmiraklInvoiceMocks(MIRAKL_MAX_RESULTS_PER_PAGE);
final List<MiraklInvoice> secondPageResponseInvoices = getListOfmiraklInvoiceMocks(
MIRAKL_MAX_RESULTS_PER_PAGE / 2);
final long totalResponseInvoices = firstPageResponseInvoices.size() + secondPageResponseInvoices.size();
when(miraklMarketplacePlatformOperatorApiClient
.getInvoices(argThat(request -> request != null && request.getOffset() == 0)))
.thenReturn(miraklInvoicesMock);
when(miraklMarketplacePlatformOperatorApiClient
.getInvoices(argThat(request -> request != null && request.getOffset() == MIRAKL_MAX_RESULTS_PER_PAGE)))
.thenReturn(miraklInvoices2Mock);
when(miraklInvoicesMock.getTotalCount()).thenReturn(totalResponseInvoices);
when(miraklInvoicesMock.getInvoices()).thenReturn(firstPageResponseInvoices);
when(miraklInvoices2Mock.getTotalCount()).thenReturn(totalResponseInvoices);
when(miraklInvoices2Mock.getInvoices()).thenReturn(secondPageResponseInvoices);
final List<MyAccountingDocumentModel> expectedAccountingDocuments = Stream
.concat(firstPageResponseInvoices.stream(), secondPageResponseInvoices.stream())
.map(invoice -> mockAndReturn(invoice)).collect(Collectors.toList());
final List<MyAccountingDocumentModel> result = testObj.extractAccountingDocuments(now);
assertThat(result).containsExactlyElementsOf(expectedAccountingDocuments);
}
private MyAccountingDocumentModel mockAndReturn(final MiraklInvoice invoice) {
final MyAccountingDocumentModel myAccountingDocumentModel = mock(MyAccountingDocumentModel.class);
when(invoiceConverterMock.convert(invoice)).thenReturn(myAccountingDocumentModel);
return myAccountingDocumentModel;
}
private List<MiraklInvoice> getListOfmiraklInvoiceMocks(final int numberOfMocks) {
return IntStream.range(0, numberOfMocks).mapToObj(i -> mock(MiraklInvoice.class)).collect(Collectors.toList());
}
private Date searchWindow() {
return Date.from(TimeMachine.now().minusDays(maxNumberOfDaysForInvoiceIdSearch).toInstant(ZoneOffset.UTC));
}
static class MyAccountingDocumentsExtractServiceImplTest
extends AbstractAccountingDocumentsExtractServiceImpl<MyAccountingDocumentModel> {
private final Converter<MiraklInvoice, MyAccountingDocumentModel> miraklInvoiceToInvoiceModelConverter;
protected MyAccountingDocumentsExtractServiceImplTest(
final Converter<MiraklShop, AccountingDocumentModel> miraklShopToAccountingModelConverter,
final MiraklClient miraklMarketplacePlatformOperatorApiClient,
final AccountingDocumentsLinksService accountingDocumentsLinksService,
final MailNotificationUtil invoicesMailNotificationUtil,
final Converter<MiraklInvoice, MyAccountingDocumentModel> miraklInvoiceToInvoiceModelConverter) {
super(miraklShopToAccountingModelConverter, miraklMarketplacePlatformOperatorApiClient,
accountingDocumentsLinksService, invoicesMailNotificationUtil);
this.miraklInvoiceToInvoiceModelConverter = miraklInvoiceToInvoiceModelConverter;
}
@Override
protected InvoiceTypeEnum getInvoiceType() {
return InvoiceTypeEnum.AUTO_INVOICE;
}
@Override
protected Converter<MiraklInvoice, MyAccountingDocumentModel> getMiraklInvoiceToAccountingModelConverter() {
return miraklInvoiceToInvoiceModelConverter;
}
}
static class MyAccountingDocumentModel extends AccountingDocumentModel {
protected MyAccountingDocumentModel(final Builder<?> builder) {
super(builder);
}
}
}
| 5,127 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/services/MiraklInvoiceLinksServiceImplTest.java | package com.paypal.invoices.extractioncommons.services;
import com.mirakl.client.core.error.MiraklErrorResponseBean;
import com.mirakl.client.core.exception.MiraklApiException;
import com.mirakl.client.mmp.domain.shop.MiraklShop;
import com.mirakl.client.mmp.domain.shop.MiraklShops;
import com.mirakl.client.mmp.request.shop.MiraklGetShopsRequest;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemLinkLocator;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemTypes;
import com.paypal.infrastructure.itemlinks.model.MiraklItemLinkLocator;
import com.paypal.infrastructure.itemlinks.model.MiraklItemTypes;
import com.paypal.infrastructure.mirakl.client.MiraklClient;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.argThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class MiraklInvoiceLinksServiceImplTest {
private static final String SHOP_ID_1 = "1";
private static final String SHOP_ID_2 = "2";
private static final String PROGRAM_TOKEN_1 = "PROG-1";
private static final String BANK_TOKEN_1 = "BANK-1";
private static final String BANK_TOKEN_2 = "BANK-2";
@InjectMocks
private MiraklInvoiceLinksServiceImpl testObj;
@Mock
private MiraklClient miraklMarketplacePlatformOperatorApiClientMock;
@Mock
private Converter<MiraklShop, AccountingDocumentModel> miraklShopToAccountingModelConverterMock;
@Mock
private MiraklShop miraklShop1Mock, miraklShop2Mock;
@Mock
private AccountingDocumentModel accountingDocumentModel1Mock, accountingDocumentModel2Mock;
@Mock
private MiraklShops miraklShopsMock, miraklShops2Mock;
@Captor
private ArgumentCaptor<MiraklGetShopsRequest> miraklGetShopsRequestArgumentCaptor;
@Test
void getShopLinks_shouldReturnProgramAndBankAccountLinks() {
when(miraklShop1Mock.getId()).thenReturn(SHOP_ID_1);
when(miraklShop2Mock.getId()).thenReturn(SHOP_ID_2);
when(miraklShopToAccountingModelConverterMock.convert(miraklShop1Mock))
.thenReturn(accountingDocumentModel1Mock);
when(miraklShopToAccountingModelConverterMock.convert(miraklShop2Mock))
.thenReturn(accountingDocumentModel2Mock);
when(accountingDocumentModel1Mock.getHyperwalletProgram()).thenReturn(PROGRAM_TOKEN_1);
when(accountingDocumentModel1Mock.getDestinationToken()).thenReturn(BANK_TOKEN_1);
when(accountingDocumentModel2Mock.getHyperwalletProgram()).thenReturn(PROGRAM_TOKEN_1);
when(accountingDocumentModel2Mock.getDestinationToken()).thenReturn(BANK_TOKEN_2);
when(miraklMarketplacePlatformOperatorApiClientMock
.getShops(argThat(req -> req.getShopIds().containsAll(Set.of(SHOP_ID_1, SHOP_ID_2)))))
.thenReturn(miraklShopsMock);
when(miraklShopsMock.getShops()).thenReturn(List.of(miraklShop1Mock, miraklShop2Mock));
final Map<MiraklItemLinkLocator, Collection<HyperwalletItemLinkLocator>> result = testObj
.getInvoiceRelatedShopLinks(Set.of("1", "2"));
//@formatter:off
final MiraklItemLinkLocator miraklItemLinkLocator1 = new MiraklItemLinkLocator(SHOP_ID_1, MiraklItemTypes.SHOP);
final MiraklItemLinkLocator miraklItemLinkLocator2 = new MiraklItemLinkLocator(SHOP_ID_2, MiraklItemTypes.SHOP);
assertThat(result.entrySet()).hasSize(2);
assertThat(result.keySet()).containsExactlyInAnyOrder(miraklItemLinkLocator1, miraklItemLinkLocator2);
assertThat(result.get(miraklItemLinkLocator1)).containsExactlyInAnyOrder(
new HyperwalletItemLinkLocator(PROGRAM_TOKEN_1, HyperwalletItemTypes.PROGRAM),
new HyperwalletItemLinkLocator(BANK_TOKEN_1, HyperwalletItemTypes.BANK_ACCOUNT));
assertThat(result.get(miraklItemLinkLocator2)).containsExactlyInAnyOrder(
new HyperwalletItemLinkLocator(PROGRAM_TOKEN_1, HyperwalletItemTypes.PROGRAM),
new HyperwalletItemLinkLocator(BANK_TOKEN_2, HyperwalletItemTypes.BANK_ACCOUNT));
//@formatter:on
}
@Test
void getShopLinks_shouldNotReturnProgramAndBankAccountLinks_WhenShopFieldsAreEmpty() {
when(miraklShop1Mock.getId()).thenReturn(SHOP_ID_1);
when(miraklShop2Mock.getId()).thenReturn(SHOP_ID_2);
when(miraklShopToAccountingModelConverterMock.convert(miraklShop1Mock))
.thenReturn(accountingDocumentModel1Mock);
when(miraklShopToAccountingModelConverterMock.convert(miraklShop2Mock))
.thenReturn(accountingDocumentModel2Mock);
when(accountingDocumentModel1Mock.getHyperwalletProgram()).thenReturn(PROGRAM_TOKEN_1);
when(accountingDocumentModel1Mock.getDestinationToken()).thenReturn(null);
when(accountingDocumentModel2Mock.getHyperwalletProgram()).thenReturn(null);
when(accountingDocumentModel2Mock.getDestinationToken()).thenReturn(BANK_TOKEN_2);
when(miraklMarketplacePlatformOperatorApiClientMock
.getShops(argThat(req -> req.getShopIds().containsAll(Set.of(SHOP_ID_1, SHOP_ID_2)))))
.thenReturn(miraklShopsMock);
when(miraklShopsMock.getShops()).thenReturn(List.of(miraklShop1Mock, miraklShop2Mock));
final Map<MiraklItemLinkLocator, Collection<HyperwalletItemLinkLocator>> result = testObj
.getInvoiceRelatedShopLinks(Set.of("1", "2"));
//@formatter:off
final MiraklItemLinkLocator miraklItemLinkLocator1 = new MiraklItemLinkLocator(SHOP_ID_1, MiraklItemTypes.SHOP);
final MiraklItemLinkLocator miraklItemLinkLocator2 = new MiraklItemLinkLocator(SHOP_ID_2, MiraklItemTypes.SHOP);
assertThat(result.entrySet()).hasSize(2);
assertThat(result.keySet()).containsExactlyInAnyOrder(miraklItemLinkLocator1, miraklItemLinkLocator2);
assertThat(result.get(miraklItemLinkLocator1)).containsExactlyInAnyOrder(
new HyperwalletItemLinkLocator(PROGRAM_TOKEN_1, HyperwalletItemTypes.PROGRAM));
assertThat(result.get(miraklItemLinkLocator2)).containsExactlyInAnyOrder(
new HyperwalletItemLinkLocator(BANK_TOKEN_2, HyperwalletItemTypes.BANK_ACCOUNT));
//@formatter:on
}
@Test
void getShopLinks_shouldIgnoreWhenMiraklHttpRequestFailAndReturnEmptyShopList() {
when(miraklMarketplacePlatformOperatorApiClientMock
.getShops(argThat(req -> req.getShopIds().containsAll(Set.of(SHOP_ID_1, SHOP_ID_2)))))
.thenThrow(new MiraklApiException(new MiraklErrorResponseBean(1, "Error", "correlation-id")));
final Map<MiraklItemLinkLocator, Collection<HyperwalletItemLinkLocator>> result = testObj
.getInvoiceRelatedShopLinks(Set.of("1", "2"));
final MiraklItemLinkLocator miraklItemLinkLocator1 = new MiraklItemLinkLocator(SHOP_ID_1, MiraklItemTypes.SHOP);
final MiraklItemLinkLocator miraklItemLinkLocator2 = new MiraklItemLinkLocator(SHOP_ID_2, MiraklItemTypes.SHOP);
assertThat(result.entrySet()).hasSize(2);
assertThat(result.keySet()).containsExactlyInAnyOrder(miraklItemLinkLocator1, miraklItemLinkLocator2);
assertThat(result.get(miraklItemLinkLocator1)).isEmpty();
assertThat(result.get(miraklItemLinkLocator2)).isEmpty();
}
@Test
void getAllShops_shouldSplitRequestInBatchesOfFixedSize_AndContinueOnErrorsInIndividualBatches() {
final MiraklApiException miraklApiException = new MiraklApiException(
new MiraklErrorResponseBean(1, "Something went wrong", "correlation-id"));
//@formatter:on
when(miraklMarketplacePlatformOperatorApiClientMock
.getShops(argThat(request -> request.getShopIds().size() <= 100))).thenReturn(miraklShopsMock)
.thenThrow(miraklApiException).thenReturn(miraklShops2Mock);
//@formatter:off
when(miraklShopsMock.getShops()).thenReturn(List.of(miraklShop1Mock));
when(miraklShops2Mock.getShops()).thenReturn(List.of(miraklShop2Mock));
when(miraklShop1Mock.getId()).thenReturn("1");
when(miraklShop2Mock.getId()).thenReturn("2");
final Set<String> invoiceIds = Stream.iterate(1, n -> n + 1)
.limit(250)
.map(String::valueOf)
.collect(Collectors.toSet());
final Map<String, MiraklShop> result = testObj.getAllShops(invoiceIds);
assertThat(result).hasSize(2);
assertThat(result.values()).containsExactlyInAnyOrder(miraklShop1Mock, miraklShop2Mock);
verify(miraklMarketplacePlatformOperatorApiClientMock, times(3))
.getShops(miraklGetShopsRequestArgumentCaptor.capture());
final MiraklGetShopsRequest failedRequest = miraklGetShopsRequestArgumentCaptor.getAllValues().get(1);
}
}
| 5,128 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/services/AccountingDocumentsLinksServiceImplTest.java | package com.paypal.invoices.extractioncommons.services;
import com.mirakl.client.mmp.domain.shop.MiraklShop;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemLinkLocator;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemTypes;
import com.paypal.infrastructure.itemlinks.model.MiraklItemLinkLocator;
import com.paypal.infrastructure.itemlinks.services.ItemLinksService;
import com.paypal.infrastructure.mirakl.support.MiraklShopUtils;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.ArgumentMatcher;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class AccountingDocumentsLinksServiceImplTest {
private static final String SHOP_ID_1 = "1";
private static final String SHOP_ID_2 = "2";
@InjectMocks
private AccountingDocumentsLinksServiceImpl testObj;
@Mock
private ItemLinksService itemLinksServiceMock;
@Mock
private MiraklInvoiceLinksService miraklInvoiceLinksServiceMock;
@Mock
private AccountingDocumentModel accountingDocumentModel1Mock, accountingDocumentModel2Mock;
@Mock
private MiraklItemLinkLocator miraklItemLinkLocator1Mock, miraklItemLinkLocator2Mock;
@Mock
private HyperwalletItemLinkLocator hyperwalletItemLink1LocatorMock, hyperwalletItemLink2LocatorMock;
@Test
void storeRequiredLinks_shouldCreateNoneExistantLinksAndReturnAllLinks() {
when(accountingDocumentModel1Mock.getShopId()).thenReturn(SHOP_ID_1);
when(accountingDocumentModel2Mock.getShopId()).thenReturn(SHOP_ID_2);
when(miraklItemLinkLocator1Mock.getId()).thenReturn(SHOP_ID_1);
when(miraklItemLinkLocator2Mock.getId()).thenReturn(SHOP_ID_2);
//@formatter:off
when(itemLinksServiceMock.findLinks(argThat(new ArgThatContainsAllShops()),
eq(Set.of(HyperwalletItemTypes.BANK_ACCOUNT, HyperwalletItemTypes.PROGRAM))))
.thenReturn(Map.of(miraklItemLinkLocator1Mock, List.of(hyperwalletItemLink1LocatorMock),
miraklItemLinkLocator2Mock, List.of()));
when(miraklInvoiceLinksServiceMock.getInvoiceRelatedShopLinks(Set.of(SHOP_ID_1, SHOP_ID_2)))
.thenReturn(Map.of(miraklItemLinkLocator1Mock, List.of(hyperwalletItemLink1LocatorMock, hyperwalletItemLink2LocatorMock),
miraklItemLinkLocator2Mock, List.of(hyperwalletItemLink1LocatorMock, hyperwalletItemLink2LocatorMock)));
//@formatter:on
testObj.storeRequiredLinks(List.of(accountingDocumentModel1Mock, accountingDocumentModel2Mock));
verify(itemLinksServiceMock, times(1)).createLinks(miraklItemLinkLocator1Mock,
List.of(hyperwalletItemLink1LocatorMock, hyperwalletItemLink2LocatorMock));
verify(itemLinksServiceMock, times(1)).createLinks(miraklItemLinkLocator2Mock,
List.of(hyperwalletItemLink1LocatorMock, hyperwalletItemLink2LocatorMock));
}
@Test
void findRequiredLinks_shouldRecoverAllLocalStoredLinks() {
when(accountingDocumentModel1Mock.getShopId()).thenReturn("SHOP-1");
when(itemLinksServiceMock.findLinks(
(MiraklItemLinkLocator) argThat(x -> ((MiraklItemLinkLocator) x).getId().equals("SHOP-1")),
eq(Set.of(HyperwalletItemTypes.BANK_ACCOUNT, HyperwalletItemTypes.PROGRAM))))
.thenReturn(List.of(hyperwalletItemLink1LocatorMock, hyperwalletItemLink2LocatorMock));
final Collection<HyperwalletItemLinkLocator> result = testObj.findRequiredLinks(accountingDocumentModel1Mock);
assertThat(result).containsExactlyInAnyOrder(hyperwalletItemLink1LocatorMock, hyperwalletItemLink2LocatorMock);
}
@SuppressWarnings("unchecked")
@Test
void storeRequiredLinks_shouldExtractRelevantLinksFromShop_andStoreThemUsingItemLinksService() {
// given
final MiraklShop miraklShop1 = new MiraklShop();
miraklShop1.setId("ID-1");
MiraklShopUtils.setProgram(miraklShop1, "PROGRAM-1");
MiraklShopUtils.setBankAccountToken(miraklShop1, "BANK-ACCOUNT-1");
final MiraklShop miraklShop2 = new MiraklShop();
miraklShop2.setId("ID-2");
MiraklShopUtils.setProgram(miraklShop2, "PROGRAM-2");
MiraklShopUtils.setBankAccountToken(miraklShop2, "BANK-ACCOUNT-2");
final List<MiraklShop> miraklShops = List.of(miraklShop1, miraklShop2);
// when
testObj.updateLinksFromShops(miraklShops);
// then
final ArgumentCaptor<MiraklItemLinkLocator> miraklItemLinkLocatorArgumentCaptor = ArgumentCaptor
.forClass(MiraklItemLinkLocator.class);
final ArgumentCaptor<Collection<HyperwalletItemLinkLocator>> hyperwalletItemLinkLocatorArgumentCaptor = ArgumentCaptor
.forClass(Collection.class);
verify(itemLinksServiceMock, times(2)).createLinks(miraklItemLinkLocatorArgumentCaptor.capture(),
hyperwalletItemLinkLocatorArgumentCaptor.capture());
final List<CreateItemLinksResult> itemLinks = getItemlLinksFromCreateLinksResult(
miraklItemLinkLocatorArgumentCaptor.getAllValues(),
hyperwalletItemLinkLocatorArgumentCaptor.getAllValues());
assertThat(itemLinks.get(0).miraklItemLinkLocator.getId()).isEqualTo("ID-1");
assertThat(itemLinks.get(0).hyperwalletItemLinkLocators).containsExactlyInAnyOrder(
new HyperwalletItemLinkLocator("PROGRAM-1", HyperwalletItemTypes.PROGRAM),
new HyperwalletItemLinkLocator("BANK-ACCOUNT-1", HyperwalletItemTypes.BANK_ACCOUNT));
assertThat(itemLinks.get(1).miraklItemLinkLocator.getId()).isEqualTo("ID-2");
assertThat(itemLinks.get(1).hyperwalletItemLinkLocators).containsExactlyInAnyOrder(
new HyperwalletItemLinkLocator("PROGRAM-2", HyperwalletItemTypes.PROGRAM),
new HyperwalletItemLinkLocator("BANK-ACCOUNT-2", HyperwalletItemTypes.BANK_ACCOUNT));
}
private List<CreateItemLinksResult> getItemlLinksFromCreateLinksResult(
final List<MiraklItemLinkLocator> miraklItemLinkLocators,
final List<Collection<HyperwalletItemLinkLocator>> hyperwalletItemLinkLocators) {
return IntStream.range(0, miraklItemLinkLocators.size()).mapToObj(
i -> new CreateItemLinksResult(miraklItemLinkLocators.get(i), hyperwalletItemLinkLocators.get(i)))
.sorted(Comparator.comparing(x -> x.miraklItemLinkLocator.getId())).collect(Collectors.toList());
}
@Test
void storeRequiredLinks_shouldDoNothing_forEmptyShops() {
// given
final List<MiraklShop> miraklShops = List.of();
// when
testObj.updateLinksFromShops(miraklShops);
// then
verify(itemLinksServiceMock, never()).createLinks(any(), any());
}
static class ArgThatContainsAllShops implements ArgumentMatcher<Collection<MiraklItemLinkLocator>> {
@Override
public boolean matches(final Collection<MiraklItemLinkLocator> argument) {
// formatter:off
return argument.stream().map(MiraklItemLinkLocator::getId).collect(Collectors.toSet())
.containsAll(Set.of(SHOP_ID_1, SHOP_ID_2));
// formatter:on
}
}
static class CreateItemLinksResult {
CreateItemLinksResult(final MiraklItemLinkLocator miraklItemLinkLocator,
final Collection<HyperwalletItemLinkLocator> hyperwalletItemLinkLocators) {
this.miraklItemLinkLocator = miraklItemLinkLocator;
this.hyperwalletItemLinkLocators = hyperwalletItemLinkLocators;
}
final MiraklItemLinkLocator miraklItemLinkLocator;
final Collection<HyperwalletItemLinkLocator> hyperwalletItemLinkLocators;
}
}
| 5,129 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/services | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncommons/services/converters/MiraklShopToAccountingModelConverterTest.java | package com.paypal.invoices.extractioncommons.services.converters;
import com.mirakl.client.mmp.domain.common.MiraklAdditionalFieldValue;
import com.mirakl.client.mmp.domain.shop.MiraklShop;
import com.paypal.invoices.extractioncommons.services.converters.MiraklShopToAccountingModelConverter;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Spy;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class MiraklShopToAccountingModelConverterTest {
private final static String SHOP_ID = "2000";
@Spy
@InjectMocks
private MiraklShopToAccountingModelConverter testObj;
@Mock
private InvoiceModel.Builder invoiceModelBuilderMock;
@Mock
private MiraklShop miraklShopMock;
@Mock
private MiraklAdditionalFieldValue miraklAdditionalFieldValueOneMock;
@Mock
private InvoiceModel invoiceModelMock;
@Test
void convert_shouldReturnInvoiceModelBasedOnValuesOfMiraklShop() {
when(miraklShopMock.getId()).thenReturn(SHOP_ID);
final List<MiraklAdditionalFieldValue> miraklAdditionalFieldValues = List.of(miraklAdditionalFieldValueOneMock);
when(miraklShopMock.getAdditionalFieldValues()).thenReturn(miraklAdditionalFieldValues);
doReturn(invoiceModelBuilderMock).when(testObj).getBuilder();
when(invoiceModelBuilderMock.shopId(SHOP_ID)).thenReturn(invoiceModelBuilderMock);
when(invoiceModelBuilderMock.destinationToken(miraklAdditionalFieldValues)).thenReturn(invoiceModelBuilderMock);
when(invoiceModelBuilderMock.hyperwalletProgram(miraklAdditionalFieldValues))
.thenReturn(invoiceModelBuilderMock);
when(invoiceModelBuilderMock.build()).thenReturn(invoiceModelMock);
final AccountingDocumentModel result = testObj.convert(miraklShopMock);
verify(invoiceModelBuilderMock).destinationToken(miraklAdditionalFieldValues);
verify(invoiceModelBuilderMock).shopId(SHOP_ID);
assertThat(result).isEqualTo(invoiceModelMock);
}
@Test
void getBuilder_shouldReturnAnInvoiceModelBuilderInstance() {
final AccountingDocumentModel.Builder builder = testObj.getBuilder();
assertThat(builder).isInstanceOf(AccountingDocumentModel.Builder.class);
}
}
| 5,130 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications/listeners/PaymentListenerTest.java | package com.paypal.invoices.paymentnotifications.listeners;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.invoices.paymentnotifications.services.PaymentNotificationService;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
class PaymentListenerTest {
private static final String NOTIFICATION_TYPE = "payment";
private PaymentListener testObj;
@Mock
private PaymentNotificationService paymentNotificationServiceMock;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotificationMock;
@BeforeEach
void setUp() {
testObj = new PaymentListener(null, paymentNotificationServiceMock, null, null);
}
@Test
void processNotification_shouldCallPaymentNotificationService() {
testObj.processNotification(hyperwalletWebhookNotificationMock);
verify(paymentNotificationServiceMock).processPaymentNotification(hyperwalletWebhookNotificationMock);
}
@Test
void getNotificationType_shouldReturnPayment() {
final String result = testObj.getNotificationType();
assertThat(result).isEqualTo(NOTIFICATION_TYPE);
}
}
| 5,131 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications/services/PaymentNotificationExecutorTest.java | package com.paypal.invoices.paymentnotifications.services;
import com.paypal.infrastructure.support.strategy.Strategy;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class PaymentNotificationExecutorTest {
@InjectMocks
private PaymentNotificationExecutor testObj;
@Mock
private Strategy<PaymentNotificationBodyModel, Void> strategyMock;
@BeforeEach
void setUp() {
testObj = new PaymentNotificationExecutor(Set.of(strategyMock));
}
@Test
void getStrategies_shouldReturnConverterStrategyMock() {
final Set<Strategy<PaymentNotificationBodyModel, Void>> result = testObj.getStrategies();
assertThat(result).containsExactly(strategyMock);
}
}
| 5,132 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications/services/AcceptedPaymentNotificationStrategyTest.java | package com.paypal.invoices.paymentnotifications.services;
import com.mirakl.client.mmp.domain.common.currency.MiraklIsoCurrencyCode;
import com.mirakl.client.mmp.domain.invoice.MiraklAccountingDocumentPaymentConfirmation;
import com.mirakl.client.mmp.request.invoice.MiraklConfirmAccountingDocumentPaymentRequest;
import com.paypal.infrastructure.hyperwallet.constants.HyperWalletConstants;
import com.paypal.infrastructure.mirakl.client.MiraklClient;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.invoices.paymentnotifications.configuration.PaymentNotificationConfig;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.List;
import java.util.Set;
import java.util.TimeZone;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class AcceptedPaymentNotificationStrategyTest {
private static final String COMPLETED = "COMPLETED";
private static final String NOT_COMPLETED = "NOT_COMPLETED";
private static final String AMOUNT = "123.45";
private static final String INVOICE_ID = "1234";
private static final String CURRENCY_EUR_ISO_CODE = "EUR";
private static final String CREATED_ON = "2021-01-11T00:00:00";
@InjectMocks
private AcceptedPaymentNotificationStrategy testObj;
@Mock
private PaymentNotificationBodyModel paymentNotificationBodyModelMock;
@Mock
private PaymentNotificationConfig paymentNotificationConfigMock;
@Mock
private MiraklClient miraklClientMock;
@Captor
ArgumentCaptor<MiraklConfirmAccountingDocumentPaymentRequest> miraklConfirmAccountingDocumentPaymentRequestArgumentCaptor;
@Test
void execute_shouldSendConfirmationPaymentToMirakl() {
when(paymentNotificationBodyModelMock.getAmount()).thenReturn(AMOUNT);
when(paymentNotificationBodyModelMock.getClientPaymentId()).thenReturn(INVOICE_ID);
when(paymentNotificationBodyModelMock.getCurrency()).thenReturn(CURRENCY_EUR_ISO_CODE);
when(paymentNotificationBodyModelMock.getCreatedOn()).thenReturn(CREATED_ON);
testObj.execute(paymentNotificationBodyModelMock);
verify(miraklClientMock).confirmAccountingDocumentPayment(
miraklConfirmAccountingDocumentPaymentRequestArgumentCaptor.capture());
final MiraklConfirmAccountingDocumentPaymentRequest miraklConfirmAccountingDocumentPaymentRequest = miraklConfirmAccountingDocumentPaymentRequestArgumentCaptor
.getValue();
final List<MiraklAccountingDocumentPaymentConfirmation> accountingDocuments = miraklConfirmAccountingDocumentPaymentRequest
.getAccountingDocuments();
assertThat(miraklConfirmAccountingDocumentPaymentRequest.getAccountingDocuments()).hasSize(1);
assertThat(accountingDocuments.get(0).getAmount()).isEqualTo(AMOUNT);
assertThat(accountingDocuments.get(0).getInvoiceId()).isEqualTo(Long.valueOf(INVOICE_ID));
assertThat(accountingDocuments.get(0).getCurrencyIsoCode()).isEqualTo(MiraklIsoCurrencyCode.EUR);
assertThat(accountingDocuments.get(0).getTransactionDate()).isEqualTo(DateUtil.convertToDate(CREATED_ON,
HyperWalletConstants.HYPERWALLET_DATE_FORMAT, TimeZone.getTimeZone("UTC")));
}
@Test
void isApplicable_shouldReturnFalse_whenPaymentNotificationBodyModelIsNull() {
final boolean result = testObj.isApplicable(null);
assertThat(result).isFalse();
}
@Test
void isApplicable_shouldReturnTrue_whenPaymentNotificationBodyModelIsAcceptedAndIsNotOperatorFee() {
when(paymentNotificationConfigMock.getAcceptedStatuses()).thenReturn(Set.of(COMPLETED));
when(paymentNotificationBodyModelMock.getStatus()).thenReturn(COMPLETED);
when(paymentNotificationBodyModelMock.getClientPaymentId()).thenReturn("290320");
final boolean result = testObj.isApplicable(paymentNotificationBodyModelMock);
assertThat(result).isTrue();
}
@Test
void isApplicable_shouldReturnFalse_whenPaymentNotificationBodyModelIsAcceptedAndIsOperatorFee() {
when(paymentNotificationConfigMock.getAcceptedStatuses()).thenReturn(Set.of(COMPLETED));
when(paymentNotificationBodyModelMock.getStatus()).thenReturn(COMPLETED);
when(paymentNotificationBodyModelMock.getClientPaymentId()).thenReturn("290320-operatorFee");
final boolean result = testObj.isApplicable(paymentNotificationBodyModelMock);
assertThat(result).isFalse();
}
@Test
void isApplicable_shouldReturnFalse_whenPaymentNotificationBodyModelIsNotAccepted() {
when(paymentNotificationConfigMock.getAcceptedStatuses()).thenReturn(Set.of(COMPLETED));
when(paymentNotificationBodyModelMock.getStatus()).thenReturn(NOT_COMPLETED);
final boolean result = testObj.isApplicable(paymentNotificationBodyModelMock);
assertThat(result).isFalse();
}
}
| 5,133 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications/services/FailurePaymentNotificationStrategyTest.java | package com.paypal.invoices.paymentnotifications.services;
import com.hyperwallet.clientsdk.Hyperwallet;
import com.hyperwallet.clientsdk.HyperwalletException;
import com.hyperwallet.clientsdk.model.HyperwalletUser;
import com.paypal.infrastructure.hyperwallet.services.UserHyperwalletSDKService;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.invoices.paymentnotifications.configuration.PaymentNotificationConfig;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class FailurePaymentNotificationStrategyTest {
private static final String FAILED = "FAILED";
private static final String NOT_FAILED = "NOT_FAILED";
@InjectMocks
private FailurePaymentNotificationStrategy testObj;
@Mock
private PaymentNotificationBodyModel paymentNotificationBodyModelMock;
@Mock
private PaymentNotificationConfig paymentNotificationConfigMock;
@Mock
private MailNotificationUtil mailNotificationUtilMock;
@Mock
private UserHyperwalletSDKService userHyperwalletSDKServiceMock;
@Mock
private Hyperwallet hyperwalletMock;
@Mock
private HyperwalletUser hyperwalletUserMock;
@Test
void executeProcessPaymentNotification_shouldSendEmailNotification_WhenPaymentNotificationIsInAFailureStatus_AndThereIsBusinessShopInfo() {
when(paymentNotificationBodyModelMock.getStatus()).thenReturn("FAILED");
when(paymentNotificationBodyModelMock.getClientPaymentId()).thenReturn("ClientPaymentID");
when(paymentNotificationBodyModelMock.getProgramToken()).thenReturn("programToken");
when(paymentNotificationBodyModelMock.getDestinationToken()).thenReturn("destinationToken");
when(userHyperwalletSDKServiceMock.getHyperwalletInstanceByProgramToken("programToken"))
.thenReturn(hyperwalletMock);
when(hyperwalletMock.getUser("destinationToken")).thenReturn(hyperwalletUserMock);
when(hyperwalletUserMock.getBusinessName()).thenReturn("BUSINESS_SHOP");
when(hyperwalletUserMock.getClientUserId()).thenReturn("ClientUserId");
testObj.execute(paymentNotificationBodyModelMock);
verify(mailNotificationUtilMock).sendPlainTextEmail(
"Problem while processing payment [ClientPaymentID] of shop BUSINESS_SHOP with id [ClientUserId]",
"A problem has been detected while processing the payment corresponding to the invoice [ClientPaymentID] of the shop BUSINESS_SHOP with id [ClientUserId].\n"
+ "The status received for the payment is [FAILED].\n"
+ "For more information please consult your Hyperwallet dashboard.");
}
@Test
void executeProcessPaymentNotification_shouldSendEmailNotification_WhenPaymentNotificationIsInAFailureStatus_AndThereIsIndividualShopInfo() {
when(paymentNotificationBodyModelMock.getStatus()).thenReturn("FAILED");
when(paymentNotificationBodyModelMock.getClientPaymentId()).thenReturn("ClientPaymentID");
when(paymentNotificationBodyModelMock.getProgramToken()).thenReturn("programToken");
when(paymentNotificationBodyModelMock.getDestinationToken()).thenReturn("destinationToken");
when(userHyperwalletSDKServiceMock.getHyperwalletInstanceByProgramToken("programToken"))
.thenReturn(hyperwalletMock);
when(hyperwalletMock.getUser("destinationToken")).thenReturn(hyperwalletUserMock);
when(hyperwalletUserMock.getFirstName()).thenReturn("First");
when(hyperwalletUserMock.getLastName()).thenReturn("Last");
when(hyperwalletUserMock.getClientUserId()).thenReturn("ClientUserId");
testObj.execute(paymentNotificationBodyModelMock);
verify(mailNotificationUtilMock).sendPlainTextEmail(
"Problem while processing payment [ClientPaymentID] of shop First Last with id [ClientUserId]",
"A problem has been detected while processing the payment corresponding to the invoice [ClientPaymentID] of the shop First Last with id [ClientUserId].\n"
+ "The status received for the payment is [FAILED].\n"
+ "For more information please consult your Hyperwallet dashboard.");
}
@Test
void executeProcessPaymentNotification_shouldSendEmailNotification_WhenPaymentNotificationIsInAFailureStatus_AndThereIsNoShopInfo() {
when(paymentNotificationBodyModelMock.getStatus()).thenReturn("FAILED");
when(paymentNotificationBodyModelMock.getClientPaymentId()).thenReturn("ClientPaymentID");
when(paymentNotificationBodyModelMock.getProgramToken()).thenReturn("programToken");
when(paymentNotificationBodyModelMock.getDestinationToken()).thenReturn("destinationToken");
when(userHyperwalletSDKServiceMock.getHyperwalletInstanceByProgramToken("programToken"))
.thenReturn(hyperwalletMock);
when(hyperwalletMock.getUser("destinationToken")).thenThrow(HyperwalletException.class);
testObj.execute(paymentNotificationBodyModelMock);
verify(mailNotificationUtilMock).sendPlainTextEmail("Problem while processing payment [ClientPaymentID]",
"A problem has been detected while processing the payment corresponding to the invoice [ClientPaymentID].\n"
+ "The status received for the payment is [FAILED].\n"
+ "For more information please consult your Hyperwallet dashboard.");
}
@Test
void isApplicable_shouldReturnTrue_whenPaymentNotificationBodyModelHasFailed() {
when(paymentNotificationConfigMock.getFailureStatuses()).thenReturn(Set.of(FAILED));
when(paymentNotificationBodyModelMock.getStatus()).thenReturn(FAILED);
final boolean result = testObj.isApplicable(paymentNotificationBodyModelMock);
assertThat(result).isTrue();
}
@Test
void isApplicable_shouldReturnFalse_whenPaymentNotificationBodyModelHasNotFailed() {
when(paymentNotificationConfigMock.getFailureStatuses()).thenReturn(Set.of(FAILED));
when(paymentNotificationBodyModelMock.getStatus()).thenReturn(NOT_FAILED);
final boolean result = testObj.isApplicable(paymentNotificationBodyModelMock);
assertThat(result).isFalse();
}
@Test
void isApplicable_shouldReturnFalse_whenPaymentNotificationBodyModelIsNull() {
final boolean result = testObj.isApplicable(null);
assertThat(result).isFalse();
}
}
| 5,134 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications/services/EmptyPaymentNotificationStrategyTest.java | package com.paypal.invoices.paymentnotifications.services;
import com.callibrity.logging.test.LogTracker;
import com.callibrity.logging.test.LogTrackerStub;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class EmptyPaymentNotificationStrategyTest {
final LogTrackerStub logTrackerStub = LogTrackerStub.create().recordForLevel(LogTracker.LogLevel.WARN)
.recordForType(EmptyPaymentNotificationStrategy.class);
@InjectMocks
private EmptyPaymentNotificationStrategy testObj;
@Mock
private PaymentNotificationBodyModel paymentNotificationBodyModelMock;
@Test
void execute() {
logTrackerStub.recordForLevel(LogTracker.LogLevel.WARN);
final Void result = testObj.execute(null);
assertThat(logTrackerStub.contains("Payment notification received with a null object.")).isTrue();
assertThat(result).isNull();
}
@Test
void isApplicable_shouldReturnTrue_whenPaymentNotificationBodyModelIsNull() {
final boolean result = testObj.isApplicable(null);
assertThat(result).isTrue();
}
@Test
void isApplicable_shouldReturnFalse_whenPaymentNotificationBodyModelIsNotNull() {
final boolean result = testObj.isApplicable(paymentNotificationBodyModelMock);
assertThat(result).isFalse();
}
}
| 5,135 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications/services/PaymentNotificationServiceImplTest.java | package com.paypal.invoices.paymentnotifications.services;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PaymentNotificationServiceImplTest {
@InjectMocks
private PaymentNotificationServiceImpl testObj;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotificationMock;
@Mock
private PaymentNotificationBodyModel paymentNotificationBodyModelMock;
@Mock
private Converter<Object, PaymentNotificationBodyModel> paymentNotificationBodyModelConverterMock;
@Mock
private PaymentNotificationExecutor paymentNotificationExecutorMock;
@Test
void processPaymentNotification_shouldNotSendAnyEmailWhenPaymentNotificationIsNull() {
when(paymentNotificationBodyModelConverterMock.convert(hyperwalletWebhookNotificationMock.getObject()))
.thenReturn(paymentNotificationBodyModelMock);
testObj.processPaymentNotification(hyperwalletWebhookNotificationMock);
verify(paymentNotificationExecutorMock).execute(paymentNotificationBodyModelMock);
}
}
| 5,136 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications/services | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/paymentnotifications/services/converters/HyperWalletObjectToPaymentNotificationBodyModelConverterTest.java | package com.paypal.invoices.paymentnotifications.services.converters;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.infrastructure.support.date.TimeMachine;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import org.json.JSONException;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.junit.jupiter.MockitoExtension;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;
import java.util.LinkedHashMap;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class HyperWalletObjectToPaymentNotificationBodyModelConverterTest {
@InjectMocks
private HyperWalletObjectToPaymentNotificationBodyModelConverter testObj;
private static final String TOKEN = "Token";
private static final String PROGRAM_TOKEN = "ProgramToken";
private static final String STATUS = "Status";
private static final String AMOUNT = "Amount";
private static final String CURRENCY = "Currency";
private static final String CLIENT_PAYMENT_ID = "ClientPaymentId";
private static final String NOTES = "Notes";
private static final String PURPOSE = "Purpose";
private static final String RELEASE_ON = "ReleaseOn";
private static final String EXPIRES_ON = "ExpiresOn";
private static final String DESTINATION_TOKEN = "DestinationToken";
@Test
void convert_shouldTransformHyperWalletWebhookNotificationToInvoiceNotificationModel_whenDetailsIsJSonObject()
throws JSONException {
TimeMachine.useFixedClockAt(LocalDateTime.now());
final LocalDateTime now = TimeMachine.now();
final Date nowAsDate = DateUtil.convertToDate(now, ZoneId.systemDefault());
final LinkedHashMap<String, String> hyperwalletPaymentBodyNotification = createHyperWalletPaymentBodyNotification(
nowAsDate);
final PaymentNotificationBodyModel result = testObj.convert(hyperwalletPaymentBodyNotification);
//@formatter:off
assertThat(result).hasFieldOrPropertyWithValue("token", TOKEN)
.hasFieldOrPropertyWithValue("programToken", PROGRAM_TOKEN)
.hasFieldOrPropertyWithValue("status", STATUS)
.hasFieldOrPropertyWithValue("createdOn", nowAsDate.toString())
.hasFieldOrPropertyWithValue("amount", AMOUNT)
.hasFieldOrPropertyWithValue("currency", CURRENCY)
.hasFieldOrPropertyWithValue("clientPaymentId", CLIENT_PAYMENT_ID)
.hasFieldOrPropertyWithValue("notes", NOTES)
.hasFieldOrPropertyWithValue("purpose", PURPOSE)
.hasFieldOrPropertyWithValue("releaseOn", RELEASE_ON)
.hasFieldOrPropertyWithValue("expiresOn", EXPIRES_ON)
.hasFieldOrPropertyWithValue("destinationToken", DESTINATION_TOKEN);
//@formatter:on
}
@Test
void convert_shouldTransformHyperWalletWebhookNotificationToInvoiceNotificationModel_whenDetailsIsAnIncompleteJSonObject()
throws JSONException {
TimeMachine.useFixedClockAt(LocalDateTime.now());
final LocalDateTime now = TimeMachine.now();
final Date nowAsDate = DateUtil.convertToDate(now, ZoneId.systemDefault());
final LinkedHashMap<String, String> hyperwalletPaymentIncompleteNotification = createIncompleteJsonObject(
nowAsDate);
final PaymentNotificationBodyModel result = testObj.convert(hyperwalletPaymentIncompleteNotification);
//@formatter:off
assertThat(result).hasFieldOrPropertyWithValue("status", STATUS)
.hasFieldOrPropertyWithValue("createdOn", nowAsDate.toString())
.hasFieldOrPropertyWithValue("amount", AMOUNT)
.hasFieldOrPropertyWithValue("clientPaymentId", CLIENT_PAYMENT_ID)
.hasFieldOrPropertyWithValue("notes", NOTES)
.hasFieldOrPropertyWithValue("purpose", PURPOSE)
.hasFieldOrPropertyWithValue("releaseOn", RELEASE_ON)
.hasFieldOrPropertyWithValue("expiresOn", EXPIRES_ON);
//@formatter:on
}
@Test
void convert_shouldTransformHyperWalletWebhookNotificationToInvoiceNotificationModel_whenObjectIsNotJSonObject()
throws JSONException {
final PaymentNotificationBodyModel result = testObj.convert(new Object());
assertThat(result).isNull();
}
private LinkedHashMap<String, String> createIncompleteJsonObject(final Date nowAsDate) {
final LinkedHashMap<String, String> detailInfo = new LinkedHashMap<>();
detailInfo.put("status", STATUS);
detailInfo.put("createdOn", nowAsDate.toString());
detailInfo.put("amount", AMOUNT);
detailInfo.put("clientPaymentId", CLIENT_PAYMENT_ID);
detailInfo.put("notes", NOTES);
detailInfo.put("releaseOn", RELEASE_ON);
detailInfo.put("expiresOn", EXPIRES_ON);
detailInfo.put("purpose", PURPOSE);
return detailInfo;
}
private LinkedHashMap<String, String> createHyperWalletPaymentBodyNotification(final Date nowAsDate) {
final LinkedHashMap<String, String> detailInfo = new LinkedHashMap<>();
detailInfo.put("token", TOKEN);
detailInfo.put("programToken", PROGRAM_TOKEN);
detailInfo.put("status", STATUS);
detailInfo.put("createdOn", nowAsDate.toString());
detailInfo.put("amount", AMOUNT);
detailInfo.put("currency", CURRENCY);
detailInfo.put("clientPaymentId", CLIENT_PAYMENT_ID);
detailInfo.put("notes", NOTES);
detailInfo.put("releaseOn", RELEASE_ON);
detailInfo.put("expiresOn", EXPIRES_ON);
detailInfo.put("destinationToken", DESTINATION_TOKEN);
detailInfo.put("purpose", PURPOSE);
return detailInfo;
}
}
| 5,137 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/CreditNotesExtractJobConfigTest.java | package com.paypal.invoices.extractioncreditnotes;
import com.paypal.invoices.extractioncreditnotes.CreditNotesExtractJobConfig;
import com.paypal.jobsystem.quartzadapter.job.QuartzBatchJobBean;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesRetryBatchJob;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.quartz.TriggerKey;
import org.quartz.impl.triggers.CronTriggerImpl;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class CreditNotesExtractJobConfigTest {
@InjectMocks
private CreditNotesExtractJobConfig testObj;
private static final String RETRY_CRON_EXPRESSION = "0 0/15 * ? * * *";
private static final String TRIGGER_PREFIX = "Trigger";
private static final String RETRY_JOB_NAME = "CreditNotesRetryJob";
@Mock
private CreditNotesRetryBatchJob creditNotesRetryBatchJob;
@Test
void creditNotesRetryJob_createsJobDetailWithNameCreditNotesRetryJobAndCreditNotesRetryBatchJob() {
final JobDetail result = testObj.creditNotesRetryJob(creditNotesRetryBatchJob);
assertThat(result.getJobClass()).hasSameClassAs(QuartzBatchJobBean.class);
assertThat(result.getKey().getName()).isEqualTo(RETRY_JOB_NAME);
assertThat(result.getJobDataMap()).containsEntry("batchJob", creditNotesRetryBatchJob);
}
@Test
void bankAccountRetryJobTrigger_shouldReturnATriggerCreatedWithTheCronExpressionPassedAsArgumentAndJob() {
final JobDetail jobDetail = testObj.creditNotesRetryJob(creditNotesRetryBatchJob);
final Trigger result = testObj.creditNotesRetryTrigger(jobDetail, RETRY_CRON_EXPRESSION);
assertThat(result.getJobKey()).isEqualTo(jobDetail.getKey());
assertThat(result.getKey()).isEqualTo(TriggerKey.triggerKey(TRIGGER_PREFIX + RETRY_JOB_NAME));
assertThat(result).isInstanceOf(CronTriggerImpl.class);
assertThat(((CronTriggerImpl) result).getCronExpression()).isEqualTo(RETRY_CRON_EXPRESSION);
}
}
| 5,138 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/batchjobs/CreditNotesRetryBatchJobItemsExtractorTest.java | package com.paypal.invoices.extractioncreditnotes.batchjobs;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNoteExtractJobItem;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesRetryBatchJobItemsExtractor;
import com.paypal.jobsystem.batchjob.model.BatchJobItem;
import com.paypal.jobsystem.batchjobfailures.services.resolvepolicies.AllRetryPendingFailedItemCacheFailureResolvePolicy;
import com.paypal.invoices.extractioncreditnotes.model.CreditNoteModel;
import com.paypal.invoices.extractioncommons.services.MiraklAccountingDocumentExtractService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class CreditNotesRetryBatchJobItemsExtractorTest {
private static final String CREDIT_NOTE_ID_1 = "1";
private static final String CREDIT_NOTE_ID_2 = "2";
@InjectMocks
private CreditNotesRetryBatchJobItemsExtractor testObj;
@Mock
private MiraklAccountingDocumentExtractService<CreditNoteModel> miraklAccountingDocumentCreditNotesExtractServiceMock;
@Mock
private AllRetryPendingFailedItemCacheFailureResolvePolicy allRetryPendingFailedItemCacheFailureResolvePolicyMock;
@Mock
private CreditNoteModel creditNoteModel1Mock, creditNoteModel2Mock;
@Test
void getItem_shouldReturnCreditNotesType() {
final String result = testObj.getItemType();
assertThat(result).isEqualTo(CreditNoteExtractJobItem.ITEM_TYPE);
}
@Test
void getBatchJobFailedItemCacheFailureResolvePolicy_shouldReturnRetryAllPendingItemsPolicy() {
assertThat(testObj.getBatchJobFailedItemCacheFailureResolvePolicy())
.contains(allRetryPendingFailedItemCacheFailureResolvePolicyMock);
}
@Test
void getItems_shouldReturnAllInvoicesByGivenIds() {
when(miraklAccountingDocumentCreditNotesExtractServiceMock
.extractAccountingDocuments(List.of(CREDIT_NOTE_ID_1, CREDIT_NOTE_ID_2)))
.thenReturn(List.of(creditNoteModel1Mock, creditNoteModel2Mock));
when(creditNoteModel1Mock.getInvoiceNumber()).thenReturn("1");
when(creditNoteModel2Mock.getInvoiceNumber()).thenReturn("2");
final Collection<CreditNoteExtractJobItem> result = testObj
.getItems(List.of(CREDIT_NOTE_ID_1, CREDIT_NOTE_ID_2));
assertThat(result.stream().map(BatchJobItem::getItemId).collect(Collectors.toList()))
.containsExactlyInAnyOrder(CREDIT_NOTE_ID_1, CREDIT_NOTE_ID_2);
}
}
| 5,139 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/batchjobs/CreditNoteExtractJobItemTest.java | package com.paypal.invoices.extractioncreditnotes.batchjobs;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNoteExtractJobItem;
import com.paypal.invoices.extractioncreditnotes.model.CreditNoteModel;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class CreditNoteExtractJobItemTest {
private static final String INVOICE_NUMBER = "001";
private static final String INVOICE_NUMBER_2 = "002";
private static final String ITEM_TYPE = "CreditNote";
@Test
void getItemId_ShouldReturnInvoiceNumber() {
final CreditNoteModel creditNoteModel = CreditNoteModel.builder().invoiceNumber(INVOICE_NUMBER).build();
final CreditNoteExtractJobItem testObj = new CreditNoteExtractJobItem(creditNoteModel);
assertThat(testObj.getItemId()).isEqualTo(INVOICE_NUMBER);
}
@Test
void getItemType_ShouldReturnCreditNote() {
final CreditNoteModel creditNoteModel = CreditNoteModel.builder().invoiceNumber(INVOICE_NUMBER).build();
final CreditNoteExtractJobItem testObj = new CreditNoteExtractJobItem(creditNoteModel);
assertThat(testObj.getItemType()).isEqualTo(ITEM_TYPE);
}
@Test
void from_ShouldReturnANewJobItemWithTheItemProvided() {
final CreditNoteModel creditNoteModel = CreditNoteModel.builder().invoiceNumber(INVOICE_NUMBER).build();
final CreditNoteModel creditNoteModel2 = CreditNoteModel.builder().invoiceNumber(INVOICE_NUMBER_2).build();
final CreditNoteExtractJobItem testObj = new CreditNoteExtractJobItem(creditNoteModel);
final CreditNoteExtractJobItem result = testObj.from(creditNoteModel2);
assertThat(result).isNotEqualTo(testObj);
assertThat(result.getItem().getInvoiceNumber()).isEqualTo(INVOICE_NUMBER_2);
}
}
| 5,140 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/batchjobs/CreditNotesExtractBatchJobItemProcessorTest.java | package com.paypal.invoices.extractioncreditnotes.batchjobs;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNoteExtractJobItem;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesExtractBatchJobItemProcessor;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.invoices.extractioncreditnotes.model.CreditNoteModel;
import com.paypal.invoices.extractioncommons.services.HyperWalletPaymentExtractService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
class CreditNotesExtractBatchJobItemProcessorTest {
@InjectMocks
private CreditNotesExtractBatchJobItemProcessor testObj;
@Mock
private HyperWalletPaymentExtractService hyperWalletPaymentExtractServiceMock;
@Mock
private BatchJobContext batchJobContextMock;
@Test
void processItem_ShouldPayPayeeCreditNote() {
final CreditNoteModel creditNoteModel = CreditNoteModel.builder().build();
final CreditNoteExtractJobItem creditNoteExtractJobItem = new CreditNoteExtractJobItem(creditNoteModel);
testObj.processItem(batchJobContextMock, creditNoteExtractJobItem);
verify(hyperWalletPaymentExtractServiceMock).payPayeeCreditNotes(creditNoteModel);
}
}
| 5,141 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/batchjobs/CreditNotesExtractBatchJobItemsExtractorTest.java | package com.paypal.invoices.extractioncreditnotes.batchjobs;
import com.paypal.invoices.extractioncommons.services.MiraklAccountingDocumentExtractService;
import com.paypal.invoices.extractioncreditnotes.model.CreditNoteModel;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class CreditNotesExtractBatchJobItemsExtractorTest {
private static final Date DELTA = new Date();
@InjectMocks
private CreditNotesExtractBatchJobItemsExtractor testObj;
@Mock
private MiraklAccountingDocumentExtractService<CreditNoteModel> miraklAccountingDocumentCreditNotesExtractServiceMock;
@Mock
private CreditNoteModel creditNoteModelMock1, creditNoteModelMock2;
@Mock
private BatchJobContext batchJobContextMock;
@Test
void getItems_ShouldReturnACollectionOfCreditNoteExtractJobItemForTheGivenDelta() {
when(miraklAccountingDocumentCreditNotesExtractServiceMock.extractAccountingDocuments(DELTA, false))
.thenReturn(List.of(creditNoteModelMock1, creditNoteModelMock2));
final Collection<CreditNoteExtractJobItem> result = testObj.getItems(batchJobContextMock, DELTA, false);
assertThat(result.stream().map(CreditNoteExtractJobItem::getItem))
.containsExactlyInAnyOrder(creditNoteModelMock1, creditNoteModelMock2);
}
}
| 5,142 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/batchjobs/CreditNotesRetryBatchJobTest.java | package com.paypal.invoices.extractioncreditnotes.batchjobs;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesExtractBatchJobItemProcessor;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesRetryBatchJob;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesRetryBatchJobItemsExtractor;
import com.paypal.jobsystem.batchjob.model.BatchJobType;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class CreditNotesRetryBatchJobTest {
@InjectMocks
private CreditNotesRetryBatchJob testObj;
@Mock
private CreditNotesExtractBatchJobItemProcessor creditNotesExtractBatchJobItemProcessorMock;
@Mock
private CreditNotesRetryBatchJobItemsExtractor creditNotesRetryBatchJobItemsExtractorMock;
@Test
void getBatchJobItemProcessor_shouldReturnBatchJobItemProcessor() {
assertThat(testObj.getBatchJobItemProcessor()).isEqualTo(creditNotesExtractBatchJobItemProcessorMock);
}
@Test
void getBatchJobItemsExtractor_shouldReturnRetryBatchJobItemExtractor() {
assertThat(testObj.getBatchJobItemsExtractor()).isEqualTo(creditNotesRetryBatchJobItemsExtractorMock);
}
@Test
void getBatchJobType_shouldReturnRetryType() {
assertThat(testObj.getType()).isEqualTo(BatchJobType.RETRY);
}
}
| 5,143 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/batchjobs/CreditNotesExtractBatchJobTest.java | package com.paypal.invoices.extractioncreditnotes.batchjobs;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNoteExtractJobItem;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesExtractBatchJob;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesExtractBatchJobItemProcessor;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesExtractBatchJobItemsExtractor;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.jobsystem.batchjob.model.BatchJobType;
import com.paypal.jobsystem.batchjobsupport.model.BatchJobItemProcessor;
import com.paypal.jobsystem.batchjobsupport.model.BatchJobItemsExtractor;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class CreditNotesExtractBatchJobTest {
@InjectMocks
private CreditNotesExtractBatchJob testObj;
@Mock
private CreditNotesExtractBatchJobItemsExtractor creditNotesExtractBatchJobItemsExtractorMock;
@Mock
private CreditNotesExtractBatchJobItemProcessor creditNotesExtractBatchJobItemProcessorMock;
@Test
void getBatchJobItemsExtractor_ShouldReturnCreditNotesExtractBatchJobItemsExtractor() {
final BatchJobItemsExtractor<BatchJobContext, CreditNoteExtractJobItem> result = testObj
.getBatchJobItemsExtractor();
assertThat(result).isEqualTo(creditNotesExtractBatchJobItemsExtractorMock);
}
@Test
void getBatchJobItemProcessor_ShouldReturnCreditNotesExtractBatchJobItemProcessor() {
final BatchJobItemProcessor<BatchJobContext, CreditNoteExtractJobItem> result = testObj
.getBatchJobItemProcessor();
assertThat(result).isEqualTo(creditNotesExtractBatchJobItemProcessorMock);
}
@Test
void getBatchJobType_shouldReturnExtractType() {
assertThat(testObj.getType()).isEqualTo(BatchJobType.EXTRACT);
}
}
| 5,144 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/services/MiraklCreditNotesExtractServiceImplTest.java | package com.paypal.invoices.extractioncreditnotes.services;
import com.mirakl.client.mmp.domain.invoice.MiraklInvoice;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.invoices.extractioncreditnotes.model.CreditNoteModel;
import com.paypal.invoices.extractioncommons.model.InvoiceTypeEnum;
import com.paypal.invoices.extractioncreditnotes.services.MiraklCreditNotesExtractServiceImpl;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class MiraklCreditNotesExtractServiceImplTest {
@InjectMocks
private MiraklCreditNotesExtractServiceImpl testObj;
@Mock
private Converter<MiraklInvoice, CreditNoteModel> miraklInvoiceToCreditNoteModelConverterMock;
@Test
void shouldReturnCreditNoteType() {
assertThat(testObj.getInvoiceType()).isEqualTo(InvoiceTypeEnum.MANUAL_CREDIT);
}
@Test
void shouldReturnCreditNoteConverter() {
assertThat(testObj.getMiraklInvoiceToAccountingModelConverter())
.isEqualTo(miraklInvoiceToCreditNoteModelConverterMock);
}
}
| 5,145 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/services | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/services/converters/MiraklInvoiceToCreditNoteModelConverterTest.java | package com.paypal.invoices.extractioncreditnotes.services.converters;
import com.mirakl.client.mmp.domain.common.currency.MiraklIsoCurrencyCode;
import com.mirakl.client.mmp.domain.invoice.MiraklInvoice;
import com.paypal.invoices.extractioncreditnotes.services.converters.MiraklInvoiceToCreditNoteModelConverter;
import com.paypal.invoices.extractioncreditnotes.model.CreditNoteModel;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.junit.jupiter.MockitoExtension;
import java.math.BigDecimal;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class MiraklInvoiceToCreditNoteModelConverterTest {
@InjectMocks
private MiraklInvoiceToCreditNoteModelConverter testObj;
@Test
void convert_shouldConvertFromMiraklInvoiceToCreditNoteModel() {
final MiraklInvoice miraklInvoiceStub = new MiraklInvoice();
miraklInvoiceStub.setId("2000050");
miraklInvoiceStub.setShopId(2000L);
miraklInvoiceStub.setTotalChargedAmount(BigDecimal.valueOf(20.00D));
miraklInvoiceStub.setCurrencyIsoCode(MiraklIsoCurrencyCode.EUR);
final CreditNoteModel result = testObj.convert(miraklInvoiceStub);
assertThat(result.getInvoiceNumber()).isEqualTo("2000050");
assertThat(result.getShopId()).isEqualTo("2000");
assertThat(result.getCreditAmount()).isEqualTo(20.00D);
assertThat(result.getCurrencyIsoCode()).isEqualTo("EUR");
}
}
| 5,146 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/services | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioncreditnotes/services/converters/PayeeCreditNoteModelToHyperwalletPaymentConverterTest.java | package com.paypal.invoices.extractioncreditnotes.services.converters;
import com.hyperwallet.clientsdk.model.HyperwalletPayment;
import com.paypal.invoices.extractioncreditnotes.model.CreditNoteModel;
import com.paypal.infrastructure.hyperwallet.services.PaymentHyperwalletSDKService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PayeeCreditNoteModelToHyperwalletPaymentConverterTest {
@InjectMocks
private PayeeCreditNoteModelToHyperwalletPaymentConverter testObj;
@Mock
private PaymentHyperwalletSDKService paymentHyperwalletSDKServiceMock;
@Test
void convert_populatesHyperwalletPaymentWithCreditNotesInformationAndPurposeOther() {
when(paymentHyperwalletSDKServiceMock.getProgramTokenByHyperwalletProgram("myProgramToken"))
.thenReturn("the-real-token");
final CreditNoteModel creditNoteModelStub = CreditNoteModel.builder().destinationToken("destination-token")
.creditAmount(20.00D).currencyIsoCode("EUR").hyperwalletProgram("myProgramToken")
.invoiceNumber("invoiceNumber").build();
final HyperwalletPayment result = testObj.convert(creditNoteModelStub);
assertThat(result.getAmount()).isEqualTo(20.00D);
assertThat(result.getCurrency()).isEqualTo("EUR");
assertThat(result.getProgramToken()).isEqualTo("the-real-token");
assertThat(result.getDestinationToken()).isEqualTo("destination-token");
assertThat(result.getClientPaymentId()).isEqualTo("invoiceNumber");
assertThat(result.getPurpose()).isEqualTo("OTHER");
}
}
| 5,147 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/InvoicesExtractJobConfigTest.java | package com.paypal.invoices.extractioninvoices;
import com.paypal.invoices.extractioninvoices.InvoicesExtractJobConfig;
import com.paypal.jobsystem.quartzadapter.job.QuartzBatchJobBean;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesRetryBatchJob;
import com.paypal.invoices.extractioncommons.jobs.InvoicesExtractJob;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.quartz.TriggerKey;
import org.quartz.impl.triggers.CronTriggerImpl;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class InvoicesExtractJobConfigTest {
private static final String TRIGGER_PREFIX = "Trigger";
private static final String JOB_NAME = "InvoicesExtractJob";
private static final String RETRY_JOB_NAME = "InvoicesRetryJob";
private static final String CRON_EXPRESSION = "0 0 0 1/1 * ? *";
private static final String RETRY_CRON_EXPRESSION = "0 0/15 * ? * * *";
@InjectMocks
private InvoicesExtractJobConfig testObj;
@Mock
private InvoicesRetryBatchJob invoicesRetryBatchJob;
@Test
void invoicesExtractJob_createsJobDetailWithNameInvoicesJobAndTypeInvoicesExtractJob() {
final JobDetail result = testObj.invoicesExtractJob();
assertThat(result.getJobClass()).hasSameClassAs(InvoicesExtractJobConfig.class);
assertThat(result.getKey().getName()).isEqualTo("InvoicesExtractJob");
}
@Test
void invoicesTrigger_shouldReturnATriggerCreatedWithTheCronExpressionPassedAsArgumentAndJob() {
final JobDetail jobDetail = JobBuilder.newJob(InvoicesExtractJob.class).withIdentity(JOB_NAME).build();
final Trigger result = testObj.invoicesExtractTrigger(jobDetail, CRON_EXPRESSION);
assertThat(result.getJobKey()).isEqualTo(jobDetail.getKey());
assertThat(result.getKey()).isEqualTo(TriggerKey.triggerKey(TRIGGER_PREFIX + JOB_NAME));
assertThat(result).isInstanceOf(CronTriggerImpl.class);
assertThat(((CronTriggerImpl) result).getCronExpression()).isEqualTo(CRON_EXPRESSION);
}
@Test
void invoicesRetryJob_createsJobDetailWithNameInvoicesRetryJobAndInvoicesRetryBatchJob() {
final JobDetail result = testObj.invoicesRetryJob(invoicesRetryBatchJob);
assertThat(result.getJobClass()).hasSameClassAs(QuartzBatchJobBean.class);
assertThat(result.getKey().getName()).isEqualTo(RETRY_JOB_NAME);
assertThat(result.getJobDataMap()).containsEntry("batchJob", invoicesRetryBatchJob);
}
@Test
void invoicesRetryJobTrigger_shouldReturnATriggerCreatedWithTheCronExpressionPassedAsArgumentAndJob() {
final JobDetail jobDetail = testObj.invoicesRetryJob(invoicesRetryBatchJob);
final Trigger result = testObj.invoicesRetryTrigger(jobDetail, RETRY_CRON_EXPRESSION);
assertThat(result.getJobKey()).isEqualTo(jobDetail.getKey());
assertThat(result.getKey()).isEqualTo(TriggerKey.triggerKey(TRIGGER_PREFIX + RETRY_JOB_NAME));
assertThat(result).isInstanceOf(CronTriggerImpl.class);
assertThat(((CronTriggerImpl) result).getCronExpression()).isEqualTo(RETRY_CRON_EXPRESSION);
}
}
| 5,148 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/batchjobs/InvoicesRetryBatchJobItemsExtractorTest.java | package com.paypal.invoices.extractioninvoices.batchjobs;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoiceExtractJobItem;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesRetryBatchJobItemsExtractor;
import com.paypal.jobsystem.batchjob.model.BatchJobItem;
import com.paypal.jobsystem.batchjobfailures.services.resolvepolicies.AllRetryPendingFailedItemCacheFailureResolvePolicy;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.invoices.extractioncommons.services.MiraklAccountingDocumentExtractService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class InvoicesRetryBatchJobItemsExtractorTest {
private static final String INVOICE_ID_1 = "1";
private static final String INVOICE_ID_2 = "2";
@InjectMocks
private InvoicesRetryBatchJobItemsExtractor testObj;
@Mock
private MiraklAccountingDocumentExtractService<InvoiceModel> miraklAccountingDocumentInvoicesExtractService;
@Mock
private AllRetryPendingFailedItemCacheFailureResolvePolicy allRetryPendingFailedItemCacheFailureResolvePolicyMock;
@Mock
private InvoiceModel invoiceModel1Mock, invoiceModel2Mock;
@Test
void getItem_shouldReturnInvoiceType() {
final String result = testObj.getItemType();
assertThat(result).isEqualTo(InvoiceExtractJobItem.ITEM_TYPE);
}
@Test
void getBatchJobFailedItemCacheFailureResolvePolicy_shouldReturnRetryAllPendingItemsPolicy() {
assertThat(testObj.getBatchJobFailedItemCacheFailureResolvePolicy())
.contains(allRetryPendingFailedItemCacheFailureResolvePolicyMock);
}
@Test
void getItems_shouldReturnAllInvoicesByGivenIds() {
when(miraklAccountingDocumentInvoicesExtractService
.extractAccountingDocuments(List.of(INVOICE_ID_1, INVOICE_ID_2)))
.thenReturn(List.of(invoiceModel1Mock, invoiceModel2Mock));
when(invoiceModel1Mock.getInvoiceNumber()).thenReturn("1");
when(invoiceModel2Mock.getInvoiceNumber()).thenReturn("2");
final Collection<InvoiceExtractJobItem> result = testObj.getItems(List.of(INVOICE_ID_1, INVOICE_ID_2));
assertThat(result.stream().map(BatchJobItem::getItemId).collect(Collectors.toList()))
.containsExactlyInAnyOrder(INVOICE_ID_1, INVOICE_ID_2);
}
}
| 5,149 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/batchjobs/InvoicesRetryBatchJobTest.java | package com.paypal.invoices.extractioninvoices.batchjobs;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesExtractBatchJobItemProcessor;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesRetryBatchJob;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesRetryBatchJobItemsExtractor;
import com.paypal.jobsystem.batchjob.model.BatchJobType;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.InjectMocks;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class InvoicesRetryBatchJobTest {
@InjectMocks
private InvoicesRetryBatchJob testObj;
@Mock
private InvoicesRetryBatchJobItemsExtractor invoicesRetryBatchJobItemsExtractorMock;
@Mock
private InvoicesExtractBatchJobItemProcessor invoicesExtractBatchJobItemProcessorMock;
@Test
void getBatchJobItemProcessor_shouldReturnBatchJobItemProcessor() {
assertThat(testObj.getBatchJobItemProcessor()).isEqualTo(invoicesExtractBatchJobItemProcessorMock);
}
@Test
void getBatchJobItemsExtractor_shouldReturnRetryBatchJobItemExtractor() {
assertThat(testObj.getBatchJobItemsExtractor()).isEqualTo(invoicesRetryBatchJobItemsExtractorMock);
}
@Test
void getBatchJobType_shouldReturnRetryType() {
assertThat(testObj.getType()).isEqualTo(BatchJobType.RETRY);
}
}
| 5,150 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/batchjobs/InvoiceExtractJobItemTest.java | package com.paypal.invoices.extractioninvoices.batchjobs;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoiceExtractJobItem;
import org.junit.jupiter.api.Test;
import static org.assertj.core.api.Assertions.assertThat;
class InvoiceExtractJobItemTest {
private static final String INVOICE_NUMBER = "001";
private static final String INVOICE_NUMBER_2 = "002";
private static final String ITEM_TYPE = "Invoice";
@Test
void getItemId_ShouldReturnInvoiceNumber() {
final InvoiceModel invoiceModel = InvoiceModel.builder().invoiceNumber(INVOICE_NUMBER).build();
final InvoiceExtractJobItem testObj = new InvoiceExtractJobItem(invoiceModel);
assertThat(testObj.getItemId()).isEqualTo(INVOICE_NUMBER);
}
@Test
void getItemType_ShouldReturnInvoice() {
final InvoiceModel invoiceModel = InvoiceModel.builder().invoiceNumber(INVOICE_NUMBER).build();
final InvoiceExtractJobItem testObj = new InvoiceExtractJobItem(invoiceModel);
assertThat(testObj.getItemType()).isEqualTo(ITEM_TYPE);
}
@Test
void from_ShouldReturnANewJobItemWithTheItemProvided() {
final InvoiceModel invoiceModel = InvoiceModel.builder().invoiceNumber(INVOICE_NUMBER).build();
final InvoiceModel invoiceModel2 = InvoiceModel.builder().invoiceNumber(INVOICE_NUMBER_2).build();
final InvoiceExtractJobItem testObj = new InvoiceExtractJobItem(invoiceModel);
final InvoiceExtractJobItem result = testObj.from(invoiceModel2);
assertThat(result).isNotEqualTo(testObj);
assertThat(result.getItem().getInvoiceNumber()).isEqualTo(INVOICE_NUMBER_2);
}
}
| 5,151 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/batchjobs/InvoicesExtractBatchJobTest.java | package com.paypal.invoices.extractioninvoices.batchjobs;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoiceExtractJobItem;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesExtractBatchJob;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesExtractBatchJobItemProcessor;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesExtractBatchJobItemsExtractor;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.jobsystem.batchjobsupport.model.BatchJobItemProcessor;
import com.paypal.jobsystem.batchjobsupport.model.BatchJobItemsExtractor;
import com.paypal.jobsystem.batchjob.model.BatchJobType;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class InvoicesExtractBatchJobTest {
@InjectMocks
private InvoicesExtractBatchJob testObj;
@Mock
private InvoicesExtractBatchJobItemsExtractor invoicesExtractBatchJobItemsExtractorMock;
@Mock
private InvoicesExtractBatchJobItemProcessor invoicesExtractBatchJobItemProcessorMock;
@Test
void getBatchJobItemsExtractor_ShouldReturnInvoicesExtractBatchJobItemsExtractor() {
final BatchJobItemsExtractor<BatchJobContext, InvoiceExtractJobItem> result = testObj
.getBatchJobItemsExtractor();
assertThat(result).isEqualTo(invoicesExtractBatchJobItemsExtractorMock);
}
@Test
void getBatchJobItemProcessor_ShouldReturnInvoicesExtractBatchJobItemProcessor() {
final BatchJobItemProcessor<BatchJobContext, InvoiceExtractJobItem> result = testObj.getBatchJobItemProcessor();
assertThat(result).isEqualTo(invoicesExtractBatchJobItemProcessorMock);
}
@Test
void getBatchJobType_shouldReturnExtractType() {
assertThat(testObj.getType()).isEqualTo(BatchJobType.EXTRACT);
}
}
| 5,152 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/batchjobs/InvoicesExtractBatchJobItemsExtractorTest.java | package com.paypal.invoices.extractioninvoices.batchjobs;
import com.paypal.invoices.extractioncommons.services.MiraklAccountingDocumentExtractService;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class InvoicesExtractBatchJobItemsExtractorTest {
private static final Date DELTA = new Date();
@InjectMocks
private InvoicesExtractBatchJobItemsExtractor testObj;
@Mock
private MiraklAccountingDocumentExtractService<InvoiceModel> miraklAccountingDocumentInvoicesExtractServiceMock;
@Mock
private InvoiceModel invoiceModelMock1, invoiceModelMock2;
@Mock
private BatchJobContext batchJobContextMock;
@Test
void getItems_ShouldReturnACollectionOfInvoiceExtractJobItemForTheGivenDetla() {
when(miraklAccountingDocumentInvoicesExtractServiceMock.extractAccountingDocuments(DELTA, false))
.thenReturn(List.of(invoiceModelMock1, invoiceModelMock2));
final Collection<InvoiceExtractJobItem> result = testObj.getItems(batchJobContextMock, DELTA, false);
assertThat(result.stream().map(InvoiceExtractJobItem::getItem)).containsExactlyInAnyOrder(invoiceModelMock1,
invoiceModelMock2);
}
}
| 5,153 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/batchjobs/InvoicesExtractBatchJobItemProcessorTest.java | package com.paypal.invoices.extractioninvoices.batchjobs;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoiceExtractJobItem;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesExtractBatchJobItemProcessor;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.invoices.extractioninvoices.services.InvoiceProcessService;
import com.paypal.invoices.extractioncommons.services.HyperWalletPaymentExtractService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
class InvoicesExtractBatchJobItemProcessorTest {
@InjectMocks
private InvoicesExtractBatchJobItemProcessor testObj;
@Mock
private HyperWalletPaymentExtractService hyperWalletPaymentExtractServiceMock;
@Mock
private InvoiceProcessService invoiceProcessServiceMock;
@Mock
private BatchJobContext batchJobContextMock;
@Test
void processItem_ShouldPayPayeeInvoiceAndPayOperator() {
final InvoiceModel invoiceModel = InvoiceModel.builder().build();
final InvoiceExtractJobItem invoiceExtractJobItem = new InvoiceExtractJobItem(invoiceModel);
testObj.processItem(batchJobContextMock, invoiceExtractJobItem);
verify(hyperWalletPaymentExtractServiceMock).payPayeeInvoice(invoiceModel);
verify(invoiceProcessServiceMock).payOperator(invoiceModel);
}
}
| 5,154 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/services/InvoiceProcessServiceImplTest.java | package com.paypal.invoices.extractioninvoices.services;
import com.paypal.invoices.extractioninvoices.configuration.InvoicesOperatorCommissionsConfig;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.invoices.extractioncommons.services.HyperWalletPaymentExtractService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class InvoiceProcessServiceImplTest {
@InjectMocks
private InvoiceProcessServiceImpl testObj;
@Mock
private InvoicesOperatorCommissionsConfig invoicesOperatorCommissionsConfigMock;
@Mock
private HyperWalletPaymentExtractService hyperWalletPaymentExtractServiceMock;
@Mock
private InvoiceModel invoiceModelMock;
@Test
void payOperator_ShouldPayInvoiceOperator_WhenOperatorCommissionsIsEnabled() {
when(invoicesOperatorCommissionsConfigMock.isEnabled()).thenReturn(Boolean.TRUE);
testObj.payOperator(invoiceModelMock);
verify(hyperWalletPaymentExtractServiceMock).payInvoiceOperator(invoiceModelMock);
}
@Test
void payOperator_ShouldNotPayInvoiceOperator_WhenOperatorCommissionsIsNotEnabled() {
when(invoicesOperatorCommissionsConfigMock.isEnabled()).thenReturn(Boolean.FALSE);
testObj.payOperator(invoiceModelMock);
verify(hyperWalletPaymentExtractServiceMock, never()).payInvoiceOperator(invoiceModelMock);
}
}
| 5,155 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/services/MiraklInvoicesExtractServiceImplTest.java | package com.paypal.invoices.extractioninvoices.services;
import com.mirakl.client.mmp.domain.invoice.MiraklInvoice;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.invoices.extractioncommons.model.InvoiceTypeEnum;
import com.paypal.invoices.extractioninvoices.services.MiraklInvoicesExtractServiceImpl;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class MiraklInvoicesExtractServiceImplTest {
@InjectMocks
private MiraklInvoicesExtractServiceImpl testObj;
@Mock
private Converter<MiraklInvoice, InvoiceModel> miraklInvoiceToInvoiceModelConverterMock;
@Test
void shouldReturnCreditNoteType() {
assertThat(testObj.getInvoiceType()).isEqualTo(InvoiceTypeEnum.AUTO_INVOICE);
}
@Test
void shouldReturnCreditNoteConverter() {
assertThat(testObj.getMiraklInvoiceToAccountingModelConverter())
.isEqualTo(miraklInvoiceToInvoiceModelConverterMock);
}
}
| 5,156 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/services | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/services/converters/OperatorInvoiceModelToHyperwalletPaymentConverterTest.java | package com.paypal.invoices.extractioninvoices.services.converters;
import com.hyperwallet.clientsdk.model.HyperwalletPayment;
import com.paypal.infrastructure.hyperwallet.configuration.HyperwalletProgramsConfiguration;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.infrastructure.hyperwallet.services.PaymentHyperwalletSDKService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static com.paypal.infrastructure.hyperwallet.constants.HyperWalletConstants.PAYMENT_OPERATOR_SUFFIX;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class OperatorInvoiceModelToHyperwalletPaymentConverterTest {
private static final String DESTINATION_TOKEN = "destinationToken";
private static final String HYPERWALLET_PROGRAM = "hyperwalletProgram";
private static final String SHOP_ID = "2000";
private static final String INVOICE_NUMBER = "100001000";
private static final String CURRENCY_ISO_CODE = "EUR";
private static final String PROGRAM_TOKEN = "programToken";
private static final String OPERATOR_BANK_ACCOUNT_TOKEN = "operatorBankAccountToken";
@InjectMocks
private OperatorInvoiceModelToHyperwalletPaymentConverter testObj;
@Mock
private PaymentHyperwalletSDKService paymentHyperwalletSDKServiceMock;
@Mock
private HyperwalletProgramsConfiguration hyperwalletProgramsConfigurationMock;
@Mock
private HyperwalletProgramsConfiguration.HyperwalletProgramConfiguration hyperwalletProgramConfigurationMock;
@Test
void convert_shouldConvertAnInvoiceIntoHyperwalletPayment() {
final Double transferAmountToOperator = 100.10D;
when(paymentHyperwalletSDKServiceMock.getProgramTokenByHyperwalletProgram(HYPERWALLET_PROGRAM))
.thenReturn(PROGRAM_TOKEN);
when(hyperwalletProgramsConfigurationMock.getProgramConfiguration(HYPERWALLET_PROGRAM))
.thenReturn(hyperwalletProgramConfigurationMock);
when(hyperwalletProgramConfigurationMock.getBankAccountToken()).thenReturn(OPERATOR_BANK_ACCOUNT_TOKEN);
//@formatter:off
final InvoiceModel invoice = InvoiceModel.builder()
.hyperwalletProgram(HYPERWALLET_PROGRAM)
.destinationToken(DESTINATION_TOKEN)
.shopId(SHOP_ID)
.invoiceNumber(INVOICE_NUMBER)
.transferAmountToOperator(transferAmountToOperator)
.currencyIsoCode(CURRENCY_ISO_CODE)
.build();
//@formatter:on
final HyperwalletPayment result = testObj.convert(invoice);
assertThat(result.getDestinationToken()).isEqualTo(OPERATOR_BANK_ACCOUNT_TOKEN);
assertThat(result.getClientPaymentId()).isEqualTo(INVOICE_NUMBER + PAYMENT_OPERATOR_SUFFIX);
assertThat(result.getAmount()).isEqualTo(transferAmountToOperator);
assertThat(result.getCurrency()).isEqualTo(CURRENCY_ISO_CODE);
assertThat(result.getPurpose()).isEqualTo("OTHER");
assertThat(result.getProgramToken()).isEqualTo(PROGRAM_TOKEN);
}
@Test
void convert_shouldReturnNullWhenCommissionIsZero() {
//@formatter:off
final InvoiceModel invoice = InvoiceModel.builder()
.destinationToken(DESTINATION_TOKEN)
.shopId(SHOP_ID)
.invoiceNumber(INVOICE_NUMBER)
.transferAmountToOperator(0.0D)
.currencyIsoCode(CURRENCY_ISO_CODE)
.build();
//@formatter:on
final HyperwalletPayment result = testObj.convert(invoice);
assertThat(result).isNull();
}
}
| 5,157 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/services | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/services/converters/MiraklInvoiceToInvoiceModelConverterTest.java | package com.paypal.invoices.extractioninvoices.services.converters;
import com.mirakl.client.mmp.domain.common.currency.MiraklIsoCurrencyCode;
import com.mirakl.client.mmp.domain.invoice.MiraklInvoice;
import com.mirakl.client.mmp.domain.invoice.MiraklInvoiceSummary;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.invoices.extractioninvoices.services.converters.MiraklInvoiceToInvoiceModelConverter;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.math.BigDecimal;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class MiraklInvoiceToInvoiceModelConverterTest {
private static final String INV_NUMBER = "INV-NUMBER";
private static final String EUR = "EUR";
private static final BigDecimal TRANSFER_AMOUNT = BigDecimal.valueOf(20.00D);
private static final BigDecimal TOTAL_COMMISSION = BigDecimal.valueOf(10.00D);
private static final BigDecimal TOTAL_SUBSCRIPTIONS = BigDecimal.valueOf(5.00D);
private static final Long SHOP_ID = 2000L;
@InjectMocks
private MiraklInvoiceToInvoiceModelConverter testObj;
@Mock
private MiraklInvoice miraklInvoiceMock;
@Mock
private MiraklInvoiceSummary miraklInvoiceSummaryMock;
@Test
void convert_shouldConvertMiraklInvoiceIntoInvoiceModel() {
when(miraklInvoiceMock.getId()).thenReturn(INV_NUMBER);
when(miraklInvoiceMock.getShopId()).thenReturn(SHOP_ID);
when(miraklInvoiceMock.getCurrencyIsoCode()).thenReturn(MiraklIsoCurrencyCode.EUR);
when(miraklInvoiceMock.getSummary()).thenReturn(miraklInvoiceSummaryMock);
when(miraklInvoiceSummaryMock.getAmountTransferred()).thenReturn(TRANSFER_AMOUNT);
when(miraklInvoiceSummaryMock.getTotalCommissionsIT()).thenReturn(TOTAL_COMMISSION);
when(miraklInvoiceSummaryMock.getTotalSubscriptionIT()).thenReturn(TOTAL_SUBSCRIPTIONS);
when(miraklInvoiceSummaryMock.getAmountTransferredToOperator()).thenReturn(BigDecimal.TEN);
final InvoiceModel result = testObj.convert(miraklInvoiceMock);
assertThat(result.getInvoiceNumber()).isEqualTo(INV_NUMBER);
assertThat(result.getCurrencyIsoCode()).isEqualTo(EUR);
assertThat(result.getTransferAmount()).isEqualTo(TRANSFER_AMOUNT.doubleValue());
assertThat(result.getSubscriptionAmountVat()).isEqualTo(TOTAL_SUBSCRIPTIONS.doubleValue());
assertThat(result.getOrderCommissionAmountVat()).isEqualTo(TOTAL_COMMISSION.doubleValue());
assertThat(result.getShopId()).isEqualTo("2000");
assertThat(result.getTransferAmountToOperator()).isEqualTo(10D);
}
@Test
void convert_shouldReturnNullWhenNullParameterIsReceived() {
final InvoiceModel result = testObj.convert(null);
assertThat(result).isNull();
}
}
| 5,158 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/services | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/test/java/com/paypal/invoices/extractioninvoices/services/converters/PayeeInvoiceModelToHyperwalletPaymentConverterTest.java | package com.paypal.invoices.extractioninvoices.services.converters;
import com.hyperwallet.clientsdk.model.HyperwalletPayment;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.infrastructure.hyperwallet.services.PaymentHyperwalletSDKService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PayeeInvoiceModelToHyperwalletPaymentConverterTest {
private static final String DESTINATION_TOKEN = "destinationToken";
private static final String HYPERWALLET_PROGRAM = "hyperwalletProgram";
private static final String SHOP_ID = "2000";
private static final String INVOICE_NUMBER = "100001000";
private static final double TRANSFER_AMOUNT = 20.00D;
private static final String CURRENCY_ISO_CODE = "EUR";
private static final String PROGRAM_TOKEN = "programToken";
@InjectMocks
private PayeeInvoiceModelToHyperwalletPaymentConverter testObj;
@Mock
private PaymentHyperwalletSDKService paymentHyperwalletSDKServiceMock;
@Test
void convert_shouldConvertAnInvoiceIntoHyperwalletPayment() {
when(paymentHyperwalletSDKServiceMock.getProgramTokenByHyperwalletProgram(HYPERWALLET_PROGRAM))
.thenReturn(PROGRAM_TOKEN);
//@formatter:off
final InvoiceModel invoice = InvoiceModel.builder()
.destinationToken(DESTINATION_TOKEN)
.shopId(SHOP_ID)
.invoiceNumber(INVOICE_NUMBER)
.transferAmount(TRANSFER_AMOUNT)
.currencyIsoCode(CURRENCY_ISO_CODE)
.hyperwalletProgram(HYPERWALLET_PROGRAM)
.build();
//@formatter:on
final HyperwalletPayment result = testObj.convert(invoice);
assertThat(result.getDestinationToken()).isEqualTo(DESTINATION_TOKEN);
assertThat(result.getClientPaymentId()).isEqualTo(INVOICE_NUMBER);
assertThat(result.getAmount()).isEqualTo(TRANSFER_AMOUNT);
assertThat(result.getCurrency()).isEqualTo(CURRENCY_ISO_CODE);
assertThat(result.getPurpose()).isEqualTo("OTHER");
assertThat(result.getProgramToken()).isEqualTo(PROGRAM_TOKEN);
}
}
| 5,159 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/integrationTest/java/com/paypal | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/integrationTest/java/com/paypal/invoices/InvoicesConfigurationManagementITTest.java | package com.paypal.invoices;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.paypal.invoices.extractioninvoices.configuration.InvoicesOperatorCommissionsConfig;
import com.paypal.invoices.management.controllers.dto.CommissionsConfigurationDto;
import com.paypal.testsupport.AbstractIntegrationTest;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.ResultActions;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@AutoConfigureMockMvc(addFilters = false)
class InvoicesConfigurationManagementITTest extends AbstractIntegrationTest {
@Autowired
private MockMvc mockMvc;
@Autowired
private InvoicesOperatorCommissionsConfig invoicesOperatorCommissionsConfig;
private static CommissionsConfigurationDto getCommissionsConfigurationDto(final ResultActions resultActions)
throws UnsupportedEncodingException, JsonProcessingException {
final MvcResult result = resultActions.andReturn();
final String contentAsString = result.getResponse().getContentAsString();
final ObjectMapper objectMapper = new ObjectMapper();
final CommissionsConfigurationDto response = objectMapper.readValue(contentAsString,
CommissionsConfigurationDto.class);
return response;
}
private static String serializeCommissionsConfigurationDto(
final CommissionsConfigurationDto commissionsConfigurationDto) throws Exception {
final ObjectMapper objectMapper = new ObjectMapper();
final StringWriter stringWriter = new StringWriter();
objectMapper.writeValue(stringWriter, commissionsConfigurationDto);
return stringWriter.toString();
}
@Test
void shouldGetOperatorCommissionsEnabledSetting_whenIsTrue() throws Exception {
invoicesOperatorCommissionsConfig.setEnabled(true);
final CommissionsConfigurationDto response = doGetOperatorCommissionsEnabled();
assertThat(response.isOperatorCommissionsEnabled()).isTrue();
}
@Test
void shouldGetOperatorCommissionsEnabledSetting_whenIsFalse() throws Exception {
invoicesOperatorCommissionsConfig.setEnabled(false);
final CommissionsConfigurationDto response = doGetOperatorCommissionsEnabled();
assertThat(response.isOperatorCommissionsEnabled()).isFalse();
}
@Test
void shouldSetOperatorCommissionsEnabledSetting() throws Exception {
invoicesOperatorCommissionsConfig.setEnabled(false);
final CommissionsConfigurationDto requestBody = new CommissionsConfigurationDto(true);
this.mockMvc
.perform(put("/configuration/invoices/commissions").contentType(MediaType.APPLICATION_JSON)
.content(serializeCommissionsConfigurationDto(requestBody)))
.andDo(print()).andExpect(status().isOk());
assertThat(invoicesOperatorCommissionsConfig.isEnabled()).isTrue();
}
private CommissionsConfigurationDto doGetOperatorCommissionsEnabled() throws Exception {
final ResultActions resultActions = this.mockMvc.perform(get("/configuration/invoices/commissions"))
.andDo(print()).andExpect(status().isOk());
final CommissionsConfigurationDto response = getCommissionsConfigurationDto(resultActions);
return response;
}
}
| 5,160 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/integrationTest/java/com/paypal | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/integrationTest/java/com/paypal/invoices/HyperWalletPaymentExtractServiceImplTest.java | package com.paypal.invoices;
import com.hyperwallet.clientsdk.model.HyperwalletPayment;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.infrastructure.support.exceptions.HMCException;
import com.paypal.invoices.extractioncommons.services.HyperWalletPaymentExtractServiceImpl;
import com.paypal.invoices.extractioncreditnotes.model.CreditNoteModel;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import com.paypal.testsupport.AbstractMockEnabledIntegrationTest;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentMatchers;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.mock.mockito.SpyBean;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Optional;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.mockito.Mockito.verify;
class HyperWalletPaymentExtractServiceImplTest extends AbstractMockEnabledIntegrationTest {
private static final String DEFAULT_INVOICE_NUMBER = "invoiceNumber";
private static final String DEFAULT_HYPERWALLET_PROGRAM = "DEFAULT";
private static final String CUSTOMER_DESTINATION_TOKEN = "customerBankAccountToken";
private static final String OPERATOR_DESTINATION_TOKEN = "bankAccountToken";
private static final String DEFAULT_PAYMENT_TOKEN = "paymentToken";
private static final double DEFAULT_TRANSFER_AMOUNT = 11.1D;
private static final String GB_ISOCODE = "GB";
@Autowired
private HyperWalletPaymentExtractServiceImpl testObj;
@SpyBean
private MailNotificationUtil mailNotificationUtil;
@Test
void payInvoice_shouldCreateAPayment_WhenNotExistAnotherCorrectPayment() {
final HyperwalletPayment expected = defaultHyperwalletPayment();
final InvoiceModel invoice = defaultInvoice();
mockToCreatePayment(expected);
final Optional<HyperwalletPayment> result = testObj.payPayeeInvoice(invoice);
assertThat(result.get()).usingRecursiveComparison().isEqualTo(expected);
}
@Test
void payInvoice_shouldSendAnEmail_WhenAnExceptionIsThrownInCreationPaymentRequest() {
final HyperwalletPayment payment = defaultHyperwalletPayment().clientPaymentId("000001234");
final InvoiceModel invoice = defaultInvoice().toBuilder().invoiceNumber("000001234").build();
paymentsEndpointMock.listPaymentsRequest(invoice.getInvoiceNumber(), Collections.emptyList());
paymentsEndpointMock.createPaymentErrorRequest(payment);
assertThatThrownBy(() -> testObj.payPayeeInvoice(invoice)).isInstanceOf(HMCException.class);
verify(mailNotificationUtil).sendPlainTextEmail(
ArgumentMatchers.eq("Issue detected when creating payment for an invoice in Hyperwallet"),
ArgumentMatchers.contains("Something went wrong creating payment for invoice [000001234]"));
}
@Test
void payInvoice_shouldContinueWithCreationPayment_WhenGetPaymentFails() {
final HyperwalletPayment expected = defaultHyperwalletPayment();
final InvoiceModel invoice = defaultInvoice();
paymentsEndpointMock.listPaymentsErrorRequest(invoice.getInvoiceNumber());
paymentsEndpointMock.createPaymentRequest(expected);
final Optional<HyperwalletPayment> result = testObj.payPayeeInvoice(invoice);
assertThat(result.get()).usingRecursiveComparison().isEqualTo(expected);
}
@Test
void payInvoice_willStopCreation_WhenSomePaymentHasAGoodStatus() {
final InvoiceModel invoice = defaultInvoice();
paymentsEndpointMock.listPaymentsRequest(invoice.getInvoiceNumber(),
Arrays.asList("FAILED", "NO_FAILURE_STATUS", "RETURNED"));
final Optional<HyperwalletPayment> result = testObj.payPayeeInvoice(invoice);
assertThat(result).isEmpty();
}
@Test
void payPayeeCreditNote_shouldCreateAPayment_WhenNotExistAnotherCorrectPayment() {
final HyperwalletPayment expected = defaultHyperwalletPayment();
final CreditNoteModel creditNote = defaultCreditModel();
mockToCreatePayment(expected);
final Optional<HyperwalletPayment> result = testObj.payPayeeCreditNotes(creditNote);
assertThat(result.get()).usingRecursiveComparison().isEqualTo(expected);
}
@Test
void payPayeeCreditNote_shouldThrowExceptionWhenPaymentNotSuccessfullyCreatedOnHyperwallet() {
final HyperwalletPayment payment = defaultHyperwalletPayment();
final CreditNoteModel creditNote = defaultCreditModel();
paymentsEndpointMock.listPaymentsRequest(creditNote.getInvoiceNumber(), Collections.emptyList());
paymentsEndpointMock.createPaymentErrorRequest(payment);
assertThatThrownBy(() -> testObj.payPayeeCreditNotes(creditNote)).isInstanceOf(HMCException.class);
}
@Test
void payInvoiceOperator_shouldCreateAPayment_WhenNotExistAnotherCorrectPayment() {
final HyperwalletPayment expected = defaultHyperwalletPayment().clientPaymentId("invoiceNumber-operatorFee")
.destinationToken(OPERATOR_DESTINATION_TOKEN);
final InvoiceModel invoice = defaultInvoiceOperator();
mockToCreatePayment(expected);
final Optional<HyperwalletPayment> result = testObj.payInvoiceOperator(invoice);
assertThat(result.get()).usingRecursiveComparison().isEqualTo(expected);
}
private HyperwalletPayment defaultHyperwalletPayment() {
return new HyperwalletPayment().programToken(DEFAULT_PAYMENT_TOKEN).clientPaymentId(DEFAULT_INVOICE_NUMBER)
.destinationToken(CUSTOMER_DESTINATION_TOKEN).amount(DEFAULT_TRANSFER_AMOUNT).currency(GB_ISOCODE)
.purpose("OTHER");
}
private InvoiceModel defaultInvoice() {
return InvoiceModel.builder().hyperwalletProgram(DEFAULT_HYPERWALLET_PROGRAM)
.destinationToken(CUSTOMER_DESTINATION_TOKEN).invoiceNumber(DEFAULT_INVOICE_NUMBER)
.transferAmount(DEFAULT_TRANSFER_AMOUNT).currencyIsoCode(GB_ISOCODE).build();
}
private InvoiceModel defaultInvoiceOperator() {
return InvoiceModel.builder().hyperwalletProgram(DEFAULT_HYPERWALLET_PROGRAM)
.destinationToken(OPERATOR_DESTINATION_TOKEN).invoiceNumber(DEFAULT_INVOICE_NUMBER)
.transferAmountToOperator(DEFAULT_TRANSFER_AMOUNT).currencyIsoCode(GB_ISOCODE).build();
}
private CreditNoteModel defaultCreditModel() {
return CreditNoteModel.builder().hyperwalletProgram(DEFAULT_HYPERWALLET_PROGRAM)
.destinationToken(CUSTOMER_DESTINATION_TOKEN).invoiceNumber(DEFAULT_INVOICE_NUMBER)
.creditAmount(DEFAULT_TRANSFER_AMOUNT).currencyIsoCode(GB_ISOCODE).build();
}
private void mockToCreatePayment(final HyperwalletPayment payment) {
final Collection<String> statuses = Arrays.asList("FAILED", "RECALLED", "RETURNED");
paymentsEndpointMock.listPaymentsRequest(payment.getClientPaymentId(), statuses);
paymentsEndpointMock.createPaymentRequest(payment);
}
}
| 5,161 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/integrationTest/java/com/paypal | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/integrationTest/java/com/paypal/invoices/MiraklClientItemLinksUpdateTest.java | package com.paypal.invoices;
import com.mirakl.client.mmp.request.shop.MiraklGetShopsRequest;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemLinkLocator;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemTypes;
import com.paypal.infrastructure.itemlinks.model.MiraklItemLinkLocator;
import com.paypal.infrastructure.itemlinks.model.MiraklItemTypes;
import com.paypal.infrastructure.itemlinks.services.ItemLinksService;
import com.paypal.infrastructure.mirakl.client.MiraklClient;
import com.paypal.testsupport.AbstractMockEnabledIntegrationTest;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import java.util.Collection;
import java.util.Date;
import java.util.Map;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
@Transactional
class MiraklClientItemLinksUpdateTest extends AbstractMockEnabledIntegrationTest {
@Autowired
private MiraklClient miraklClient;
@Autowired
private ItemLinksService itemLinksService;
@Test
void itemLinks_shouldBeUpdated_afterReceivingShops_whenNoPreviousDataExists() {
// given
mockServerExpectationsLoader.loadExpectationsFromFolder("expectations/miraklclientitemlinksupdate", "mirakl",
Map.of());
// when
final MiraklGetShopsRequest request = new MiraklGetShopsRequest();
request.setUpdatedSince(new Date());
miraklClient.getShops(request);
// then
final Set<HyperwalletItemTypes> types = Set.of(HyperwalletItemTypes.BANK_ACCOUNT, HyperwalletItemTypes.PROGRAM);
MiraklItemLinkLocator miraklItemLinkLocator = new MiraklItemLinkLocator("10001", MiraklItemTypes.SHOP);
Collection<HyperwalletItemLinkLocator> links = itemLinksService.findLinks(miraklItemLinkLocator, types);
assertThat(links).hasSize(2).containsExactlyInAnyOrder(
new HyperwalletItemLinkLocator("trm-00000000-0000-0000-0000-0000000000",
HyperwalletItemTypes.BANK_ACCOUNT),
new HyperwalletItemLinkLocator("PROGRAM-1", HyperwalletItemTypes.PROGRAM));
miraklItemLinkLocator = new MiraklItemLinkLocator("10002", MiraklItemTypes.SHOP);
links = itemLinksService.findLinks(miraklItemLinkLocator, types);
assertThat(links).hasSize(1)
.containsExactlyInAnyOrder(new HyperwalletItemLinkLocator("PROGRAM-2", HyperwalletItemTypes.PROGRAM));
}
@Test
void itemLinks_shouldBeUpdated_afterReceivingShops_whenPreviousDataExists() {
// given
mockServerExpectationsLoader.loadExpectationsFromFolder("expectations/miraklclientitemlinksupdate", "mirakl",
Map.of());
// when
final MiraklGetShopsRequest request = new MiraklGetShopsRequest();
request.setUpdatedSince(new Date());
miraklClient.getShops(request);
miraklClient.getShops(request);
// then
final Set<HyperwalletItemTypes> types = Set.of(HyperwalletItemTypes.BANK_ACCOUNT, HyperwalletItemTypes.PROGRAM);
MiraklItemLinkLocator miraklItemLinkLocator = new MiraklItemLinkLocator("10001", MiraklItemTypes.SHOP);
Collection<HyperwalletItemLinkLocator> links = itemLinksService.findLinks(miraklItemLinkLocator, types);
assertThat(links).hasSize(2).containsExactlyInAnyOrder(
new HyperwalletItemLinkLocator("trm-00000000-0000-0000-0000-0000000001",
HyperwalletItemTypes.BANK_ACCOUNT),
new HyperwalletItemLinkLocator("PROGRAM-2", HyperwalletItemTypes.PROGRAM));
miraklItemLinkLocator = new MiraklItemLinkLocator("10002", MiraklItemTypes.SHOP);
links = itemLinksService.findLinks(miraklItemLinkLocator, types);
assertThat(links).hasSize(2).containsExactlyInAnyOrder(
new HyperwalletItemLinkLocator("trm-00000000-0000-0000-0000-0000000002",
HyperwalletItemTypes.BANK_ACCOUNT),
new HyperwalletItemLinkLocator("PROGRAM-1", HyperwalletItemTypes.PROGRAM));
}
}
| 5,162 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/connectors/PaymentHyperwalletApiClient.java | package com.paypal.invoices.extractioncommons.connectors;
import com.hyperwallet.clientsdk.Hyperwallet;
import com.hyperwallet.clientsdk.model.HyperwalletList;
import com.hyperwallet.clientsdk.model.HyperwalletPayment;
import com.hyperwallet.clientsdk.model.HyperwalletPaymentListOptions;
import com.paypal.infrastructure.hyperwallet.services.PaymentHyperwalletSDKService;
import org.springframework.stereotype.Component;
@Component
public class PaymentHyperwalletApiClient {
private final PaymentHyperwalletSDKService sdkService;
public PaymentHyperwalletApiClient(final PaymentHyperwalletSDKService paymentHyperwalletSDKService) {
this.sdkService = paymentHyperwalletSDKService;
}
public HyperwalletPayment createPayment(final HyperwalletPayment hyperwalletPayment) {
final Hyperwallet client = sdkService
.getHyperwalletInstanceByProgramToken(hyperwalletPayment.getProgramToken());
return client.createPayment(hyperwalletPayment);
}
public HyperwalletList<HyperwalletPayment> listPayments(final String programToken, final String clientPaymentId) {
final Hyperwallet client = sdkService.getHyperwalletInstanceByProgramToken(programToken);
final HyperwalletPaymentListOptions queryOptions = new HyperwalletPaymentListOptions()
.clientPaymentId(clientPaymentId);
return client.listPayments(queryOptions);
}
}
| 5,163 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/batchjobs/AbstractAccountingDocumentBatchJobItem.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.jobsystem.batchjob.model.BatchJobItem;
import com.paypal.jobsystem.batchjobsupport.support.AbstractBatchJobItem;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
/**
* Base class for all invoice related batch job items.
*
* @param <T> the type of the invoice domain object model.
*/
public abstract class AbstractAccountingDocumentBatchJobItem<T extends AccountingDocumentModel>
extends AbstractBatchJobItem<T> implements BatchJobItem<T> {
protected AbstractAccountingDocumentBatchJobItem(final T item) {
super(item);
}
protected abstract AbstractAccountingDocumentBatchJobItem<T> from(T item);
}
| 5,164 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/batchjobs/AccountingDocumentBatchJobItemValidator.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.infrastructure.mirakl.services.IgnoreProgramsService;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.jobsystem.batchjob.model.BatchJobItem;
import com.paypal.jobsystem.batchjob.model.BatchJobItemValidationResult;
import com.paypal.jobsystem.batchjob.model.BatchJobItemValidationStatus;
import com.paypal.jobsystem.batchjobsupport.model.BatchJobItemValidator;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Component;
import java.util.Optional;
/**
* Batch job validator for invoice items that checks if destination and program tokens are
* fulfiled.
*/
@Component
public class AccountingDocumentBatchJobItemValidator
implements BatchJobItemValidator<BatchJobContext, AbstractAccountingDocumentBatchJobItem<?>> {
private final IgnoreProgramsService ignoreProgramsService;
public AccountingDocumentBatchJobItemValidator(final IgnoreProgramsService ignoreProgramsService) {
this.ignoreProgramsService = ignoreProgramsService;
}
@Override
public BatchJobItemValidationResult validateItem(final BatchJobContext ctx,
final AbstractAccountingDocumentBatchJobItem<?> jobItem) {
// formatter:off
if (hasAllRequiredTokens(jobItem) && !belongsToIgnoredProgram(jobItem)) {
return BatchJobItemValidationResult.builder().status(BatchJobItemValidationStatus.VALID).build();
}
else if (belongsToIgnoredProgram(jobItem)) {
return BatchJobItemValidationResult.builder().status(BatchJobItemValidationStatus.INVALID)
.reason(Optional.of(
"Invoice documents with id [%s] should be skipped because it belongs to an ignored program"
.formatted(jobItem.getItemId())))
.build();
}
else {
return BatchJobItemValidationResult.builder().status(BatchJobItemValidationStatus.INVALID).reason(Optional
.of("Invoice documents with id [%s] should be skipped because are lacking hw-program or bank account token"
.formatted(jobItem.getItemId())))
.build();
}
// formatter:on
}
private boolean hasAllRequiredTokens(final BatchJobItem<? extends AccountingDocumentModel> jobItem) {
return StringUtils.isNotEmpty(jobItem.getItem().getHyperwalletProgram())
&& StringUtils.isNotEmpty(jobItem.getItem().getDestinationToken());
}
private boolean belongsToIgnoredProgram(final BatchJobItem<? extends AccountingDocumentModel> jobItem) {
return ignoreProgramsService.isIgnored(jobItem.getItem().getHyperwalletProgram());
}
}
| 5,165 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/batchjobs/AccountingDocumentBatchJobItemEnricher.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemLinkLocator;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemTypes;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import com.paypal.invoices.extractioncommons.services.AccountingDocumentsLinksService;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.jobsystem.batchjobsupport.model.BatchJobItemEnricher;
import org.springframework.stereotype.Component;
import java.util.Collection;
/**
* Batch job item enricher for invoice items that enrichs their information adding the
* bank account and the program token managed by the item links service.
*/
@Component
public class AccountingDocumentBatchJobItemEnricher implements
BatchJobItemEnricher<BatchJobContext, AbstractAccountingDocumentBatchJobItem<? super AccountingDocumentModel>> {
private final AccountingDocumentsLinksService accountingDocumentsLinksService;
public AccountingDocumentBatchJobItemEnricher(
final AccountingDocumentsLinksService accountingDocumentsLinksService) {
this.accountingDocumentsLinksService = accountingDocumentsLinksService;
}
@Override
public AbstractAccountingDocumentBatchJobItem enrichItem(final BatchJobContext ctx,
final AbstractAccountingDocumentBatchJobItem jobItem) {
return jobItem.from(enrichedItem((AccountingDocumentModel) jobItem.getItem()));
}
private AccountingDocumentModel enrichedItem(final AccountingDocumentModel item) {
final Collection<HyperwalletItemLinkLocator> accountingDocumentLinks = accountingDocumentsLinksService
.findRequiredLinks(item);
final String destinationToken = getDestinationToken(accountingDocumentLinks);
final String hyperwalletProgram = getHyperwalletProgram(accountingDocumentLinks);
return buildEnriched(item, destinationToken, hyperwalletProgram);
}
protected AccountingDocumentModel buildEnriched(final AccountingDocumentModel item, final String destinationToken,
final String hyperwalletProgram) {
return item.toBuilder().destinationToken(destinationToken).hyperwalletProgram(hyperwalletProgram).build();
}
private String getHyperwalletProgram(final Collection<HyperwalletItemLinkLocator> accountingDocumentLinks) {
return getLink(accountingDocumentLinks, HyperwalletItemTypes.PROGRAM);
}
private String getDestinationToken(final Collection<HyperwalletItemLinkLocator> accountingDocumentLinks) {
return getLink(accountingDocumentLinks, HyperwalletItemTypes.BANK_ACCOUNT);
}
private String getLink(final Collection<HyperwalletItemLinkLocator> accountingDocumentLinks,
final HyperwalletItemTypes type) {
//@formatter:off
return accountingDocumentLinks.stream()
.filter(locator -> locator.getType().equals(type))
.map(HyperwalletItemLinkLocator::getId)
.findAny()
.orElse(null);
//@formatter:on
}
}
| 5,166 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/batchjobs/AbstractAccountingDocumentBatchJob.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.jobsystem.batchjobsupport.model.BatchJobItemEnricher;
import com.paypal.jobsystem.batchjobsupport.model.BatchJobItemValidator;
import com.paypal.jobsystem.batchjobsupport.model.BatchJobPreProcessor;
import com.paypal.jobsystem.batchjobsupport.support.AbstractBatchJob;
import java.util.Optional;
@SuppressWarnings("unchecked")
public abstract class AbstractAccountingDocumentBatchJob<T extends AbstractAccountingDocumentBatchJobItem<?>>
extends AbstractBatchJob<BatchJobContext, T> {
private final AccountingDocumentBatchJobItemEnricher accountingDocumentBatchJobItemEnricher;
private final AccountingDocumentBatchJobPreProcessor accountingDocumentBatchJobPreProcessor;
private final AccountingDocumentBatchJobItemValidator accountingDocumentBatchJobItemValidator;
protected AbstractAccountingDocumentBatchJob(
final AccountingDocumentBatchJobItemEnricher accountingDocumentBatchJobItemEnricher,
final AccountingDocumentBatchJobPreProcessor accountingDocumentBatchJobPreProcessor,
final AccountingDocumentBatchJobItemValidator accountingDocumentBatchJobItemValidator) {
this.accountingDocumentBatchJobItemEnricher = accountingDocumentBatchJobItemEnricher;
this.accountingDocumentBatchJobPreProcessor = accountingDocumentBatchJobPreProcessor;
this.accountingDocumentBatchJobItemValidator = accountingDocumentBatchJobItemValidator;
}
@Override
protected Optional<BatchJobItemValidator<BatchJobContext, T>> getBatchJobItemValidator() {
return Optional.of((BatchJobItemValidator) accountingDocumentBatchJobItemValidator);
}
@Override
protected Optional<BatchJobPreProcessor<BatchJobContext, T>> getBatchJobPreProcessor() {
return Optional.of((BatchJobPreProcessor) accountingDocumentBatchJobPreProcessor);
}
@Override
protected Optional<BatchJobItemEnricher<BatchJobContext, T>> getBatchJobItemEnricher() {
return Optional.of((BatchJobItemEnricher) accountingDocumentBatchJobItemEnricher);
}
}
| 5,167 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/batchjobs/AccountingDocumentBatchJobPreProcessor.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import com.paypal.invoices.extractioncommons.services.AccountingDocumentsLinksService;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.jobsystem.batchjob.model.BatchJobItem;
import com.paypal.jobsystem.batchjobsupport.model.BatchJobPreProcessor;
import org.springframework.stereotype.Component;
import java.util.Collection;
import java.util.Set;
import java.util.stream.Collectors;
/**
* Batch job preprocessor for invoice job items that ensures that all required
* relationships between Mirakl and Hyperwallet items are stored in the item links service
* before starting the invoice items processing.
*/
@Component
public class AccountingDocumentBatchJobPreProcessor
implements BatchJobPreProcessor<BatchJobContext, BatchJobItem<? extends AccountingDocumentModel>> {
private final AccountingDocumentsLinksService accountingDocumentsLinksService;
public AccountingDocumentBatchJobPreProcessor(
final AccountingDocumentsLinksService accountingDocumentsLinksService) {
this.accountingDocumentsLinksService = accountingDocumentsLinksService;
}
@Override
public void prepareForProcessing(final BatchJobContext ctx,
final Collection<BatchJobItem<? extends AccountingDocumentModel>> itemsToBeProcessed) {
//@formatter:off
final Set<AccountingDocumentModel> accountingDocumentModels = itemsToBeProcessed.stream()
.map(BatchJobItem::getItem)
.collect(Collectors.toSet());
//@formatter:on
accountingDocumentsLinksService.storeRequiredLinks(accountingDocumentModels);
}
}
| 5,168 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/batchjobs/AbstractAccountingDocumentBatchJobExtractor.java | package com.paypal.invoices.extractioncommons.batchjobs;
import com.paypal.jobsystem.batchjob.model.BatchJobContext;
import com.paypal.jobsystem.batchjob.model.BatchJobItem;
import com.paypal.jobsystem.batchjobaudit.services.BatchJobTrackingService;
import com.paypal.jobsystem.batchjobsupport.support.AbstractDynamicWindowDeltaBatchJobItemsExtractor;
import java.util.Collection;
import java.util.Date;
import static com.paypal.invoices.extractioncommons.controllers.InvoiceExtractJobController.INCLUDE_PAID;
/**
* Base class Accounting Document batch job items extraction. That allows to extract items
* based on a delta date and a flag to include paid invoices.
*
* @param <C>
* @param <T>
*/
public abstract class AbstractAccountingDocumentBatchJobExtractor<C extends BatchJobContext, T extends BatchJobItem<?>>
extends AbstractDynamicWindowDeltaBatchJobItemsExtractor<C, T> {
protected AbstractAccountingDocumentBatchJobExtractor(final BatchJobTrackingService batchJobTrackingService) {
super(batchJobTrackingService);
}
private boolean getIncludePaidParam(final C ctx) {
final Boolean includePaid = (Boolean) ctx.getJobExecutionContext().getJobDetail().getJobDataMap()
.get(INCLUDE_PAID);
return includePaid != null && includePaid;
}
@Override
protected Collection<T> getItems(final C ctx, final Date delta) {
return getItems(ctx, delta, getIncludePaidParam(ctx));
}
protected abstract Collection<T> getItems(final C ctx, final Date delta, final boolean includePaid);
}
| 5,169 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/model/InvoiceModelConstants.java | package com.paypal.invoices.extractioncommons.model;
public final class InvoiceModelConstants {
private InvoiceModelConstants() {
}
public static final String HYPERWALLET_BANK_ACCOUNT_TOKEN = "hw-bankaccount-token";
public static final String HYPERWALLET_PROGRAM = "hw-program";
}
| 5,170 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/model/InvoiceTypeEnum.java | package com.paypal.invoices.extractioncommons.model;
public enum InvoiceTypeEnum {
AUTO_INVOICE, MANUAL_CREDIT
}
| 5,171 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/model/AccountingDocumentModel.java | package com.paypal.invoices.extractioncommons.model;
import com.mirakl.client.mmp.domain.common.MiraklAdditionalFieldValue;
import lombok.Getter;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import static com.paypal.invoices.extractioncommons.model.InvoiceModelConstants.HYPERWALLET_BANK_ACCOUNT_TOKEN;
import static com.paypal.invoices.extractioncommons.model.InvoiceModelConstants.HYPERWALLET_PROGRAM;
@Getter
public class AccountingDocumentModel {
protected final String shopId;
protected final Date startTime;
protected final Date endTime;
protected final String shopName;
protected final String shopCorporateName;
protected final String shopAddressLastName;
protected final String shopAddressFirstName;
protected final String shopAddressStreet1;
protected final String shopAddressStreet2;
protected final String shopAddressComplementary;
protected final String shopAddressZipCode;
protected final String shopAddressCity;
protected final String shopAddressCountry;
protected final String shopAddressState;
protected final String shopEmail;
protected final boolean shopIsProfessional;
protected final String shopVatNumber;
protected final Date dateCreated;
protected final String invoiceNumber;
protected final String paymentInfoOwner;
protected final String paymentInfoBankName;
protected final String paymentInfoBankStreet;
protected final String paymentInfoBankZip;
protected final String paymentInfoBankCity;
protected final String paymentInfoBic;
protected final String paymentInfoIban;
protected final Double orderAmount;
protected final Double orderShippingAmount;
protected final Double orderCommissionAmount;
protected final Double refundAmount;
protected final Double refundShippingAmount;
protected final Double refundCommissionAmount;
protected final Double refundCommissionAmountVat;
protected final Double subscriptionAmount;
protected final Double totalChargedAmount;
protected final Double totalChargedAmountVat;
protected final String shopOperatorInternalId;
protected final String shopIdentificationNumber;
protected final Double totalManualInvoiceAmount;
protected final Double totalManualInvoiceAmountVat;
protected final Double totalManualCreditAmount;
protected final Double totalManualCreditAmountVat;
protected final String currencyIsoCode;
protected final String paymentInfoType;
protected final String destinationToken;
protected final String hyperwalletProgram;
protected AccountingDocumentModel(final Builder<?> builder) {
shopId = builder.shopId;
startTime = builder.startTime;
endTime = builder.endTime;
shopName = builder.shopName;
shopCorporateName = builder.shopCorporateName;
shopAddressLastName = builder.shopAddressLastName;
shopAddressFirstName = builder.shopAddressFirstName;
shopAddressStreet1 = builder.shopAddressStreet1;
shopAddressStreet2 = builder.shopAddressStreet2;
shopAddressComplementary = builder.shopAddressComplementary;
shopAddressZipCode = builder.shopAddressZipCode;
shopAddressCity = builder.shopAddressCity;
shopAddressCountry = builder.shopAddressCountry;
shopAddressState = builder.shopAddressState;
shopEmail = builder.shopEmail;
shopIsProfessional = builder.shopIsProfessional;
shopVatNumber = builder.shopVatNumber;
dateCreated = builder.dateCreated;
invoiceNumber = builder.invoiceNumber;
paymentInfoOwner = builder.paymentInfoOwner;
paymentInfoBankName = builder.paymentInfoBankName;
paymentInfoBankStreet = builder.paymentInfoBankStreet;
paymentInfoBankZip = builder.paymentInfoBankZip;
paymentInfoBankCity = builder.paymentInfoBankCity;
paymentInfoBic = builder.paymentInfoBic;
paymentInfoIban = builder.paymentInfoIban;
orderAmount = builder.orderAmount;
orderShippingAmount = builder.orderShippingAmount;
orderCommissionAmount = builder.orderCommissionAmount;
refundAmount = builder.refundAmount;
refundShippingAmount = builder.refundShippingAmount;
refundCommissionAmount = builder.refundCommissionAmount;
refundCommissionAmountVat = builder.refundCommissionAmountVat;
subscriptionAmount = builder.subscriptionAmount;
totalChargedAmount = builder.totalChargedAmount;
totalChargedAmountVat = builder.totalChargedAmountVat;
shopOperatorInternalId = builder.shopOperatorInternalId;
shopIdentificationNumber = builder.shopIdentificationNumber;
totalManualInvoiceAmount = builder.totalManualInvoiceAmount;
totalManualInvoiceAmountVat = builder.totalManualInvoiceAmountVat;
totalManualCreditAmount = builder.totalManualCreditAmount;
totalManualCreditAmountVat = builder.totalManualCreditAmountVat;
currencyIsoCode = builder.currencyIsoCode;
paymentInfoType = builder.paymentInfoType;
destinationToken = builder.destinationToken;
hyperwalletProgram = builder.hyperwalletProgram;
}
@SuppressWarnings("java:S3740")
public static Builder builder() {
return new Builder() {
@Override
public Builder getThis() {
return this;
}
};
}
@SuppressWarnings("java:S3740")
public Builder toBuilder() {
//@formatter:off
return builder()
.shopId(shopId)
.startTime(startTime)
.endTime(endTime)
.shopName(shopName)
.shopCorporateName(shopCorporateName)
.shopAddressLastName(shopAddressLastName)
.shopAddressFirstName(shopAddressFirstName)
.shopAddressStreet1(shopAddressStreet1)
.shopAddressStreet2(shopAddressStreet2)
.shopAddressComplementary(shopAddressComplementary)
.shopAddressZipCode(shopAddressZipCode)
.shopAddressCity(shopAddressCity)
.shopAddressCountry(shopAddressCountry)
.shopAddressState(shopAddressState)
.shopEmail(shopEmail)
.shopIsProfessional(shopIsProfessional)
.shopVatNumber(shopVatNumber)
.dateCreated(dateCreated)
.invoiceNumber(invoiceNumber)
.paymentInfoOwner(paymentInfoOwner)
.paymentInfoBankName(paymentInfoBankName)
.paymentInfoBankStreet(paymentInfoBankStreet)
.paymentInfoBankZip(paymentInfoBankZip)
.paymentInfoBankCity(paymentInfoBankCity)
.paymentInfoBic(paymentInfoBic)
.paymentInfoIban(paymentInfoIban)
.orderAmount(orderAmount)
.orderShippingAmount(orderShippingAmount)
.orderCommissionAmount(orderCommissionAmount)
.refundAmount(refundAmount)
.refundShippingAmount(refundShippingAmount)
.refundCommissionAmount(refundCommissionAmount)
.refundCommissionAmountVat(refundCommissionAmountVat)
.subscriptionAmount(subscriptionAmount)
.totalChargedAmount(totalChargedAmount)
.totalChargedAmountVat(totalChargedAmountVat)
.shopOperatorInternalId(shopOperatorInternalId)
.shopIdentificationNumber(shopIdentificationNumber)
.totalManualInvoiceAmount(totalManualInvoiceAmount)
.totalManualInvoiceAmountVat(totalManualInvoiceAmountVat)
.totalManualCreditAmount(totalManualCreditAmount)
.totalManualCreditAmountVat(totalManualCreditAmountVat)
.currencyIsoCode(currencyIsoCode)
.paymentInfoType(paymentInfoType)
.destinationToken(destinationToken)
.hyperwalletProgram(hyperwalletProgram);
//@formatter:on
}
public abstract static class Builder<T extends Builder<T>> {
private String shopId;
private Date startTime;
private Date endTime;
private String shopName;
private String shopCorporateName;
private String shopAddressLastName;
private String shopAddressFirstName;
private String shopAddressStreet1;
private String shopAddressStreet2;
private String shopAddressComplementary;
private String shopAddressZipCode;
private String shopAddressCity;
private String shopAddressCountry;
private String shopAddressState;
private String shopEmail;
private boolean shopIsProfessional;
private String shopVatNumber;
private Date dateCreated;
private String invoiceNumber;
private String paymentInfoOwner;
private String paymentInfoBankName;
private String paymentInfoBankStreet;
private String paymentInfoBankZip;
private String paymentInfoBankCity;
private String paymentInfoBic;
private String paymentInfoIban;
private Double orderAmount;
private Double orderShippingAmount;
private Double orderCommissionAmount;
private Double refundAmount;
private Double refundShippingAmount;
private Double refundCommissionAmount;
private Double refundCommissionAmountVat;
private Double subscriptionAmount;
private Double totalChargedAmount;
private Double totalChargedAmountVat;
private String shopOperatorInternalId;
private String shopIdentificationNumber;
private Double totalManualInvoiceAmount;
private Double totalManualInvoiceAmountVat;
private Double totalManualCreditAmount;
private Double totalManualCreditAmountVat;
private String currencyIsoCode;
private String paymentInfoType;
private String destinationToken;
private String hyperwalletProgram;
public abstract T getThis();
public T shopId(final String shopId) {
this.shopId = shopId;
return getThis();
}
public T startTime(final Date startTime) {
this.startTime = startTime;
return getThis();
}
public T endTime(final Date endTime) {
this.endTime = endTime;
return getThis();
}
public T shopName(final String shopName) {
this.shopName = shopName;
return getThis();
}
public T shopCorporateName(final String shopCorporateName) {
this.shopCorporateName = shopCorporateName;
return getThis();
}
public T shopAddressLastName(final String shopAddressLastName) {
this.shopAddressLastName = shopAddressLastName;
return getThis();
}
public T shopAddressFirstName(final String shopAddressFirstName) {
this.shopAddressFirstName = shopAddressFirstName;
return getThis();
}
public T shopAddressStreet1(final String shopAddressStreet1) {
this.shopAddressStreet1 = shopAddressStreet1;
return getThis();
}
public T shopAddressStreet2(final String shopAddressStreet2) {
this.shopAddressStreet2 = shopAddressStreet2;
return getThis();
}
public T shopAddressComplementary(final String shopAddressComplementary) {
this.shopAddressComplementary = shopAddressComplementary;
return getThis();
}
public T shopAddressZipCode(final String shopAddressZipCode) {
this.shopAddressZipCode = shopAddressZipCode;
return getThis();
}
public T shopAddressCity(final String shopAddressCity) {
this.shopAddressCity = shopAddressCity;
return getThis();
}
public T shopAddressCountry(final String shopAddressCountry) {
this.shopAddressCountry = shopAddressCountry;
return getThis();
}
public T shopAddressState(final String shopAddressState) {
this.shopAddressState = shopAddressState;
return getThis();
}
public T shopEmail(final String shopEmail) {
this.shopEmail = shopEmail;
return getThis();
}
public T shopIsProfessional(final boolean shopIsProfessional) {
this.shopIsProfessional = shopIsProfessional;
return getThis();
}
public T shopVatNumber(final String shopVatNumber) {
this.shopVatNumber = shopVatNumber;
return getThis();
}
public T dateCreated(final Date dateCreated) {
this.dateCreated = dateCreated;
return getThis();
}
public T invoiceNumber(final String invoiceNumber) {
this.invoiceNumber = invoiceNumber;
return getThis();
}
public T paymentInfoOwner(final String paymentInfoOwner) {
this.paymentInfoOwner = paymentInfoOwner;
return getThis();
}
public T paymentInfoBankName(final String paymentInfoBankName) {
this.paymentInfoBankName = paymentInfoBankName;
return getThis();
}
public T paymentInfoBankStreet(final String paymentInfoBankStreet) {
this.paymentInfoBankStreet = paymentInfoBankStreet;
return getThis();
}
public T paymentInfoBankZip(final String paymentInfoBankZip) {
this.paymentInfoBankZip = paymentInfoBankZip;
return getThis();
}
public T paymentInfoBankCity(final String paymentInfoBankCity) {
this.paymentInfoBankCity = paymentInfoBankCity;
return getThis();
}
public T paymentInfoBic(final String paymentInfoBic) {
this.paymentInfoBic = paymentInfoBic;
return getThis();
}
public T paymentInfoIban(final String paymentInfoIban) {
this.paymentInfoIban = paymentInfoIban;
return getThis();
}
public T orderAmount(final Double orderAmount) {
this.orderAmount = orderAmount;
return getThis();
}
public T orderShippingAmount(final Double orderShippingAmount) {
this.orderShippingAmount = orderShippingAmount;
return getThis();
}
public T orderCommissionAmount(final Double orderCommissionAmount) {
this.orderCommissionAmount = orderCommissionAmount;
return getThis();
}
public T refundAmount(final Double refundAmount) {
this.refundAmount = refundAmount;
return getThis();
}
public T refundShippingAmount(final Double refundShippingAmount) {
this.refundShippingAmount = refundShippingAmount;
return getThis();
}
public T refundCommissionAmount(final Double refundCommissionAmount) {
this.refundCommissionAmount = refundCommissionAmount;
return getThis();
}
public T refundCommissionAmountVat(final Double refundCommissionAmountVat) {
this.refundCommissionAmountVat = refundCommissionAmountVat;
return getThis();
}
public T subscriptionAmount(final Double subscriptionAmount) {
this.subscriptionAmount = subscriptionAmount;
return getThis();
}
public T totalChargedAmount(final Double totalChargedAmount) {
this.totalChargedAmount = totalChargedAmount;
return getThis();
}
public T totalChargedAmountVat(final Double totalChargedAmountVat) {
this.totalChargedAmountVat = totalChargedAmountVat;
return getThis();
}
public T shopOperatorInternalId(final String shopOperatorInternalId) {
this.shopOperatorInternalId = shopOperatorInternalId;
return getThis();
}
public T shopIdentificationNumber(final String shopIdentificationNumber) {
this.shopIdentificationNumber = shopIdentificationNumber;
return getThis();
}
public T totalManualInvoiceAmount(final Double totalManualInvoiceAmount) {
this.totalManualInvoiceAmount = totalManualInvoiceAmount;
return getThis();
}
public T totalManualInvoiceAmountVat(final Double totalManualInvoiceAmountVat) {
this.totalManualInvoiceAmountVat = totalManualInvoiceAmountVat;
return getThis();
}
public T totalManualCreditAmount(final Double totalManualCreditAmount) {
this.totalManualCreditAmount = totalManualCreditAmount;
return getThis();
}
public T totalManualCreditAmountVat(final Double totalManualCreditAmountVat) {
this.totalManualCreditAmountVat = totalManualCreditAmountVat;
return getThis();
}
public T currencyIsoCode(final String currencyIsoCode) {
this.currencyIsoCode = currencyIsoCode;
return getThis();
}
public T paymentInfoType(final String paymentInfoType) {
this.paymentInfoType = paymentInfoType;
return getThis();
}
public T destinationToken(final String destinationToken) {
this.destinationToken = destinationToken;
return getThis();
}
public T destinationToken(final List<MiraklAdditionalFieldValue> fields) {
getMiraklStringCustomFieldValue(fields, HYPERWALLET_BANK_ACCOUNT_TOKEN)
.ifPresent(retrievedToken -> destinationToken = retrievedToken);
return getThis();
}
public T hyperwalletProgram(final String hyperwalletProgram) {
this.hyperwalletProgram = hyperwalletProgram;
return getThis();
}
public T hyperwalletProgram(final List<MiraklAdditionalFieldValue> fields) {
getMiraklSingleValueListCustomFieldValue(fields, HYPERWALLET_PROGRAM)
.ifPresent(retrievedHyperwalletProgram -> this.hyperwalletProgram = retrievedHyperwalletProgram);
return getThis();
}
public AccountingDocumentModel build() {
return new AccountingDocumentModel(this);
}
private Optional<String> getMiraklStringCustomFieldValue(final List<MiraklAdditionalFieldValue> fields,
final String customFieldCode) {
//@formatter:off
return fields.stream()
.filter(field -> field.getCode().equals(customFieldCode))
.filter(MiraklAdditionalFieldValue.MiraklStringAdditionalFieldValue.class::isInstance)
.map(MiraklAdditionalFieldValue.MiraklStringAdditionalFieldValue.class::cast).findAny()
.map(MiraklAdditionalFieldValue.MiraklAbstractAdditionalFieldWithSingleValue::getValue);
//@formatter:on
}
private Optional<String> getMiraklSingleValueListCustomFieldValue(final List<MiraklAdditionalFieldValue> fields,
final String customFieldCode) {
//@formatter:off
return fields.stream()
.filter(field -> field.getCode().equals(customFieldCode))
.filter(MiraklAdditionalFieldValue.MiraklValueListAdditionalFieldValue.class::isInstance)
.map(MiraklAdditionalFieldValue.MiraklValueListAdditionalFieldValue.class::cast).findAny()
.map(MiraklAdditionalFieldValue.MiraklAbstractAdditionalFieldWithSingleValue::getValue);
//@formatter:on
}
}
}
| 5,172 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/jobs/InvoicesExtractJob.java | package com.paypal.invoices.extractioncommons.jobs;
import com.paypal.jobsystem.quartzadapter.support.AbstractBatchJobSupportQuartzJob;
import com.paypal.jobsystem.quartzadapter.job.QuartzBatchJobAdapterFactory;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesExtractBatchJob;
import com.paypal.invoices.extractioninvoices.batchjobs.InvoicesExtractBatchJob;
import com.paypal.invoices.extractioncreditnotes.configuration.CreditNotesConfig;
import com.paypal.invoices.extractioninvoices.configuration.InvoicesOperatorCommissionsConfig;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
/**
* Quartz Job for executing the {@link InvoicesExtractBatchJob} and
* {@link CreditNotesExtractBatchJob}.
*/
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
@Slf4j
public class InvoicesExtractJob extends AbstractBatchJobSupportQuartzJob implements Job {
private final InvoicesExtractBatchJob invoicesExtractBatchJob;
private final CreditNotesExtractBatchJob creditNotesExtractBatchJob;
private final CreditNotesConfig creditNotesConfig;
private final InvoicesOperatorCommissionsConfig invoicesOperatorCommissionsConfig;
public InvoicesExtractJob(final QuartzBatchJobAdapterFactory quartzBatchJobAdapterFactory,
final InvoicesExtractBatchJob invoicesExtractBatchJob,
final CreditNotesExtractBatchJob creditNotesExtractBatchJob, final CreditNotesConfig creditNotesConfig,
final InvoicesOperatorCommissionsConfig invoicesOperatorCommissionsConfig) {
super(quartzBatchJobAdapterFactory);
this.invoicesExtractBatchJob = invoicesExtractBatchJob;
this.creditNotesExtractBatchJob = creditNotesExtractBatchJob;
this.creditNotesConfig = creditNotesConfig;
this.invoicesOperatorCommissionsConfig = invoicesOperatorCommissionsConfig;
}
@Override
public void execute(final JobExecutionContext context) throws JobExecutionException {
logCommissionsConfig();
executeBatchJob(invoicesExtractBatchJob, context);
if (creditNotesConfig.isEnabled()) {
executeBatchJob(creditNotesExtractBatchJob, context);
}
}
private void logCommissionsConfig() {
if (invoicesOperatorCommissionsConfig.isEnabled()) {
log.info("Payment of commissions is enabled, retrieving payments for the operator");
}
else {
log.info("Payment of commissions is disabled, skipping processing payments to operator");
}
}
}
| 5,173 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/controllers/InvoiceExtractJobController.java | package com.paypal.invoices.extractioncommons.controllers;
import com.paypal.invoices.extractioncommons.jobs.InvoicesExtractJob;
import com.paypal.jobsystem.quartzintegration.controllers.AbstractJobController;
import lombok.extern.slf4j.Slf4j;
import org.quartz.SchedulerException;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.Date;
import java.util.Map;
/**
* Specific controller to fire Extract Invoices process
*/
@Slf4j
@RestController
@RequestMapping("/job")
public class InvoiceExtractJobController extends AbstractJobController {
private static final String DEFAULT_INVOICES_EXTRACT_JOB_NAME = "InvoicesExtractJobSingleExecution";
public static final String INCLUDE_PAID = "includePaid";
/**
* Triggers the {@link InvoicesExtractJob} with the {@code delta} time to retrieve
* invoices created or updated since that {@code delta} and schedules the job with the
* {@code name} provided
* @param delta the {@link Date} in {@link DateTimeFormat.ISO}
* @param name the job name in {@link String}
* @param includePaid includes into the extraction paid invoices {@link Boolean}
* @return a {@link ResponseEntity <String>} with the name of the job scheduled
* @throws SchedulerException if quartz {@link org.quartz.Scheduler} fails
*/
@PostMapping("/invoices-extract")
public ResponseEntity<String> runJob(
@RequestParam(required = false) @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) final Date delta,
@RequestParam(required = false, defaultValue = DEFAULT_INVOICES_EXTRACT_JOB_NAME) final String name,
@RequestParam(required = false) final Boolean includePaid) throws SchedulerException {
runSingleJob(name, InvoicesExtractJob.class, delta,
includePaid != null ? Map.of(INCLUDE_PAID, includePaid) : Map.of());
return ResponseEntity.accepted().body(name);
}
}
| 5,174 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/aspects/UpdateStoredItemLinksAspect.java | package com.paypal.invoices.extractioncommons.aspects;
import com.mirakl.client.mmp.domain.shop.MiraklShops;
import com.paypal.invoices.extractioncommons.services.AccountingDocumentsLinksService;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Aspect that updates the stored item links after the Mirakl shops are retrieved, so the
* ItemLinks persistent cache is always up to date.
*/
@Slf4j
@Aspect
@Component
public class UpdateStoredItemLinksAspect {
private final AccountingDocumentsLinksService accountingDocumentsLinksService;
public UpdateStoredItemLinksAspect(final AccountingDocumentsLinksService accountingDocumentsLinksService) {
this.accountingDocumentsLinksService = accountingDocumentsLinksService;
}
/**
* Intercepts the getShops method from the MiraklClient, and updates the stored item
* links after the shops are retrieved.
* @param pjp ProceedingJoinPoint
* @return the original MiraklShops returned by the intercepted method
* @throws Throwable if the intercepted method throws an exception
*/
@Around("execution(* com.paypal.infrastructure.mirakl.client.MiraklClient.getShops(..))")
public MiraklShops interceptNotificationMethod(final ProceedingJoinPoint pjp) throws Throwable {
final MiraklShops shops = (MiraklShops) pjp.proceed();
updateStoredItemLinks(shops);
return shops;
}
private void updateStoredItemLinks(final MiraklShops shops) {
try {
if (shops == null) {
return;
}
accountingDocumentsLinksService
.updateLinksFromShops(shops.getShops() != null ? shops.getShops() : List.of());
}
catch (final Exception e) {
log.error("Error updating stored item links", e);
}
}
}
| 5,175 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/services/MiraklInvoiceLinksService.java | package com.paypal.invoices.extractioncommons.services;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemLinkLocator;
import com.paypal.infrastructure.itemlinks.model.MiraklItemLinkLocator;
import java.util.Collection;
import java.util.Map;
import java.util.Set;
/**
* This service retrieves from Mirakl the relationships with Hyperwallet items that are
* required for invoice processing. This relationships are:
* <ul>
* <li>{@link com.paypal.infrastructure.itemlinks.model.HyperwalletItemTypes#BANK_ACCOUNT}</li>
* <li>{@link com.paypal.infrastructure.itemlinks.model.HyperwalletItemTypes#PROGRAM}</li>
* </ul>
*
* This relationships are obtained from the custom fields of the Mirakl shop, so S20 will
* be used to retrieve this information.
*/
public interface MiraklInvoiceLinksService {
/**
* Retrieves from Mirakl the relationships with Hyperwallet items required for invoice
* processing for the provided shop ids.
* @param shopIds List of shop ids.
* @return A Map with the references to a Mirakl item of type Shop and the list of
* related Hyperwallet items references.
*/
Map<MiraklItemLinkLocator, Collection<HyperwalletItemLinkLocator>> getInvoiceRelatedShopLinks(Set<String> shopIds);
}
| 5,176 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/services/HyperWalletPaymentExtractService.java | package com.paypal.invoices.extractioncommons.services;
import com.hyperwallet.clientsdk.model.HyperwalletPayment;
import com.paypal.invoices.extractioncreditnotes.model.CreditNoteModel;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import java.util.Optional;
/**
* Service to manipulate the payment creation within Hyperwallet
*/
public interface HyperWalletPaymentExtractService {
/**
* Creates a payment of type {@link HyperwalletPayment} based on {@code invoices} for
* the payees
* @param invoice the {@link InvoiceModel}
* @return
*/
Optional<HyperwalletPayment> payPayeeInvoice(InvoiceModel invoice);
/**
* Creates a payment of type {@link HyperwalletPayment} based on {@code invoices} for
* the payees
* @param creditNote the {@link CreditNoteModel}
* @return
*/
Optional<HyperwalletPayment> payPayeeCreditNotes(CreditNoteModel creditNote);
/**
* Create a payment of type {@link HyperwalletPayment} based on {@code invoices} for
* the operator
* @param invoice the {@link InvoiceModel}
* @return
*/
Optional<HyperwalletPayment> payInvoiceOperator(InvoiceModel invoice);
}
| 5,177 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/services/AbstractAccountingDocumentsExtractServiceImpl.java | package com.paypal.invoices.extractioncommons.services;
import com.mirakl.client.mmp.domain.accounting.document.MiraklAccountingDocumentPaymentStatus;
import com.mirakl.client.mmp.domain.accounting.document.MiraklAccountingDocumentType;
import com.mirakl.client.mmp.domain.invoice.MiraklInvoice;
import com.mirakl.client.mmp.domain.invoice.MiraklInvoices;
import com.mirakl.client.mmp.domain.shop.MiraklShop;
import com.mirakl.client.mmp.operator.request.payment.invoice.MiraklGetInvoicesRequest;
import com.mirakl.client.mmp.request.payment.invoice.MiraklAccountingDocumentState;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.infrastructure.mirakl.client.MiraklClient;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import com.paypal.invoices.extractioncommons.model.InvoiceTypeEnum;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.EnumUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import static com.paypal.infrastructure.hyperwallet.constants.HyperWalletConstants.MIRAKL_MAX_RESULTS_PER_PAGE;
@Slf4j
@Service
public abstract class AbstractAccountingDocumentsExtractServiceImpl<T extends AccountingDocumentModel>
implements MiraklAccountingDocumentExtractService<T> {
protected final Converter<MiraklShop, AccountingDocumentModel> miraklShopToAccountingModelConverter;
protected final MiraklClient miraklMarketplacePlatformOperatorApiClient;
protected final AccountingDocumentsLinksService accountingDocumentsLinksService;
protected final MailNotificationUtil invoicesMailNotificationUtil;
@Value("${hmc.jobs.settings.search-invoices-maxdays}")
protected int maxNumberOfDaysForInvoiceIdSearch;
protected AbstractAccountingDocumentsExtractServiceImpl(
final Converter<MiraklShop, AccountingDocumentModel> miraklShopToAccountingModelConverter,
final MiraklClient miraklMarketplacePlatformOperatorApiClient,
final AccountingDocumentsLinksService accountingDocumentsLinksService,
final MailNotificationUtil invoicesMailNotificationUtil) {
this.miraklShopToAccountingModelConverter = miraklShopToAccountingModelConverter;
this.miraklMarketplacePlatformOperatorApiClient = miraklMarketplacePlatformOperatorApiClient;
this.accountingDocumentsLinksService = accountingDocumentsLinksService;
this.invoicesMailNotificationUtil = invoicesMailNotificationUtil;
}
@Override
public List<T> extractAccountingDocuments(final Date delta) {
return extractAccountingDocuments(delta, false);
}
@Override
public List<T> extractAccountingDocuments(final Date delta, final boolean includePaid) {
final List<MiraklInvoice> invoices = getInvoicesForDateAndType(delta, getInvoiceType(), includePaid);
//@formatter:off
return invoices.stream()
.map(getMiraklInvoiceToAccountingModelConverter()::convert)
.collect(Collectors.toList());
//@formatter:on
}
@NonNull
protected MiraklGetInvoicesRequest createAccountingDocumentRequest(final Date delta,
final InvoiceTypeEnum invoiceType) {
return createAccountingDocumentRequest(delta, invoiceType, false);
}
@NonNull
protected MiraklGetInvoicesRequest createAccountingDocumentRequest(final Date delta,
final InvoiceTypeEnum invoiceType, final boolean includePaid) {
final MiraklGetInvoicesRequest miraklGetInvoicesRequest = new MiraklGetInvoicesRequest();
miraklGetInvoicesRequest.setStartDate(delta);
if (!includePaid) {
miraklGetInvoicesRequest.setPaymentStatus(MiraklAccountingDocumentPaymentStatus.PENDING);
}
miraklGetInvoicesRequest.addState(MiraklAccountingDocumentState.COMPLETE);
miraklGetInvoicesRequest.setType(EnumUtils.getEnum(MiraklAccountingDocumentType.class, invoiceType.name()));
miraklGetInvoicesRequest.setMax(MIRAKL_MAX_RESULTS_PER_PAGE);
return miraklGetInvoicesRequest;
}
protected List<MiraklInvoice> getInvoicesForDateAndType(final Date delta, final InvoiceTypeEnum invoiceType) {
return getInvoicesForDateAndType(delta, invoiceType, false);
}
protected List<MiraklInvoice> getInvoicesForDateAndType(final Date delta, final InvoiceTypeEnum invoiceType,
final boolean includePaid) {
final List<MiraklInvoice> invoices = new ArrayList<>();
int offset = 0;
final MiraklGetInvoicesRequest accountingDocumentRequest = createAccountingDocumentRequest(delta, invoiceType,
includePaid);
while (true) {
accountingDocumentRequest.setOffset(offset);
final MiraklInvoices receivedInvoices = miraklMarketplacePlatformOperatorApiClient
.getInvoices(accountingDocumentRequest);
invoices.addAll(receivedInvoices.getInvoices());
if (receivedInvoices.getTotalCount() <= invoices.size()) {
break;
}
offset += MIRAKL_MAX_RESULTS_PER_PAGE;
}
return invoices;
}
@Override
public Collection<T> extractAccountingDocuments(final List<String> ids) {
final List<MiraklInvoice> invoices = getInvoicesForDateAndType(getTimeRangeForFindByIdInvoices(),
getInvoiceType());
//@formatter:off
return invoices.stream()
.filter(invoice -> ids.contains(invoice.getId()))
.map(getMiraklInvoiceToAccountingModelConverter()::convert)
.collect(Collectors.toList());
//@formatter:on
}
private Date getTimeRangeForFindByIdInvoices() {
return Date.from(LocalDateTime.now().minusMinutes(maxNumberOfDaysForInvoiceIdSearch).toInstant(ZoneOffset.UTC));
}
protected abstract InvoiceTypeEnum getInvoiceType();
protected abstract Converter<MiraklInvoice, T> getMiraklInvoiceToAccountingModelConverter();
}
| 5,178 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/services/MiraklInvoiceLinksServiceImpl.java | package com.paypal.invoices.extractioncommons.services;
import com.mirakl.client.core.exception.MiraklApiException;
import com.mirakl.client.mmp.domain.shop.MiraklShop;
import com.mirakl.client.mmp.domain.shop.MiraklShops;
import com.mirakl.client.mmp.request.shop.MiraklGetShopsRequest;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemLinkLocator;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemTypes;
import com.paypal.infrastructure.itemlinks.model.MiraklItemLinkLocator;
import com.paypal.infrastructure.itemlinks.model.MiraklItemTypes;
import com.paypal.infrastructure.mirakl.client.MiraklClient;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.infrastructure.support.logging.MiraklLoggingErrorsUtil;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.ListUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
@Slf4j
@Service
public class MiraklInvoiceLinksServiceImpl implements MiraklInvoiceLinksService {
private final MiraklClient miraklMarketplacePlatformOperatorApiClient;
private final Converter<MiraklShop, AccountingDocumentModel> miraklShopToAccountingModelConverter;
public MiraklInvoiceLinksServiceImpl(final MiraklClient miraklMarketplacePlatformOperatorApiClient,
final Converter<MiraklShop, AccountingDocumentModel> miraklShopToAccountingModelConverter) {
this.miraklMarketplacePlatformOperatorApiClient = miraklMarketplacePlatformOperatorApiClient;
this.miraklShopToAccountingModelConverter = miraklShopToAccountingModelConverter;
}
@Override
public Map<MiraklItemLinkLocator, Collection<HyperwalletItemLinkLocator>> getInvoiceRelatedShopLinks(
final Set<String> shopIds) {
if (shopIds.isEmpty()) {
return Map.of();
}
final Map<String, MiraklShop> miraklShops = getAllShops(shopIds);
//@formatter:off
return shopIds.stream()
.map(this::createMiraklItemLocator)
.collect(Collectors.toMap(Function.identity(), miraklLocator -> getHyperwalletLinks(miraklShops.get(miraklLocator.getId()))));
//@formatter:on
}
private Collection<HyperwalletItemLinkLocator> getHyperwalletLinks(final MiraklShop miraklShop) {
if (miraklShop == null) {
return Collections.emptyList();
}
return extractHyperwalletItemLocators(miraklShopToAccountingModelConverter.convert(miraklShop));
}
private Set<HyperwalletItemLinkLocator> extractHyperwalletItemLocators(final AccountingDocumentModel invoiceModel) {
final Set<HyperwalletItemLinkLocator> hyperwalletItemLinkLocators = new HashSet<>();
if (StringUtils.isNotEmpty(invoiceModel.getDestinationToken())) {
hyperwalletItemLinkLocators.add(new HyperwalletItemLinkLocator(invoiceModel.getDestinationToken(),
HyperwalletItemTypes.BANK_ACCOUNT));
}
if (StringUtils.isNotEmpty(invoiceModel.getHyperwalletProgram())) {
hyperwalletItemLinkLocators.add(
new HyperwalletItemLinkLocator(invoiceModel.getHyperwalletProgram(), HyperwalletItemTypes.PROGRAM));
}
return hyperwalletItemLinkLocators;
}
private MiraklItemLinkLocator createMiraklItemLocator(final String shopId) {
return new MiraklItemLinkLocator(shopId, MiraklItemTypes.SHOP);
}
protected Map<String, MiraklShop> getAllShops(final Set<String> shopIds) {
final List<List<String>> partitionedShopIds = ListUtils.partition(new ArrayList<>(shopIds), 100);
//@formatter:off
final List<MiraklShop> miraklShops = partitionedShopIds.stream()
.map(this::getAllShopsWithoutPartitioning)
.flatMap(List::stream)
.collect(Collectors.toList());
//@formatter:on
return miraklShops.stream().collect(Collectors.toMap(MiraklShop::getId, Function.identity()));
}
private List<MiraklShop> getAllShopsWithoutPartitioning(final List<String> shopIds) {
if (shopIds.isEmpty()) {
return Collections.emptyList();
}
try {
final MiraklGetShopsRequest request = createShopRequest(new HashSet<>(shopIds));
final MiraklShops miraklShops = miraklMarketplacePlatformOperatorApiClient.getShops(request);
return miraklShops.getShops();
}
catch (final MiraklApiException ex) {
log.warn(
"Error while recovering shop info during invoice processing. Failing shop ids[%s]. Failure reason: %s"
.formatted(String.join(",", shopIds), MiraklLoggingErrorsUtil.stringify(ex)));
return Collections.emptyList();
}
}
@NonNull
private MiraklGetShopsRequest createShopRequest(final Set<String> shopIds) {
final MiraklGetShopsRequest request = new MiraklGetShopsRequest();
request.setShopIds(shopIds);
request.setPaginate(false);
return request;
}
}
| 5,179 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/services/AccountingDocumentsLinksServiceImpl.java | package com.paypal.invoices.extractioncommons.services;
import com.mirakl.client.mmp.domain.shop.MiraklShop;
import com.paypal.infrastructure.itemlinks.model.*;
import com.paypal.infrastructure.itemlinks.services.ItemLinksService;
import com.paypal.infrastructure.mirakl.support.MiraklShopUtils;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import org.jetbrains.annotations.NotNull;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;
@Service
public class AccountingDocumentsLinksServiceImpl implements AccountingDocumentsLinksService {
private static final Set<HyperwalletItemTypes> REQUIRED_HYPERWALLET_TYPES = Set
.of(HyperwalletItemTypes.BANK_ACCOUNT, HyperwalletItemTypes.PROGRAM);
private final ItemLinksService itemLinksService;
private final MiraklInvoiceLinksService miraklInvoiceLinksService;
public AccountingDocumentsLinksServiceImpl(final ItemLinksService itemLinksService,
final MiraklInvoiceLinksService miraklInvoiceLinksService) {
this.itemLinksService = itemLinksService;
this.miraklInvoiceLinksService = miraklInvoiceLinksService;
}
@Override
public <T extends AccountingDocumentModel> void storeRequiredLinks(final Collection<T> accountingDocumentModels) {
final Map<MiraklItemLinkLocator, Collection<HyperwalletItemLinkLocator>> retrievedFromHmcShopLinks = itemLinksService
.findLinks(getMiraklItemLocators(getShopIdsSet(accountingDocumentModels)), REQUIRED_HYPERWALLET_TYPES);
//@formatter:off
final Set<MiraklItemLinkLocator> notFoundShopLinks = retrievedFromHmcShopLinks.entrySet().stream()
.filter(e -> !hasAllRequiredShopLinks(e.getValue()))
.map(Map.Entry::getKey)
.collect(Collectors.toSet());
//@formatter:on
final Map<MiraklItemLinkLocator, Collection<HyperwalletItemLinkLocator>> retrievedFromMiraklShopLinks = miraklInvoiceLinksService
.getInvoiceRelatedShopLinks(getShopIdsSet(notFoundShopLinks));
retrievedFromMiraklShopLinks.forEach(itemLinksService::createLinks);
}
@Override
public <T extends AccountingDocumentModel> Collection<HyperwalletItemLinkLocator> findRequiredLinks(
final T accountingDocumentModel) {
return itemLinksService.findLinks(
new MiraklItemLinkLocator(accountingDocumentModel.getShopId(), MiraklItemTypes.SHOP),
REQUIRED_HYPERWALLET_TYPES);
}
@Override
public void updateLinksFromShops(@NotNull final Collection<MiraklShop> shops) {
final Map<MiraklItemLinkLocator, Collection<HyperwalletItemLinkLocator>> linksFromShops = shops.stream()
.map(this::getItemLocatorsFromShop).filter(Optional::isPresent).map(Optional::get)
.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
linksFromShops.forEach(itemLinksService::createLinks);
}
private Optional<Map.Entry<MiraklItemLinkLocator, Collection<HyperwalletItemLinkLocator>>> getItemLocatorsFromShop(
final MiraklShop shop) {
final MiraklItemLinkLocator miraklItemLinkLocator = createMiraklItemLocator(shop.getId());
final Optional<HyperwalletItemLinkLocator> bankAccountItemLinkLocator = MiraklShopUtils
.getBankAccountToken(shop).map(bankAccountToken -> new HyperwalletItemLinkLocator(bankAccountToken,
HyperwalletItemTypes.BANK_ACCOUNT));
final Optional<HyperwalletItemLinkLocator> programItemLinkLocator = MiraklShopUtils.getProgram(shop)
.map(programToken -> new HyperwalletItemLinkLocator(programToken, HyperwalletItemTypes.PROGRAM));
final Collection<HyperwalletItemLinkLocator> hyperwalletItemLinkLocators = Stream
.of(bankAccountItemLinkLocator, programItemLinkLocator).filter(Optional::isPresent).map(Optional::get)
.toList();
return hyperwalletItemLinkLocators.isEmpty() ? Optional.empty()
: Optional.of(Map.entry(miraklItemLinkLocator, hyperwalletItemLinkLocators));
}
private boolean hasAllRequiredShopLinks(final Collection<HyperwalletItemLinkLocator> hyperwalletItemLinkLocators) {
if (hyperwalletItemLinkLocators.isEmpty()) {
return false;
}
return hyperwalletItemLinkLocators.stream().map(HyperwalletItemLinkLocator::getType).collect(Collectors.toSet())
.containsAll(REQUIRED_HYPERWALLET_TYPES);
}
@NotNull
private <T extends AccountingDocumentModel> Set<String> getShopIdsSet(
final Collection<T> accountingDocumentModels) {
//@formatter:off
return accountingDocumentModels.stream()
.map(AccountingDocumentModel::getShopId)
.collect(Collectors.toSet());
//@formatter:on
}
@NotNull
private Set<String> getShopIdsSet(final Set<MiraklItemLinkLocator> notFoundShopLinks) {
return notFoundShopLinks.stream().map(ItemLinkLocator::getId).collect(Collectors.toSet());
}
@NotNull
private Set<MiraklItemLinkLocator> getMiraklItemLocators(final Set<String> invoiceShopIds) {
return invoiceShopIds.stream().map(this::createMiraklItemLocator).collect(Collectors.toSet());
}
private MiraklItemLinkLocator createMiraklItemLocator(final String shopId) {
return new MiraklItemLinkLocator(shopId, MiraklItemTypes.SHOP);
}
}
| 5,180 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/services/MiraklAccountingDocumentExtractService.java | package com.paypal.invoices.extractioncommons.services;
import com.mirakl.client.mmp.domain.invoice.MiraklInvoice;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import org.springframework.lang.Nullable;
import java.util.Collection;
import java.util.Date;
import java.util.List;
public interface MiraklAccountingDocumentExtractService<T extends AccountingDocumentModel> {
/**
* Extracts the {@link MiraklInvoice} data from Mirakl environment
* @param delta Optional parameter to filter all invoices that have been modified
* since this parameter value
* @return a {@link List} of {@link InvoiceModel}
*/
List<T> extractAccountingDocuments(@Nullable Date delta);
/**
* Extracts the {@link MiraklInvoice} data from Mirakl environment
* @param delta Optional parameter to filter all invoices that have been modified
* @param includePaid Optional parameter to filter all invoices that have been paid
* since this parameter value
* @return a {@link List} of {@link InvoiceModel}
*/
List<T> extractAccountingDocuments(@Nullable Date delta, boolean includePaid);
/**
* Extracts the {@link MiraklInvoice} data from Mirakl environment
* @param ids List of identifiers of the invoices to be returned
* @return a {@link List} of {@link InvoiceModel}
*/
Collection<T> extractAccountingDocuments(List<String> ids);
}
| 5,181 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/services/HyperWalletPaymentExtractServiceImpl.java | package com.paypal.invoices.extractioncommons.services;
import com.hyperwallet.clientsdk.HyperwalletException;
import com.hyperwallet.clientsdk.model.HyperwalletList;
import com.hyperwallet.clientsdk.model.HyperwalletPayment;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.infrastructure.support.exceptions.HMCException;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.infrastructure.support.logging.HyperwalletLoggingErrorsUtil;
import com.paypal.invoices.extractioncommons.connectors.PaymentHyperwalletApiClient;
import com.paypal.invoices.paymentnotifications.configuration.PaymentNotificationConfig;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import com.paypal.invoices.extractioncreditnotes.model.CreditNoteModel;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Collection;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* Class that connects with hyperwallet to creates the payments
*/
@Slf4j
@Service
public class HyperWalletPaymentExtractServiceImpl implements HyperWalletPaymentExtractService {
protected final Converter<InvoiceModel, HyperwalletPayment> payeeInvoiceModelToHyperwalletPaymentConverter;
protected final Converter<InvoiceModel, HyperwalletPayment> operatorInvoiceModelToHyperwalletPaymentConverter;
protected final Converter<CreditNoteModel, HyperwalletPayment> payeeCreditModelToHyperwalletPaymentConverter;
protected final MailNotificationUtil mailNotificationUtil;
protected final PaymentHyperwalletApiClient client;
protected final PaymentNotificationConfig paymentNotificationConfig;
public HyperWalletPaymentExtractServiceImpl(
final Converter<InvoiceModel, HyperwalletPayment> payeeInvoiceModelToHyperwalletPaymentConverter,
final Converter<InvoiceModel, HyperwalletPayment> operatorInvoiceModelToHyperwalletPaymentConverter,
final Converter<CreditNoteModel, HyperwalletPayment> payeeCreditModelToHyperwalletPaymentConverter,
final MailNotificationUtil mailNotificationUtil, final PaymentHyperwalletApiClient client,
final PaymentNotificationConfig paymentNotificationConfig) {
this.payeeInvoiceModelToHyperwalletPaymentConverter = payeeInvoiceModelToHyperwalletPaymentConverter;
this.operatorInvoiceModelToHyperwalletPaymentConverter = operatorInvoiceModelToHyperwalletPaymentConverter;
this.payeeCreditModelToHyperwalletPaymentConverter = payeeCreditModelToHyperwalletPaymentConverter;
this.mailNotificationUtil = mailNotificationUtil;
this.client = client;
this.paymentNotificationConfig = paymentNotificationConfig;
}
/**
* {@inheritDoc}
* @return
*/
@Override
public Optional<HyperwalletPayment> payPayeeInvoice(final InvoiceModel invoice) {
return payInvoice(invoice, payeeInvoiceModelToHyperwalletPaymentConverter);
}
@Override
public Optional<HyperwalletPayment> payPayeeCreditNotes(final CreditNoteModel creditNote) {
return payInvoice(creditNote, payeeCreditModelToHyperwalletPaymentConverter);
}
@Override
public Optional<HyperwalletPayment> payInvoiceOperator(final InvoiceModel invoice) {
return payInvoice(invoice, operatorInvoiceModelToHyperwalletPaymentConverter);
}
protected <T extends AccountingDocumentModel> Optional<HyperwalletPayment> payInvoice(final T invoice,
final Converter<T, HyperwalletPayment> invoiceConverter) {
final HyperwalletPayment pendingPayment = invoiceConverter.convert(invoice);
if (isInvoiceCreated(pendingPayment)) {
log.warn("Invoice {} already sent to Hyperwallet", pendingPayment.getClientPaymentId());
return Optional.empty();
}
log.info("Pending invoices to pay: [{}]", pendingPayment.getClientPaymentId());
final HyperwalletPayment paidInvoice = createPayment(pendingPayment);
log.info("Paid invoices: [{}]", paidInvoice.getClientPaymentId());
return Optional.of(paidInvoice);
}
protected HyperwalletPayment createPayment(final HyperwalletPayment hyperwalletPayment) {
try {
log.info("Trying to create payment for invoice [{}]", hyperwalletPayment.getClientPaymentId());
final HyperwalletPayment payment = client.createPayment(hyperwalletPayment);
log.info("Payment successfully created for invoice [{}]", hyperwalletPayment.getClientPaymentId());
return payment;
}
catch (final HyperwalletException e) {
mailNotificationUtil
.sendPlainTextEmail("Issue detected when creating payment for an invoice in Hyperwallet",
"Something went wrong creating payment for invoice [%s]%n%s".formatted(
hyperwalletPayment.getClientPaymentId(),
HyperwalletLoggingErrorsUtil.stringify(e)));
log.error("Something went wrong creating payment for invoice [%s].%n%s"
.formatted(hyperwalletPayment.getClientPaymentId(), HyperwalletLoggingErrorsUtil.stringify(e)), e);
throw new HMCException("Error while invoking Hyperwallet", e);
}
}
protected boolean isInvoiceCreated(final HyperwalletPayment payment) {
try {
return getPayments(payment.getProgramToken(), payment.getClientPaymentId()).stream()
.map(HyperwalletPayment::getStatus)
.anyMatch(status -> !paymentNotificationConfig.getFailureStatuses().contains(status));
}
catch (final Exception e) {
// Let the flow of execution continue. Checking the existence of the payment
// shouldn't abort
// the payment creation process. If something is wrong the payment creation
// should fail and that
// is going to trigger the error reporting process (currently via email)s.
return false;
}
}
protected Collection<HyperwalletPayment> getPayments(final String programToken, final String clientPaymentId) {
try {
final HyperwalletList<HyperwalletPayment> payments = client.listPayments(programToken, clientPaymentId);
return extractPaymentsFromQueryDTO(payments);
}
catch (final HyperwalletException e) {
log.error("Something went wrong trying to find payment for invoice [%s].%n%s".formatted(clientPaymentId,
HyperwalletLoggingErrorsUtil.stringify(e)), e);
throw new HMCException("Error while invoking Hyperwallet", e);
}
}
private Collection<HyperwalletPayment> extractPaymentsFromQueryDTO(
final HyperwalletList<HyperwalletPayment> payments) {
return Stream.ofNullable(payments).map(HyperwalletList::getData).filter(Objects::nonNull)
.flatMap(Collection::stream).collect(Collectors.toUnmodifiableList());
}
}
| 5,182 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/services/AccountingDocumentsLinksService.java | package com.paypal.invoices.extractioncommons.services;
import com.mirakl.client.mmp.domain.shop.MiraklShop;
import com.paypal.infrastructure.itemlinks.model.HyperwalletItemLinkLocator;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import org.jetbrains.annotations.NotNull;
import java.util.Collection;
/**
* This service manages the relationships between Mirakl and Hyperwallet items that are
* needed for the invoice creation process.
*
* It ensures that all the relationships required for the processing are stored in the HMC
* and tries to recover from Mirakl the additional relationships that weren't found on the
* HMC
*
* @see {@link MiraklInvoiceLinksService}
*/
public interface AccountingDocumentsLinksService {
/**
* Stores the required relationships to be used during invoice processing for the
* collection of invoices provided.
*
* It checks if the relationships are already stored in HMC and if not found it tries
* to recovers the information from Mirakl using {@link MiraklInvoiceLinksService}
* @param accountingDocumentModels A collection of {@link AccountingDocumentModel}.
* @param <T> Type of the invoice
*/
<T extends AccountingDocumentModel> void storeRequiredLinks(Collection<T> accountingDocumentModels);
/**
* Retrieves the required relationships between Mirakl and Hyperwallet needed for the
* processing of the provided invoice.
*
* These relationships are retrieved from HMC local storage, so not found
* relationships are not requested to Mirakl API.
* @param accountingDocumentModel The invoice.
* @param <T> Type of the invoice
* @return
*/
<T extends AccountingDocumentModel> Collection<HyperwalletItemLinkLocator> findRequiredLinks(
T accountingDocumentModel);
/**
* Updates the relationships between Mirakl and Hyperwallet for the provided shops.
* This information is used during the processing of the invoices
*
* This method is used to update the relationships when a shop is updated on Mirakl.
* @param shops A collection of {@link MiraklShop}.
*/
void updateLinksFromShops(@NotNull Collection<MiraklShop> shops);
}
| 5,183 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/services | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncommons/services/converters/MiraklShopToAccountingModelConverter.java | package com.paypal.invoices.extractioncommons.services.converters;
import com.mirakl.client.mmp.domain.common.MiraklAdditionalFieldValue;
import com.mirakl.client.mmp.domain.shop.MiraklShop;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.invoices.extractioncommons.model.AccountingDocumentModel;
import com.paypal.invoices.extractioninvoices.model.InvoiceModel;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* Class to convert from {@link MiraklShop} to {@link InvoiceModel}
*/
@Service
public class MiraklShopToAccountingModelConverter implements Converter<MiraklShop, AccountingDocumentModel> {
/**
* {@inheritDoc}
*/
@Override
public AccountingDocumentModel convert(final @NonNull MiraklShop source) {
final List<MiraklAdditionalFieldValue> additionalFieldValues = source.getAdditionalFieldValues();
//@formatter:off
return getBuilder()
.hyperwalletProgram(source.getAdditionalFieldValues())
.shopId(source.getId())
.destinationToken(additionalFieldValues)
.build();
//@formatter:on
}
@SuppressWarnings("java:S3740")
protected AccountingDocumentModel.Builder getBuilder() {
return AccountingDocumentModel.builder();
}
}
| 5,184 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/management | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/management/controllers/InvoicesConfigurationController.java | package com.paypal.invoices.management.controllers;
import com.paypal.invoices.management.controllers.dto.CommissionsConfigurationDto;
import com.paypal.invoices.management.services.InvoicesConfigurationService;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/configuration/invoices")
public class InvoicesConfigurationController {
private final InvoicesConfigurationService invoicesConfigurationService;
public InvoicesConfigurationController(final InvoicesConfigurationService invoicesConfigurationService) {
this.invoicesConfigurationService = invoicesConfigurationService;
}
@PutMapping("/commissions")
public ResponseEntity<String> setCommissions(
@RequestBody final CommissionsConfigurationDto commissionsConfiguration) {
invoicesConfigurationService
.setOperatorCommissionsEnabled(commissionsConfiguration.isOperatorCommissionsEnabled());
return ResponseEntity.ok().build();
}
@GetMapping("/commissions")
public ResponseEntity<CommissionsConfigurationDto> getCommissions() {
return new ResponseEntity<>(
new CommissionsConfigurationDto(invoicesConfigurationService.isOperatorCommissionsEnabled()),
HttpStatus.OK);
}
}
| 5,185 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/management/controllers | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/management/controllers/dto/CommissionsConfigurationDto.java | package com.paypal.invoices.management.controllers.dto;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@AllArgsConstructor
@NoArgsConstructor
public class CommissionsConfigurationDto {
private boolean operatorCommissionsEnabled;
}
| 5,186 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/management | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/management/services/InvoicesConfigurationServiceImpl.java | package com.paypal.invoices.management.services;
import com.paypal.invoices.extractioninvoices.configuration.InvoicesOperatorCommissionsConfig;
import org.springframework.stereotype.Service;
@Service
public class InvoicesConfigurationServiceImpl implements InvoicesConfigurationService {
private final InvoicesOperatorCommissionsConfig invoicesOperatorCommissionsConfig;
public InvoicesConfigurationServiceImpl(final InvoicesOperatorCommissionsConfig invoicesOperatorCommissionsConfig) {
this.invoicesOperatorCommissionsConfig = invoicesOperatorCommissionsConfig;
}
@Override
public boolean isOperatorCommissionsEnabled() {
return invoicesOperatorCommissionsConfig.isEnabled();
}
@Override
public void setOperatorCommissionsEnabled(final boolean enabled) {
invoicesOperatorCommissionsConfig.setEnabled(enabled);
}
}
| 5,187 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/management | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/management/services/InvoicesConfigurationService.java | package com.paypal.invoices.management.services;
public interface InvoicesConfigurationService {
boolean isOperatorCommissionsEnabled();
void setOperatorCommissionsEnabled(boolean enabled);
}
| 5,188 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/configuration/PaymentNotificationConfig.java | package com.paypal.invoices.paymentnotifications.configuration;
import lombok.Getter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;
import java.util.Set;
/**
* Configuration class to handle the payment notifications
*/
@Getter
@Configuration
public class PaymentNotificationConfig {
@Value("#{'${hmc.webhooks.payments.failure-statuses}'}")
private Set<String> failureStatuses;
@Value("#{'${hmc.webhooks.payments.accepted-statuses}'}")
private Set<String> acceptedStatuses;
}
| 5,189 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/model/PaymentNotificationBodyModel.java | package com.paypal.invoices.paymentnotifications.model;
import com.paypal.notifications.storage.model.NotificationBodyModel;
import lombok.Builder;
import lombok.Getter;
/**
* Represents an payment notification
*/
@Getter
@Builder(toBuilder = true)
public class PaymentNotificationBodyModel implements NotificationBodyModel {
private final String token;
private final String status;
private final String createdOn;
private final String amount;
private final String currency;
private final String clientPaymentId;
private final String notes;
private final String purpose;
private final String releaseOn;
private final String expiresOn;
private final String destinationToken;
private final String programToken;
}
| 5,190 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/listeners/PaymentListener.java | package com.paypal.invoices.paymentnotifications.listeners;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.invoices.paymentnotifications.services.PaymentNotificationService;
import com.paypal.notifications.events.model.PaymentEvent;
import com.paypal.notifications.events.support.AbstractNotificationListener;
import com.paypal.notifications.failures.repositories.FailedNotificationInformationRepository;
import com.paypal.notifications.storage.repositories.entities.NotificationInfoEntity;
import org.springframework.stereotype.Component;
/**
* Listener for payment notification events
*/
@Component
public class PaymentListener extends AbstractNotificationListener<PaymentEvent> {
private static final String NOTIFICATION_TYPE = "payment";
private final PaymentNotificationService paymentNotificationService;
public PaymentListener(final MailNotificationUtil mailNotificationUtil,
final PaymentNotificationService paymentNotificationService,
final FailedNotificationInformationRepository failedNotificationInformationRepository,
final Converter<HyperwalletWebhookNotification, NotificationInfoEntity> notificationInfoEntityToNotificationConverter) {
super(mailNotificationUtil, failedNotificationInformationRepository,
notificationInfoEntityToNotificationConverter);
this.paymentNotificationService = paymentNotificationService;
}
@Override
protected void processNotification(final HyperwalletWebhookNotification notification) {
paymentNotificationService.processPaymentNotification(notification);
}
@Override
protected String getNotificationType() {
return NOTIFICATION_TYPE;
}
}
| 5,191 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/services/FailurePaymentNotificationStrategy.java | package com.paypal.invoices.paymentnotifications.services;
import com.hyperwallet.clientsdk.Hyperwallet;
import com.hyperwallet.clientsdk.HyperwalletException;
import com.hyperwallet.clientsdk.model.HyperwalletUser;
import com.paypal.infrastructure.hyperwallet.services.UserHyperwalletSDKService;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.infrastructure.support.logging.HyperwalletLoggingErrorsUtil;
import com.paypal.infrastructure.support.strategy.Strategy;
import com.paypal.invoices.paymentnotifications.configuration.PaymentNotificationConfig;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import java.util.Objects;
/**
* Class that handles the error on payment notifications
*/
@Service
@Slf4j
public class FailurePaymentNotificationStrategy implements Strategy<PaymentNotificationBodyModel, Void> {
public static final String EMAILMSG_WITHSHOPINFO_SUBJECT = "Problem while processing payment [%s] of shop %s with id [%s]";
public static final String EMAILMSG_WITHSHOPINFO_BODY = "A problem has been detected while processing the payment corresponding to the invoice [%s] of the shop %s with id [%s].%n"
+ "The status received for the payment is [%s].%n"
+ "For more information please consult your Hyperwallet dashboard.";
public static final String EMAILMSG_NOSHOPINFO_SUBJECT = "Problem while processing payment [%s]";
public static final String EMAILMSG_NOSHOPINFO_BODY = "A problem has been detected while processing the payment corresponding to the invoice [%s].%n"
+ "The status received for the payment is [%s].%n"
+ "For more information please consult your Hyperwallet dashboard.";
@Resource
private PaymentNotificationConfig paymentNotificationConfig;
@Resource
private MailNotificationUtil mailNotificationUtil;
@Resource
private UserHyperwalletSDKService userHyperwalletSDKService;
/**
* Executes the business logic based on the content of
* {@code paymentNotificationBodyModel} and returns a {@link Void} class based on a
* set of strategies
* @param paymentNotificationBodyModel the paymentNotificationBodyModel object of type
* {@link PaymentNotificationBodyModel}
* @return the converted object of type {@link Void}
*/
@Override
public Void execute(final PaymentNotificationBodyModel paymentNotificationBodyModel) {
final HyperwalletUser hyperwalletUser = getHyperwalletUserInfo(paymentNotificationBodyModel);
if (hyperwalletUser != null) {
sendErrorMailWithShopInfo(paymentNotificationBodyModel, hyperwalletUser);
}
else {
sendErrorMailWithoutShopInfo(paymentNotificationBodyModel);
}
return null;
}
private void sendErrorMailWithShopInfo(final PaymentNotificationBodyModel paymentNotificationBodyModel,
final HyperwalletUser hyperwalletUser) {
//@formatter:off
final String shopName = StringUtils.hasText(hyperwalletUser.getBusinessName()) ? hyperwalletUser.getBusinessName() :
"%s %s".formatted(hyperwalletUser.getFirstName(), hyperwalletUser.getLastName());
mailNotificationUtil.sendPlainTextEmail(
String.format(EMAILMSG_WITHSHOPINFO_SUBJECT,
paymentNotificationBodyModel.getClientPaymentId(), shopName, hyperwalletUser.getClientUserId()),
String.format(EMAILMSG_WITHSHOPINFO_BODY,
paymentNotificationBodyModel.getClientPaymentId(), shopName, hyperwalletUser.getClientUserId(),
paymentNotificationBodyModel.getStatus()));
//@formatter:on
}
private void sendErrorMailWithoutShopInfo(final PaymentNotificationBodyModel paymentNotificationBodyModel) {
//@formatter:off
mailNotificationUtil.sendPlainTextEmail(
String.format(EMAILMSG_NOSHOPINFO_SUBJECT, paymentNotificationBodyModel.getClientPaymentId()),
String.format(EMAILMSG_NOSHOPINFO_BODY, paymentNotificationBodyModel.getClientPaymentId(),
paymentNotificationBodyModel.getStatus()));
//@formatter:on
}
/**
* Checks whether the strategy must be executed based on the
* {@code paymentNotificationBodyModel}
* @param paymentNotificationBodyModel the paymentNotificationBodyModel object
* @return returns whether the strategy is applicable or not
*/
@Override
public boolean isApplicable(final PaymentNotificationBodyModel paymentNotificationBodyModel) {
return Objects.nonNull(paymentNotificationBodyModel)
&& paymentNotificationConfig.getFailureStatuses().contains(paymentNotificationBodyModel.getStatus());
}
HyperwalletUser getHyperwalletUserInfo(final PaymentNotificationBodyModel paymentNotificationBodyModel) {
final Hyperwallet hyperwallet = userHyperwalletSDKService
.getHyperwalletInstanceByProgramToken(paymentNotificationBodyModel.getProgramToken());
try {
return hyperwallet.getUser(paymentNotificationBodyModel.getDestinationToken());
}
catch (final HyperwalletException e) {
log.warn(String.format("Error while retrieving Hyperwallet User info for destination token[%s].%n%s",
paymentNotificationBodyModel.getDestinationToken(), HyperwalletLoggingErrorsUtil.stringify(e)), e);
return null;
}
}
}
| 5,192 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/services/EmptyPaymentNotificationStrategy.java | package com.paypal.invoices.paymentnotifications.services;
import com.paypal.infrastructure.support.strategy.Strategy;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Objects;
/**
* Class that logs that a notification is empty
*/
@Service
@Slf4j
public class EmptyPaymentNotificationStrategy implements Strategy<PaymentNotificationBodyModel, Void> {
/**
* Executes the business logic based on the content of
* {@code paymentNotificationBodyModel} and returns a {@link Void} class based on a
* set of strategies
* @param paymentNotificationBodyModel the paymentNotificationBodyModel object of type
* {@link PaymentNotificationBodyModel}
* @return the converted object of type {@link Void}
*/
@Override
public Void execute(final PaymentNotificationBodyModel paymentNotificationBodyModel) {
log.warn("Payment notification received with a null object.");
return null;
}
/**
* Checks whether the strategy must be executed based on the
* {@code paymentNotificationBodyModel}
* @param paymentNotificationBodyModel the paymentNotificationBodyModel object
* @return returns whether the strategy is applicable or not
*/
@Override
public boolean isApplicable(final PaymentNotificationBodyModel paymentNotificationBodyModel) {
return Objects.isNull(paymentNotificationBodyModel);
}
}
| 5,193 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/services/PaymentNotificationService.java | package com.paypal.invoices.paymentnotifications.services;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
/**
* Service to process incoming payment notifications
*/
public interface PaymentNotificationService {
/**
* Process the {@link HyperwalletWebhookNotification} notification and send it to
* Mirakl
* @param incomingNotificationDTO {@link HyperwalletWebhookNotification} Payment
* notification
*/
void processPaymentNotification(HyperwalletWebhookNotification incomingNotificationDTO);
}
| 5,194 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/services/AcceptedPaymentNotificationStrategy.java | package com.paypal.invoices.paymentnotifications.services;
import com.mirakl.client.mmp.domain.common.currency.MiraklIsoCurrencyCode;
import com.mirakl.client.mmp.domain.invoice.MiraklAccountingDocumentPaymentConfirmation;
import com.mirakl.client.mmp.request.invoice.MiraklConfirmAccountingDocumentPaymentRequest;
import com.paypal.infrastructure.hyperwallet.constants.HyperWalletConstants;
import com.paypal.infrastructure.mirakl.client.MiraklClient;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.infrastructure.support.strategy.Strategy;
import com.paypal.invoices.paymentnotifications.configuration.PaymentNotificationConfig;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.EnumUtils;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.List;
import java.util.Objects;
import static com.paypal.infrastructure.hyperwallet.constants.HyperWalletConstants.PAYMENT_OPERATOR_SUFFIX;
/**
* Strategy to update the status of an accepted payment in Mirakl
*/
@Slf4j
@Service
public class AcceptedPaymentNotificationStrategy implements Strategy<PaymentNotificationBodyModel, Void> {
@Resource
private PaymentNotificationConfig paymentNotificationConfig;
@Resource
private MiraklClient miraklClient;
/**
* Executes the business logic based on the content of
* {@code paymentNotificationBodyModel} and returns a {@link Void} class based on a
* set of strategies
* @param paymentNotificationBodyModel the paymentNotificationBodyModel object of type
* {@link PaymentNotificationBodyModel}
* @return the converted object of type {@link Void}
*/
@Override
public Void execute(final PaymentNotificationBodyModel paymentNotificationBodyModel) {
final MiraklConfirmAccountingDocumentPaymentRequest paymentConfirmationRequest = createPaymentConfirmationRequest(
paymentNotificationBodyModel);
miraklClient.confirmAccountingDocumentPayment(paymentConfirmationRequest);
return null;
}
protected MiraklConfirmAccountingDocumentPaymentRequest createPaymentConfirmationRequest(
final PaymentNotificationBodyModel paymentNotificationBodyModel) {
final MiraklAccountingDocumentPaymentConfirmation miraklAccountingDocumentPaymentConfirmation = new MiraklAccountingDocumentPaymentConfirmation();
miraklAccountingDocumentPaymentConfirmation.setAmount(new BigDecimal(paymentNotificationBodyModel.getAmount()));
miraklAccountingDocumentPaymentConfirmation.setCurrencyIsoCode(
EnumUtils.getEnum(MiraklIsoCurrencyCode.class, paymentNotificationBodyModel.getCurrency(), null));
miraklAccountingDocumentPaymentConfirmation
.setInvoiceId(Long.valueOf(paymentNotificationBodyModel.getClientPaymentId()));
miraklAccountingDocumentPaymentConfirmation
.setTransactionDate(DateUtil.convertToDate(paymentNotificationBodyModel.getCreatedOn(),
HyperWalletConstants.HYPERWALLET_DATE_FORMAT, DateUtil.TIME_UTC));
log.info("Creating payment confirmation request for invoice ID {} and amount {}",
miraklAccountingDocumentPaymentConfirmation.getInvoiceId(),
miraklAccountingDocumentPaymentConfirmation.getAmount());
return new MiraklConfirmAccountingDocumentPaymentRequest(List.of(miraklAccountingDocumentPaymentConfirmation));
}
/**
* Checks whether the strategy must be executed based on the
* {@code paymentNotificationBodyModel}
* @param paymentNotificationBodyModel the {@code paymentNotificationBodyModel} object
* @return returns whether the strategy is applicable or not
*/
@Override
public boolean isApplicable(final PaymentNotificationBodyModel paymentNotificationBodyModel) {
return Objects.nonNull(paymentNotificationBodyModel)
&& paymentNotificationConfig.getAcceptedStatuses().contains(paymentNotificationBodyModel.getStatus())
&& !paymentNotificationBodyModel.getClientPaymentId().endsWith(PAYMENT_OPERATOR_SUFFIX);
}
}
| 5,195 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/services/PaymentNotificationExecutor.java | package com.paypal.invoices.paymentnotifications.services;
import com.paypal.infrastructure.support.strategy.SingleAbstractStrategyExecutor;
import com.paypal.infrastructure.support.strategy.Strategy;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import org.springframework.stereotype.Service;
import java.util.Set;
/**
* Payment notification executor
*/
@Service
public class PaymentNotificationExecutor extends SingleAbstractStrategyExecutor<PaymentNotificationBodyModel, Void> {
private final Set<Strategy<PaymentNotificationBodyModel, Void>> strategies;
public PaymentNotificationExecutor(final Set<Strategy<PaymentNotificationBodyModel, Void>> strategies) {
this.strategies = strategies;
}
/**
* {@inheritDoc}
*/
@Override
protected Set<Strategy<PaymentNotificationBodyModel, Void>> getStrategies() {
return strategies;
}
}
| 5,196 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/services/PaymentNotificationServiceImpl.java | package com.paypal.invoices.paymentnotifications.services;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@Slf4j
@Service
public class PaymentNotificationServiceImpl implements PaymentNotificationService {
private final Converter<Object, PaymentNotificationBodyModel> hyperWalletObjectToPaymentNotificationBodyModelConverter;
private final PaymentNotificationExecutor paymentNotificationExecutor;
public PaymentNotificationServiceImpl(
final Converter<Object, PaymentNotificationBodyModel> hyperWalletObjectToPaymentNotificationBodyModelConverter,
final PaymentNotificationExecutor paymentNotificationExecutor) {
this.hyperWalletObjectToPaymentNotificationBodyModelConverter = hyperWalletObjectToPaymentNotificationBodyModelConverter;
this.paymentNotificationExecutor = paymentNotificationExecutor;
}
/**
* {@inheritDoc}
*/
@Override
public void processPaymentNotification(final HyperwalletWebhookNotification incomingNotificationDTO) {
final PaymentNotificationBodyModel paymentNotificationBodyModel = hyperWalletObjectToPaymentNotificationBodyModelConverter
.convert(incomingNotificationDTO.getObject());
paymentNotificationExecutor.execute(paymentNotificationBodyModel);
}
}
| 5,197 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/services | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/paymentnotifications/services/converters/HyperWalletObjectToPaymentNotificationBodyModelConverter.java | package com.paypal.invoices.paymentnotifications.services.converters;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.invoices.paymentnotifications.model.PaymentNotificationBodyModel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.Optional;
/**
* Class to convert from {@link Object} to {@link PaymentNotificationBodyModel}
*/
@Slf4j
@Service
public class HyperWalletObjectToPaymentNotificationBodyModelConverter
implements Converter<Object, PaymentNotificationBodyModel> {
/**
* {@inheritDoc}
*/
@SuppressWarnings("unchecked")
@Override
public PaymentNotificationBodyModel convert(final Object source) {
if (source instanceof Map) {
final Map<String, String> notificationDetails = (Map<String, String>) source;
//@formatter:off
return PaymentNotificationBodyModel.builder()
.programToken(Optional.ofNullable(notificationDetails.get("programToken")).orElse(null))
.token(Optional.ofNullable(notificationDetails.get("token")).orElse(null))
.status(Optional.ofNullable(notificationDetails.get("status")).orElse(null))
.createdOn(Optional.ofNullable(notificationDetails.get("createdOn")).orElse(null))
.amount(Optional.ofNullable(notificationDetails.get("amount")).orElse(null))
.currency(Optional.ofNullable(notificationDetails.get("currency")).orElse(null))
.clientPaymentId(Optional.ofNullable(notificationDetails.get("clientPaymentId")).orElse(null))
.notes(Optional.ofNullable(notificationDetails.get("notes")).orElse(null))
.purpose(Optional.ofNullable(notificationDetails.get("purpose")).orElse(null))
.releaseOn(Optional.ofNullable(notificationDetails.get("releaseOn")).orElse(null))
.expiresOn(Optional.ofNullable(notificationDetails.get("expiresOn")).orElse(null))
.destinationToken(Optional.ofNullable(notificationDetails.get("destinationToken")).orElse(null))
.build();
//@formatter:on
}
log.warn("The notification body looks empty");
return null;
}
}
| 5,198 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices | Create_ds/mirakl-hyperwallet-connector/hmc-invoices/src/main/java/com/paypal/invoices/extractioncreditnotes/CreditNotesExtractJobConfig.java | package com.paypal.invoices.extractioncreditnotes;
import com.paypal.invoices.extractioncreditnotes.batchjobs.CreditNotesRetryBatchJob;
import com.paypal.jobsystem.quartzadapter.job.QuartzBatchJobBuilder;
import org.quartz.CronScheduleBuilder;
import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class CreditNotesExtractJobConfig {
private static final String TRIGGER_SUFFIX = "Trigger";
private static final String RETRY_JOB_NAME = "CreditNotesRetryJob";
@Bean
public JobDetail creditNotesRetryJob(final CreditNotesRetryBatchJob creditNotesRetryBatchJob) {
//@formatter:off
return QuartzBatchJobBuilder.newJob(creditNotesRetryBatchJob)
.withIdentity(RETRY_JOB_NAME)
.storeDurably()
.build();
//@formatter:on
}
@Bean
public Trigger creditNotesRetryTrigger(@Qualifier("creditNotesRetryJob") final JobDetail jobDetails,
@Value("${hmc.jobs.scheduling.retry-jobs.creditnotes}") final String cronExpression) {
//@formatter:off
return TriggerBuilder.newTrigger()
.forJob(jobDetails)
.withIdentity(TRIGGER_SUFFIX + RETRY_JOB_NAME)
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
.build();
//@formatter:on
}
}
| 5,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.