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-reports/src/test/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services/converters/MiraklTransactionLineToFinancialReportLineConverterTest.java | package com.paypal.reports.services.converters;
import com.paypal.reports.model.HmcFinancialReportLine;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import com.paypal.reports.services.converters.MiraklTransactionLineToFinancialReportLineConverter;
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 java.time.LocalDateTime;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class MiraklTransactionLineToFinancialReportLineConverterTest {
private static final String SELLER_ID = "2000";
private static final String ORDER_ID = "120000";
private static final String TRANSACTION_NUMBER = "jhv8jh";
private static final String ORDER_AMOUNT = "ORDER_AMOUNT";
private static final String TRANSACTION_LINE_ID = "1234546587";
private static final BigDecimal CREDIT_AMOUNT = BigDecimal.valueOf(0.00D);
private static final BigDecimal DEBIT_AMOUNT = BigDecimal.valueOf(20.00D);
@InjectMocks
private MiraklTransactionLineToFinancialReportLineConverter testObj;
@Test
void convert_shouldReturnHMCFinancialReportTimeWithAttributesPopulatedWhenAFilledHMCMiraklTransactionLineIsPassed() {
final LocalDateTime now = LocalDateTime.now();
//@formatter:off
final HmcMiraklTransactionLine source = HmcMiraklTransactionLine.builder()
.amount(BigDecimal.valueOf(20.00D))
.currencyIsoCode("USD")
.transactionLineId(TRANSACTION_LINE_ID)
.creditAmount(CREDIT_AMOUNT)
.debitAmount(DEBIT_AMOUNT)
.sellerId(SELLER_ID)
.transactionNumber(TRANSACTION_NUMBER)
.transactionTime(now)
.orderId(ORDER_ID)
.transactionType(ORDER_AMOUNT)
.build();
//@formatter:on
final HmcFinancialReportLine result = testObj.convert(source);
assertThat(result.getMiraklTransactionLineId()).isEqualTo(TRANSACTION_LINE_ID);
assertThat(result.getMiraklTransactionTime()).isEqualTo(now);
assertThat(result.getMiraklTransactionType()).isEqualTo(ORDER_AMOUNT);
assertThat(result.getMiraklCreditAmount()).isEqualTo(CREDIT_AMOUNT);
assertThat(result.getMiraklDebitAmount()).isEqualTo(DEBIT_AMOUNT);
assertThat(result.getMiraklSellerId()).isEqualTo(SELLER_ID);
}
}
| 5,000 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services/converters/MiraklTransactionLogToMiraklTransactionLineModelConverterTest.java | package com.paypal.reports.services.converters;
import com.mirakl.client.mmp.domain.common.currency.MiraklIsoCurrencyCode;
import com.mirakl.client.mmp.domain.payment.MiraklTransactionLog;
import com.mirakl.client.mmp.domain.payment.MiraklTransactionType;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import com.paypal.reports.services.converters.MiraklTransactionLogToMiraklTransactionLineModelConverter;
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 java.time.LocalDateTime;
import java.util.Date;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class MiraklTransactionLogToMiraklTransactionLineModelConverterTest {
private static final BigDecimal AMOUNT_CREDITED = BigDecimal.valueOf(20.00D);
private static final BigDecimal AMOUNT_DEBITED = BigDecimal.valueOf(0.00D);
private static final BigDecimal AMOUNT = BigDecimal.valueOf(23.00D);
private static final String TRANSACTION_NUMBER = "mkl-2567478968";
private static final MiraklTransactionType TRANSACTION_TYPE = MiraklTransactionType.PAYMENT;
private static final String ID = "12358468";
private static final MiraklIsoCurrencyCode CURRENCY_ISO_CODE = MiraklIsoCurrencyCode.AUD;
private static final String SHOP_ID = "2000";
private static final String ORDER_ID = "231465455445";
@InjectMocks
private MiraklTransactionLogToMiraklTransactionLineModelConverter testObj;
@Test
void convert_shouldReturnPopulatedHMCMiraklTransactionLineWhenValidMiraklTransactionLogIsPassedAsArgument() {
final Date now = new Date();
final LocalDateTime nowLocalDate = DateUtil.convertToLocalDateTime(now);
final MiraklTransactionLog miraklTransactionLog = new MiraklTransactionLog();
miraklTransactionLog.setAmountCredited(AMOUNT_CREDITED);
miraklTransactionLog.setAmountDebited(AMOUNT_DEBITED);
miraklTransactionLog.setAmount(AMOUNT);
miraklTransactionLog.setTransactionNumber(TRANSACTION_NUMBER);
miraklTransactionLog.setTransactionType(TRANSACTION_TYPE);
miraklTransactionLog.setId(ID);
miraklTransactionLog.setCurrencyIsoCode(CURRENCY_ISO_CODE);
miraklTransactionLog.setShopId(SHOP_ID);
miraklTransactionLog.setDateCreated(now);
miraklTransactionLog.setOrderId(ORDER_ID);
final HmcMiraklTransactionLine result = testObj.convert(miraklTransactionLog);
assertThat(result.getCreditAmount()).isEqualTo(AMOUNT_CREDITED);
assertThat(result.getDebitAmount()).isEqualTo(AMOUNT_DEBITED);
assertThat(result.getAmount()).isEqualTo(AMOUNT);
assertThat(result.getTransactionNumber()).isEqualTo(TRANSACTION_NUMBER);
assertThat(result.getTransactionType()).isEqualTo("PAYMENT");
assertThat(result.getTransactionLineId()).isEqualTo(ID);
assertThat(result.getCurrencyIsoCode()).isEqualTo("AUD");
assertThat(result.getSellerId()).isEqualTo(SHOP_ID);
assertThat(result.getTransactionTime()).isEqualTo(nowLocalDate);
assertThat(result.getOrderId()).isEqualTo(ORDER_ID);
}
@Test
void convert_shouldReturnNullWhenInputArgumentIsNull() {
final HmcMiraklTransactionLine result = testObj.convert(null);
assertThat(result).isNull();
}
}
| 5,001 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services/converters/HMCBraintreeTransactionLineToHmcFinancialReportLineConverterTest.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.date.TimeMachine;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.HmcFinancialReportLine;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeTransactionTypeEnum;
import com.paypal.reports.services.converters.BraintreeTransactionLineToFinancialReportLineConverter;
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 java.time.LocalDateTime;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class HMCBraintreeTransactionLineToHmcFinancialReportLineConverterTest {
private static final String EUR_CURRENCY_ISO_CODE = "EUR";
@InjectMocks
private BraintreeTransactionLineToFinancialReportLineConverter testObj;
private static final String ORDER_ID = "orderId";
private static final String PAYMENT_TRANSACTION_ID = "payamentTransactionId";
@Test
void convert_shouldConvertBraintreeTransactionLineIntoFinancialReportLineWhenAllAttributesAreFilled() {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 45));
final LocalDateTime now = TimeMachine.now();
//@formatter:off
final HmcBraintreeTransactionLine HmcBraintreeTransactionLineStub = HmcBraintreeTransactionLine.builder()
.orderId(ORDER_ID)
.amount(BigDecimal.TEN)
.currencyIsoCode(EUR_CURRENCY_ISO_CODE)
.paymentTransactionId(PAYMENT_TRANSACTION_ID)
.transactionType(BraintreeTransactionTypeEnum.OPERATOR_ORDER_AMOUNT.name())
.paymentTransactionTime(now)
.build();
//@formatter:on
final HmcFinancialReportLine result = testObj.convert(HmcBraintreeTransactionLineStub);
assertThat(result.getBraintreeCommerceOrderId()).isEqualTo(ORDER_ID);
assertThat(result.getCurrencyIsoCode()).isEqualTo(EUR_CURRENCY_ISO_CODE);
assertThat(result.getBraintreeAmount()).isEqualTo(BigDecimal.TEN);
assertThat(result.getBraintreeTransactionId()).isEqualTo(PAYMENT_TRANSACTION_ID);
assertThat(result.getBraintreeTransactionTime()).isEqualTo(now);
assertThat(result.getMiraklTransactionType())
.isEqualTo(BraintreeTransactionTypeEnum.OPERATOR_ORDER_AMOUNT.name());
}
@Test
void convert_shouldReturnNullWhenBraintreeTransactionLineIsNull() {
final HmcFinancialReportLine result = testObj.convert(null);
assertThat(result).isNull();
}
}
| 5,002 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services/converters/AbstractMapToBraintreeLineConverterTest.java | package com.paypal.reports.services.converters;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeNodeGraphQLModel;
import com.paypal.reports.services.converters.AbstractMapToBraintreeLineConverter;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.File;
import java.io.IOException;
import java.math.BigDecimal;
import java.nio.file.Paths;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class AbstractMapToBraintreeLineConverterTest {
private MyAbstractMapToBraintreeLineConverter testObj;
@BeforeEach
void setUp() {
testObj = new MyAbstractMapToBraintreeLineConverter();
}
@Test
void convert_shouldReturnPopulatedHMCBraintreeTransactionLineWhenInputDataIsAValidEdgeMapWithOrderIdFilled()
throws IOException {
final File edgeJsonWithOrderId = Paths.get("src", "test", "resources", "graphQLEdgeWithOrderId.json").toFile();
final Map<String, Object> edge = new ObjectMapper().readValue(edgeJsonWithOrderId, Map.class);
final BraintreeNodeGraphQLModel result = testObj.getBraintreeNodeGraphQLModel(edge);
BigDecimal expected = BigDecimal.valueOf(108.84);
expected = expected.setScale(2);
assertThat(result.getAmount().getValue()).isEqualTo(expected);
assertThat(result.getCreatedAt()).isEqualTo("2021-05-13T06:56:03.000000Z");
assertThat(result.getAmount().getCurrencyCode()).isEqualTo("USD");
assertThat(result.getOrderId()).isEqualTo("854201000");
}
@Test
void convert_shouldReturnNullWhenInputMapIsNull() {
final BraintreeNodeGraphQLModel result = testObj.getBraintreeNodeGraphQLModel(null);
assertThat(result).isNull();
}
private static class MyAbstractMapToBraintreeLineConverter extends AbstractMapToBraintreeLineConverter {
}
}
| 5,003 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services/converters/HMCMiraklTransactionLineToHmcFinancialReportLineConverterTest.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.date.TimeMachine;
import com.paypal.reports.model.HmcFinancialReportLine;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import com.paypal.reports.services.converters.MiraklTransactionLineToFinancialReportLineConverter;
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 java.time.LocalDateTime;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class HMCMiraklTransactionLineToHmcFinancialReportLineConverterTest {
private static final String ORDER_ID = "orderId";
private static final String SELLER_ID = "sellerId";
private static final String TRANSACTION_TYPE = "transactionType";
private static final String PAYMENT_TRANSACTION_ID = "payamentTransactionId";
private static final String MIRAKL_TRANSACTION_LINE_ID = "miraklTransactionLineId";
@InjectMocks
private MiraklTransactionLineToFinancialReportLineConverter testObj;
@Test
void convert_shouldConvertMiraklTransactionLineIntoFinancialReportLineWhenAllAttributesAreFilled() {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 45));
final LocalDateTime now = TimeMachine.now();
//@formatter:off
final HmcMiraklTransactionLine HmcMiraklTransactionLineStub = HmcMiraklTransactionLine.builder()
.orderId(ORDER_ID)
.sellerId(SELLER_ID)
.transactionLineId(MIRAKL_TRANSACTION_LINE_ID)
.transactionTime(now)
.transactionType(TRANSACTION_TYPE)
.amount(BigDecimal.ONE)
.creditAmount(BigDecimal.TEN)
.debitAmount(BigDecimal.ZERO)
.transactionNumber(PAYMENT_TRANSACTION_ID)
.build();
//@formatter:on
final HmcFinancialReportLine result = testObj.convert(HmcMiraklTransactionLineStub);
assertThat(result.getMiraklOrderId()).isEqualTo(ORDER_ID);
assertThat(result.getMiraklSellerId()).isEqualTo(SELLER_ID);
assertThat(result.getMiraklTransactionLineId()).isEqualTo(MIRAKL_TRANSACTION_LINE_ID);
assertThat(result.getMiraklTransactionTime()).isEqualTo(now);
assertThat(result.getMiraklTransactionType()).isEqualTo(TRANSACTION_TYPE);
assertThat(result.getMiraklCreditAmount()).isEqualTo(BigDecimal.TEN);
assertThat(result.getMiraklDebitAmount()).isEqualTo(BigDecimal.ZERO);
}
@Test
void convert_shouldReturnNullWhenMiraklTransactionLineIsNull() {
final HmcFinancialReportLine result = testObj.convert(null);
assertThat(result).isNull();
}
}
| 5,004 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services/converters/MapToBraintreeTransactionLineConverterTest.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.infrastructure.support.date.TimeMachine;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeGraphQLAmountModel;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeNodeGraphQLModel;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeTransactionTypeEnum;
import com.paypal.reports.services.converters.MapToBraintreeTransactionLineConverter;
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.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class MapToBraintreeTransactionLineConverterTest {
@Spy
@InjectMocks
private MapToBraintreeTransactionLineConverter testObj;
@Mock
private BraintreeNodeGraphQLModel braintreeNodeGraphQLModelMock;
@Mock
private BraintreeGraphQLAmountModel braintreeNodeGraphQLAmountModelMock;
@Mock
private Map<String, Object> edgeMock;
@Test
void convert_shouldReturnPopulatedHMCBraintreeTransactionLineWhenInputDataIsAValidEdgeMapWithOrderIdFilled() {
TimeMachine.useFixedClockAt(LocalDateTime.of(2021, 5, 13, 6, 56, 3));
final LocalDateTime createdAt = TimeMachine.now();
BigDecimal expected = BigDecimal.valueOf(108.84);
expected = expected.setScale(2);
doReturn(braintreeNodeGraphQLModelMock).when(testObj).getBraintreeNodeGraphQLModel(edgeMock);
when(braintreeNodeGraphQLModelMock.getOrderId()).thenReturn("854201000");
when(edgeMock.get("legacyId")).thenReturn("dHJhbnNhY3Rpb25fbXZ5YXZxamo");
when(braintreeNodeGraphQLModelMock.getAmount()).thenReturn(braintreeNodeGraphQLAmountModelMock);
when(braintreeNodeGraphQLModelMock.getCreatedAt())
.thenReturn(DateUtil.convertToDate(createdAt, ZoneId.systemDefault()));
when(braintreeNodeGraphQLAmountModelMock.getValue()).thenReturn(expected);
when(braintreeNodeGraphQLAmountModelMock.getCurrencyCode()).thenReturn("USD");
final HmcBraintreeTransactionLine result = testObj.convert(edgeMock);
assertThat(result.getAmount()).isEqualTo(expected);
assertThat(result.getPaymentTransactionId()).isEqualTo("dHJhbnNhY3Rpb25fbXZ5YXZxamo");
assertThat(result.getPaymentTransactionTime()).isEqualTo(createdAt);
assertThat(result.getCurrencyIsoCode()).isEqualTo("USD");
assertThat(result.getOrderId()).isEqualTo("854201000");
assertThat(result.getTransactionType()).isEqualTo(BraintreeTransactionTypeEnum.OPERATOR_ORDER_AMOUNT.name());
}
@Test
void convert_shouldReturnNullWhenInputMapIsNull() {
doReturn(null).when(testObj).getBraintreeNodeGraphQLModel(null);
final HmcBraintreeTransactionLine result = testObj.convert(null);
assertThat(result).isNull();
}
}
| 5,005 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services/converters/MapToBraintreeRefundLineConverterTest.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.infrastructure.support.date.TimeMachine;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeGraphQLAmountModel;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeNodeGraphQLModel;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeTransactionTypeEnum;
import com.paypal.reports.services.converters.MapToBraintreeRefundLineConverter;
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.math.BigDecimal;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class MapToBraintreeRefundLineConverterTest {
@Spy
@InjectMocks
private MapToBraintreeRefundLineConverter testObj;
@Mock
private BraintreeNodeGraphQLModel braintreeNodeGraphQLModelMock;
@Mock
private Map<String, Object> edgeMock;
@Mock
private BraintreeGraphQLAmountModel braintreeNodeGraphQLAmountModelMock;
@Test
void convert_shouldReturnPopulatedHMCBraintreeTransactionLineWhenInputDataIsAValidEdgeMapWithOrderIdFilled() {
BigDecimal expected = BigDecimal.valueOf(20.00);
expected = expected.setScale(2);
TimeMachine.useFixedClockAt(LocalDateTime.of(2021, 5, 13, 6, 56, 3));
final LocalDateTime createdAt = TimeMachine.now();
doReturn(braintreeNodeGraphQLModelMock).when(testObj).getBraintreeNodeGraphQLModel(edgeMock);
when(braintreeNodeGraphQLModelMock.getOrderId()).thenReturn("871633000");
when(edgeMock.get("legacyId")).thenReturn("cmVmdW5kXzhod3k1ZGZ0");
when(braintreeNodeGraphQLModelMock.getAmount()).thenReturn(braintreeNodeGraphQLAmountModelMock);
when(braintreeNodeGraphQLModelMock.getCreatedAt())
.thenReturn(DateUtil.convertToDate(createdAt, ZoneId.systemDefault()));
when(braintreeNodeGraphQLAmountModelMock.getValue()).thenReturn(expected);
when(braintreeNodeGraphQLAmountModelMock.getCurrencyCode()).thenReturn("USD");
final HmcBraintreeTransactionLine result = testObj.convert(edgeMock);
assertThat(result.getAmount()).isEqualTo(expected.negate());
assertThat(result.getPaymentTransactionId()).isEqualTo("cmVmdW5kXzhod3k1ZGZ0");
assertThat(result.getPaymentTransactionTime()).isEqualTo(createdAt);
assertThat(result.getCurrencyIsoCode()).isEqualTo("USD");
assertThat(result.getOrderId()).isEqualTo("871633000");
assertThat(result.getTransactionType())
.isEqualTo(BraintreeTransactionTypeEnum.REFUND_OPERATOR_ORDER_AMOUNT.name());
}
@Test
void convert_shouldReturnNullWhenInputMapIsNull() {
final HmcBraintreeTransactionLine result = testObj.convert(null);
assertThat(result).isNull();
}
}
| 5,006 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/test/java/com/paypal/reports/services/converters/BrainTreeHMCMiraklTransactionLinesIntoHmcFinancialReportLineConverterTest.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.date.TimeMachine;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.HmcFinancialReportLine;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import com.paypal.reports.services.converters.BrainTreeMiraklTransactionLinesIntoFinancialReportLineConverter;
import org.apache.commons.lang3.tuple.Pair;
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 java.time.LocalDateTime;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class BrainTreeHMCMiraklTransactionLinesIntoHmcFinancialReportLineConverterTest {
private static final String EUR_CURRENCY_ISO_CODE = "EUR";
@InjectMocks
private BrainTreeMiraklTransactionLinesIntoFinancialReportLineConverter testObj;
private static final String MIRAKL_ORDER_ID = "miraklOrderId";
private static final String MIRAKL_SELLER_ID = "miraklSellerId";
private static final String BRAINTREE_ORDER_ID = "braintreeOrderId";
private static final String PAYMENT_TRANSACTION_ID = "paymentTransactionId";
private static final String MIRAKL_TRANSACTION_TYPE = "miraklTransactionType";
private static final String MIRAKL_TRANSACTION_LINE_ID = "miraklTransactionLineId";
@Test
void convert_shouldConvertBraintreeTransactionLineAndMiraklTransactionLineIntoFinancialReportLineWhenAllAttributesAreFilled() {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 45));
final LocalDateTime now = TimeMachine.now();
//@formatter:off
final HmcBraintreeTransactionLine HmcBraintreeTransactionLineStub = HmcBraintreeTransactionLine.builder()
.orderId(BRAINTREE_ORDER_ID)
.amount(BigDecimal.TEN)
.currencyIsoCode(EUR_CURRENCY_ISO_CODE)
.paymentTransactionId(PAYMENT_TRANSACTION_ID)
.paymentTransactionTime(now)
.build();
//@formatter:on
//@formatter:off
final HmcMiraklTransactionLine HmcMiraklTransactionLineStub = HmcMiraklTransactionLine.builder()
.orderId(MIRAKL_ORDER_ID)
.sellerId(MIRAKL_SELLER_ID)
.transactionLineId(MIRAKL_TRANSACTION_LINE_ID)
.transactionTime(now)
.transactionType(MIRAKL_TRANSACTION_TYPE)
.amount(BigDecimal.ONE)
.debitAmount(BigDecimal.ZERO)
.creditAmount(BigDecimal.TEN)
.transactionNumber(PAYMENT_TRANSACTION_ID)
.build();
//@formatter:on
final HmcFinancialReportLine result = testObj
.convert(Pair.of(HmcBraintreeTransactionLineStub, HmcMiraklTransactionLineStub));
assertThat(result.getBraintreeCommerceOrderId()).isEqualTo(BRAINTREE_ORDER_ID);
assertThat(result.getMiraklOrderId()).isEqualTo(MIRAKL_ORDER_ID);
assertThat(result.getMiraklSellerId()).isEqualTo(MIRAKL_SELLER_ID);
assertThat(result.getMiraklTransactionLineId()).isEqualTo(MIRAKL_TRANSACTION_LINE_ID);
assertThat(result.getMiraklTransactionTime()).isEqualTo(now);
assertThat(result.getMiraklTransactionType()).isEqualTo(MIRAKL_TRANSACTION_TYPE);
assertThat(result.getBraintreeAmount()).isEqualTo(BigDecimal.TEN);
assertThat(result.getMiraklDebitAmount()).isEqualTo(BigDecimal.ZERO);
assertThat(result.getMiraklCreditAmount()).isEqualTo(BigDecimal.TEN);
assertThat(result.getBraintreeTransactionId()).isEqualTo(PAYMENT_TRANSACTION_ID);
assertThat(result.getBraintreeTransactionTime()).isEqualTo(now);
}
@Test
void convert_shouldReturnNullWhenWhenBraintreeTransactionLineIsNull() {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 45));
final LocalDateTime now = TimeMachine.now();
//@formatter:off
final HmcMiraklTransactionLine HmcMiraklTransactionLineStub = HmcMiraklTransactionLine.builder()
.orderId(MIRAKL_ORDER_ID)
.sellerId(MIRAKL_SELLER_ID)
.transactionLineId(MIRAKL_TRANSACTION_LINE_ID)
.transactionTime(now)
.transactionType(MIRAKL_TRANSACTION_TYPE)
.amount(BigDecimal.ONE)
.debitAmount(BigDecimal.ZERO)
.creditAmount(BigDecimal.TEN)
.transactionNumber(PAYMENT_TRANSACTION_ID)
.build();
//@formatter:on
final HmcFinancialReportLine result = testObj.convert(Pair.of(null, HmcMiraklTransactionLineStub));
assertThat(result).isNull();
}
@Test
void convert_shouldReturnNullWhenWhenMiraklTransactionLineIsNull() {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 45));
final LocalDateTime now = TimeMachine.now();
//@formatter:off
final HmcBraintreeTransactionLine HmcBraintreeTransactionLineStub = HmcBraintreeTransactionLine.builder()
.orderId(BRAINTREE_ORDER_ID)
.amount(BigDecimal.TEN)
.currencyIsoCode(EUR_CURRENCY_ISO_CODE)
.paymentTransactionId(PAYMENT_TRANSACTION_ID)
.paymentTransactionTime(now)
.build();
//@formatter:on
final HmcFinancialReportLine result = testObj.convert(Pair.of(HmcBraintreeTransactionLineStub, null));
assertThat(result).isNull();
}
@Test
void convert_shouldReturnNullWhenPaymentTransactionIdsAreDifferent() {
TimeMachine.useFixedClockAt(LocalDateTime.of(2020, 11, 10, 20, 45));
final LocalDateTime now = TimeMachine.now();
//@formatter:off
final HmcBraintreeTransactionLine HmcBraintreeTransactionLineStub = HmcBraintreeTransactionLine.builder()
.orderId(BRAINTREE_ORDER_ID)
.amount(BigDecimal.TEN)
.currencyIsoCode(EUR_CURRENCY_ISO_CODE)
.paymentTransactionId(PAYMENT_TRANSACTION_ID)
.paymentTransactionTime(now)
.build();
//@formatter:on
//@formatter:off
final HmcMiraklTransactionLine HmcMiraklTransactionLineStub = HmcMiraklTransactionLine.builder()
.orderId(MIRAKL_ORDER_ID)
.sellerId(MIRAKL_SELLER_ID)
.transactionLineId(MIRAKL_TRANSACTION_LINE_ID)
.transactionTime(now)
.transactionType(MIRAKL_TRANSACTION_TYPE)
.amount(BigDecimal.ONE)
.debitAmount(BigDecimal.ZERO)
.creditAmount(BigDecimal.TEN)
.transactionNumber("paymentTransactionId2")
.build();
//@formatter:on
final HmcFinancialReportLine result = testObj
.convert(Pair.of(HmcBraintreeTransactionLineStub, HmcMiraklTransactionLineStub));
assertThat(result).isNull();
}
}
| 5,007 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/integrationTest/java/com/paypal | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/integrationTest/java/com/paypal/reports/ReportsContextConfigurationITTest.java | package com.paypal.reports;
import com.braintreegateway.BraintreeGateway;
import com.paypal.testsupport.AbstractIntegrationTest;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import static org.assertj.core.api.Assertions.assertThat;
class ReportsContextConfigurationITTest extends AbstractIntegrationTest {
@Autowired
private BraintreeGateway braintreeGateway;
@Test
void context_shouldStart_withDefault_NotConfiguredProperties() {
assertThat(braintreeGateway.getConfiguration().getPrivateKey()).isEqualTo("not-set");
assertThat(braintreeGateway.getConfiguration().getPublicKey()).isEqualTo("not-set");
assertThat(braintreeGateway.getConfiguration().getMerchantPath()).isEqualTo("/merchants/not-set");
}
}
| 5,008 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/ReportsConfiguration.java | package com.paypal.reports;
import com.braintreegateway.BraintreeGateway;
import com.paypal.reports.configuration.ReportsBraintreeApiConfig;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class ReportsConfiguration {
@Bean
BraintreeGateway getBraintreeSDKClient(final ReportsBraintreeApiConfig reportsBraintreeApiConfig) {
return new BraintreeGateway(reportsBraintreeApiConfig.getEnvironment(),
reportsBraintreeApiConfig.getMerchantId(), reportsBraintreeApiConfig.getPublicKey(),
reportsBraintreeApiConfig.getPrivateKey());
}
}
| 5,009 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/configuration/ReportsBraintreeApiConfig.java | package com.paypal.reports.configuration;
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* Configuration class to instantiate Braintree sdk client
*/
@Data
@ConfigurationProperties(prefix = "hmc.braintree.connection")
@Component
public class ReportsBraintreeApiConfig {
private String merchantId;
private String privateKey;
private String publicKey;
private String environment;
}
| 5,010 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/configuration/ReportsConfig.java | package com.paypal.reports.configuration;
import lombok.Getter;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
/**
* Configuration class to define report's headers
*/
@Getter
@Component
public class ReportsConfig {
@Value("#{'${hmc.financial-reports.header}'}")
private String financialReportHeader;
@Value("#{'${hmc.financial-reports.filename-prefix}'}")
private String financialReportPrefixFileName;
@Value("#{'${hmc.financial-reports.outputdir}'}")
protected String repoPath;
@Value("#{'${hmc.server.public-url}'}")
protected String hmcServerUri;
}
| 5,011 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/HmcFinancialReportLine.java | package com.paypal.reports.model;
import com.paypal.infrastructure.support.date.DateUtil;
import lombok.Builder;
import lombok.Getter;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.Objects;
@Getter
@Builder
public class HmcFinancialReportLine {
private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
private String braintreeCommerceOrderId;
private String miraklOrderId;
private String miraklSellerId;
private String miraklTransactionLineId;
private LocalDateTime miraklTransactionTime;
private String miraklTransactionType;
private String currencyIsoCode;
private BigDecimal miraklCreditAmount;
private BigDecimal miraklDebitAmount;
private BigDecimal braintreeAmount;
private String braintreeTransactionId;
private LocalDateTime braintreeTransactionTime;
@Override
public String toString() {
//@formatter:off
return new ToStringBuilder(this, ToStringStyle.SIMPLE_STYLE)
.append("braintreeCommerceOrderId", Objects.nonNull(braintreeCommerceOrderId) ? braintreeCommerceOrderId : StringUtils.EMPTY)
.append("miraklOrderId", Objects.nonNull(miraklOrderId) ? miraklOrderId : StringUtils.EMPTY)
.append("miraklSellerId", Objects.nonNull(miraklSellerId) ? miraklSellerId : StringUtils.EMPTY)
.append("miraklTransactionLineId", Objects.nonNull(miraklTransactionLineId) ? miraklTransactionLineId : StringUtils.EMPTY)
.append("miraklTransactionTime", Objects.nonNull(miraklTransactionTime) ? DateUtil.convertToString(miraklTransactionTime, DATE_FORMAT) : StringUtils.EMPTY)
.append("miraklTransactionType", Objects.nonNull(miraklTransactionType) ? miraklTransactionType : StringUtils.EMPTY)
.append("braintreeAmount", Objects.nonNull(braintreeAmount) ? braintreeAmount : BigDecimal.ZERO)
.append("miraklDebitAmount", Objects.nonNull(miraklDebitAmount) ? String.valueOf(miraklDebitAmount) : StringUtils.EMPTY)
.append("miraklCreditAmount", Objects.nonNull(miraklCreditAmount) ? String.valueOf(miraklCreditAmount) : StringUtils.EMPTY)
.append("currencyIsoCode", Objects.nonNull(currencyIsoCode) ? currencyIsoCode : StringUtils.EMPTY)
.append("braintreeTransactionId", Objects.nonNull(braintreeTransactionId) ? braintreeTransactionId : StringUtils.EMPTY)
.append("braintreeTransactionTime", Objects.nonNull(braintreeTransactionTime) ? DateUtil.convertToString(braintreeTransactionTime, DATE_FORMAT) : StringUtils.EMPTY)
.toString();
//@formatter:on
}
}
| 5,012 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/HmcMiraklTransactionLine.java | package com.paypal.reports.model;
import lombok.Builder;
import lombok.Getter;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Getter
@Builder
public class HmcMiraklTransactionLine {
private String orderId;
private String transactionNumber;
private String sellerId;
private String transactionLineId;
private LocalDateTime transactionTime;
private String transactionType;
private BigDecimal amount;
private BigDecimal creditAmount;
private BigDecimal debitAmount;
private String currencyIsoCode;
}
| 5,013 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/HmcBraintreeTransactionLine.java | package com.paypal.reports.model;
import lombok.Getter;
import lombok.experimental.SuperBuilder;
import java.math.BigDecimal;
import java.time.LocalDateTime;
@Getter
@SuperBuilder
public class HmcBraintreeTransactionLine {
protected String orderId;
protected String paymentTransactionId;
protected LocalDateTime paymentTransactionTime;
protected String transactionType;
protected String currencyIsoCode;
protected BigDecimal amount;
}
| 5,014 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/HmcBraintreeRefundLine.java | package com.paypal.reports.model;
import lombok.Getter;
import lombok.experimental.SuperBuilder;
@Getter
@SuperBuilder
public class HmcBraintreeRefundLine extends HmcBraintreeTransactionLine {
}
| 5,015 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/graphql/braintree | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/graphql/braintree/paymentransaction/BraintreeGraphQLAmountModel.java | package com.paypal.reports.model.graphql.braintree.paymentransaction;
import lombok.Builder;
import lombok.Getter;
import java.math.BigDecimal;
@Getter
@Builder
public class BraintreeGraphQLAmountModel {
private final BigDecimal value;
private final String currencyCode;
}
| 5,016 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/graphql/braintree | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/graphql/braintree/paymentransaction/BraintreeTypeEnum.java | package com.paypal.reports.model.graphql.braintree.paymentransaction;
import lombok.Getter;
@Getter
public enum BraintreeTypeEnum {
TRANSACTIONS("transactions"), REFUNDS("refunds");
private final String typeName;
BraintreeTypeEnum(final String type) {
this.typeName = type;
}
}
| 5,017 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/graphql/braintree | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/graphql/braintree/paymentransaction/BraintreeNodeGraphQLModel.java | package com.paypal.reports.model.graphql.braintree.paymentransaction;
import lombok.Builder;
import lombok.Getter;
import java.util.*;
import java.util.stream.Collectors;
@Builder
@Getter
public class BraintreeNodeGraphQLModel {
String id;
Date createdAt;
String orderId;
String status;
BraintreeGraphQLAmountModel amount;
List<Map<String, String>> customFields;
public String getOrderId() {
if (Objects.nonNull(orderId)) {
return orderId;
}
final Map<String, String> customFieldsAsMap = Optional.ofNullable(customFields).orElse(List.of()).stream()
.collect(Collectors.toMap(entry -> entry.get("name"), entry -> entry.get("value")));
return customFieldsAsMap.get("order_id");
}
}
| 5,018 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/graphql/braintree | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/graphql/braintree/paymentransaction/BraintreeTransactionStatusEnum.java | package com.paypal.reports.model.graphql.braintree.paymentransaction;
public enum BraintreeTransactionStatusEnum {
SETTLED
}
| 5,019 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/graphql/braintree | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/model/graphql/braintree/paymentransaction/BraintreeTransactionTypeEnum.java | package com.paypal.reports.model.graphql.braintree.paymentransaction;
public enum BraintreeTransactionTypeEnum {
OPERATOR_ORDER_AMOUNT, REFUND_OPERATOR_ORDER_AMOUNT
}
| 5,020 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/jobs/ReportsExtractJob.java | package com.paypal.reports.jobs;
import com.paypal.reports.services.ReportsExtractService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import java.util.Date;
/**
* Extract invoices job for extracting Mirakl invoices data and populate it on HyperWallet
* as users
*/
@Slf4j
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class ReportsExtractJob implements Job {
private static final String START_DATE = "startDate";
private static final String END_DATE = "endDate";
private static final String FILE_NAME = "fileName";
@Resource
protected ReportsExtractService reportsExtractService;
/**
* Creates the delta time for mirakl data retrieval query
* @param startDate the start {@link Date} interval
* @param endDate the end {@link Date} interval
* @return the {@link JobDataMap}
*/
public static JobDataMap createJobDataMap(final Date startDate, final Date endDate, final String fileName) {
final JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put(START_DATE, startDate);
jobDataMap.put(END_DATE, endDate);
jobDataMap.put(FILE_NAME, fileName);
return jobDataMap;
}
@Override
public void execute(final JobExecutionContext context) {
reportsExtractService.extractFinancialReport(getStartDate(context), getEndDate(context), getFileName(context));
}
/**
* Retrieves the start date from {@link JobDataMap} linked to
* {@link JobExecutionContext}
* @param context the {@link JobExecutionContext}
* @return the {@link Date}
*/
public Date getStartDate(final JobExecutionContext context) {
return (Date) context.getJobDetail().getJobDataMap().get(START_DATE);
}
/**
* Retrieves the end date from {@link JobDataMap} linked to
* {@link JobExecutionContext}
* @param context the {@link JobExecutionContext}
* @return the {@link Date}
*/
public Date getEndDate(final JobExecutionContext context) {
return (Date) context.getJobDetail().getJobDataMap().get(END_DATE);
}
/**
* Retrieves the fileName from {@link JobDataMap} linked to
* {@link JobExecutionContext}
* @param context the {@link JobExecutionContext}
* @return the {@link Date}
*/
public String getFileName(final JobExecutionContext context) {
return (String) context.getJobDetail().getJobDataMap().get(FILE_NAME);
}
}
| 5,021 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/controllers/ReportsExtractController.java | package com.paypal.reports.controllers;
import com.paypal.jobsystem.quartzintegration.services.JobService;
import com.paypal.reports.jobs.ReportsExtractJob;
import jakarta.annotation.Resource;
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;
@Slf4j
@RestController
@RequestMapping("/job/reports")
public class ReportsExtractController {
private static final String DEFAULT_FINANCIAL_REPORT_EXTRACT_JOB_NAME = "FinancialReportExtractJobSingleExecution";
@Resource
private JobService jobService;
@PostMapping("/financial-report-extract")
public ResponseEntity<String> runJob(
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) final Date startDate,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) final Date endDate,
@RequestParam(required = false, defaultValue = DEFAULT_FINANCIAL_REPORT_EXTRACT_JOB_NAME) final String name,
@RequestParam(required = false) final String fileName) throws SchedulerException {
jobService.createAndRunSingleExecutionJob(name, ReportsExtractJob.class,
ReportsExtractJob.createJobDataMap(startDate, endDate, fileName), null);
return ResponseEntity.accepted().body(name);
}
}
| 5,022 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/controllers/DownloadReportController.java | package com.paypal.reports.controllers;
import com.paypal.reports.configuration.ReportsConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.io.ByteArrayResource;
import org.springframework.core.io.Resource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.NoSuchFileException;
import java.nio.file.Path;
import java.nio.file.Paths;
@Slf4j
@RestController
@RequestMapping("/downloads")
public class DownloadReportController {
private final ReportsConfig reportsConfig;
public DownloadReportController(final ReportsConfig reportsConfig) {
this.reportsConfig = reportsConfig;
}
@GetMapping("/financial-report/{file_name}")
public ResponseEntity<Resource> getFinancialReport(@PathVariable("file_name") final String fileName) {
final Path path = Paths.get(reportsConfig.getRepoPath() + fileName);
try {
final ByteArrayResource resource = new ByteArrayResource(Files.readAllBytes(path));
return ResponseEntity.ok().header(HttpHeaders.CONTENT_DISPOSITION, "attachment; filename=" + fileName)
.contentType(MediaType.parseMediaType("application/csv")).body(resource);
}
catch (final NoSuchFileException ex) {
log.error("Financial report file: [{}] not found in path [{}]", fileName, path.toAbsolutePath(), ex);
return ResponseEntity.notFound().build();
}
catch (final IOException ex) {
log.error("There was an error reading: [{}] file", fileName, ex);
return ResponseEntity.badRequest().build();
}
}
}
| 5,023 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/ReportsMiraklExtractService.java | package com.paypal.reports.services;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import java.util.Date;
import java.util.List;
public interface ReportsMiraklExtractService {
List<HmcMiraklTransactionLine> getAllTransactionLinesByDate(Date startDate, Date endDate);
}
| 5,024 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/ReportsExtractService.java | package com.paypal.reports.services;
import java.util.Date;
public interface ReportsExtractService {
void extractFinancialReport(Date startDate, Date endDate, String fileName);
}
| 5,025 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/FinancialReportConverterService.java | package com.paypal.reports.services;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.HmcFinancialReportLine;
import com.paypal.reports.model.HmcMiraklTransactionLine;
/**
* Interface that manages all converters needed to generate the financial report
*/
public interface FinancialReportConverterService {
/**
* Converts a braintree transaction line into a financial report line
* @param hmcBraintreeTransactionLine {@link HmcBraintreeTransactionLine}
* @return {@link HmcFinancialReportLine}
*/
HmcFinancialReportLine convertBraintreeTransactionLineIntoFinancialReportLine(
HmcBraintreeTransactionLine hmcBraintreeTransactionLine);
/**
* Converts a mirakl transaction line into a financial report line
* @param hmcMiraklTransactionLine {@link HmcMiraklTransactionLine}
* @return {@link HmcFinancialReportLine}
*/
HmcFinancialReportLine convertMiraklTransactionLineIntoFinancialReportLine(
HmcMiraklTransactionLine hmcMiraklTransactionLine);
/**
* Converts a pair of {@link HmcBraintreeTransactionLine} and
* {@link HmcMiraklTransactionLine} into a financial report line
* @param hmcBraintreeTransactionLine {@link HmcBraintreeTransactionLine}
* @param hmcMiraklTransactionLine {@link HmcMiraklTransactionLine}
* @return {@link HmcFinancialReportLine}
*/
HmcFinancialReportLine convertBrainTreeAndMiraklTransactionLineIntoFinancialReportLine(
HmcBraintreeTransactionLine hmcBraintreeTransactionLine, HmcMiraklTransactionLine hmcMiraklTransactionLine);
}
| 5,026 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/FinancialReportService.java | package com.paypal.reports.services;
import java.util.Date;
/**
* Interface that generates a financial report
*/
public interface FinancialReportService {
/**
* Generates a Financial Report from startDate to endDate, using a prefix name for the
* file created
* @param startDate {@link Date} start date
* @param endDate {@link Date} end date
* @param fileName {@link String} prefix file name
* @return {@link String} file name generated in hard disk
*/
String generateFinancialReport(Date startDate, Date endDate, String fileName);
}
| 5,027 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/ReportsBraintreeRefundsExtractService.java | package com.paypal.reports.services;
import com.paypal.reports.model.HmcBraintreeRefundLine;
import java.util.Date;
import java.util.List;
public interface ReportsBraintreeRefundsExtractService {
/**
* Retrieves all the refunds registered in Braintree by {@code transactionType},
* {@code startDate} and {@code endDate}
* @param transactionType e.g. SETTLED
* @param startDate Starting date
* @param endDate Ending date
* @return a filtered {@link List < HmcBraintreeTransactionLine >}
*/
List<HmcBraintreeRefundLine> getAllRefundsByTypeAndDateInterval(String transactionType, Date startDate,
Date endDate);
}
| 5,028 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/ReportsBraintreeTransactionsExtractService.java | package com.paypal.reports.services;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import java.util.Date;
import java.util.List;
/**
* Service that retrieves data from Braintree API focused on the financial report
* generation
*/
public interface ReportsBraintreeTransactionsExtractService {
/**
* Retrieves all the transactions registered in Braintree by {@code transactionType},
* {@code startDate} and {@code endDate}
* @param transactionType e.g. SETTLED
* @param startDate Starting date
* @param endDate Ending date
* @return a filtered {@link List< HmcBraintreeTransactionLine >}
*/
List<HmcBraintreeTransactionLine> getAllTransactionsByTypeAndDateInterval(String transactionType, Date startDate,
Date endDate);
}
| 5,029 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/HMCFileService.java | package com.paypal.reports.services;
import java.util.List;
/**
* Interface that save a CSV into a File
*/
public interface HMCFileService {
/**
* Save a CSV into a File
* @param path {@link String} path where file will be saved
* @param prefixFileName {@link String} prefix file name for the file generated
* @param lines {@link List<String>} data content
* @param headers {@link String} comma separated string that will be the header of the
* CSV file
* @return {@link String} final file name generated
*/
String saveCSVFile(String path, String prefixFileName, List<String> lines, String headers);
}
| 5,030 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/impl/ReportsMiraklExtractServiceImpl.java | package com.paypal.reports.services.impl;
import com.mirakl.client.core.exception.MiraklException;
import com.mirakl.client.mmp.domain.payment.MiraklTransactionLog;
import com.mirakl.client.mmp.domain.payment.MiraklTransactionLogs;
import com.mirakl.client.mmp.request.payment.MiraklGetTransactionLogsRequest;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.infrastructure.mirakl.client.MiraklClient;
import com.paypal.infrastructure.support.logging.MiraklLoggingErrorsUtil;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import com.paypal.reports.services.ReportsMiraklExtractService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import static com.paypal.infrastructure.support.date.DateUtil.convertToLocalDateTime;
import static com.paypal.infrastructure.support.date.DateUtil.convertToString;
@Slf4j
@Service
public class ReportsMiraklExtractServiceImpl implements ReportsMiraklExtractService {
private static final String DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
private static final String EMAIL_SUBJECT_MESSAGE = "Issue detected retrieving log lines from Mirakl";
private static final String ERROR_MESSAGE_PREFIX = "There was an error, please check the logs for further information:\n";
private final MiraklClient miraklClient;
private final Converter<MiraklTransactionLog, HmcMiraklTransactionLine> miraklTransactionLogMiraklTransactionLineConverter;
private final MailNotificationUtil mailNotificationUtil;
public ReportsMiraklExtractServiceImpl(final MiraklClient miraklClient,
final Converter<MiraklTransactionLog, HmcMiraklTransactionLine> miraklTransactionLogMiraklTransactionLineConverter,
final MailNotificationUtil mailNotificationUtil) {
this.miraklClient = miraklClient;
this.miraklTransactionLogMiraklTransactionLineConverter = miraklTransactionLogMiraklTransactionLineConverter;
this.mailNotificationUtil = mailNotificationUtil;
}
@SuppressWarnings("java:S1874")
@Override
public List<HmcMiraklTransactionLine> getAllTransactionLinesByDate(final Date startDate, final Date endDate) {
log.info("Retrieving Mirakl transaction logs from {} to {}", startDate, endDate);
final var miraklGetTransactionLogsRequest = new MiraklGetTransactionLogsRequest();
miraklGetTransactionLogsRequest.setStartDate(startDate);
miraklGetTransactionLogsRequest.setEndDate(endDate);
miraklGetTransactionLogsRequest.setPaginate(false);
try {
final MiraklTransactionLogs transactionLogs = miraklClient
.getTransactionLogs(miraklGetTransactionLogsRequest);
log.info("{} Mirakl transaction logs from {} to {}", transactionLogs.getTotalCount(), startDate, endDate);
//@formatter:off
return Optional.ofNullable(transactionLogs.getLines()).orElse(List.of()).stream()
.map(miraklTransactionLogMiraklTransactionLineConverter::convert)
.collect(Collectors.toList());
//@formatter:on
}
catch (final MiraklException e) {
log.error("Something went wrong retrieving log lines from Mirakl from %1$tT %1$tF to %2$tT %2$tF"
.formatted(startDate, endDate), e);
mailNotificationUtil.sendPlainTextEmail(EMAIL_SUBJECT_MESSAGE,
(ERROR_MESSAGE_PREFIX
+ "Something went wrong getting transaction log information from %s to %s\n%s").formatted(
convertToString(convertToLocalDateTime(startDate), DATE_FORMAT),
convertToString(convertToLocalDateTime(endDate), DATE_FORMAT),
MiraklLoggingErrorsUtil.stringify(e)));
return List.of();
}
}
}
| 5,031 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/impl/ReportsBraintreeRefundsExtractServiceImpl.java | package com.paypal.reports.services.impl;
import com.braintreegateway.BraintreeGateway;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.reports.model.HmcBraintreeRefundLine;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeTypeEnum;
import com.paypal.reports.services.ReportsBraintreeRefundsExtractService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Slf4j
@Service
public class ReportsBraintreeRefundsExtractServiceImpl
extends AbstractReportsBraintreeExtractServiceImpl<HmcBraintreeRefundLine>
implements ReportsBraintreeRefundsExtractService {
private final Converter<Map<String, Object>, HmcBraintreeRefundLine> mapToBraintreeRefundLineConverter;
public ReportsBraintreeRefundsExtractServiceImpl(final BraintreeGateway braintreeGateway,
final Converter<Map<String, Object>, HmcBraintreeRefundLine> mapToBraintreeRefundLineConverter) {
super(braintreeGateway);
this.mapToBraintreeRefundLineConverter = mapToBraintreeRefundLineConverter;
}
/**
* {@inheritDoc}
*/
@Override
public List<HmcBraintreeRefundLine> getAllRefundsByTypeAndDateInterval(final String transactionType,
final Date startDate, final Date endDate) {
log.info("Retrieving {} refunds from {} to {} from Braintree", transactionType, startDate, endDate);
final List<HmcBraintreeRefundLine> allRefundsList = new ArrayList<>();
boolean hasNextPage;
String cursor = null;
do {
final Map<String, Object> result = getGraphQLClient().query(getSearchQuery(),
populateVars(transactionType, startDate, endDate, cursor));
hasNextPage = getHasNextPage(BraintreeTypeEnum.REFUNDS, result);
cursor = getCursor(BraintreeTypeEnum.REFUNDS, result);
final List<HmcBraintreeRefundLine> refundLines = getEdges(BraintreeTypeEnum.REFUNDS, result);
allRefundsList.addAll(refundLines);
}
while (hasNextPage);
log.info("Retrieved {} {} refunds from {} to {} from Braintree", allRefundsList.size(), transactionType,
startDate, endDate);
return allRefundsList;
}
protected List<HmcBraintreeRefundLine> getEdges(final BraintreeTypeEnum braintreeType,
final Map<String, Object> search) {
final List<Map<String, Object>> edges = (List<Map<String, Object>>) ((Map<String, Object>) ((Map<String, Object>) ((Map<String, Object>) search
.get(DATA)).get(SEARCH)).get(braintreeType.getTypeName())).get(EDGES);
//@formatter:off
return edges.stream()
.map(value -> (Map<String, Object>) value.get(NODE))
.map(mapToBraintreeRefundLineConverter::convert)
.collect(Collectors.toList());
//@formatter:on
}
protected String getSearchQuery() {
try {
final InputStream refundSearchQueryInputStream = ReportsBraintreeRefundsExtractServiceImpl.class
.getResourceAsStream("/refundsSearchQuery.graphql");
return IOUtils.toString(refundSearchQueryInputStream, StandardCharsets.UTF_8.name());
}
catch (final IOException ex) {
log.error("Impossible to access to [transactionSearchQuery.graphql] file", ex);
}
return StringUtils.EMPTY;
}
}
| 5,032 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/impl/AbstractHmcFileService.java | package com.paypal.reports.services.impl;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.csv.CSVFormat;
import org.apache.commons.csv.CSVPrinter;
import org.apache.commons.lang3.StringUtils;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Path;
import java.util.List;
import java.util.Objects;
/**
* Abstract HMC File Service that manages the way to print a CSV File (with RFC4180
* format) and the way to save it into a certain path.
*/
@Slf4j
@Data
public abstract class AbstractHmcFileService {
/**
* Print and save a CSV File into a certain path
* @param filePath {@link Path} where storing the CSV file
* @param headers {@link String}of CSV
* @param fileName {@link String} prefix fileName
* @param lines {@link List<String>} contains the information to be printed into CSV
* format
* @return {@link String} result filename
* @throws IOException when file could not be written into path received as parameter
*/
protected String printCSVFile(final Path filePath, final String headers, final String fileName,
final List<String> lines) throws IOException {
CSVPrinter csvPrinter = null;
try {
csvPrinter = getCSVPrinter(filePath, headers, fileName);
if (Objects.nonNull(csvPrinter)) {
csvPrinter.printRecords(lines);
csvPrinter.flush();
return fileName;
}
}
catch (final IOException e) {
log.error("CSV File [{}] could not be written into path: [{}]", fileName, filePath.toAbsolutePath(), e);
}
finally {
if (Objects.nonNull(csvPrinter)) {
csvPrinter.close();
}
}
return StringUtils.EMPTY;
}
/**
* Creates a CSVPrinter instance according to parameters received
* @param path {@link Path} where the CSVPrinter points to
* @param headers {@link String} contains the header for the CSV
* @param fileName {@link String} prefix name for the file created
* @return {@link CSVPrinter} object
*/
@SuppressWarnings("java:S2095")
protected CSVPrinter getCSVPrinter(final Path path, final String headers, final String fileName) {
try {
final FileWriter writer = new FileWriter(path.toString());
return new CSVPrinter(writer, CSVFormat.RFC4180.withHeader(headers).withQuote(null));
}
catch (final IOException e) {
log.error("CSV File [{}] could not be written into path: [{}]", fileName, path, e);
return null;
}
}
}
| 5,033 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/impl/HMCFileServiceImpl.java | package com.paypal.reports.services.impl;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.reports.services.HMCFileService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;
/**
* Implementation of {@link HMCFileService}
*/
@Slf4j
@Service
public class HMCFileServiceImpl extends AbstractHmcFileService implements HMCFileService {
private static final String DATE_FORMAT = "yyyy-MM-dd_HH-mm";
private static final String CSV_EXTENSION = ".csv";
private static final String SLASH = "/";
/**
* {@inheritDoc}
*/
@Override
public String saveCSVFile(final String path, final String prefixFileName, final List<String> lines,
final String headers) {
try {
if (Objects.nonNull(lines)) {
final String dateString = DateUtil.convertToString(LocalDateTime.now(), DATE_FORMAT);
final String fileName = prefixFileName + "_" + dateString + CSV_EXTENSION;
final Path filePath = Paths.get(path + SLASH + fileName);
return printCSVFile(filePath, headers, fileName, lines);
}
}
catch (final IOException ex) {
log.error("There was an error trying to close file", ex);
}
return StringUtils.EMPTY;
}
}
| 5,034 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/impl/FinancialReportConverterServiceImpl.java | package com.paypal.reports.services.impl;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.HmcFinancialReportLine;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import com.paypal.reports.services.FinancialReportConverterService;
import com.paypal.reports.services.FinancialReportService;
import lombok.Data;
import org.apache.commons.lang3.tuple.Pair;
import org.springframework.stereotype.Service;
/**
* Implementation of {@link FinancialReportService}
*/
@Data
@Service
public class FinancialReportConverterServiceImpl implements FinancialReportConverterService {
private final Converter<HmcBraintreeTransactionLine, HmcFinancialReportLine> braintreeTransactionLineFinancialReportLineConverter;
private final Converter<HmcMiraklTransactionLine, HmcFinancialReportLine> miraklTransactionLineFinancialReportServiceConverter;
private final Converter<Pair<HmcBraintreeTransactionLine, HmcMiraklTransactionLine>, HmcFinancialReportLine> braintreeAndMiraklTransactionLineFinancialReportLineConverter;
public FinancialReportConverterServiceImpl(
final Converter<HmcBraintreeTransactionLine, HmcFinancialReportLine> braintreeTransactionLineFinancialReportLineConverter,
final Converter<HmcMiraklTransactionLine, HmcFinancialReportLine> miraklTransactionLineFinancialReportServiceConverter,
final Converter<Pair<HmcBraintreeTransactionLine, HmcMiraklTransactionLine>, HmcFinancialReportLine> braintreeAndMiraklTransactionLineFinancialReportLineConverter) {
this.braintreeTransactionLineFinancialReportLineConverter = braintreeTransactionLineFinancialReportLineConverter;
this.miraklTransactionLineFinancialReportServiceConverter = miraklTransactionLineFinancialReportServiceConverter;
this.braintreeAndMiraklTransactionLineFinancialReportLineConverter = braintreeAndMiraklTransactionLineFinancialReportLineConverter;
}
/**
* {@inheritDoc}
*/
@Override
public HmcFinancialReportLine convertBraintreeTransactionLineIntoFinancialReportLine(
final HmcBraintreeTransactionLine hmcBraintreeTransactionLine) {
return braintreeTransactionLineFinancialReportLineConverter.convert(hmcBraintreeTransactionLine);
}
/**
* {@inheritDoc}
*/
@Override
public HmcFinancialReportLine convertMiraklTransactionLineIntoFinancialReportLine(
final HmcMiraklTransactionLine hmcMiraklTransactionLine) {
return miraklTransactionLineFinancialReportServiceConverter.convert(hmcMiraklTransactionLine);
}
/**
* {@inheritDoc}
*/
@Override
public HmcFinancialReportLine convertBrainTreeAndMiraklTransactionLineIntoFinancialReportLine(
final HmcBraintreeTransactionLine hmcBraintreeTransactionLine,
final HmcMiraklTransactionLine hmcMiraklTransactionLine) {
return braintreeAndMiraklTransactionLineFinancialReportLineConverter
.convert(Pair.of(hmcBraintreeTransactionLine, hmcMiraklTransactionLine));
}
}
| 5,035 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/impl/ReportsBraintreeTransactionsExtractServiceImpl.java | package com.paypal.reports.services.impl;
import com.braintreegateway.BraintreeGateway;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeTypeEnum;
import com.paypal.reports.services.ReportsBraintreeTransactionsExtractService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Slf4j
@Service
public class ReportsBraintreeTransactionsExtractServiceImpl
extends AbstractReportsBraintreeExtractServiceImpl<HmcBraintreeTransactionLine>
implements ReportsBraintreeTransactionsExtractService {
protected final Converter<Map<String, Object>, HmcBraintreeTransactionLine> mapToBraintreeTransactionLineConverter;
public ReportsBraintreeTransactionsExtractServiceImpl(final BraintreeGateway braintreeGateway,
final Converter<Map<String, Object>, HmcBraintreeTransactionLine> mapToBraintreeTransactionLineConverter) {
super(braintreeGateway);
this.mapToBraintreeTransactionLineConverter = mapToBraintreeTransactionLineConverter;
}
/**
* {@inheritDoc}
*/
@Override
public List<HmcBraintreeTransactionLine> getAllTransactionsByTypeAndDateInterval(final String transactionType,
final Date startDate, final Date endDate) {
log.info("Retrieving {} transactions from {} to {} from Braintree", transactionType, startDate, endDate);
final List<HmcBraintreeTransactionLine> allTransactionsList = new ArrayList<>();
boolean hasNextPage;
String cursor = null;
do {
final Map<String, Object> result = getGraphQLClient().query(getSearchQuery(),
populateVars(transactionType, startDate, endDate, cursor));
hasNextPage = getHasNextPage(BraintreeTypeEnum.TRANSACTIONS, result);
cursor = getCursor(BraintreeTypeEnum.TRANSACTIONS, result);
final List<HmcBraintreeTransactionLine> transactionLines = getEdges(BraintreeTypeEnum.TRANSACTIONS, result);
allTransactionsList.addAll(transactionLines);
}
while (hasNextPage);
log.info("Retrieved {} {} transactions from {} to {} from Braintree", allTransactionsList.size(),
transactionType, startDate, endDate);
return allTransactionsList;
}
protected List<HmcBraintreeTransactionLine> getEdges(final BraintreeTypeEnum braintreeType,
final Map<String, Object> search) {
final List<Map<String, Object>> edges = (List<Map<String, Object>>) ((Map<String, Object>) ((Map<String, Object>) ((Map<String, Object>) search
.get(DATA)).get(SEARCH)).get(braintreeType.getTypeName())).get(EDGES);
//@formatter:off
return edges.stream()
.map(value -> (Map<String, Object>) value.get(NODE))
.map(mapToBraintreeTransactionLineConverter::convert)
.collect(Collectors.toList());
//@formatter:on
}
protected String getSearchQuery() {
try {
final InputStream transactionSearchQueryInputStream = ReportsBraintreeTransactionsExtractServiceImpl.class
.getResourceAsStream("/transactionSearchQuery.graphql");
return IOUtils.toString(transactionSearchQueryInputStream, StandardCharsets.UTF_8.name());
}
catch (final IOException ex) {
log.error("Impossible to access to [transactionSearchQuery.graphql] file", ex);
}
return StringUtils.EMPTY;
}
}
| 5,036 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/impl/ReportsExtractServiceImpl.java | package com.paypal.reports.services.impl;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.reports.configuration.ReportsConfig;
import com.paypal.reports.services.FinancialReportService;
import com.paypal.reports.services.ReportsExtractService;
import org.springframework.stereotype.Service;
import java.util.Date;
@Service
public class ReportsExtractServiceImpl implements ReportsExtractService {
private final FinancialReportService financialReportService;
private final MailNotificationUtil mailNotificationUtil;
private final ReportsConfig reportsConfig;
public ReportsExtractServiceImpl(final FinancialReportService financialReportService,
final MailNotificationUtil mailNotificationUtil, final ReportsConfig reportsConfig) {
this.financialReportService = financialReportService;
this.mailNotificationUtil = mailNotificationUtil;
this.reportsConfig = reportsConfig;
}
@Override
public void extractFinancialReport(final Date startDate, final Date endDate, final String fileName) {
final String name = financialReportService.generateFinancialReport(startDate, endDate, fileName);
mailNotificationUtil.sendPlainTextEmail(
"Your Marketplace Financial Report from " + startDate + " to " + endDate,
"Below there is a link to your Marketplace Financial Report for the period from " + startDate + " to "
+ endDate + ". Please click on it to download the report:\n\n" + reportsConfig.getHmcServerUri()
+ "/downloads/financial-report/" + name);
}
}
| 5,037 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/impl/FinancialReportServiceImpl.java | package com.paypal.reports.services.impl;
import com.paypal.reports.configuration.ReportsConfig;
import com.paypal.reports.model.HmcBraintreeRefundLine;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.HmcFinancialReportLine;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeTransactionStatusEnum;
import com.paypal.reports.services.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.lang.NonNull;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* Implementation of {@link FinancialReportService}
*/
@Service
public class FinancialReportServiceImpl implements FinancialReportService {
private final FinancialReportConverterService financialReportConverterService;
private final ReportsConfig reportsConfig;
private final HMCFileService hmcFileService;
private final ReportsBraintreeTransactionsExtractService reportsBraintreeTransactionsExtractService;
private final ReportsBraintreeRefundsExtractService reportsBraintreeRefundsExtractService;
private final ReportsMiraklExtractService reportsMiraklExtractService;
public FinancialReportServiceImpl(final FinancialReportConverterService financialReportConverterService,
final ReportsConfig reportsConfig, final HMCFileService hmcFileService,
final ReportsBraintreeTransactionsExtractService reportsBraintreeTransactionsExtractService,
final ReportsBraintreeRefundsExtractService reportsBraintreeRefundsExtractService,
final ReportsMiraklExtractService reportsMiraklExtractService) {
this.financialReportConverterService = financialReportConverterService;
this.reportsConfig = reportsConfig;
this.hmcFileService = hmcFileService;
this.reportsBraintreeTransactionsExtractService = reportsBraintreeTransactionsExtractService;
this.reportsBraintreeRefundsExtractService = reportsBraintreeRefundsExtractService;
this.reportsMiraklExtractService = reportsMiraklExtractService;
}
/**
* {@inheritDoc}
*/
@Override
public String generateFinancialReport(final Date startDate, final Date endDate, final String prefixFileName) {
final List<HmcBraintreeTransactionLine> braintreeTransactionsAndRefunds = getBraintreeTransactionsAndRefunds(
startDate, endDate);
final List<HmcMiraklTransactionLine> miraklTransactions = getMiraklTransactions(startDate, endDate);
final Map<String, List<HmcBraintreeTransactionLine>> braintreeTransactionLines = groupBraintreeTransactionLinesByPaymentTransactionId(
braintreeTransactionsAndRefunds);
final Map<String, List<HmcMiraklTransactionLine>> miraklCommonTransactionLines = groupMiraklTransactionLinesByTransactionNumber(
miraklTransactions);
final List<HmcMiraklTransactionLine> miraklTransactionLinesWithEmptyTransactionNumber = groupMiraklTransactionLinesByWithEmptyTransactionNumber(
miraklTransactions);
final List<HmcBraintreeTransactionLine> uncommonHmcBraintreeTransactionLines = getBraintreeNotCommonTransactionLines(
braintreeTransactionLines, miraklCommonTransactionLines);
final Map<HmcBraintreeTransactionLine, List<HmcMiraklTransactionLine>> commonTransactions = groupMiraklTransactionLinesByBraintreeTransactionLines(
braintreeTransactionLines, miraklCommonTransactionLines);
final List<HmcMiraklTransactionLine> uncommonMiraklTransactionLines = getNotCommonMiraklTransactions(
braintreeTransactionLines, miraklCommonTransactionLines);
final List<HmcFinancialReportLine> financialReportLines = new ArrayList<>();
financialReportLines.addAll(convertUncommonBraintreeTransactionLines(uncommonHmcBraintreeTransactionLines));
financialReportLines
.addAll(convertUncommonMiraklTransactionLines(miraklTransactionLinesWithEmptyTransactionNumber));
financialReportLines.addAll(convertCommonTransactionLines(commonTransactions));
financialReportLines.addAll(convertUncommonMiraklTransactionLines(uncommonMiraklTransactionLines));
//@formatter:off
final List<String> financialReportStringLines = financialReportLines.stream()
.map(HmcFinancialReportLine::toString)
.collect(Collectors.toList());
//@formatter:on
final String fileName;
if (StringUtils.isNotEmpty(prefixFileName)) {
fileName = hmcFileService.saveCSVFile(reportsConfig.getRepoPath(), prefixFileName,
financialReportStringLines, reportsConfig.getFinancialReportHeader());
}
else {
fileName = hmcFileService.saveCSVFile(reportsConfig.getRepoPath(),
reportsConfig.getFinancialReportPrefixFileName(), financialReportStringLines,
reportsConfig.getFinancialReportHeader());
}
return fileName;
}
private List<HmcMiraklTransactionLine> getNotCommonMiraklTransactions(
final Map<String, List<HmcBraintreeTransactionLine>> braintreeTransactionLines,
final Map<String, List<HmcMiraklTransactionLine>> miraklCommonTransactionLines) {
//@formatter:off
return miraklCommonTransactionLines.keySet().stream()
.filter(Predicate.not(braintreeTransactionLines::containsKey))
.map(miraklCommonTransactionLines::get)
.flatMap(Collection::stream)
.collect(Collectors.toList());
//@formatter:on
}
@NonNull
private Map<HmcBraintreeTransactionLine, List<HmcMiraklTransactionLine>> groupMiraklTransactionLinesByBraintreeTransactionLines(
final Map<String, List<HmcBraintreeTransactionLine>> braintreeTransactionLines,
final Map<String, List<HmcMiraklTransactionLine>> miraklCommonTransactionLines) {
//@formatter:off
return braintreeTransactionLines.keySet().stream()
.filter(miraklCommonTransactionLines::containsKey)
.map(braintreeTransactionLines::get)
.flatMap(Collection::stream)
.collect(Collectors.toMap(braintreeTransactionLine -> braintreeTransactionLine,
braintreeTransactionLine -> miraklCommonTransactionLines
.get(braintreeTransactionLine.getPaymentTransactionId())));
//@formatter:on
}
@NonNull
private List<HmcBraintreeTransactionLine> getBraintreeNotCommonTransactionLines(
final Map<String, List<HmcBraintreeTransactionLine>> braintreeTransactionLines,
final Map<String, List<HmcMiraklTransactionLine>> miraklCommonTransactionLines) {
//@formatter:off
return braintreeTransactionLines.keySet().stream()
.filter(Predicate.not(miraklCommonTransactionLines::containsKey))
.map(braintreeTransactionLines::get)
.flatMap(Collection::stream)
.collect(Collectors.toList());
//@formatter:on
}
@NonNull
private List<HmcMiraklTransactionLine> groupMiraklTransactionLinesByWithEmptyTransactionNumber(
final List<HmcMiraklTransactionLine> miraklTransactions) {
//@formatter:off
return Stream.ofNullable(miraklTransactions)
.flatMap(Collection::stream)
.filter(miraklTransaction -> StringUtils.isEmpty(miraklTransaction.getTransactionNumber()))
.collect(Collectors.toList());
//@formatter:on
}
private Map<String, List<HmcMiraklTransactionLine>> groupMiraklTransactionLinesByTransactionNumber(
final List<HmcMiraklTransactionLine> miraklTransactions) {
//@formatter:off
return Stream.ofNullable(miraklTransactions)
.flatMap(Collection::stream)
.filter(miraklTransaction -> StringUtils.isNotEmpty(miraklTransaction.getTransactionNumber()))
.collect(Collectors.groupingBy(HmcMiraklTransactionLine::getTransactionNumber));
//@formatter:on
}
private Map<String, List<HmcBraintreeTransactionLine>> groupBraintreeTransactionLinesByPaymentTransactionId(
final List<HmcBraintreeTransactionLine> braintreeTransactions) {
//@formatter:off
return Stream
.ofNullable(braintreeTransactions)
.flatMap(Collection::stream)
.collect(Collectors.groupingBy(HmcBraintreeTransactionLine::getPaymentTransactionId));
//@formatter:on
}
private List<HmcMiraklTransactionLine> getMiraklTransactions(final Date startDate, final Date endDate) {
return reportsMiraklExtractService.getAllTransactionLinesByDate(startDate, endDate);
}
private List<HmcBraintreeTransactionLine> getBraintreeTransactionsAndRefunds(final Date startDate,
final Date endDate) {
final List<HmcBraintreeTransactionLine> braintreeTransactionsAndRefunds = new ArrayList<>();
final List<HmcBraintreeTransactionLine> braintreeTransactions = reportsBraintreeTransactionsExtractService
.getAllTransactionsByTypeAndDateInterval(BraintreeTransactionStatusEnum.SETTLED.toString(), startDate,
endDate);
final List<HmcBraintreeRefundLine> braintreeRefunds = reportsBraintreeRefundsExtractService
.getAllRefundsByTypeAndDateInterval(BraintreeTransactionStatusEnum.SETTLED.toString(), startDate,
endDate);
braintreeTransactionsAndRefunds.addAll(braintreeTransactions);
braintreeTransactionsAndRefunds.addAll(braintreeRefunds);
return braintreeTransactionsAndRefunds;
}
private List<HmcFinancialReportLine> generateFinancialReportLine(
final HmcBraintreeTransactionLine braintreeTransactionLine,
final List<HmcMiraklTransactionLine> miraklTransactionLines) {
return Optional.ofNullable(miraklTransactionLines).orElse(List.of()).stream()
.map(miraklTransactionLine -> financialReportConverterService
.convertBrainTreeAndMiraklTransactionLineIntoFinancialReportLine(braintreeTransactionLine,
miraklTransactionLine))
.collect(Collectors.toList());
}
private List<HmcFinancialReportLine> convertCommonTransactionLines(
final Map<HmcBraintreeTransactionLine, List<HmcMiraklTransactionLine>> commonTransactions) {
return commonTransactions.entrySet().stream()
.map(entry -> generateFinancialReportLine(entry.getKey(), entry.getValue())).flatMap(Collection::stream)
.collect(Collectors.toList());
}
private List<HmcFinancialReportLine> convertUncommonBraintreeTransactionLines(
final List<HmcBraintreeTransactionLine> uncommonHmcBraintreeTransactionLines) {
return uncommonHmcBraintreeTransactionLines.stream()
.map(financialReportConverterService::convertBraintreeTransactionLineIntoFinancialReportLine)
.collect(Collectors.toList());
}
private List<HmcFinancialReportLine> convertUncommonMiraklTransactionLines(
final List<HmcMiraklTransactionLine> uncommonHmcMiraklTransactionLines) {
return uncommonHmcMiraklTransactionLines.stream()
.map(financialReportConverterService::convertMiraklTransactionLineIntoFinancialReportLine)
.collect(Collectors.toList());
}
}
| 5,038 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/impl/AbstractReportsBraintreeExtractServiceImpl.java | package com.paypal.reports.services.impl;
import com.braintreegateway.BraintreeGateway;
import com.braintreegateway.util.GraphQLClient;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeTypeEnum;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.temporal.TemporalAccessor;
import java.util.*;
public abstract class AbstractReportsBraintreeExtractServiceImpl<T extends HmcBraintreeTransactionLine> {
protected static final String DATA = "data";
protected static final String SEARCH = "search";
protected static final String PAGE_INFO = "pageInfo";
protected static final String END_CURSOR = "endCursor";
protected static final String EDGES = "edges";
protected static final String HAS_NEXT_PAGE = "hasNextPage";
protected static final String NODE = "node";
protected static final String STATUS = "status";
protected static final String INPUT = "input";
protected static final String IS = "is";
protected static final String AFTER = "after";
protected static final String GREATER_THAN_OR_EQUAL_TO = "greaterThanOrEqualTo";
protected static final String LESS_THAN_OR_EQUAL_TO = "lessThanOrEqualTo";
protected static final String CREATED_AT = "createdAt";
// ISO-8601 format
private static final DateTimeFormatter DATE_TIME_FORMATTER = DateTimeFormatter.ISO_INSTANT;
private final BraintreeGateway braintreeGateway;
protected AbstractReportsBraintreeExtractServiceImpl(final BraintreeGateway braintreeGateway) {
this.braintreeGateway = braintreeGateway;
}
protected abstract String getSearchQuery();
protected abstract List<T> getEdges(BraintreeTypeEnum braintreeType, Map<String, Object> search);
protected String getCursor(final BraintreeTypeEnum braintreeType, final Map<String, Object> result) {
return (String) ((Map<String, Object>) ((Map<String, Object>) ((Map<String, Object>) ((Map<String, Object>) result
.get(DATA)).get(SEARCH)).get(braintreeType.getTypeName())).get(PAGE_INFO)).get(END_CURSOR);
}
protected Boolean getHasNextPage(final BraintreeTypeEnum braintreeType, final Map<String, Object> result) {
return (Boolean) ((Map<String, Object>) ((Map<String, Object>) ((Map<String, Object>) ((Map<String, Object>) result
.get(DATA)).get(SEARCH)).get((braintreeType.getTypeName()))).get(PAGE_INFO)).get(HAS_NEXT_PAGE);
}
protected Map<String, Object> populateVars(final String transactionStatus, final Date startDate, final Date endDate,
final String cursor) {
final HashMap<String, Object> isTransactionStatus = new HashMap<>(
Map.of(STATUS, (Map.of(IS, transactionStatus))));
final HashMap<String, Object> vars = new HashMap<>(Map.of(INPUT, isTransactionStatus));
if (Objects.nonNull(cursor)) {
vars.put(AFTER, cursor);
}
final HashMap<String, Object> intervalDates = new HashMap<>();
if (Objects.nonNull(startDate)) {
intervalDates.put(GREATER_THAN_OR_EQUAL_TO, convertToISO8601(DateUtil.convertToLocalDateTime(startDate)));
}
if (Objects.nonNull(endDate)) {
intervalDates.put(LESS_THAN_OR_EQUAL_TO, convertToISO8601(DateUtil.convertToLocalDateTime(endDate)));
}
if (!intervalDates.isEmpty()) {
final Map<String, Object> input = (Map<String, Object>) vars.get(INPUT);
input.put(CREATED_AT, intervalDates);
}
return vars;
}
private String convertToISO8601(final LocalDateTime date) {
final TemporalAccessor temp = date.atZone(ZoneId.systemDefault());
return DATE_TIME_FORMATTER.format(temp);
}
protected GraphQLClient getGraphQLClient() {
return braintreeGateway.graphQLClient;
}
}
| 5,039 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/converters/MapToBraintreeTransactionLineConverter.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeNodeGraphQLModel;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeTransactionTypeEnum;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
@Slf4j
@Service
public class MapToBraintreeTransactionLineConverter extends AbstractMapToBraintreeLineConverter
implements Converter<Map<String, Object>, HmcBraintreeTransactionLine> {
@Override
public HmcBraintreeTransactionLine convert(final Map<String, Object> source) {
final BraintreeNodeGraphQLModel braintreeNodeGraphQLModel = getBraintreeNodeGraphQLModel(source);
if (Objects.isNull(braintreeNodeGraphQLModel)) {
return null;
}
//@formatter:off
return HmcBraintreeTransactionLine.builder()
.paymentTransactionId((Optional.ofNullable((String) source.get("legacyId")).orElse(StringUtils.EMPTY)))
.orderId(braintreeNodeGraphQLModel.getOrderId())
.amount(braintreeNodeGraphQLModel.getAmount().getValue())
.currencyIsoCode(braintreeNodeGraphQLModel.getAmount().getCurrencyCode())
.paymentTransactionTime(DateUtil.convertToLocalDateTime(braintreeNodeGraphQLModel.getCreatedAt()))
.transactionType(BraintreeTransactionTypeEnum.OPERATOR_ORDER_AMOUNT.name())
.build();
//@formatter:on
}
}
| 5,040 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/converters/AbstractMapToBraintreeLineConverter.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeGraphQLAmountModel;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeNodeGraphQLModel;
import java.math.BigDecimal;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.TimeZone;
public abstract class AbstractMapToBraintreeLineConverter {
// ISO-8601
private static final String DATE_FORMATTER = "yyyy-MM-dd'T'HH:mm:ss.SSSXXX";
protected BraintreeNodeGraphQLModel getBraintreeNodeGraphQLModel(final Map<String, Object> source) {
if (Objects.isNull(source)) {
return null;
}
final String createdAt = (String) source.get("createdAt");
final String orderId = (String) source.get("orderId");
final String status = (String) source.get("status");
final List<Map<String, String>> customFields = (List<Map<String, String>>) source.get("customFields");
final Map<String, Object> amountMap = (Map<String, Object>) source.get("amount");
final BigDecimal amountValue = new BigDecimal((String) amountMap.get("value"));
final String amountCurrencyCode = (String) amountMap.get("currencyCode");
//@formatter:off
final BraintreeGraphQLAmountModel amount = BraintreeGraphQLAmountModel.builder()
.value(amountValue)
.currencyCode(amountCurrencyCode)
.build();
//@formatter:on
//@formatter:off
return BraintreeNodeGraphQLModel.builder()
.createdAt(DateUtil.convertToDate(createdAt, DATE_FORMATTER, TimeZone.getDefault()))
.orderId(orderId)
.status(status)
.amount(amount)
.customFields(customFields)
.build();
//@formatter:on
}
}
| 5,041 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/converters/MiraklTransactionLineToFinancialReportLineConverter.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.reports.model.HmcFinancialReportLine;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import org.springframework.stereotype.Service;
import java.util.Objects;
@Service
public class MiraklTransactionLineToFinancialReportLineConverter
implements Converter<HmcMiraklTransactionLine, HmcFinancialReportLine> {
/**
* Method that retrieves a {@link HmcMiraklTransactionLine} and returns a
* {@link HmcFinancialReportLine}
* @param source the source object {@link HmcMiraklTransactionLine}
* @return the returned object {@link HmcFinancialReportLine}
*/
@Override
public HmcFinancialReportLine convert(final HmcMiraklTransactionLine source) {
if (Objects.isNull(source)) {
return null;
}
//@formatter:off
return HmcFinancialReportLine.builder()
.miraklOrderId(source.getOrderId())
.miraklSellerId(source.getSellerId())
.miraklTransactionLineId(source.getTransactionLineId())
.miraklTransactionTime(source.getTransactionTime())
.miraklTransactionType(source.getTransactionType())
.miraklCreditAmount(source.getCreditAmount())
.miraklDebitAmount(source.getDebitAmount())
.currencyIsoCode(source.getCurrencyIsoCode())
.build();
//@formatter:on
}
}
| 5,042 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/converters/BraintreeTransactionLineToFinancialReportLineConverter.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.HmcFinancialReportLine;
import org.springframework.stereotype.Service;
import java.util.Objects;
@Service
public class BraintreeTransactionLineToFinancialReportLineConverter
implements Converter<HmcBraintreeTransactionLine, HmcFinancialReportLine> {
/**
* Method that retrieves a {@link HmcBraintreeTransactionLine} and returns a
* {@link HmcFinancialReportLine}
* @param source the source object {@link HmcBraintreeTransactionLine}
* @return the returned object {@link HmcFinancialReportLine}
*/
@Override
public HmcFinancialReportLine convert(final HmcBraintreeTransactionLine source) {
if (Objects.isNull(source)) {
return null;
}
//@formatter:off
return HmcFinancialReportLine.builder()
.braintreeCommerceOrderId(source.getOrderId())
.braintreeAmount(source.getAmount())
.currencyIsoCode(source.getCurrencyIsoCode())
.miraklTransactionType(source.getTransactionType())
.braintreeTransactionId(source.getPaymentTransactionId())
.braintreeTransactionTime(source.getPaymentTransactionTime())
.build();
//@formatter:on
}
}
| 5,043 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/converters/MapToBraintreeRefundLineConverter.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.reports.model.HmcBraintreeRefundLine;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeNodeGraphQLModel;
import com.paypal.reports.model.graphql.braintree.paymentransaction.BraintreeTransactionTypeEnum;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
@Slf4j
@Service
public class MapToBraintreeRefundLineConverter extends AbstractMapToBraintreeLineConverter
implements Converter<Map<String, Object>, HmcBraintreeRefundLine> {
@Override
public HmcBraintreeRefundLine convert(final Map<String, Object> source) {
final BraintreeNodeGraphQLModel braintreeNodeGraphQLModel = getBraintreeNodeGraphQLModel(source);
if (Objects.isNull(braintreeNodeGraphQLModel)) {
return null;
}
//@formatter:off
return HmcBraintreeRefundLine.builder()
.paymentTransactionId((Optional.ofNullable((String) source.get("legacyId")).orElse(StringUtils.EMPTY)))
.orderId(braintreeNodeGraphQLModel.getOrderId())
.amount(braintreeNodeGraphQLModel.getAmount().getValue().negate())
.currencyIsoCode(braintreeNodeGraphQLModel.getAmount().getCurrencyCode())
.paymentTransactionTime(DateUtil.convertToLocalDateTime(braintreeNodeGraphQLModel.getCreatedAt()))
.transactionType(BraintreeTransactionTypeEnum.REFUND_OPERATOR_ORDER_AMOUNT.name())
.build();
//@formatter:on
}
}
| 5,044 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/converters/MiraklTransactionLogToMiraklTransactionLineModelConverter.java | package com.paypal.reports.services.converters;
import com.mirakl.client.mmp.domain.payment.MiraklTransactionLog;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Objects;
/**
* Converts {@link MiraklTransactionLog} to {@link HmcMiraklTransactionLine}
*/
@Slf4j
@Service
public class MiraklTransactionLogToMiraklTransactionLineModelConverter
implements Converter<MiraklTransactionLog, HmcMiraklTransactionLine> {
@Override
public HmcMiraklTransactionLine convert(final MiraklTransactionLog source) {
if (Objects.isNull(source)) {
log.warn("Input MiraklTransactionLog is null");
return null;
}
//@formatter:off
return HmcMiraklTransactionLine.builder()
.orderId(source.getOrderId())
.creditAmount(source.getAmountCredited())
.debitAmount(source.getAmountDebited())
.amount(source.getAmount())
.transactionTime(Objects.nonNull(source.getDateCreated()) ? DateUtil.convertToLocalDateTime(source.getDateCreated()) : null)
.transactionNumber(source.getTransactionNumber())
.transactionType(String.valueOf(source.getTransactionType()))
.transactionLineId(source.getId())
.currencyIsoCode(String.valueOf(source.getCurrencyIsoCode()))
.sellerId(source.getShopId())
.build();
//@formatter:on
}
}
| 5,045 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services | Create_ds/mirakl-hyperwallet-connector/hmc-reports/src/main/java/com/paypal/reports/services/converters/BrainTreeMiraklTransactionLinesIntoFinancialReportLineConverter.java | package com.paypal.reports.services.converters;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.reports.model.HmcBraintreeTransactionLine;
import com.paypal.reports.model.HmcFinancialReportLine;
import com.paypal.reports.model.HmcMiraklTransactionLine;
import org.apache.commons.lang3.tuple.Pair;
import org.springframework.stereotype.Service;
import java.util.Objects;
@Service
public class BrainTreeMiraklTransactionLinesIntoFinancialReportLineConverter
implements Converter<Pair<HmcBraintreeTransactionLine, HmcMiraklTransactionLine>, HmcFinancialReportLine> {
/**
* Method that retrieves a {@link Pair< HmcBraintreeTransactionLine ,
* HmcMiraklTransactionLine >} and returns a {@link HmcFinancialReportLine}
* @param source the source object {@link Pair< HmcBraintreeTransactionLine ,
* HmcMiraklTransactionLine >}
* @return the returned object {@link HmcFinancialReportLine}
*/
@Override
public HmcFinancialReportLine convert(final Pair<HmcBraintreeTransactionLine, HmcMiraklTransactionLine> source) {
final HmcBraintreeTransactionLine hmcBraintreeTransactionLine = source.getLeft();
final HmcMiraklTransactionLine hmcMiraklTransactionLine = source.getRight();
if (Objects.isNull(hmcBraintreeTransactionLine) || Objects.isNull(hmcMiraklTransactionLine)) {
return null;
}
if (!hmcBraintreeTransactionLine.getPaymentTransactionId()
.equals(hmcMiraklTransactionLine.getTransactionNumber())) {
return null;
}
//@formatter:off
return HmcFinancialReportLine.builder()
.braintreeCommerceOrderId(hmcBraintreeTransactionLine.getOrderId())
.miraklOrderId(hmcMiraklTransactionLine.getOrderId())
.miraklSellerId(hmcMiraklTransactionLine.getSellerId())
.miraklTransactionLineId(hmcMiraklTransactionLine.getTransactionLineId())
.miraklTransactionTime(hmcMiraklTransactionLine.getTransactionTime())
.miraklTransactionType(hmcMiraklTransactionLine.getTransactionType())
.braintreeAmount(hmcBraintreeTransactionLine.getAmount())
.miraklDebitAmount(hmcMiraklTransactionLine.getDebitAmount())
.miraklCreditAmount(hmcMiraklTransactionLine.getCreditAmount())
.currencyIsoCode(hmcBraintreeTransactionLine.getCurrencyIsoCode())
.braintreeTransactionId(hmcBraintreeTransactionLine.getPaymentTransactionId())
.braintreeTransactionTime(hmcBraintreeTransactionLine.getPaymentTransactionTime())
.build();
//@formatter:on
}
}
| 5,046 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/NotificationsArchTest.java | package com.paypal.notifications;
import com.paypal.testsupport.archrules.SliceLayeredModuleLayerProtectionRules;
import com.paypal.testsupport.archrules.SliceLayeredModulePackageStructureRules;
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;
//@formatter:off
@AnalyzeClasses(packages = "com.paypal.notifications",
importOptions = ImportOption.DoNotIncludeTests.class)
class NotificationsArchTest {
@ArchTest
public static final ArchTests packageRules = ArchTests.in(SliceLayeredModulePackageStructureRules.class);
@ArchTest
public static final ArchTests layerRules = ArchTests.in(SliceLayeredModuleLayerProtectionRules.class);
}
| 5,047 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/encryption | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/encryption/httpconverters/JWEConverterTest.java | package com.paypal.notifications.encryption.httpconverters;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.hyperwallet.clientsdk.Hyperwallet;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.hyperwallet.clientsdk.util.HyperwalletEncryption;
import com.nimbusds.jose.JOSEException;
import org.apache.commons.io.IOUtils;
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 org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.StandardCharsets;
import java.text.ParseException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class JWEConverterTest {
private static final String UTF_8 = "UTF-8";
@Spy
@InjectMocks
private JWEConverter testObj;
@Mock
private ObjectMapper objectMapper;
@Mock
private HyperwalletEncryption hyperwalletEncryptionMock;
@Mock
private HttpInputMessage inputMessageMock;
@Mock
private InputStream inputStreamMock, decryptedInputMock;
@Mock
private HyperwalletWebhookNotification expectedResultMock, objectMock;
@Mock
private HttpOutputMessage outputMessageMock;
@Mock
private OutputStream outputStreamMock;
@Test
void supports_shouldReturnTrueWhenIncomingClassIsHyperwalletWebhookNotification() {
final boolean result = testObj.supports(HyperwalletWebhookNotification.class);
assertThat(result).isTrue();
}
@Test
void supports_shouldReturnTrueWhenIncomingClassIsDifferentFromHyperwalletWebhookNotification() {
final boolean result = testObj.supports(Hyperwallet.class);
assertThat(result).isFalse();
}
@Test
void readInternal_shouldUseObjectMapperWithTheDecryptedInputStream() throws IOException {
when(inputMessageMock.getBody()).thenReturn(inputStreamMock);
doReturn(decryptedInputMock).when(testObj).decrypt(inputStreamMock);
when(objectMapper.readValue(decryptedInputMock, HyperwalletWebhookNotification.class))
.thenReturn(expectedResultMock);
final HyperwalletWebhookNotification result = testObj.readInternal(HyperwalletWebhookNotification.class,
inputMessageMock);
verify(objectMapper).readValue(decryptedInputMock, HyperwalletWebhookNotification.class);
assertThat(result).isEqualTo(expectedResultMock);
}
@Test
void writeInternal_shouldWriteInOutputStreamResultOfObjectMapperWritingValuesAsBytes() throws IOException {
final byte[] outputByteStub = "anyString".getBytes();
when(outputMessageMock.getBody()).thenReturn(outputStreamMock);
when(objectMapper.writeValueAsBytes(objectMock)).thenReturn(outputByteStub);
testObj.writeInternal(objectMock, outputMessageMock);
verify(outputStreamMock).write(outputByteStub);
}
@Test
void getBodyAsString_shouldReturnCorrespondentStringFromInputStream() throws IOException {
final InputStream inputStream = IOUtils.toInputStream("This is the input stream", UTF_8);
final String result = testObj.getBodyAsString(inputStream);
assertThat(result).isEqualTo("This is the input stream");
}
@Test
void decrypt_shouldDecryptTheBodyOfInputStreamUsingHyperwalletEncryptionClass()
throws ParseException, JOSEException, IOException {
final String encryptedBody = "encryptedBody";
final String decryptedBody = "decryptedBody";
doReturn(encryptedBody).when(testObj).getBodyAsString(inputStreamMock);
when(hyperwalletEncryptionMock.decrypt(encryptedBody)).thenReturn(decryptedBody);
final InputStream result = testObj.decrypt(inputStreamMock);
assertThat(IOUtils.toString(result, StandardCharsets.UTF_8)).isEqualTo(decryptedBody);
}
}
| 5,048 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/failures | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/failures/connectors/NotificationsRepositoryImplTest.java | package com.paypal.notifications.failures.connectors;
import com.callibrity.logging.test.LogTracker;
import com.callibrity.logging.test.LogTrackerStub;
import com.hyperwallet.clientsdk.Hyperwallet;
import com.hyperwallet.clientsdk.HyperwalletException;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.hyperwallet.services.UserHyperwalletSDKService;
import com.paypal.infrastructure.support.logging.HyperwalletLoggingErrorsUtil;
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.junit.jupiter.MockitoExtension;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class NotificationsRepositoryImplTest {
private static final String HYPERWALLET_NOTIFICATION_TOKEN = "TEST_TOKEN";
private static final String HYPERWALLET_NOTIFICATION_PROGRAM = "TEST_PROGRAM";
private static final String MSG_ERROR = "An error has occurred";
@InjectMocks
private NotificationsRepositoryImpl testObj;
@Mock
private UserHyperwalletSDKService userHyperwalletSDKService;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotificationMock;
@Mock
private Hyperwallet hyperwalletInstanceMock;
@RegisterExtension
final LogTrackerStub logTrackerStub = LogTrackerStub.create().recordForLevel(LogTracker.LogLevel.ERROR)
.recordForType(NotificationsRepositoryImpl.class);
@Test
void getHyperwalletWebhookNotification_shouldReturnAnHyperwalletNotification_WhenTokenExists() {
when(userHyperwalletSDKService.getHyperwalletInstanceByHyperwalletProgram(HYPERWALLET_NOTIFICATION_PROGRAM))
.thenReturn(hyperwalletInstanceMock);
when(hyperwalletInstanceMock.getWebhookEvent(HYPERWALLET_NOTIFICATION_TOKEN))
.thenReturn(hyperwalletWebhookNotificationMock);
final HyperwalletWebhookNotification result = testObj
.getHyperwalletWebhookNotification(HYPERWALLET_NOTIFICATION_PROGRAM, HYPERWALLET_NOTIFICATION_TOKEN);
assertThat(result).isEqualTo(hyperwalletWebhookNotificationMock);
}
@Test
void getHyperwalletWebhookNotification_shouldReturnNull_WhenTokenNotExists() {
when(userHyperwalletSDKService.getHyperwalletInstanceByHyperwalletProgram(HYPERWALLET_NOTIFICATION_PROGRAM))
.thenReturn(hyperwalletInstanceMock);
when(hyperwalletInstanceMock.getWebhookEvent(HYPERWALLET_NOTIFICATION_TOKEN)).thenReturn(null);
final HyperwalletWebhookNotification result = testObj
.getHyperwalletWebhookNotification(HYPERWALLET_NOTIFICATION_PROGRAM, HYPERWALLET_NOTIFICATION_TOKEN);
assertThat(result).isNull();
}
@Test
void getHyperwalletWebhookNotification_shouldReturnNull_andLogException_WhenExceptionIsThrown() {
when(userHyperwalletSDKService.getHyperwalletInstanceByHyperwalletProgram(HYPERWALLET_NOTIFICATION_PROGRAM))
.thenReturn(hyperwalletInstanceMock);
final HyperwalletException hyperwalletException = new HyperwalletException(MSG_ERROR);
when(hyperwalletInstanceMock.getWebhookEvent(HYPERWALLET_NOTIFICATION_TOKEN)).thenThrow(hyperwalletException);
final HyperwalletWebhookNotification result = testObj
.getHyperwalletWebhookNotification(HYPERWALLET_NOTIFICATION_PROGRAM, HYPERWALLET_NOTIFICATION_TOKEN);
assertThat(result).isNull();
assertThat(logTrackerStub.contains("Could not fetch notification [%s] due to reason:%n%s".formatted(
HYPERWALLET_NOTIFICATION_TOKEN, HyperwalletLoggingErrorsUtil.stringify(hyperwalletException))))
.isTrue();
}
}
| 5,049 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/failures | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/failures/jobs/NotificationProcessJobTest.java | package com.paypal.notifications.failures.jobs;
import com.paypal.notifications.failures.services.FailedNotificationService;
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 org.quartz.JobExecutionContext;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class NotificationProcessJobTest {
@Spy
@InjectMocks
private NotificationProcessJob testObj;
@Mock
protected FailedNotificationService failedNotificationServiceMock;
@Mock
private JobExecutionContext jobExecutionContextMock;
@Test
void execute_whenRetryNotificationsAreEnabled_shouldProcessFailedNotifications() {
doReturn(true).when(testObj).shouldRetryNotifications();
testObj.execute(jobExecutionContextMock);
verify(failedNotificationServiceMock).processFailedNotifications();
}
@Test
void execute_whenRetryNotificationsAreDisabled_shouldNotProcessFailedNotifications() {
doReturn(false).when(testObj).shouldRetryNotifications();
testObj.execute(jobExecutionContextMock);
verify(failedNotificationServiceMock, never()).processFailedNotifications();
}
}
| 5,050 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/failures | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/failures/services/FailedNotificationServiceImplTest.java | package com.paypal.notifications.failures.services;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.notifications.storage.repositories.entities.NotificationInfoEntity;
import com.paypal.notifications.failures.repositories.FailedNotificationInformationRepository;
import com.paypal.notifications.failures.connectors.NotificationsRepository;
import com.paypal.notifications.incoming.services.NotificationProcessingService;
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.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class FailedNotificationServiceImplTest {
private static final String TOKEN_1 = "token1";
private static final String TOKEN_2 = "token2";
private static final String TOKEN_3 = "token3";
private static final String PROGRAM_TOKEN = "programToken";
@InjectMocks
private FailedNotificationServiceImpl testObj;
@Mock
private NotificationsRepository notificationsRepositoryMock;
@Mock
private FailedNotificationInformationRepository failedNotificationInformationRepositoryMock;
@Mock
private NotificationInfoEntity notificationInfoEntity1Mock, notificationInfoEntity2Mock,
notificationInfoEntity3Mock;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotification1Mock, hyperwalletWebhookNotification2Mock;
@Mock
private NotificationProcessingService notificationProcessingServiceMock;
@Test
void processFailedNotifications_whenFailedNotificationsExist_shouldProcessFailedNotifications_andSkipNotificationsThatCantBeFetched() {
when(failedNotificationInformationRepositoryMock.findAll()).thenReturn(
List.of(notificationInfoEntity1Mock, notificationInfoEntity2Mock, notificationInfoEntity3Mock));
when(notificationInfoEntity1Mock.getNotificationToken()).thenReturn(TOKEN_1);
when(notificationInfoEntity1Mock.getProgram()).thenReturn(PROGRAM_TOKEN);
when(notificationInfoEntity2Mock.getNotificationToken()).thenReturn(TOKEN_2);
when(notificationInfoEntity2Mock.getProgram()).thenReturn(PROGRAM_TOKEN);
when(notificationInfoEntity3Mock.getNotificationToken()).thenReturn(TOKEN_3);
when(notificationInfoEntity3Mock.getProgram()).thenReturn(PROGRAM_TOKEN);
when(notificationsRepositoryMock.getHyperwalletWebhookNotification(PROGRAM_TOKEN, TOKEN_1))
.thenReturn(hyperwalletWebhookNotification1Mock);
when(notificationsRepositoryMock.getHyperwalletWebhookNotification(PROGRAM_TOKEN, TOKEN_2))
.thenReturn(hyperwalletWebhookNotification2Mock);
when(notificationsRepositoryMock.getHyperwalletWebhookNotification(PROGRAM_TOKEN, TOKEN_3)).thenReturn(null);
testObj.processFailedNotifications();
verify(notificationProcessingServiceMock).processNotification(hyperwalletWebhookNotification1Mock);
verify(notificationProcessingServiceMock).processNotification(hyperwalletWebhookNotification2Mock);
}
}
| 5,051 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/testsupport | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/testsupport/controllers/IncomingHyperwalletNotificationWebhookControllerTest.java | package com.paypal.notifications.testsupport.controllers;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.notifications.incoming.services.NotificationProcessingService;
import com.paypal.notifications.incoming.controllers.IncomingHyperwalletNotificationWebhookController;
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 IncomingHyperwalletNotificationWebhookControllerTest {
@InjectMocks
private IncomingHyperwalletNotificationWebhookController testObj;
@Mock
private NotificationProcessingService notificationProcessingServiceMock;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotificationMock;
@Test
void receiveIncomingNotification_shouldDelegateToService() {
testObj.receiveIncomingNotification(hyperwalletWebhookNotificationMock);
verify(notificationProcessingServiceMock).processNotification(hyperwalletWebhookNotificationMock);
}
}
| 5,052 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/storage | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/storage/controllers/NotificationsControllerTest.java | package com.paypal.notifications.storage.controllers;
import com.paypal.infrastructure.support.exceptions.DateIntervalException;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import com.paypal.notifications.storage.services.NotificationStorageService;
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.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class NotificationsControllerTest {
private static final Date FROM_DATE = new GregorianCalendar(2014, Calendar.FEBRUARY, 11).getTime();
private static final Date TO_DATE = new GregorianCalendar(2015, Calendar.FEBRUARY, 11).getTime();
private static final String DATE_INTERVAL_FORMATTED_MESSAGE = "[From] date [2015-02-11T00:00:00] can not be later than [To] date [2014-02-11T00:00:00]";
@InjectMocks
private NotificationsController testObj;
@Mock
private NotificationStorageService notificationStorageServiceMock;
@Mock
private NotificationEntity notificationEntity1Mock, notificationEntity2Mock;
@Test
void getAllNotifications_ShouldThrowADateIntervalException_WhenFromDateIsLaterThanToDate() {
final DateIntervalException exception = assertThrows(DateIntervalException.class,
() -> testObj.getAllNotifications(TO_DATE, FROM_DATE));
assertThat(exception.getMessage()).isEqualTo(DATE_INTERVAL_FORMATTED_MESSAGE);
}
@Test
void getAllNotifications_ShouldAnOkStatusAndAllTheNotificationsBetweenFromAndTo_WhenFromDateIsBeforeThanToDate() {
when(notificationStorageServiceMock.getNotificationsBetween(FROM_DATE, TO_DATE))
.thenReturn(List.of(notificationEntity1Mock, notificationEntity2Mock));
final List<NotificationEntity> result = testObj.getAllNotifications(FROM_DATE, TO_DATE);
assertThat(result).containsExactly(notificationEntity1Mock, notificationEntity2Mock);
}
@Test
void deleteNotificationsBetween_ShouldThrowADateIntervalException_WhenFromDateIsLaterThanToDate() {
final DateIntervalException exception = assertThrows(DateIntervalException.class,
() -> testObj.deleteNotificationsBetween(TO_DATE, FROM_DATE));
assertThat(exception.getMessage()).isEqualTo(DATE_INTERVAL_FORMATTED_MESSAGE);
}
@Test
void deleteNotificationsBetween_ShouldRemoveAllNotificationsBetween() {
testObj.deleteNotificationsBetween(FROM_DATE, TO_DATE);
verify(notificationStorageServiceMock).deleteNotificationsBetween(FROM_DATE, TO_DATE);
}
}
| 5,053 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/storage | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/storage/services/NotificationStorageServiceImplTest.java | package com.paypal.notifications.storage.services;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import com.paypal.notifications.storage.repositories.NotificationEntityRepository;
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.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
class NotificationStorageServiceImplTest {
private static final String WEB_HOOK_TOKEN = "webHookToken";
private static final String OBJECT_TOKEN = "objectToken";
private static final Date CREATION_DATE = new GregorianCalendar(2014, Calendar.FEBRUARY, 11).getTime();
@InjectMocks
private NotificationStorageServiceImpl testObj;
@Mock
private NotificationEntityRepository notificationEntityRepositoryMock;
@Mock
private NotificationEntity notificationEntityMock;
@Mock
private Date fromDateMock, toDateMock;
@Test
void saveNotification_ShouldSaveTheNotification() {
testObj.saveNotification(notificationEntityMock);
verify(notificationEntityRepositoryMock).save(notificationEntityMock);
}
@Test
void getNotificationBetween_ShouldGetAllNotificationsByTheGivenDate() {
testObj.getNotificationsBetween(fromDateMock, toDateMock);
verify(notificationEntityRepositoryMock).findNotificationsBetween(fromDateMock, toDateMock);
}
@Test
void deleteNotificationsBetween_ShouldRemoveNotificationsBetweenTheGivenDates() {
testObj.deleteNotificationsBetween(fromDateMock, toDateMock);
verify(notificationEntityRepositoryMock).deleteNotificationsBetween(fromDateMock, toDateMock);
}
@Test
void getNotificationsByWebHookToken_ShouldGetAllNotificationsByTheGivenWebHookToken() {
testObj.getNotificationsByWebHookToken(WEB_HOOK_TOKEN);
verify(notificationEntityRepositoryMock).findNotificationsByWebHookToken(WEB_HOOK_TOKEN);
}
@Test
void getNotificationsByObjectTokenAndAndCreationDateAfter_ShouldGetAllNotificationsByTheGivensObjectTokenAndCreationDate() {
testObj.getNotificationsByObjectTokenAndAndCreationDateAfter(OBJECT_TOKEN, CREATION_DATE);
verify(notificationEntityRepositoryMock).findNotificationsByObjectTokenAndAndCreationDateAfter(OBJECT_TOKEN,
CREATION_DATE);
}
}
| 5,054 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/NotificationsFailuresJobConfigurationTest.java | package com.paypal.notifications.incoming;
import com.paypal.notifications.failures.NotificationsFailuresJobConfiguration;
import com.paypal.notifications.failures.jobs.NotificationProcessJob;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
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 NotificationsFailuresJobConfigurationTest {
private static final String CRON_EXPRESSION = "* 0/15 * * * ? *";
private static final String TRIGGER_PREFIX = "Trigger";
private static final String JOB_NAME = "NotificationProcessJob";
@InjectMocks
private NotificationsFailuresJobConfiguration testObj;
@Test
void extractSellersJob_createsJobDetailWithNameExtractProfessionalSellersJobAndTypeExtractProfessionalSellersJob() {
final JobDetail result = testObj.notificationProcessJob();
assertThat(result.getJobClass()).hasSameClassAs(NotificationProcessJob.class);
assertThat(result.getKey().getName()).isEqualTo("NotificationProcessJob");
}
@Test
void sellerExtractTrigger_shouldReturnATriggerCreatedWithTheCronExpressionPassedAsArgumentAndJob() {
final JobDetail jobDetail = JobBuilder.newJob(NotificationProcessJob.class).withIdentity(JOB_NAME).build();
final Trigger result = testObj.notificationProcessTrigger(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);
}
}
| 5,055 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/controllers/NotificationProcessJobControllerTest.java | package com.paypal.notifications.incoming.controllers;
import com.paypal.jobsystem.quartzintegration.support.AbstractDeltaInfoJob;
import com.paypal.jobsystem.quartzintegration.services.JobService;
import com.paypal.notifications.failures.controllers.NotificationProcessJobController;
import com.paypal.notifications.failures.jobs.NotificationProcessJob;
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 static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
class NotificationProcessJobControllerTest {
private static final String JOB_NAME = "jobName";
@InjectMocks
private NotificationProcessJobController testObj;
@Mock
private JobService jobServiceMock;
@Test
void runJob_shouldCallJobServiceWithValuesPassedAsParam() throws SchedulerException {
testObj.runJob(JOB_NAME);
verify(jobServiceMock).createAndRunSingleExecutionJob(JOB_NAME, NotificationProcessJob.class,
AbstractDeltaInfoJob.createJobDataMap(null), null);
}
}
| 5,056 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/services/NotificationProcessingServiceImplTest.java | package com.paypal.notifications.incoming.services;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.strategy.StrategyExecutor;
import com.paypal.notifications.incoming.services.converters.NotificationConverter;
import com.paypal.notifications.incoming.services.evaluators.NotificationEntityEvaluator;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import com.paypal.notifications.storage.services.NotificationStorageService;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.*;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class NotificationProcessingServiceImplTest {
@Spy
@InjectMocks
private NotificationProcessingServiceImpl testObj;
@Mock
private NotificationStorageService notificationStorageServiceMock;
@Mock
private NotificationConverter notificationConverterMock;
@Mock
private NotificationEntityEvaluator notificationEntityEvaluatorMock;
@Mock
private StrategyExecutor<HyperwalletWebhookNotification, Void> hyperwalletWebhookNotificationSenderStrategyExecutorMock;
@Mock
private NotificationEntity notificationEntityMock;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotification1Mock;
@Test
void processNotification_shouldSaveAndProcessIncomingNotificationAndReturnsOK_WhenNotificationIsProcessable() {
when(notificationEntityEvaluatorMock.isProcessable(notificationEntityMock)).thenReturn(true);
when(notificationConverterMock.convert(hyperwalletWebhookNotification1Mock)).thenReturn(notificationEntityMock);
testObj.processNotification(hyperwalletWebhookNotification1Mock);
final InOrder inOrder = Mockito.inOrder(notificationConverterMock, notificationStorageServiceMock,
hyperwalletWebhookNotificationSenderStrategyExecutorMock);
inOrder.verify(notificationConverterMock).convert(hyperwalletWebhookNotification1Mock);
inOrder.verify(notificationStorageServiceMock).saveNotification(notificationEntityMock);
verify(hyperwalletWebhookNotificationSenderStrategyExecutorMock).execute(hyperwalletWebhookNotification1Mock);
}
@Test
void processNotification_shouldSaveAndNotProcessIncomingNotificationAndReturnsOK_WhenNotificationIsNotProcessable() {
when(notificationEntityEvaluatorMock.isProcessable(notificationEntityMock)).thenReturn(false);
when(notificationConverterMock.convert(hyperwalletWebhookNotification1Mock)).thenReturn(notificationEntityMock);
testObj.processNotification(hyperwalletWebhookNotification1Mock);
final InOrder inOrder = Mockito.inOrder(notificationConverterMock, notificationStorageServiceMock,
hyperwalletWebhookNotificationSenderStrategyExecutorMock);
inOrder.verify(notificationConverterMock).convert(hyperwalletWebhookNotification1Mock);
inOrder.verify(notificationStorageServiceMock).saveNotification(notificationEntityMock);
verify(hyperwalletWebhookNotificationSenderStrategyExecutorMock, never())
.execute(hyperwalletWebhookNotification1Mock);
}
}
| 5,057 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/services/converters/NotificationConverterTest.java | package com.paypal.notifications.incoming.services.converters;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.infrastructure.support.date.TimeMachine;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import com.paypal.notifications.storage.repositories.entities.NotificationType;
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 java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class NotificationConverterTest {
private static final String OBJECT_TOKEN_MAP_KEY = "token";
private static final String PAYMENT_OBJECT_TOKEN_MAP_VALUE = "pmt-ffffffff-fff-ffff-4444-444444444444";
private static final String UNKNOWN_OBJECT_TOKEN_MAP_VALUE = "ffffffff-fff-ffff-4444-444444444444";
private static final String WEB_HOOK_TOKEN = "webHookToken";
private static final Date CREATION_DATE = new GregorianCalendar(2015, Calendar.FEBRUARY, 11).getTime();
private final NotificationConverter testObj = new NotificationConverter();
@Mock
private HyperwalletWebhookNotification sourceMock;
@BeforeEach
public void setUp() {
when(sourceMock.getToken()).thenReturn(WEB_HOOK_TOKEN);
when(sourceMock.getCreatedOn()).thenReturn(CREATION_DATE);
}
@Test
void convert_ShouldPopulateWebHookTokenAndCreationDateAndReceptionDateAndNotPopulateObjectTokenAndNotPopulateNotificationType_WhenObjectIsNull() {
TimeMachine.useFixedClockAt(LocalDateTime.now());
final LocalDateTime now = TimeMachine.now();
final Date nowAsDate = DateUtil.convertToDate(now, ZoneId.systemDefault());
final NotificationEntity result = testObj.convert(sourceMock);
assertThat(result.getWebHookToken()).isEqualTo(WEB_HOOK_TOKEN);
assertThat(result.getCreationDate()).isEqualTo(CREATION_DATE);
assertThat(result.getReceptionDate()).isEqualTo(nowAsDate);
assertThat(result.getObjectToken()).isNull();
assertThat(result.getNotificationType()).isNull();
}
@Test
void convert_ShouldNotPopulateObjectTokenAndNotPopulateNotificationType_WhenObjectIsNotAMap() {
when(sourceMock.getObject()).thenReturn(new Object());
final NotificationEntity result = testObj.convert(sourceMock);
assertThat(result.getObjectToken()).isNull();
assertThat(result.getNotificationType()).isNull();
}
@Test
void convert_ShouldNotPopulateObjectTokenAndNotPopulateNotificationType_WhenObjectTokenIsNotAString() {
when(sourceMock.getObject()).thenReturn(Map.of(OBJECT_TOKEN_MAP_KEY, new Object()));
final NotificationEntity result = testObj.convert(sourceMock);
assertThat(result.getObjectToken()).isNull();
assertThat(result.getNotificationType()).isNull();
}
@Test
void convert_ShouldPopulateObjectTokenAndPopulateNotificationType_WhenObjectTokenIsAString() {
when(sourceMock.getObject()).thenReturn(Map.of(OBJECT_TOKEN_MAP_KEY, PAYMENT_OBJECT_TOKEN_MAP_VALUE));
final NotificationEntity result = testObj.convert(sourceMock);
assertThat(result.getObjectToken()).isEqualTo(PAYMENT_OBJECT_TOKEN_MAP_VALUE);
assertThat(result.getNotificationType()).isEqualTo(NotificationType.PMT);
}
@Test
void convert_ShouldPopulateObjectTokenAndPopulateAnUnknownNotificationType_WhenObjectTokenIsAStringAndObjectTokenHasNotAKnownPrefix() {
when(sourceMock.getObject()).thenReturn(Map.of(OBJECT_TOKEN_MAP_KEY, UNKNOWN_OBJECT_TOKEN_MAP_VALUE));
final NotificationEntity result = testObj.convert(sourceMock);
assertThat(result.getObjectToken()).isEqualTo(UNKNOWN_OBJECT_TOKEN_MAP_VALUE);
assertThat(result.getNotificationType()).isEqualTo(NotificationType.UNK);
}
}
| 5,058 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/services/evaluators/NotificationEntityEvaluatorImplTest.java | package com.paypal.notifications.incoming.services.evaluators;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import org.junit.jupiter.api.Test;
import java.util.Set;
import java.util.function.Predicate;
import static org.assertj.core.api.Assertions.assertThat;
class NotificationEntityEvaluatorImplTest {
private NotificationEntityEvaluatorImpl testObj;
private final Predicate<NotificationEntity> isDuplicated = notificationEntity -> true;
private final Predicate<NotificationEntity> isNotDuplicated = notificationEntity -> false;
private final Predicate<NotificationEntity> isOutdated = notificationEntity -> true;
private final Predicate<NotificationEntity> isNotOutdated = notificationEntity -> false;
@Test
void isProcessable_ShouldReturnFalse_WhenAllThePredicatesReturnTrue() {
testObj = new NotificationEntityEvaluatorImpl(Set.of(isDuplicated, isOutdated));
final boolean result = testObj.isProcessable(new NotificationEntity());
assertThat(result).isFalse();
}
@Test
void isProcessable_ShouldReturnFalse_WhenOnePredicateReturnsTrue() {
testObj = new NotificationEntityEvaluatorImpl(Set.of(isDuplicated, isNotOutdated));
final boolean result = testObj.isProcessable(new NotificationEntity());
assertThat(result).isFalse();
}
@Test
void isProcessable_ShouldReturnTrue_WhenAllThePredicatesReturnFalse() {
testObj = new NotificationEntityEvaluatorImpl(Set.of(isNotDuplicated, isNotOutdated));
final boolean result = testObj.isProcessable(new NotificationEntity());
assertThat(result).isTrue();
}
}
| 5,059 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/services/evaluators | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/services/evaluators/predicates/IsOutdatedTest.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 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.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class IsOutdatedTest {
private static final String OBJECT_TOKEN = "objectToken";
private static final Date CREATION_DATE = new GregorianCalendar(2014, Calendar.FEBRUARY, 11).getTime();
@InjectMocks
private IsOutdated testObj;
@Mock
private NotificationStorageService notificationStorageService;
@Mock
private NotificationEntity notificationEntityMock;
@BeforeEach
public void setUp() {
when(notificationEntityMock.getObjectToken()).thenReturn(OBJECT_TOKEN);
when(notificationEntityMock.getCreationDate()).thenReturn(CREATION_DATE);
}
@Test
void test_ShouldReturnFalse_WhenThereAreNotNotificationsWithTheSameObjectTokenAndALaterCreationTime() {
when(notificationStorageService.getNotificationsByObjectTokenAndAndCreationDateAfter(OBJECT_TOKEN,
CREATION_DATE)).thenReturn(List.of());
final boolean result = testObj.test(notificationEntityMock);
assertThat(result).isFalse();
}
@Test
void test_ShouldReturnTrue_WhenThereAreNotificationsWithTheSameObjectTokenAndALaterCreationTime() {
when(notificationStorageService.getNotificationsByObjectTokenAndAndCreationDateAfter(OBJECT_TOKEN,
CREATION_DATE)).thenReturn(List.of(new NotificationEntity()));
final boolean result = testObj.test(notificationEntityMock);
assertThat(result).isTrue();
}
}
| 5,060 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/services/evaluators | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/incoming/services/evaluators/predicates/IsDuplicatedTest.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 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.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class IsDuplicatedTest {
private static final String WEB_HOOK_TOKEN = "webHookToken";
@InjectMocks
private IsDuplicated testObj;
@Mock
private NotificationStorageService notificationStorageService;
@Mock
private NotificationEntity notificationEntityMock;
@BeforeEach
public void setUp() {
when(notificationEntityMock.getWebHookToken()).thenReturn(WEB_HOOK_TOKEN);
}
@Test
void test_ShouldReturnFalse_WhenThereAreNotNotificationWithTheSameWebHookToken() {
when(notificationStorageService.getNotificationsByWebHookToken(WEB_HOOK_TOKEN)).thenReturn(List.of());
final boolean result = testObj.test(notificationEntityMock);
assertThat(result).isFalse();
}
@Test
void test_ShouldReturnFalse_WhenThereIsOneNotificationWithTheSameWebHookToken() {
when(notificationStorageService.getNotificationsByWebHookToken(WEB_HOOK_TOKEN))
.thenReturn(List.of(new NotificationEntity()));
final boolean result = testObj.test(notificationEntityMock);
assertThat(result).isFalse();
}
@Test
void test_ShouldReturnTrue_WhenThereAreMoreThanOneNotificationWithTheSameWebHookToken() {
when(notificationStorageService.getNotificationsByWebHookToken(WEB_HOOK_TOKEN))
.thenReturn(List.of(new NotificationEntity(), new NotificationEntity()));
final boolean result = testObj.test(notificationEntityMock);
assertThat(result).isTrue();
}
}
| 5,061 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/support/AbstractNotificationListenerTest.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.notifications.events.model.PaymentEvent;
import com.paypal.infrastructure.mail.services.MailNotificationUtil;
import com.paypal.notifications.storage.repositories.entities.NotificationInfoEntity;
import com.paypal.notifications.failures.repositories.FailedNotificationInformationRepository;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InOrder;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.Date;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class AbstractNotificationListenerTest {
private static final int MAX_RETRIES = 5;
private static final String TARGET_TOKEN = "targetToken";
private static final String NOTIFICATION_TYPE = "TestNotification";
private static final String NOTIFICATION_TOKEN = "notificationToken";
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.";
private MyAbstractNotificationListener testObj;
@Mock
private MailNotificationUtil mailNotificationUtilMock;
@Mock
private FailedNotificationInformationRepository failedNotificationInformationRepositoryMock;
@Mock
private Converter<HyperwalletWebhookNotification, NotificationInfoEntity> notificationInfoEntityToNotificationConverterMock;
@Mock
private PaymentEvent paymentEventMock;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotificationMock;
@Mock
private NotificationInfoEntity notificationInfoEntityMock, oldNotificationEntityMock;
@BeforeEach
void setUp() {
testObj = spy(new MyAbstractNotificationListener(mailNotificationUtilMock,
failedNotificationInformationRepositoryMock, notificationInfoEntityToNotificationConverterMock));
when(paymentEventMock.getNotification()).thenReturn(hyperwalletWebhookNotificationMock);
when(notificationInfoEntityToNotificationConverterMock.convert(hyperwalletWebhookNotificationMock))
.thenReturn(notificationInfoEntityMock);
lenient().when(hyperwalletWebhookNotificationMock.getToken()).thenReturn(NOTIFICATION_TOKEN);
lenient().when(notificationInfoEntityMock.getNotificationToken()).thenReturn(NOTIFICATION_TOKEN);
lenient().doReturn(MAX_RETRIES).when(testObj).getMaxRetries();
lenient().doReturn(true).when(testObj).hasEnabledNotificationRetries();
}
@Test
void onApplicationEvent_whenNotificationIsNew_shouldProcessNotificationWithoutDeletingOrSavingNotifications() {
testObj.onApplicationEvent(paymentEventMock);
verify(testObj).processNotification(hyperwalletWebhookNotificationMock);
verify(failedNotificationInformationRepositoryMock, never()).delete(any());
verify(failedNotificationInformationRepositoryMock, never()).save(any());
}
@Test
void onApplicationEvent_whenNotificationFailsDuringProcess_shouldSaveNotificationIncreasingRetryCounter() {
doThrow(RuntimeException.class).when(testObj).processNotification(hyperwalletWebhookNotificationMock);
testObj.onApplicationEvent(paymentEventMock);
final InOrder inOrder = inOrder(testObj, notificationInfoEntityMock,
failedNotificationInformationRepositoryMock);
inOrder.verify(testObj).processNotification(hyperwalletWebhookNotificationMock);
inOrder.verify(notificationInfoEntityMock).setRetryCounter(1);
inOrder.verify(failedNotificationInformationRepositoryMock).save(notificationInfoEntityMock);
}
@Test
void onApplicationEvent_whenNotificationAlreadyExistedInTheDatabase_shouldRemoveStoredNotification_andProcessNewNotification() {
when(failedNotificationInformationRepositoryMock.findByNotificationToken(NOTIFICATION_TOKEN))
.thenReturn(notificationInfoEntityMock);
testObj.onApplicationEvent(paymentEventMock);
final InOrder inOrder = inOrder(testObj, failedNotificationInformationRepositoryMock);
inOrder.verify(failedNotificationInformationRepositoryMock).delete(notificationInfoEntityMock);
inOrder.verify(testObj).processNotification(hyperwalletWebhookNotificationMock);
}
@Test
void onApplicationEvent_whenNotificationExistedInTheDatabase_andNotificationFailsDuringProcess_andNotificationHasFailedLessThanTheMaxAmountOfAllowedRetries_shouldSaveNotificationIncreasingRetryCounter() {
when(failedNotificationInformationRepositoryMock.findByNotificationToken(NOTIFICATION_TOKEN))
.thenReturn(notificationInfoEntityMock);
when(notificationInfoEntityMock.getRetryCounter()).thenReturn(1);
doThrow(RuntimeException.class).when(testObj).processNotification(hyperwalletWebhookNotificationMock);
testObj.onApplicationEvent(paymentEventMock);
final InOrder inOrder = inOrder(testObj, notificationInfoEntityMock,
failedNotificationInformationRepositoryMock);
inOrder.verify(testObj).processNotification(hyperwalletWebhookNotificationMock);
inOrder.verify(notificationInfoEntityMock).setRetryCounter(2);
inOrder.verify(failedNotificationInformationRepositoryMock).save(notificationInfoEntityMock);
}
@Test
void onApplicationEvent_whenReceivedNotificationIsNewerThanStoredNotification_shouldRemoveStoredNotification_andProcessNewNotification() {
final Instant present = Instant.now();
final Instant past = present.minus(2, ChronoUnit.DAYS);
when(notificationInfoEntityMock.getType()).thenReturn(NOTIFICATION_TYPE);
when(notificationInfoEntityMock.getTarget()).thenReturn(TARGET_TOKEN);
when(notificationInfoEntityMock.getCreationDate()).thenReturn(Date.from(present));
when(oldNotificationEntityMock.getCreationDate()).thenReturn(Date.from(past));
when(failedNotificationInformationRepositoryMock.findByTypeAndTarget(NOTIFICATION_TYPE, TARGET_TOKEN))
.thenReturn(oldNotificationEntityMock);
testObj.onApplicationEvent(paymentEventMock);
final InOrder inOrder = inOrder(testObj, failedNotificationInformationRepositoryMock);
inOrder.verify(failedNotificationInformationRepositoryMock).delete(oldNotificationEntityMock);
inOrder.verify(testObj).processNotification(hyperwalletWebhookNotificationMock);
}
@Test
void onApplicationEvent_whenReceivedNotificationIsOlderThanStoredNotification_shouldNotRemoveStoredNotification_andNotProcessNewNotification() {
final Instant present = Instant.now();
final Instant past = present.minus(2, ChronoUnit.DAYS);
when(notificationInfoEntityMock.getType()).thenReturn(NOTIFICATION_TYPE);
when(notificationInfoEntityMock.getTarget()).thenReturn(TARGET_TOKEN);
when(notificationInfoEntityMock.getCreationDate()).thenReturn(Date.from(past));
when(oldNotificationEntityMock.getCreationDate()).thenReturn(Date.from(present));
when(failedNotificationInformationRepositoryMock.findByTypeAndTarget(NOTIFICATION_TYPE, TARGET_TOKEN))
.thenReturn(oldNotificationEntityMock);
testObj.onApplicationEvent(paymentEventMock);
verify(failedNotificationInformationRepositoryMock, never()).delete(oldNotificationEntityMock);
verify(testObj, never()).processNotification(hyperwalletWebhookNotificationMock);
}
@Test
void onApplicationEvent_whenNotitficationFailsDuringProcess_andNotificationHasFailedMaxAmountOfRetries_shouldSaveNotificationIncreasingRetryCounter() {
when(failedNotificationInformationRepositoryMock.findByNotificationToken(NOTIFICATION_TOKEN))
.thenReturn(notificationInfoEntityMock);
when(notificationInfoEntityMock.getRetryCounter()).thenReturn(MAX_RETRIES + 20);
doThrow(RuntimeException.class).when(testObj).processNotification(hyperwalletWebhookNotificationMock);
testObj.onApplicationEvent(paymentEventMock);
final InOrder inOrder = inOrder(failedNotificationInformationRepositoryMock, testObj, mailNotificationUtilMock);
inOrder.verify(failedNotificationInformationRepositoryMock).delete(notificationInfoEntityMock);
inOrder.verify(testObj).processNotification(hyperwalletWebhookNotificationMock);
inOrder.verify(mailNotificationUtilMock).sendPlainTextEmail(EMAIL_SUBJECT.formatted(NOTIFICATION_TOKEN),
EMAIL_BODY.formatted(NOTIFICATION_TOKEN, MAX_RETRIES));
verify(failedNotificationInformationRepositoryMock, never()).save(any());
}
@Test
void onApplicationEvent_whenNotitficationFailsDuringProcess_andNotificationRetriesAreDisabled_shouldNotSaveNotification() {
doThrow(RuntimeException.class).when(testObj).processNotification(hyperwalletWebhookNotificationMock);
doReturn(false).when(testObj).hasEnabledNotificationRetries();
testObj.onApplicationEvent(paymentEventMock);
verify(testObj).processNotification(hyperwalletWebhookNotificationMock);
verify(failedNotificationInformationRepositoryMock, never()).save(any());
}
private static class MyAbstractNotificationListener extends AbstractNotificationListener<HMCEvent> {
private MyAbstractNotificationListener(final MailNotificationUtil mailNotificationUtil,
final FailedNotificationInformationRepository failedNotificationInformationRepository,
final Converter<HyperwalletWebhookNotification, NotificationInfoEntity> notificationInfoEntityToNotificationConverter) {
super(mailNotificationUtil, failedNotificationInformationRepository,
notificationInfoEntityToNotificationConverter);
}
@Override
protected void processNotification(final HyperwalletWebhookNotification notification) {
// Do nothing
}
@Override
protected String getNotificationType() {
return NOTIFICATION_TYPE;
}
}
}
| 5,062 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/support | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/support/converters/NotificationToNotificationInfoConverterTest.java | package com.paypal.notifications.events.support.converters;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.notifications.storage.repositories.entities.NotificationInfoEntity;
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 java.util.Date;
import java.util.Map;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class NotificationToNotificationInfoConverterTest {
private static final String TARGET_TOKEN = "targetToken";
private static final String NOTIFICATION_TYPE = "PAYMENT";
private static final String PROGRAM_TOKEN = "programToken";
private static final String NOTIFICATION_TOKEN = "not-1234-1234";
private final NotificationToNotificationInfoConverter testObj = new NotificationToNotificationInfoConverter();
@Mock
private Date dateMock;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotificationMock;
@BeforeEach
void setUp() {
when(hyperwalletWebhookNotificationMock.getToken()).thenReturn(NOTIFICATION_TOKEN);
when(hyperwalletWebhookNotificationMock.getType()).thenReturn(NOTIFICATION_TYPE);
when(hyperwalletWebhookNotificationMock.getCreatedOn()).thenReturn(dateMock);
}
@Test
void convert_whenNotificationObjectIsNotAMap_shouldSetNotificationTokenAndTypeAndDate() {
when(hyperwalletWebhookNotificationMock.getObject()).thenReturn("not a map");
final NotificationInfoEntity result = testObj.convert(hyperwalletWebhookNotificationMock);
assertThat(result).hasNoNullFieldsOrPropertiesExcept("program", "target");
assertThat(result.getNotificationToken()).isEqualTo(NOTIFICATION_TOKEN);
assertThat(result.getType()).isEqualTo(NOTIFICATION_TYPE);
assertThat(result.getCreationDate()).isEqualTo(dateMock);
}
@Test
void convert_whenNotificationObjectIsAMap_andDoesNotContainTokens_shouldSetNotificationTokenAndTypeAndDate() {
when(hyperwalletWebhookNotificationMock.getObject()).thenReturn(Map.of("somethingThatIsNotAToken", 1234));
final NotificationInfoEntity result = testObj.convert(hyperwalletWebhookNotificationMock);
assertThat(result).hasNoNullFieldsOrPropertiesExcept("program", "target");
assertThat(result.getNotificationToken()).isEqualTo(NOTIFICATION_TOKEN);
assertThat(result.getType()).isEqualTo(NOTIFICATION_TYPE);
assertThat(result.getCreationDate()).isEqualTo(dateMock);
}
@Test
void convert_whenNotificationObjectIsAMap_andMapContainsTargetTokenAndProgramToken_shouldPopulateAllFields() {
when(hyperwalletWebhookNotificationMock.getObject())
.thenReturn(Map.of("token", TARGET_TOKEN, "programToken", PROGRAM_TOKEN));
final NotificationInfoEntity result = testObj.convert(hyperwalletWebhookNotificationMock);
assertThat(result.getNotificationToken()).isEqualTo(NOTIFICATION_TOKEN);
assertThat(result.getType()).isEqualTo(NOTIFICATION_TYPE);
assertThat(result.getTarget()).isEqualTo(TARGET_TOKEN);
assertThat(result.getProgram()).isEqualTo(PROGRAM_TOKEN);
assertThat(result.getCreationDate()).isEqualTo(dateMock);
}
}
| 5,063 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services/EventSenderExecutorTest.java | package com.paypal.notifications.events.services;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.strategy.Strategy;
import com.paypal.notifications.events.services.EventSenderExecutor;
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 java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
@ExtendWith(MockitoExtension.class)
class EventSenderExecutorTest {
private EventSenderExecutor testObj;
@Mock
private Strategy<HyperwalletWebhookNotification, Void> strategy1, strategy2;
@BeforeEach
void setUp() {
testObj = new EventSenderExecutor(Set.of(strategy1, strategy2));
}
@Test
void getStrategies_shouldReturnSetOfAvailableStrategies() {
final Set<Strategy<HyperwalletWebhookNotification, Void>> result = testObj.getStrategies();
assertThat(result).containsExactlyInAnyOrder(strategy1, strategy2);
}
}
| 5,064 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services/eventpublishers/KycUserEventSenderTest.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.notifications.events.services.eventpublishers.KycUserEventSender;
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 org.springframework.context.ApplicationEventPublisher;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class KycUserEventSenderTest {
private static final String EXPECTED_TYPE = "expectedType";
private static final String UNEXPECTED_TYPE = "unexpectedType";
@Spy
@InjectMocks
private KycUserEventSender testObj;
@Mock
private ApplicationEventPublisher applicationEventPublisherMock;
@Mock
private KycUserEvent kycUserEventMock;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotificationMock;
@Test
void execute_shouldPublishEvent() {
doReturn(kycUserEventMock).when(testObj).getEvent(hyperwalletWebhookNotificationMock);
testObj.execute(hyperwalletWebhookNotificationMock);
verify(applicationEventPublisherMock).publishEvent(kycUserEventMock);
}
@Test
void getEvent_shouldReturnKycEventWithNotification() {
final HMCEvent event = testObj.getEvent(hyperwalletWebhookNotificationMock);
assertThat(event).isInstanceOf(KycUserEvent.class);
assertThat(event.getNotification()).isEqualTo(hyperwalletWebhookNotificationMock);
}
@Test
void isApplicable_whenNotificationTypeIsNull_shouldReturnFalse() {
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isFalse();
}
@Test
void isApplicable_whenNotificationStartsWithExpectedType_shouldReturnTrue() {
when(hyperwalletWebhookNotificationMock.getType()).thenReturn(EXPECTED_TYPE);
doReturn(EXPECTED_TYPE).when(testObj).getNotificationType();
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isTrue();
}
@Test
void isApplicable_whenNotificationDoesNotStartWithExpectedType_shouldReturnTrue() {
when(hyperwalletWebhookNotificationMock.getType()).thenReturn(UNEXPECTED_TYPE);
doReturn(EXPECTED_TYPE).when(testObj).getNotificationType();
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isFalse();
}
}
| 5,065 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services/eventpublishers/UnknownEventSenderTest.java | package com.paypal.notifications.events.services.eventpublishers;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.strategy.Strategy;
import com.paypal.notifications.events.services.eventpublishers.UnknownEventSender;
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.Collections;
import java.util.Set;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class UnknownEventSenderTest {
@InjectMocks
private UnknownEventSender testObj;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotificationMock;
@Mock
private Strategy<HyperwalletWebhookNotification, Void> strategy1Mock, strategy2Mock;
@BeforeEach
void setUp() {
testObj = new UnknownEventSender(Set.of(strategy1Mock, strategy2Mock));
}
@Test
void execute_shouldReturnNull() {
final Void result = testObj.execute(hyperwalletWebhookNotificationMock);
assertThat(result).isNull();
}
@Test
void isApplicable_whenNoStrategiesAreAvailable_shouldReturnTrue() {
testObj = new UnknownEventSender(Collections.emptySet());
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isTrue();
}
@Test
void isApplicable_whenNoStrategyIsApplicable_shouldReturnTrue() {
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isTrue();
}
@Test
void isApplicable_whenSomeStrategyIsApplicable_shouldReturnFalse() {
when(strategy2Mock.isApplicable(hyperwalletWebhookNotificationMock)).thenReturn(true);
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isFalse();
}
}
| 5,066 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services/eventpublishers/AbstractHMCEventSenderTest.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.services.eventpublishers.AbstractHMCEventSender;
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 org.springframework.context.ApplicationEventPublisher;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.verify;
@ExtendWith(MockitoExtension.class)
class AbstractHMCEventSenderTest {
@InjectMocks
private MyHMCEventSender testObj;
@Mock
private ApplicationEventPublisher applicationEventPublisherMock;
@Mock
private HyperwalletWebhookNotification notificationMock;
@Captor
private ArgumentCaptor<HMCEvent> hmcEventArgumentCaptor;
@Test
void execute_shouldPublishEventWithNotification() {
testObj.execute(notificationMock);
verify(applicationEventPublisherMock).publishEvent(hmcEventArgumentCaptor.capture());
final HMCEvent event = hmcEventArgumentCaptor.getValue();
assertThat(event.getNotification()).isEqualTo(notificationMock);
}
private static class MyHMCEventSender extends AbstractHMCEventSender {
@Override
protected HMCEvent getEvent(final HyperwalletWebhookNotification notification) {
return new MyEvent(this, notification);
}
}
private static class MyEvent extends HMCEvent {
MyEvent(final Object source, final HyperwalletWebhookNotification notification) {
super(source, notification);
}
}
}
| 5,067 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services/eventpublishers/PaymentSenderTest.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.notifications.events.services.eventpublishers.PaymentSender;
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 org.springframework.context.ApplicationEventPublisher;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class PaymentSenderTest {
private static final String EXPECTED_TYPE = "expectedType";
private static final String UNEXPECTED_TYPE = "unexpectedType";
@Spy
@InjectMocks
private PaymentSender testObj;
@Mock
private ApplicationEventPublisher applicationEventPublisherMock;
@Mock
private PaymentEvent paymentEventMock;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotificationMock;
@Test
void execute_shouldPublishEvent() {
doReturn(paymentEventMock).when(testObj).getEvent(hyperwalletWebhookNotificationMock);
testObj.execute(hyperwalletWebhookNotificationMock);
verify(applicationEventPublisherMock).publishEvent(paymentEventMock);
}
@Test
void getEvent_shouldReturnPaymentEventWithNotification() {
final HMCEvent event = testObj.getEvent(hyperwalletWebhookNotificationMock);
assertThat(event).isInstanceOf(PaymentEvent.class);
assertThat(event.getNotification()).isEqualTo(hyperwalletWebhookNotificationMock);
}
@Test
void isApplicable_whenNotificationTypeIsNull_shouldReturnFalse() {
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isFalse();
}
@Test
void isApplicable_whenNotificationStartsWithExpectedType_shouldReturnTrue() {
when(hyperwalletWebhookNotificationMock.getType()).thenReturn(EXPECTED_TYPE);
doReturn(EXPECTED_TYPE).when(testObj).getNotificationType();
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isTrue();
}
@Test
void isApplicable_whenNotificationDoesNotStartWithExpectedType_shouldReturnTrue() {
when(hyperwalletWebhookNotificationMock.getType()).thenReturn(UNEXPECTED_TYPE);
doReturn(EXPECTED_TYPE).when(testObj).getNotificationType();
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isFalse();
}
}
| 5,068 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/test/java/com/paypal/notifications/events/services/eventpublishers/KycBusinessStakeHolderSenderTest.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.notifications.events.services.eventpublishers.KycBusinessStakeHolderSender;
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 org.springframework.context.ApplicationEventPublisher;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class KycBusinessStakeHolderSenderTest {
private static final String EXPECTED_TYPE = "expectedType";
private static final String UNEXPECTED_TYPE = "unexpectedType";
@Spy
@InjectMocks
private KycBusinessStakeHolderSender testObj;
@Mock
private ApplicationEventPublisher applicationEventPublisherMock;
@Mock
private KycBusinessStakeholderEvent kycBusinessStakeholderEventMock;
@Mock
private HyperwalletWebhookNotification hyperwalletWebhookNotificationMock;
@Test
void execute_shouldPublishEvent() {
doReturn(kycBusinessStakeholderEventMock).when(testObj).getEvent(hyperwalletWebhookNotificationMock);
testObj.execute(hyperwalletWebhookNotificationMock);
verify(applicationEventPublisherMock).publishEvent(kycBusinessStakeholderEventMock);
}
@Test
void getEvent_shouldReturnKycBusinessStakeholderEventWithNotification() {
final HMCEvent event = testObj.getEvent(hyperwalletWebhookNotificationMock);
assertThat(event).isInstanceOf(KycBusinessStakeholderEvent.class);
assertThat(event.getNotification()).isEqualTo(hyperwalletWebhookNotificationMock);
}
@Test
void isApplicable_whenNotificationTypeIsNull_shouldReturnFalse() {
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isFalse();
}
@Test
void isApplicable_whenNotificationStartsWithExpectedType_shouldReturnTrue() {
when(hyperwalletWebhookNotificationMock.getType()).thenReturn(EXPECTED_TYPE);
doReturn(EXPECTED_TYPE).when(testObj).getNotificationType();
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isTrue();
}
@Test
void isApplicable_whenNotificationDoesNotStartWithExpectedType_shouldReturnTrue() {
when(hyperwalletWebhookNotificationMock.getType()).thenReturn(UNEXPECTED_TYPE);
doReturn(EXPECTED_TYPE).when(testObj).getNotificationType();
final boolean result = testObj.isApplicable(hyperwalletWebhookNotificationMock);
assertThat(result).isFalse();
}
}
| 5,069 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/integrationTest/java/com/paypal/notifications | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/integrationTest/java/com/paypal/notifications/management/FailedNotificationsManagementITTest.java | package com.paypal.notifications.management;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.paypal.notifications.failures.repositories.FailedNotificationInformationRepository;
import com.paypal.notifications.management.controllers.dto.FailedNotificationInfoDTO;
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 java.io.StringWriter;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import static org.assertj.core.api.Assertions.assertThat;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.print;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
//@formatter:off
@AutoConfigureMockMvc(addFilters = false)
class FailedNotificationsManagementITTest extends AbstractIntegrationTest {
@Autowired
private MockMvc mockMvc;
@Autowired
private FailedNotificationInformationRepository failedNotificationInformationRepository;
@Test
void shouldSetFailedNotificationList() throws Exception {
final List<FailedNotificationInfoDTO> failedNotificationInfoDTOs = List.of(
FailedNotificationInfoMother.list("type-A", 10),
FailedNotificationInfoMother.list("type-B", 10, 10))
.stream().flatMap(List::stream).toList();
this.mockMvc.perform(put("/management/failed-notifications/")
.contentType(MediaType.APPLICATION_JSON)
.content(toJson(failedNotificationInfoDTOs)))
.andDo(print())
.andExpect(status().isOk());
assertThat(failedNotificationInformationRepository.findAll()).hasSize(20);
}
@Test
void shouldReplaceFailedNotificationList() throws Exception {
List<FailedNotificationInfoDTO> failedNotificationInfoDTOs = List.of(
FailedNotificationInfoMother.list("type-A", 10),
FailedNotificationInfoMother.list("type-B", 10, 10))
.stream().flatMap(List::stream).toList();
this.mockMvc.perform(put("/management/failed-notifications/")
.contentType(MediaType.APPLICATION_JSON)
.content(toJson(failedNotificationInfoDTOs)));
failedNotificationInfoDTOs = List.of(
FailedNotificationInfoMother.list("type-C", 8, 100),
FailedNotificationInfoMother.list("type-D", 8, 200))
.stream().flatMap(List::stream).toList();
this.mockMvc.perform(put("/management/failed-notifications/")
.contentType(MediaType.APPLICATION_JSON)
.content(toJson(failedNotificationInfoDTOs)))
.andDo(print())
.andExpect(status().isOk());
assertThat(failedNotificationInformationRepository.findAll()).hasSize(16);
assertThat(failedNotificationInformationRepository.findAll().stream()
.filter(x -> x.getType().equals("type-C")))
.hasSize(8);
assertThat(failedNotificationInformationRepository.findAll().stream()
.filter(x -> x.getType().equals("type-D")))
.hasSize(8);
}
@Test
void shouldGetNotificationById() throws Exception {
final List<FailedNotificationInfoDTO> failedNotificationInfoDTOs = List.of(
FailedNotificationInfoMother.list("type-A", 10),
FailedNotificationInfoMother.list("type-B", 10, 10))
.stream().flatMap(List::stream).toList();
this.mockMvc.perform(put("/management/failed-notifications/")
.contentType(MediaType.APPLICATION_JSON)
.content(toJson(failedNotificationInfoDTOs)));
this.mockMvc.perform(get("/management/failed-notifications/wbh-1"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.notificationToken").value("wbh-1"));
}
@Test
void shouldGetNotificationById_andReturnNotFound_whenNotificationNotExists() throws Exception {
this.mockMvc.perform(put("/management/failed-notifications/")
.contentType(MediaType.APPLICATION_JSON)
.content(toJson(List.of())));
this.mockMvc.perform(get("/management/failed-notifications/wbh-1"))
.andExpect(status().isNotFound());
}
@Test
void shouldModifyNotification() throws Exception {
final List<FailedNotificationInfoDTO> failedNotificationInfoDTOs = List.of(
FailedNotificationInfoMother.list("type-A", 10),
FailedNotificationInfoMother.list("type-B", 10, 10))
.stream().flatMap(List::stream).toList();
this.mockMvc.perform(put("/management/failed-notifications/")
.contentType(MediaType.APPLICATION_JSON)
.content(toJson(failedNotificationInfoDTOs)));
final FailedNotificationInfoDTO failedNotificationInfoDTO = FailedNotificationInfoMother.single("type-A", 1);
failedNotificationInfoDTO.setRetryCounter(1);
this.mockMvc.perform(put("/management/failed-notifications/wbh-1")
.contentType(MediaType.APPLICATION_JSON)
.content(toJson(failedNotificationInfoDTO)));
this.mockMvc.perform(get("/management/failed-notifications/wbh-1"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.notificationToken").value("wbh-1"))
.andExpect(jsonPath("$.retryCounter").value("1"));
}
@Test
void shouldRemoveNotification() throws Exception {
final List<FailedNotificationInfoDTO> failedNotificationInfoDTOs = List.of(
FailedNotificationInfoMother.list("type-A", 10),
FailedNotificationInfoMother.list("type-B", 10, 10))
.stream().flatMap(List::stream).toList();
this.mockMvc.perform(put("/management/failed-notifications/")
.contentType(MediaType.APPLICATION_JSON)
.content(toJson(failedNotificationInfoDTOs)));
final FailedNotificationInfoDTO failedNotificationInfoDTO = FailedNotificationInfoMother.single("type-A", 1);
failedNotificationInfoDTO.setRetryCounter(1);
this.mockMvc.perform(delete("/management/failed-notifications/wbh-1"));
this.mockMvc.perform(get("/management/failed-notifications/wbh-1"))
.andExpect(status().isNotFound());
}
@Test
void shouldFindNotificationByTargetToken() throws Exception {
final List<FailedNotificationInfoDTO> failedNotificationInfoDTOs = List.of(
FailedNotificationInfoMother.list("type-A", 10),
FailedNotificationInfoMother.list("type-B", 10, 10))
.stream().flatMap(List::stream).toList();
this.mockMvc.perform(put("/management/failed-notifications/")
.contentType(MediaType.APPLICATION_JSON)
.content(toJson(failedNotificationInfoDTOs)));
this.mockMvc.perform(get("/management/failed-notifications/?target=trg-1&type=type-A"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.page.totalElements").value(1))
.andExpect(jsonPath("$._embedded.failed-notifications[0].notificationToken").value("wbh-1"));
}
private String toJson(final Object obj) throws Exception {
final ObjectMapper objectMapper = new ObjectMapper();
final StringWriter stringWriter = new StringWriter();
objectMapper.writeValue(stringWriter, obj);
return stringWriter.toString();
}
static class FailedNotificationInfoMother {
static FailedNotificationInfoDTO single(final String type, final int idx) {
return FailedNotificationInfoDTO.builder()
.notificationToken("wbh-%s".formatted(idx))
.type(type)
.target("trg-%s".formatted(idx))
.program("prg-%s".formatted(0))
.retryCounter(0)
.creationDate(new Date())
.build();
}
static List<FailedNotificationInfoDTO> list(final String type, final int num) {
return list(type, num, 0);
}
static List<FailedNotificationInfoDTO> list(final String type, final int num, final int offset) {
return IntStream
.range(0, num)
.mapToObj(idx -> FailedNotificationInfoMother.single(type, offset + idx))
.collect(Collectors.toList());
}
}
}
| 5,070 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/encryption/NotificationsEncryptionConfigurer.java | package com.paypal.notifications.encryption;
import com.paypal.notifications.encryption.httpconverters.JWEConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.List;
@Component
public class NotificationsEncryptionConfigurer implements WebMvcConfigurer {
private final JWEConverter jweConverter;
public NotificationsEncryptionConfigurer(final JWEConverter jweConverter) {
this.jweConverter = jweConverter;
}
@Override
public void extendMessageConverters(final List<HttpMessageConverter<?>> converters) {
converters.add(0, jweConverter);
}
}
| 5,071 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/encryption | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/encryption/httpconverters/JWEConverter.java | package com.paypal.notifications.encryption.httpconverters;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.hyperwallet.clientsdk.util.HyperwalletEncryption;
import com.nimbusds.jose.JOSEException;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.HttpOutputMessage;
import org.springframework.http.MediaType;
import org.springframework.http.converter.AbstractHttpMessageConverter;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.HttpMessageNotReadableException;
import org.springframework.http.converter.HttpMessageNotWritableException;
import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.text.ParseException;
import java.util.Optional;
/**
* Converts a JWE payload into the specific {@link HyperwalletWebhookNotification}
*/
@Slf4j
@Component
public class JWEConverter extends AbstractHttpMessageConverter<HyperwalletWebhookNotification>
implements HttpMessageConverter<HyperwalletWebhookNotification> {
private static final Charset DEFAULT_CHARSET = StandardCharsets.UTF_8;
private final HyperwalletEncryption hyperwalletEncryption;
private final ObjectMapper objectMapper;
public JWEConverter(@Nullable final HyperwalletEncryption hyperwalletEncryption, final ObjectMapper objectMapper) {
super(new MediaType("application", "jose+json", DEFAULT_CHARSET));
this.hyperwalletEncryption = hyperwalletEncryption;
this.objectMapper = objectMapper;
}
@Override
protected boolean supports(final Class<?> clazz) {
return clazz.equals(HyperwalletWebhookNotification.class);
}
@Override
protected HyperwalletWebhookNotification readInternal(final Class<? extends HyperwalletWebhookNotification> clazz,
final HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
return objectMapper.readValue(decrypt(inputMessage.getBody()), clazz);
}
@Override
protected void writeInternal(final HyperwalletWebhookNotification object, final HttpOutputMessage outputMessage)
throws IOException, HttpMessageNotWritableException {
outputMessage.getBody().write(objectMapper.writeValueAsBytes(object));
}
/**
* requests params of any API
* @param inputStream inputStream
* @return inputStream
*/
protected InputStream decrypt(final InputStream inputStream) {
final String body = getBodyAsString(inputStream);
String decrypt = null;
try {
decrypt = hyperwalletEncryption.decrypt(body);
}
catch (final ParseException | IOException | JOSEException e) {
log.error("Something went wrong decrypting the JWE", e);
}
return new ByteArrayInputStream(
Optional.ofNullable(decrypt).orElse(StringUtils.EMPTY).getBytes(StandardCharsets.UTF_8));
}
protected String getBodyAsString(final InputStream inputStream) {
try {
return new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
}
catch (final IOException e) {
log.error("Something went wrong converting inputStream into string", e);
return null;
}
}
}
| 5,072 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures/NotificationsFailuresJobConfiguration.java | package com.paypal.notifications.failures;
import com.paypal.notifications.failures.jobs.NotificationProcessJob;
import org.quartz.*;
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 NotificationsFailuresJobConfiguration {
private static final String TRIGGER_SUFFIX = "Trigger";
private static final String JOB_NAME = "NotificationProcessJob";
/**
* Creates a recurring job {@link NotificationProcessJob}
* @return the {@link JobDetail}
*/
@Bean
public JobDetail notificationProcessJob() {
//@formatter:off
return JobBuilder.newJob(NotificationProcessJob.class)
.withIdentity(JOB_NAME)
.storeDurably()
.build();
//@formatter:on
}
/**
* Schedules the recurring job {@link NotificationProcessJob} with the
* {@code jobDetails} set on
* {@link NotificationsFailuresJobConfiguration#notificationProcessJob()}
* @param jobDetails the {@link JobDetail}
* @return the {@link Trigger}
*/
@Bean
public Trigger notificationProcessTrigger(@Qualifier("notificationProcessJob") final JobDetail jobDetails,
@Value("${hmc.jobs.scheduling.retry-jobs.webhooks}") final String cronExpression) {
//@formatter:off
return TriggerBuilder.newTrigger()
.forJob(jobDetails)
.withIdentity(TRIGGER_SUFFIX + JOB_NAME)
.withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
.build();
//@formatter:on
}
}
| 5,073 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures/connectors/NotificationsRepository.java | package com.paypal.notifications.failures.connectors;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
/**
* Repository to access notifications previously sent by Hyperwallet via webhooks.
*/
public interface NotificationsRepository {
/**
* Retrieves a notification generated by Hyperwallet.
* @param program The program associated to the notification.
* @param token The token of the notification.
* @return The notification generated by Hyperwallet with the provided token or
* <code>null</code> if there is no previously generated notification with that token
*/
HyperwalletWebhookNotification getHyperwalletWebhookNotification(String program, String token);
}
| 5,074 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures/connectors/NotificationsRepositoryImpl.java | package com.paypal.notifications.failures.connectors;
import com.hyperwallet.clientsdk.Hyperwallet;
import com.hyperwallet.clientsdk.HyperwalletException;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.hyperwallet.services.UserHyperwalletSDKService;
import com.paypal.infrastructure.support.logging.HyperwalletLoggingErrorsUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
/**
* Implementation of {@link NotificationsRepository} that connects to Hyperwallet API to
* retrieve previously generated notifications.
*/
@Slf4j
@Component
public class NotificationsRepositoryImpl implements NotificationsRepository {
private final UserHyperwalletSDKService userHyperwalletSDKService;
public NotificationsRepositoryImpl(final UserHyperwalletSDKService userHyperwalletSDKService) {
this.userHyperwalletSDKService = userHyperwalletSDKService;
}
@Override
public HyperwalletWebhookNotification getHyperwalletWebhookNotification(final String program, final String token) {
final Hyperwallet hyperwalletInstance = userHyperwalletSDKService
.getHyperwalletInstanceByHyperwalletProgram(program);
try {
return hyperwalletInstance.getWebhookEvent(token);
}
catch (final HyperwalletException ex) {
log.error("Could not fetch notification [%s] due to reason:%n%s".formatted(token,
HyperwalletLoggingErrorsUtil.stringify(ex)), ex);
return null;
}
}
}
| 5,075 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures/repositories/FailedNotificationInformationRepository.java | package com.paypal.notifications.failures.repositories;
import com.paypal.notifications.storage.repositories.entities.NotificationInfoEntity;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
/**
* Repository for {@link NotificationInfoEntity}
*/
@Repository
@Transactional
public interface FailedNotificationInformationRepository extends JpaRepository<NotificationInfoEntity, Long> {
NotificationInfoEntity findByNotificationToken(String notificationToken);
NotificationInfoEntity findByTypeAndTarget(String type, String target);
Page<NotificationInfoEntity> findByTypeAndTarget(Pageable pageable, String type, String target);
}
| 5,076 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures/jobs/NotificationProcessJob.java | package com.paypal.notifications.failures.jobs;
import com.paypal.jobsystem.quartzintegration.support.AbstractDeltaInfoJob;
import com.paypal.notifications.failures.services.FailedNotificationService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobExecutionContext;
import org.quartz.PersistJobDataAfterExecution;
import org.springframework.beans.factory.annotation.Value;
/**
* Extracts stored failed notifications and tries to process them again
*/
@Slf4j
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class NotificationProcessJob extends AbstractDeltaInfoJob {
@Value("#{'${hmc.webhooks.retries.enabled}'}")
private boolean retryNotifications;
@Resource
protected FailedNotificationService failedNotificationService;
@Override
public void execute(final JobExecutionContext context) {
if (shouldRetryNotifications()) {
failedNotificationService.processFailedNotifications();
}
}
protected boolean shouldRetryNotifications() {
return retryNotifications;
}
}
| 5,077 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures/controllers/NotificationProcessJobController.java | package com.paypal.notifications.failures.controllers;
import com.paypal.jobsystem.quartzintegration.controllers.AbstractJobController;
import com.paypal.notifications.failures.jobs.NotificationProcessJob;
import lombok.extern.slf4j.Slf4j;
import org.quartz.SchedulerException;
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;
/**
* Specific controller to fire a notification retry process
*/
@Slf4j
@RestController
@RequestMapping("/job")
public class NotificationProcessJobController extends AbstractJobController {
private static final String DEFAULT_NOTIFICATION_PROCESS_JOB_NAME = "NotificationProcessJobSingleExecution";
/**
* Triggers the {@link NotificationProcessJob} 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 name the job name in {@link String}
* @return a {@link ResponseEntity <String>} with the name of the job scheduled
* @throws SchedulerException if quartz {@link org.quartz.Scheduler} fails
*/
@PostMapping("/process-failed-notifications")
public ResponseEntity<String> runJob(
@RequestParam(required = false, defaultValue = DEFAULT_NOTIFICATION_PROCESS_JOB_NAME) final String name)
throws SchedulerException {
runSingleJob(name, NotificationProcessJob.class, null);
return ResponseEntity.accepted().body(name);
}
}
| 5,078 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures/services/FailedNotificationServiceImpl.java | package com.paypal.notifications.failures.services;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.notifications.failures.connectors.NotificationsRepository;
import com.paypal.notifications.failures.repositories.FailedNotificationInformationRepository;
import com.paypal.notifications.incoming.services.NotificationProcessingService;
import com.paypal.notifications.storage.repositories.entities.NotificationInfoEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Objects;
import java.util.stream.StreamSupport;
@Slf4j
@Service
public class FailedNotificationServiceImpl implements FailedNotificationService {
private final NotificationsRepository notificationsRepository;
private final FailedNotificationInformationRepository failedNotificationInformationRepository;
private final NotificationProcessingService notificationProcessingService;
public FailedNotificationServiceImpl(final NotificationsRepository notificationsRepository,
final FailedNotificationInformationRepository failedNotificationInformationRepository,
final NotificationProcessingService notificationProcessingService) {
this.notificationsRepository = notificationsRepository;
this.failedNotificationInformationRepository = failedNotificationInformationRepository;
this.notificationProcessingService = notificationProcessingService;
}
/**
* {@inheritDoc}
*/
@Override
public void processFailedNotifications() {
final Iterable<NotificationInfoEntity> failedNotifications = failedNotificationInformationRepository.findAll();
//@formatter:off
StreamSupport.stream(failedNotifications.spliterator(), false)
.map(this::getNotificationToReprocess)
.filter(Objects::nonNull)
.forEach(notificationProcessingService::processNotification);
//@formatter:on
}
private HyperwalletWebhookNotification getNotificationToReprocess(
final NotificationInfoEntity failedNotificationInformationEntity) {
log.info("Reprocessing notification [{}]", failedNotificationInformationEntity.getNotificationToken());
return notificationsRepository.getHyperwalletWebhookNotification(
failedNotificationInformationEntity.getProgram(),
failedNotificationInformationEntity.getNotificationToken());
}
}
| 5,079 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/failures/services/FailedNotificationService.java | package com.paypal.notifications.failures.services;
public interface FailedNotificationService {
/**
* Processes failed notifications that have been stored in the database
*/
void processFailedNotifications();
}
| 5,080 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/management | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/management/controllers/FailedNotificationsManagementController.java | package com.paypal.notifications.management.controllers;
import com.paypal.notifications.failures.repositories.FailedNotificationInformationRepository;
import com.paypal.notifications.management.controllers.converters.FailedNotificationsDtoConverter;
import com.paypal.notifications.management.controllers.dto.FailedNotificationInfoDTO;
import com.paypal.notifications.storage.repositories.entities.NotificationInfoEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.web.PagedResourcesAssembler;
import org.springframework.hateoas.EntityModel;
import org.springframework.hateoas.PagedModel;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.server.ResponseStatusException;
import java.util.List;
import java.util.stream.Collectors;
import static org.springframework.http.HttpStatus.CREATED;
import static org.springframework.http.HttpStatus.NOT_FOUND;
/**
* Rest controller that adds utilities for notifications used in automated tests
*/
@Slf4j
@RestController
@RequestMapping("/management/failed-notifications")
public class FailedNotificationsManagementController {
public static final String MSG_NOTIFICATION_NOT_FOUND = "Notification not found";
private final FailedNotificationInformationRepository failedNotificationInformationRepository;
private final FailedNotificationsDtoConverter failedNotificationsDtoConverter;
private final PagedResourcesAssembler<FailedNotificationInfoDTO> pagedResourcesAssembler;
public FailedNotificationsManagementController(
final FailedNotificationInformationRepository failedNotificationInformationRepository,
final FailedNotificationsDtoConverter failedNotificationsDtoConverter,
final PagedResourcesAssembler<FailedNotificationInfoDTO> pagedResourcesAssembler) {
this.failedNotificationInformationRepository = failedNotificationInformationRepository;
this.failedNotificationsDtoConverter = failedNotificationsDtoConverter;
this.pagedResourcesAssembler = pagedResourcesAssembler;
}
@GetMapping("/")
public PagedModel<EntityModel<FailedNotificationInfoDTO>> findAll(final Pageable pageable) {
final Page<NotificationInfoEntity> notifications = failedNotificationInformationRepository.findAll(pageable);
return pagedResourcesAssembler.toModel(failedNotificationsDtoConverter.from(notifications));
}
@GetMapping(value = "/", params = { "type", "target" })
public PagedModel<EntityModel<FailedNotificationInfoDTO>> findAll(final Pageable pageable,
@RequestParam final String type, @RequestParam final String target) {
final Page<NotificationInfoEntity> notifications = failedNotificationInformationRepository
.findByTypeAndTarget(pageable, type, target);
return pagedResourcesAssembler.toModel(failedNotificationsDtoConverter.from(notifications));
}
@PostMapping("/")
@ResponseStatus(CREATED)
public void add(@RequestBody final FailedNotificationInfoDTO notification) {
failedNotificationInformationRepository.save(failedNotificationsDtoConverter.from(notification));
}
@PutMapping("/")
public void replaceAll(@RequestBody final List<FailedNotificationInfoDTO> notifications) {
failedNotificationInformationRepository.deleteAll();
failedNotificationInformationRepository.saveAll(
notifications.stream().map(failedNotificationsDtoConverter::from).collect(Collectors.toList()));
}
@GetMapping("/{notificationToken}")
public EntityModel<FailedNotificationInfoDTO> get(@PathVariable final String notificationToken) {
final NotificationInfoEntity notification = failedNotificationInformationRepository
.findByNotificationToken(notificationToken);
if (notification == null) {
throw new ResponseStatusException(NOT_FOUND, MSG_NOTIFICATION_NOT_FOUND);
}
return EntityModel.of(failedNotificationsDtoConverter.from(notification));
}
@PutMapping("/{notificationToken}")
public void update(@PathVariable final String notificationToken,
@RequestBody final FailedNotificationInfoDTO notification) {
notification.setNotificationToken(notificationToken);
failedNotificationInformationRepository.save(failedNotificationsDtoConverter.from(notification));
}
@DeleteMapping("/{notificationToken}")
public void delete(@PathVariable final String notificationToken) {
final NotificationInfoEntity notification = failedNotificationInformationRepository
.findByNotificationToken(notificationToken);
if (notification != null) {
failedNotificationInformationRepository.delete(notification);
}
}
}
| 5,081 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/management/controllers | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/management/controllers/dto/FailedNotificationInfoDTO.java | package com.paypal.notifications.management.controllers.dto;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.hateoas.server.core.Relation;
import java.util.Date;
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
@Relation(collectionRelation = "failed-notifications")
public class FailedNotificationInfoDTO {
protected String notificationToken;
protected String type;
protected String target;
protected String program;
protected int retryCounter;
protected Date creationDate;
}
| 5,082 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/management/controllers | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/management/controllers/converters/FailedNotificationsDtoConverter.java | package com.paypal.notifications.management.controllers.converters;
import com.paypal.notifications.management.controllers.dto.FailedNotificationInfoDTO;
import com.paypal.notifications.storage.repositories.entities.NotificationInfoEntity;
import org.mapstruct.Mapper;
import org.springframework.data.domain.Page;
@Mapper(componentModel = "spring")
public interface FailedNotificationsDtoConverter {
FailedNotificationInfoDTO from(NotificationInfoEntity source);
NotificationInfoEntity from(FailedNotificationInfoDTO source);
default Page<FailedNotificationInfoDTO> from(final Page<NotificationInfoEntity> source) {
return source.map(this::from);
}
}
| 5,083 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/management | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/management/services/FailedNotificationsManagementService.java | package com.paypal.notifications.management.services;
public interface FailedNotificationsManagementService {
}
| 5,084 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/repositories/NotificationEntityRepository.java | package com.paypal.notifications.storage.repositories;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import java.util.Date;
import java.util.List;
/**
* Repository for retrieving {@link NotificationEntity} from repository.
*/
@Repository
@Transactional
public interface NotificationEntityRepository extends JpaRepository<NotificationEntity, Long> {
/**
* Retrieves all the {@link NotificationEntity} whose reception date are between the
* given dates.
* @param from from {@link Date}.
* @param to to {@link Date}.
* @return a {@link List} of {@link NotificationEntity} whose date are between the
* given dates.
*/
@Query("Select n from NotificationEntity n where n.receptionDate >= :from and n.receptionDate <= :to")
List<NotificationEntity> findNotificationsBetween(@Param("from") Date from, @Param("to") Date to);
/**
* Deletes all the {@link NotificationEntity} whose reception date are between the
* given dates.
* @param from from {@link Date}.
* @param to to {@link Date}.
*/
@Modifying
@Query("Delete from NotificationEntity n where n.receptionDate >= :from and n.receptionDate <= :to")
void deleteNotificationsBetween(@Param("from") Date from, @Param("to") Date to);
/**
* Retrieves all the {@link NotificationEntity} whose webHookToken is equals to the
* given one.
* @param webHookToken the webHookToken to search for.
* @return a {@link List} of {@link NotificationEntity} whose webHookToken is equals
* to the given one.
*/
@Query("Select n from NotificationEntity n where n.webHookToken = :webHookToken")
List<NotificationEntity> findNotificationsByWebHookToken(@Param("webHookToken") final String webHookToken);
/**
* Retrieves all the {@link NotificationEntity} whose objectToken is equals to the
* given one and creationDate is later than the given one.
* @param objectToken the objectToken to search for.
* @param creationDate the creationDate to search for.
* @return a {@link List} of {@link NotificationEntity} whose objectToken is equals to
* the given one and creationDate is later than the given one.
*/
@Query("Select n from NotificationEntity n where n.objectToken = :objectToken and n.creationDate > :creationDate")
List<NotificationEntity> findNotificationsByObjectTokenAndAndCreationDateAfter(
@Param("objectToken") final String objectToken, @Param("creationDate") final Date creationDate);
}
| 5,085 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/repositories | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/repositories/entities/NotificationEntity.java | package com.paypal.notifications.storage.repositories.entities;
import lombok.Data;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import java.io.Serializable;
import java.util.Date;
/**
* Entity class for Notifications.
*/
@Entity
@Data
public class NotificationEntity implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private String webHookToken;
private String objectToken;
private Date creationDate;
private Date receptionDate;
private NotificationType notificationType;
}
| 5,086 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/repositories | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/repositories/entities/NotificationType.java | package com.paypal.notifications.storage.repositories.entities;
/**
* Notification type of entity {@link NotificationEntity}.
*/
public enum NotificationType {
//@formatter:off
/**
* Each type corresponds with the following Mirakl types:
* USR -> Seller
* PMT -> Payment
* STK -> Stakeholder
* TRM -> Bank account
* UNK -> Unknown
*/
//@formatter:off
USR, PMT, STK, TRM, UNK
}
| 5,087 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/repositories | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/repositories/entities/NotificationInfoEntity.java | package com.paypal.notifications.storage.repositories.entities;
import lombok.Data;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import java.io.Serializable;
import java.util.Date;
/**
* Class to hold information about failed notifications
*/
@Entity
@Data
public class NotificationInfoEntity implements Serializable {
@Id
protected String notificationToken;
protected String type;
protected String target;
protected String program;
protected int retryCounter;
protected Date creationDate;
}
| 5,088 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/model/NotificationModel.java | package com.paypal.notifications.storage.model;
import lombok.Builder;
import lombok.Getter;
/**
* Notification Model that holds all notification types coming from Hyperwallet
*
* @param <T> Class that must extend from NotificationModel
*/
@Getter
@Builder(toBuilder = true)
public class NotificationModel<T extends NotificationBodyModel> {
private final String token;
private final String eventType;
private final String createdOn;
private final T object;
}
| 5,089 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/model/NotificationBodyModel.java | package com.paypal.notifications.storage.model;
import java.io.Serializable;
/**
* Interface that holds the notification body's information
*/
public interface NotificationBodyModel extends Serializable {
}
| 5,090 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/controllers/NotificationsController.java | package com.paypal.notifications.storage.controllers;
import com.paypal.infrastructure.support.exceptions.DateIntervalException;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import com.paypal.notifications.storage.services.NotificationStorageService;
import jakarta.annotation.Resource;
import org.springframework.format.annotation.DateTimeFormat;
import org.springframework.web.bind.annotation.*;
import java.util.Date;
import java.util.List;
import static org.springframework.http.HttpStatus.OK;
/**
* Rest controller for {@link NotificationEntity}.
*/
@RestController
@RequestMapping("/webhooks")
public class NotificationsController {
@Resource
private NotificationStorageService notificationStorageService;
/**
* Retrieves all the {@link NotificationEntity} whose date are between the given
* dates.
* <p>
* A {@link DateIntervalException} will be thrown if {@code from} date is after thant
* {@code to} date.
* @param from from {@link Date}.
* @param to to {@link Date}.
* @return a {@link List} of {@link NotificationEntity} whose reception date are
* between the given from and to dates.
*/
@GetMapping("/notifications")
@ResponseStatus(OK)
public List<NotificationEntity> getAllNotifications(
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) final Date from,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) final Date to) {
checkDateIntervals(from, to);
return notificationStorageService.getNotificationsBetween(from, to);
}
/**
* Deletes all the {@link NotificationEntity} whose date are between the given dates.
* <p>
* A {@link DateIntervalException} will be thrown if {@code from} date is after thant
* {@code to} date.
* @param from from {@link Date}.
* @param to to {@link Date}.
*/
@DeleteMapping("/notifications")
@ResponseStatus(OK)
public void deleteNotificationsBetween(
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) final Date from,
@RequestParam @DateTimeFormat(iso = DateTimeFormat.ISO.DATE_TIME) final Date to) {
checkDateIntervals(from, to);
notificationStorageService.deleteNotificationsBetween(from, to);
}
/**
* Checks if {@code from} date is earlier than {@code to} date. If not a
* {@link DateIntervalException} is throw.
* @param from from {@link Date}.
* @param to to {@link Date}.
*/
private void checkDateIntervals(final Date from, final Date to) {
if (from.toInstant().isAfter(to.toInstant())) {
throw new DateIntervalException(from, to);
}
}
}
| 5,091 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/services/NotificationStorageServiceImpl.java | package com.paypal.notifications.storage.services;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import com.paypal.notifications.storage.repositories.NotificationEntityRepository;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.util.Date;
import java.util.List;
/**
* Default implementation of {@link NotificationStorageService}.
*/
@Slf4j
@Service
public class NotificationStorageServiceImpl implements NotificationStorageService {
private final NotificationEntityRepository notificationEntityRepository;
public NotificationStorageServiceImpl(final NotificationEntityRepository notificationEntityRepository) {
this.notificationEntityRepository = notificationEntityRepository;
}
/**
* {@inheritDoc}
*/
@Override
public NotificationEntity saveNotification(final NotificationEntity notificationEntity) {
log.debug("Saving notification with token [{}]", notificationEntity.getWebHookToken());
return notificationEntityRepository.save(notificationEntity);
}
/**
* {@inheritDoc}
*/
@Override
public List<NotificationEntity> getNotificationsBetween(final Date from, final Date to) {
return notificationEntityRepository.findNotificationsBetween(from, to);
}
/**
* {@inheritDoc}
*/
@Override
public void deleteNotificationsBetween(final Date from, final Date to) {
notificationEntityRepository.deleteNotificationsBetween(from, to);
}
/**
* {@inheritDoc}
*/
@Override
public List<NotificationEntity> getNotificationsByWebHookToken(final String webHookToken) {
return notificationEntityRepository.findNotificationsByWebHookToken(webHookToken);
}
/**
* {@inheritDoc}
*/
@Override
public List<NotificationEntity> getNotificationsByObjectTokenAndAndCreationDateAfter(final String objectToken,
final Date creationDate) {
return notificationEntityRepository.findNotificationsByObjectTokenAndAndCreationDateAfter(objectToken,
creationDate);
}
}
| 5,092 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/storage/services/NotificationStorageService.java | package com.paypal.notifications.storage.services;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import java.util.Date;
import java.util.List;
/**
* Service for dealing with {@link NotificationEntity}.
*/
public interface NotificationStorageService {
/**
* Save the given {@link NotificationEntity} in DB.
* @param notificationEntity a {@link NotificationEntity}.
* @return the saved notification.
*/
NotificationEntity saveNotification(final NotificationEntity notificationEntity);
/**
* Retrieves all the {@link NotificationEntity} whose date are between the given
* dates.
* @param from from {@link Date}.
* @param to to {@link Date}.
* @return a {@link List} of {@link NotificationEntity} whose reception date are
* between the given from and to dates.
*/
List<NotificationEntity> getNotificationsBetween(final Date from, final Date to);
/**
* Deletes all the {@link NotificationEntity} whose reception date are between the
* given dates.
* @param from from {@link Date}.
* @param to to {@link Date}.
*/
void deleteNotificationsBetween(final Date from, final Date to);
/**
* Retrieves all the {@link NotificationEntity} whose webHookToken is equals to the
* given one.
* @param webHookToken the webHookToken to search for.
* @return a {@link List} of {@link NotificationEntity} whose webHookToken is equals
* to the given one.
*/
List<NotificationEntity> getNotificationsByWebHookToken(final String webHookToken);
/**
* Retrieves all the {@link NotificationEntity} whose objectToken is equals to the
* given one and creationDate is later than the given one.
* @param objectToken the objectToken to search for.
* @param creationDate the creationDate to search for.
* @return a {@link List} of {@link NotificationEntity} whose objectToken is equals to
* the given one and creationDate is later than the given one.
*/
List<NotificationEntity> getNotificationsByObjectTokenAndAndCreationDateAfter(final String objectToken,
final Date creationDate);
}
| 5,093 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/controllers/IncomingHyperwalletNotificationWebhookController.java | package com.paypal.notifications.incoming.controllers;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.notifications.incoming.services.NotificationProcessingService;
import jakarta.annotation.Resource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.*;
/**
* Rest controller for handling incoming notifications from Hyperwallet
*/
@Slf4j
@RestController
@RequestMapping("/webhooks")
public class IncomingHyperwalletNotificationWebhookController {
@Resource
private NotificationProcessingService notificationProcessingService;
@PostMapping("/notifications")
@ResponseStatus(HttpStatus.OK)
public void receiveIncomingNotification(@RequestBody final HyperwalletWebhookNotification incomingNotificationDTO) {
notificationProcessingService.processNotification(incomingNotificationDTO);
}
}
| 5,094 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/NotificationProcessingService.java | package com.paypal.notifications.incoming.services;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
/**
* Service that receives incoming notifications and sends them to the proper event sender
* (users, payments, etc)
*/
public interface NotificationProcessingService {
/**
* Process the {@link HyperwalletWebhookNotification} notification and send it to the
* proper sender, depending on the strategy
* @param incomingNotificationDTO {@link HyperwalletWebhookNotification} notification
*/
void processNotification(HyperwalletWebhookNotification incomingNotificationDTO);
}
| 5,095 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/NotificationProcessingServiceImpl.java | package com.paypal.notifications.incoming.services;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.strategy.StrategyExecutor;
import com.paypal.notifications.storage.services.NotificationStorageService;
import com.paypal.notifications.incoming.services.converters.NotificationConverter;
import com.paypal.notifications.incoming.services.evaluators.NotificationEntityEvaluator;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
@Slf4j
@Service
public class NotificationProcessingServiceImpl implements NotificationProcessingService {
private final NotificationConverter notificationConverter;
private final NotificationStorageService notificationStorageService;
private final NotificationEntityEvaluator notificationEntityEvaluator;
private final StrategyExecutor<HyperwalletWebhookNotification, Void> hyperwalletWebhookNotificationSenderStrategyExecutor;
public NotificationProcessingServiceImpl(final NotificationConverter notificationConverter,
final NotificationStorageService notificationStorageService,
final NotificationEntityEvaluator notificationEntityEvaluator,
final StrategyExecutor<HyperwalletWebhookNotification, Void> hyperwalletWebhookNotificationSenderStrategyExecutor) {
this.notificationConverter = notificationConverter;
this.notificationStorageService = notificationStorageService;
this.notificationEntityEvaluator = notificationEntityEvaluator;
this.hyperwalletWebhookNotificationSenderStrategyExecutor = hyperwalletWebhookNotificationSenderStrategyExecutor;
}
/**
* {@inheritDoc}
*/
@Override
public void processNotification(final HyperwalletWebhookNotification incomingNotificationDTO) {
final NotificationEntity notificationEntity = notificationConverter.convert(incomingNotificationDTO);
notificationStorageService.saveNotification(notificationEntity);
if (notificationEntityEvaluator.isProcessable(notificationEntity)) {
hyperwalletWebhookNotificationSenderStrategyExecutor.execute(incomingNotificationDTO);
}
}
}
| 5,096 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/converters/NotificationConverter.java | package com.paypal.notifications.incoming.services.converters;
import com.hyperwallet.clientsdk.model.HyperwalletWebhookNotification;
import com.paypal.infrastructure.support.converter.Converter;
import com.paypal.infrastructure.support.date.DateUtil;
import com.paypal.infrastructure.support.date.TimeMachine;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import com.paypal.notifications.storage.repositories.entities.NotificationType;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import java.time.ZoneId;
import java.util.Map;
import java.util.Optional;
/**
* Notification converter that converts from {@link HyperwalletWebhookNotification} to
* {@link NotificationEntity}.
*/
@Slf4j
@Service
public class NotificationConverter implements Converter<HyperwalletWebhookNotification, NotificationEntity> {
private static final String TOKEN_MAP_KEY = "token";
/**
* Retrieves a {@link HyperwalletWebhookNotification} and returns a
* {@link NotificationEntity}
* @param source the source object {@link HyperwalletWebhookNotification}
* @return the returned object {@link NotificationEntity}
*/
@Override
public NotificationEntity convert(final HyperwalletWebhookNotification source) {
final NotificationEntity target = new NotificationEntity();
target.setWebHookToken(source.getToken());
target.setCreationDate(source.getCreatedOn());
target.setReceptionDate(DateUtil.convertToDate(TimeMachine.now(), ZoneId.systemDefault()));
populateObjectToken(source, target);
return target;
}
private void populateObjectToken(final HyperwalletWebhookNotification source, final NotificationEntity target) {
//@formatter:off
Optional.ofNullable(source.getObject())
.filter(Map.class::isInstance)
.map(Map.class::cast)
.map(map -> map.get(TOKEN_MAP_KEY))
.filter(String.class::isInstance)
.map(String.class::cast)
.ifPresent(objectToken -> {
target.setObjectToken(objectToken);
target.setNotificationType(getNotificationType(objectToken));
});
//@formatter:on
}
private NotificationType getNotificationType(final String objectToken) {
try {
return NotificationType.valueOf(objectToken.split("-")[0].toUpperCase());
}
catch (final Exception exception) {
log.warn("Notification with unknown object token [{}] received", objectToken);
return NotificationType.UNK;
}
}
}
| 5,097 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/evaluators/NotificationEntityEvaluatorImpl.java | package com.paypal.notifications.incoming.services.evaluators;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
import org.springframework.stereotype.Service;
import java.util.Set;
import java.util.function.Predicate;
/**
* Default implementation of {@link NotificationEntityEvaluator}.
*/
@Service
public class NotificationEntityEvaluatorImpl implements NotificationEntityEvaluator {
private final Set<Predicate<NotificationEntity>> notificationEvaluators;
public NotificationEntityEvaluatorImpl(final Set<Predicate<NotificationEntity>> notificationEvaluators) {
this.notificationEvaluators = notificationEvaluators;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isProcessable(final NotificationEntity notificationEntity) {
return notificationEvaluators.stream().noneMatch(predicate -> predicate.test(notificationEntity));
}
}
| 5,098 |
0 | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services | Create_ds/mirakl-hyperwallet-connector/hmc-notifications/src/main/java/com/paypal/notifications/incoming/services/evaluators/NotificationEntityEvaluator.java | package com.paypal.notifications.incoming.services.evaluators;
import com.paypal.notifications.storage.repositories.entities.NotificationEntity;
/**
* Notifications evaluator, checks if a {@link NotificationEntity} is processable.
*/
public interface NotificationEntityEvaluator {
/**
* Checks if a {@link NotificationEntity} is processable.
* @param notificationEntity to be checked.
* @return true if the {@link NotificationEntity} is processable, false otherwise.
*/
boolean isProcessable(final NotificationEntity notificationEntity);
}
| 5,099 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.