From 287d673009f82c980151d842e4330216bb927268 Mon Sep 17 00:00:00 2001 From: Jonas Borges Date: Fri, 21 Feb 2025 14:04:48 -0300 Subject: [PATCH] Add merchant purchase, merchant session, merchant card and merchant installment --- CHANGELOG.md | 2 + README.md | 129 +++++++ src/main/java/com/starkbank/MerchantCard.java | 171 +++++++++ .../com/starkbank/MerchantInstallment.java | 176 +++++++++ .../java/com/starkbank/MerchantPurchase.java | 257 ++++++++++++++ .../java/com/starkbank/MerchantSession.java | 336 ++++++++++++++++++ src/main/java/com/starkbank/utils/Rest.java | 16 + src/test/java/TestMerchantCard.java | 83 +++++ src/test/java/TestMerchantInstallment.java | 83 +++++ src/test/java/TestMerchantPurchase.java | 121 +++++++ src/test/java/TestMerchantSession.java | 149 ++++++++ src/test/java/utils/MerchantPurchase.java | 30 ++ src/test/java/utils/MerchantSession.java | 80 +++++ 13 files changed, 1633 insertions(+) create mode 100644 src/main/java/com/starkbank/MerchantCard.java create mode 100644 src/main/java/com/starkbank/MerchantInstallment.java create mode 100644 src/main/java/com/starkbank/MerchantPurchase.java create mode 100644 src/main/java/com/starkbank/MerchantSession.java create mode 100644 src/test/java/TestMerchantCard.java create mode 100644 src/test/java/TestMerchantInstallment.java create mode 100644 src/test/java/TestMerchantPurchase.java create mode 100644 src/test/java/TestMerchantSession.java create mode 100644 src/test/java/utils/MerchantPurchase.java create mode 100644 src/test/java/utils/MerchantSession.java diff --git a/CHANGELOG.md b/CHANGELOG.md index cb713fe..11de06e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,8 @@ Given a version number MAJOR.MINOR.PATCH, increment: - PATCH version when backwards compatible bug **fixes** are implemented. ## [Unreleased] +### Added +- merchantSession, merchantCard, merchantInstallment and merchantPurchase resources ## [2.19.0] - 2024-09-17 ### Added diff --git a/README.md b/README.md index 8b601f1..dbba51e 100644 --- a/README.md +++ b/README.md @@ -52,6 +52,8 @@ is as easy as sending a text message to your client! - [CorporateEnums](#corporate-enums): Query enums related to the corporate purchases, such as merchant categories, countries and card purchase methods - [Split](#query-splits): Split received Invoice payments between different receivers - [SplitReceiver](#create-splitreceivers): Receiver of an Invoice split + - [MerchantSession](#merchant-session): The Merchant Session allows you to create a session prior to a purchase. Sessions are essential for defining the parameters of a purchase, including funding type, expiration, 3DS, and more. + - [MerchantPurchase](#merchant-purchase): The Merchant Purchase section allows users to retrieve detailed information of the purchases. - [Webhooks](#create-a-webhook-subscription): Configure your webhook endpoints and subscriptions - [WebhookEvents](#process-webhook-events): Manage webhook events - [WebhookEventAttempts](#query-failed-webhook-event-delivery-attempts-information): Query failed webhook event deliveries @@ -2637,6 +2639,133 @@ SplitReceiver.Log log = SplitReceiver.Log.get("5155165527080960"); System.out.println(log); ``` +## Merchant Session + +The Merchant Session allows you to create a session prior to a purchase. +Sessions are essential for defining the parameters of a purchase, including funding type, expiration, 3DS, and more. + +## Create a MerchantSession + +```java +import com.starkbank.*; +import java.util.Map; +import java.util.List; +import java.util.HashMap; +import java.util.ArrayList; + +Map data = new HashMap<>(); +List allowedFundingTypes = new ArrayList<>(); +allowedFundingTypes.add("debit"); +allowedFundingTypes.add("credit"); +data.put("allowedFundingTypes", allowedFundingTypes); + +List> allowedInstallments = new ArrayList<>(); +Map installment1 = new HashMap<>(); +installment1.put("totalAmount", 0); +installment1.put("count", 1); +allowedInstallments.add(installment1); + +Map installment2 = new HashMap<>(); +installment2.put("totalAmount", 120); +installment2.put("count", 2); +allowedInstallments.add(installment2); + +Map installment3 = new HashMap<>(); +installment3.put("totalAmount", 180); +installment3.put("count", 12); +allowedInstallments.add(installment3); + +data.put("allowedInstallments", allowedInstallments); +data.put("expiration", 3600); +data.put("challengeMode", "disabled"); + +data.put("tags", new String[]{"Stark", "Suit"}); + +MerchantSession.create(new MerchantSession(data)); + +System.out.println(log); +``` + +You can create a MerchantPurchase through a MerchantSession by passing its UUID. +**Note**: This method must be implemented in your front-end to ensure that sensitive card data does not pass through the back-end of the integration. + +### Create a MerchantSession Purchase + +```java +import com.starkbank.*; +import java.util.Map; +import java.util.HashMap; + +Map purchaseData = new HashMap<>(); +purchaseData.put("amount", 1000L); +purchaseData.put("cardExpiration", "2035-01"); +purchaseData.put("cardNumber", "36490101441625"); +purchaseData.put("cardSecurityCode", "123"); +purchaseData.put("holderName", "Margaery Tyrell"); +purchaseData.put("fundingType", "credit"); + +MerchantSession.Purchase purchase= MerchantSession.purchase( + merchantSession.uuid, new com.starkbank.MerchantSession.Purchase(purchaseData);); + +System.out.println(purchase); +``` + +### Query MerchantSessions + +```java +import com.starkbank.*; +import java.util.Map; +import java.util.HashMap; + +HashMap params = new HashMap<>(); +params.put("limit", 10); + +Generator sessions = MerchantSession.query(params); + +for (MerchantSession session : sessions) { + System.out.println(session); +} +``` + +### Get a MerchantSession + +```java +import com.starkbank.*; + +MerchantSession retrievedSession = MerchantSession.get("5441927222657024"); +System.out.println(retrievedSession); +``` + +## Merchant Purchase + +The Merchant Purchase section allows users to retrieve detailed information of the purchases. + +### Query MerchantPurchases + +```java +import com.starkbank.*; +import java.util.Map; +import java.util.HashMap; + +HashMap params = new HashMap<>(); +params.put("limit", 10); +Generator merchantPurchases = MerchantPurchase.query(params); + +for (MerchantPurchase purchase : merchantPurchases) { + System.out.println(purchase); +} +``` + +### Get a MerchantPurchase + +```java +import com.starkbank.*; + +MerchantPurchase retrievedPurchase = MerchantPurchase.get("5441927222657024"); + +System.out.println(retrievedPurchase); +``` + ## Create a webhook subscription To create a webhook subscription and be notified whenever an event occurs, run: diff --git a/src/main/java/com/starkbank/MerchantCard.java b/src/main/java/com/starkbank/MerchantCard.java new file mode 100644 index 0000000..4081266 --- /dev/null +++ b/src/main/java/com/starkbank/MerchantCard.java @@ -0,0 +1,171 @@ +package com.starkbank; + +import com.starkbank.utils.Generator; +import com.starkbank.utils.Resource; +import com.starkbank.utils.Rest; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + + +public class MerchantCard extends Resource { + + /** + # MerchantCard object + Check out our API Documentation at https://starkbank.com/docs/api#merchant-card + **/ + + static ClassData data = new ClassData(MerchantCard.class, "MerchantCard"); + + public String ending; + public String fundingType; + public String holderName; + public String network; + public String status; + public List tags; + public String expiration; + public String created; + public String updated; + + public MerchantCard(String id, String ending, String fundingType, String holderName, String network, String status, List tags, String expiration, String created, String updated) { + super(id); + this.ending = ending; + this.fundingType = fundingType; + this.holderName = holderName; + this.network = network; + this.status = status; + this.tags = tags; + this.expiration = expiration; + this.created = created; + this.updated = updated; + } + + public static Generator query(Map params, User user) throws Exception { + return Rest.getStream(data, params, user); + } + + public static Generator query(Map params) throws Exception { + return MerchantCard.query(params, null); + } + + public static Generator query() throws Exception { + return Rest.getStream(data, new HashMap<>(), null); + } + + public static MerchantCard get(String id, User user) throws Exception { + return Rest.getId(data, id, user); + } + + public static MerchantCard get(String id) throws Exception { + return MerchantCard.get(id, null); + } + + public static MerchantCard.Page page(Map params) throws Exception { + return page(params, null); + } + + public static MerchantCard.Page page(User user) throws Exception { + return page(new HashMap<>(), user); + } + + public static MerchantCard.Page page() throws Exception { + return page(new HashMap<>(), null); + } + + + public static MerchantCard.Page page(Map params, User user) throws Exception { + com.starkcore.utils.Page page = Rest.getPage(data, params, user); + List MerchantCards = new ArrayList<>(); + for (com.starkcore.utils.SubResource MerchantCard: page.entities) { + MerchantCards.add((MerchantCard) MerchantCard); + } + return new MerchantCard.Page(MerchantCards, page.cursor); + } + + public final static class Page { + public List merchantCards; + public String cursor; + + public Page(List merchantCards, String cursor) { + this.merchantCards = merchantCards; + this.cursor = cursor; + } + } + + public final static class Log extends Resource { + static ClassData data = new ClassData(MerchantCard.Log.class, "MerchantCardLog"); + + public String created; + public String type; + public String[] errors; + public MerchantCard card; + + public Log(String created, String type, String[] errors, MerchantCard card, String id) { + super(id); + this.created = created; + this.type = type; + this.errors = errors; + this.card = card; + } + + + public static MerchantCard.Log get(String id) throws Exception { + return MerchantCard.Log.get(id, null); + } + + public static MerchantCard.Log get(String id, User user) throws Exception { + return Rest.getId(data, id, user); + } + + public static Generator query(Map params) throws Exception { + return MerchantCard.Log.query(params, null); + } + + public static Generator query(User user) throws Exception { + return MerchantCard.Log.query(new HashMap<>(), user); + } + + public static Generator query() throws Exception { + return MerchantCard.Log.query(new HashMap<>(), null); + } + + public static Generator query(Map params, User user) throws Exception { + return Rest.getStream(data, params, user); + } + + public final static class Page { + public List logs; + public String cursor; + + public Page(List logs, String cursor) { + this.logs = logs; + this.cursor = cursor; + } + } + + public static MerchantCard.Log.Page page(Map params) throws Exception { + return MerchantCard.Log.page(params, null); + } + + public static MerchantCard.Log.Page page(User user) throws Exception { + return MerchantCard.Log.page(new HashMap<>(), user); + } + + public static MerchantCard.Log.Page page() throws Exception { + return MerchantCard.Log.page(new HashMap<>(), null); + } + + public static MerchantCard.Log.Page page(Map params, User user) throws Exception { + com.starkcore.utils.Page page = Rest.getPage(data, params, user); + List logs = new ArrayList<>(); + for (com.starkcore.utils.SubResource log: page.entities) { + logs.add((MerchantCard.Log) log); + } + return new MerchantCard.Log.Page(logs, page.cursor); + } + + } + +} diff --git a/src/main/java/com/starkbank/MerchantInstallment.java b/src/main/java/com/starkbank/MerchantInstallment.java new file mode 100644 index 0000000..8cbffaf --- /dev/null +++ b/src/main/java/com/starkbank/MerchantInstallment.java @@ -0,0 +1,176 @@ +package com.starkbank; + +import com.starkbank.error.ErrorElement; +import com.starkbank.utils.Generator; +import com.starkbank.utils.Resource; +import com.starkbank.utils.Rest; + +import java.io.InputStream; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class MerchantInstallment extends Resource { + + /** + # MerchantInstallment object + Check out our API Documentation at https://starkbank.com/docs/api#merchant-installment + **/ + + static ClassData data = new ClassData(MerchantInstallment.class, "MerchantInstallment"); + + public long amount; + public String created; + public String due; + public int fee; + public String fundingType; + public String network; + public String purchaseId; + public String status; + public String[] tags; + public List transactionIds; + public String updated; + + public MerchantInstallment(String id, long amount, String created, String due, int fee, String fundingType, String network, String purchaseId, String status, String[] tags, List transactionIds, String updated) { + super(id); + this.amount = amount; + this.created = created; + this.due = due; + this.fee = fee; + this.fundingType = fundingType; + this.network = network; + this.purchaseId = purchaseId; + this.status = status; + this.tags = tags; + this.transactionIds = transactionIds; + this.updated = updated; + } + + public static Generator query(Map params, User user) throws Exception { + return Rest.getStream(data, params, user); + } + + public static Generator query(Map params) throws Exception { + return MerchantInstallment.query(params, null); + } + + public static Generator query() throws Exception { + return Rest.getStream(data, new HashMap<>(), null); + } + + public static MerchantInstallment get(String id, User user) throws Exception { + return Rest.getId(data, id, user); + } + + public static MerchantInstallment get(String id) throws Exception { + return MerchantInstallment.get(id, null); + } + + public static MerchantInstallment.Page page(Map params) throws Exception { + return page(params, null); + } + + public static MerchantInstallment.Page page(User user) throws Exception { + return page(new HashMap<>(), user); + } + + public static MerchantInstallment.Page page() throws Exception { + return page(new HashMap<>(), null); + } + + + public static MerchantInstallment.Page page(Map params, User user) throws Exception { + com.starkcore.utils.Page page = Rest.getPage(data, params, user); + List MerchantInstallments = new ArrayList<>(); + for (com.starkcore.utils.SubResource MerchantInstallment: page.entities) { + MerchantInstallments.add((MerchantInstallment) MerchantInstallment); + } + return new MerchantInstallment.Page(MerchantInstallments, page.cursor); + } + + public final static class Page { + public List merchantInstallments; + public String cursor; + + public Page(List MerchantInstallments, String cursor) { + this.merchantInstallments = MerchantInstallments; + this.cursor = cursor; + } + } + + public final static class Log extends Resource { + static ClassData data = new ClassData(MerchantInstallment.Log.class, "MerchantInstallmentLog"); + + public String created; + public String type; + public List errors; + public MerchantInstallment installment; + + public Log(String created, String type, List errors, MerchantInstallment merchantInstallment, String id) { + super(id); + this.created = created; + this.type = type; + this.errors = errors; + this.installment = merchantInstallment; + } + + + public static MerchantInstallment.Log get(String id) throws Exception { + return MerchantInstallment.Log.get(id, null); + } + + public static MerchantInstallment.Log get(String id, User user) throws Exception { + return Rest.getId(data, id, user); + } + + public static Generator query(Map params) throws Exception { + return MerchantInstallment.Log.query(params, null); + } + + public static Generator query(User user) throws Exception { + return MerchantInstallment.Log.query(new HashMap<>(), user); + } + + public static Generator query() throws Exception { + return MerchantInstallment.Log.query(new HashMap<>(), null); + } + + public static Generator query(Map params, User user) throws Exception { + return Rest.getStream(data, params, user); + } + + public final static class Page { + public List logs; + public String cursor; + + public Page(List logs, String cursor) { + this.logs = logs; + this.cursor = cursor; + } + } + + public static MerchantInstallment.Log.Page page(Map params) throws Exception { + return MerchantInstallment.Log.page(params, null); + } + + public static MerchantInstallment.Log.Page page(User user) throws Exception { + return MerchantInstallment.Log.page(new HashMap<>(), user); + } + + public static MerchantInstallment.Log.Page page() throws Exception { + return MerchantInstallment.Log.page(new HashMap<>(), null); + } + + public static MerchantInstallment.Log.Page page(Map params, User user) throws Exception { + com.starkcore.utils.Page page = Rest.getPage(data, params, user); + List logs = new ArrayList<>(); + for (com.starkcore.utils.SubResource log: page.entities) { + logs.add((MerchantInstallment.Log) log); + } + return new MerchantInstallment.Log.Page(logs, page.cursor); + } + + } + +} diff --git a/src/main/java/com/starkbank/MerchantPurchase.java b/src/main/java/com/starkbank/MerchantPurchase.java new file mode 100644 index 0000000..0ea7146 --- /dev/null +++ b/src/main/java/com/starkbank/MerchantPurchase.java @@ -0,0 +1,257 @@ +package com.starkbank; + +import com.starkbank.utils.Generator; +import com.starkbank.utils.Resource; +import com.starkbank.utils.Rest; + +import java.util.List; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +public class MerchantPurchase extends Resource { + + /** + # MerchantPurchase object + Check out our API Documentation at https://starkbank.com/docs/api#merchant-purchase + **/ + + static ClassData data = new ClassData(MerchantPurchase.class, "MerchantPurchase"); + + public long amount; + public int installmentCount; + public String cardId; + public String holderName; + public String holderEmail; + public String holderPhone; + public String fundingType; + public String challengeMode; + public String billingCountryCode; + public String billingCity; + public String billingStateCode; + public String billingStreetLine1; + public String billingStreetLine2; + public String billingZipCode; + public Map metadata; + public String cardEnding; + public String challengeUrl; + public String created; + public String currencyCode; + public String endToEndId; + public Integer fee; + public String network; + public String source; + public String status; + public String[] tags; + public String updated; + + public MerchantPurchase(String id, long amount, int installmentCount, String holderName, String holderEmail, String holderPhone, String fundingType, String billingCountryCode, String billingCity, String billingStateCode, String billingStreetLine1, String billingStreetLine2, String billingZipCode, Map metadata, String cardEnding, String cardId, String challengeMode, String challengeUrl, String created, String currencyCode, String endToEndId, int fee, String network, String source, String status, String[] tags, String updated) { + super(id); + this.amount = amount; + this.installmentCount = installmentCount; + this.holderName = holderName; + this.holderEmail = holderEmail; + this.holderPhone = holderPhone; + this.fundingType = fundingType; + this.billingCountryCode = billingCountryCode; + this.billingCity = billingCity; + this.billingStateCode = billingStateCode; + this.billingStreetLine1 = billingStreetLine1; + this.billingStreetLine2 = billingStreetLine2; + this.billingZipCode = billingZipCode; + this.metadata = metadata; + this.cardEnding = cardEnding; + this.cardId = cardId; + this.challengeMode = challengeMode; + this.challengeUrl = challengeUrl; + this.created = created; + this.currencyCode = currencyCode; + this.endToEndId = endToEndId; + this.fee = fee; + this.network = network; + this.source = source; + this.status = status; + this.tags = tags; + this.updated = updated; + } + + public MerchantPurchase(Map data) throws Exception { + super(null); + HashMap dataCopy = new HashMap<>(data); + + this.amount = (Long) dataCopy.remove("amount"); + this.installmentCount = (int) dataCopy.remove("installmentCount"); + this.cardId = (String) dataCopy.remove("cardId"); + this.holderName = (String) dataCopy.remove("holderName"); + this.holderEmail = (String) dataCopy.remove("holderEmail"); + this.holderPhone = (String) dataCopy.remove("holderPhone"); + this.fundingType = (String) dataCopy.remove("fundingType"); + this.billingCountryCode = (String) dataCopy.remove("billingCountryCode"); + this.billingCity = (String) dataCopy.remove("billingCity"); + this.billingStateCode = (String) dataCopy.remove("billingStateCode"); + this.billingStreetLine1 = (String) dataCopy.remove("billingStreetLine1"); + this.billingStreetLine2 = (String) dataCopy.remove("billingStreetLine2"); + this.billingZipCode = (String) dataCopy.remove("billingZipCode"); + this.metadata = (Map) dataCopy.remove("metadata"); + this.challengeMode = (String) dataCopy.remove("challengeMode"); + this.tags = (String[]) dataCopy.remove("tags"); + this.cardEnding = null; + this.challengeUrl = null; + this.currencyCode = null; + this.endToEndId = null; + this.fee = null; + this.network = null; + this.source = null; + this.status = null; + this.updated = null; + this.created = null; + + + if (!dataCopy.isEmpty()) { + throw new Exception("Unknown parameters used in constructor: [" + String.join(", ", dataCopy.keySet()) + "]"); + } + } + + public static MerchantPurchase create(MerchantPurchase merchantPurchase, User user) throws Exception { + return Rest.postSingle(data, merchantPurchase, user); + } + + public static MerchantPurchase create(MerchantPurchase merchantPurchase) throws Exception { + return MerchantPurchase.create(merchantPurchase, null); + } + + public static MerchantPurchase update(String id, Map patchData) throws Exception { + return MerchantPurchase.update(id, patchData, null); + } + + public static MerchantPurchase update(String id, Map patchData, User user) throws Exception { + return Rest.patch(data, id, patchData, user); + } + + public static MerchantPurchase get(String id, User user) throws Exception { + return Rest.getId(data, id, user); + } + + public static MerchantPurchase get(String id) throws Exception { + return MerchantPurchase.get(id, null); + } + + public static Generator query(Map params, User user) throws Exception { + return Rest.getStream(data, params, user); + } + + public static Generator query(Map params) throws Exception { + return MerchantPurchase.query(params, null); + } + + public static Generator query() throws Exception { + return Rest.getStream(data, new HashMap<>(), null); + } + + public static MerchantPurchase.Page page(Map params) throws Exception { + return page(params, null); + } + + public static MerchantPurchase.Page page(User user) throws Exception { + return page(new HashMap<>(), user); + } + + public static MerchantPurchase.Page page() throws Exception { + return page(new HashMap<>(), null); + } + + + public static MerchantPurchase.Page page(Map params, User user) throws Exception { + com.starkcore.utils.Page page = Rest.getPage(data, params, user); + List merchantPurchases = new ArrayList<>(); + for (com.starkcore.utils.SubResource merchantPurchase: page.entities) { + merchantPurchases.add((MerchantPurchase) merchantPurchase); + } + return new MerchantPurchase.Page(merchantPurchases, page.cursor); + } + + public final static class Page { + public List merchantPurchases; + public String cursor; + + public Page(List merchantPurchases, String cursor) { + this.merchantPurchases = merchantPurchases; + this.cursor = cursor; + } + } + + public final static class Log extends Resource { + static ClassData data = new ClassData(MerchantPurchase.Log.class, "MerchantPurchaseLog"); + + public String created; + public String type; + public String[] errors; + public MerchantPurchase purchase; + + public Log(String created, String type, String[] errors, MerchantPurchase purchase, String id) { + super(id); + this.created = created; + this.type = type; + this.errors = errors; + this.purchase = purchase; + } + + + public static MerchantPurchase.Log get(String id) throws Exception { + return MerchantPurchase.Log.get(id, null); + } + + public static MerchantPurchase.Log get(String id, User user) throws Exception { + return Rest.getId(data, id, user); + } + + public static Generator query(Map params) throws Exception { + return MerchantPurchase.Log.query(params, null); + } + + public static Generator query(User user) throws Exception { + return MerchantPurchase.Log.query(new HashMap<>(), user); + } + + public static Generator query() throws Exception { + return MerchantPurchase.Log.query(new HashMap<>(), null); + } + + public static Generator query(Map params, User user) throws Exception { + return Rest.getStream(data, params, user); + } + + public final static class Page { + public List logs; + public String cursor; + + public Page(List logs, String cursor) { + this.logs = logs; + this.cursor = cursor; + } + } + + public static MerchantPurchase.Log.Page page(Map params) throws Exception { + return MerchantPurchase.Log.page(params, null); + } + + public static MerchantPurchase.Log.Page page(User user) throws Exception { + return MerchantPurchase.Log.page(new HashMap<>(), user); + } + + public static MerchantPurchase.Log.Page page() throws Exception { + return MerchantPurchase.Log.page(new HashMap<>(), null); + } + + public static MerchantPurchase.Log.Page page(Map params, User user) throws Exception { + com.starkcore.utils.Page page = Rest.getPage(data, params, user); + List logs = new ArrayList<>(); + for (com.starkcore.utils.SubResource log: page.entities) { + logs.add((MerchantPurchase.Log) log); + } + return new MerchantPurchase.Log.Page(logs, page.cursor); + } + + } + +} diff --git a/src/main/java/com/starkbank/MerchantSession.java b/src/main/java/com/starkbank/MerchantSession.java new file mode 100644 index 0000000..2c79f9b --- /dev/null +++ b/src/main/java/com/starkbank/MerchantSession.java @@ -0,0 +1,336 @@ +package com.starkbank; + +import com.starkbank.utils.Generator; +import com.starkbank.utils.Resource; +import com.starkbank.utils.Rest; +import com.starkbank.utils.SubResource; + +import java.util.List; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + + +public class MerchantSession extends Resource { + + /** + # MerchantSession object + Check out our API Documentation at https://starkbank.com/docs/api#merchant-session + **/ + + static ClassData data = new ClassData(MerchantSession.class, "MerchantSession"); + + public List allowedFundingTypes; + public List allowedInstallments; + public List allowedIps; + public String challengeMode; + public String created; + public Number expiration; + public String status; + public String[] tags; + public String updated; + public String uuid; + + public MerchantSession(String id, List allowedFundingTypes, List allowedInstallments, List allowedIps, String challengeMode, String created, Number expiration, String status, String[] tags, String updated, String uuid) { + super(id); + this.allowedFundingTypes = allowedFundingTypes; + this.allowedInstallments = allowedInstallments; + this.allowedIps = allowedIps; + this.challengeMode = challengeMode; + this.created = created; + this.expiration = expiration; + this.status = status; + this.tags = tags; + this.updated = updated; + this.uuid = uuid; + } + + + public MerchantSession(Map data) throws Exception { + super(null); + HashMap dataCopy = new HashMap<>(data); + + this.allowedFundingTypes = (List) dataCopy.remove("allowedFundingTypes"); + this.allowedInstallments = parseAllowedInstallments((List) dataCopy.remove("allowedInstallments")); + this.challengeMode = (String) dataCopy.remove("challengeMode"); + this.expiration = (Number) dataCopy.remove("expiration"); + this.tags = (String[]) dataCopy.remove("tags"); + this.uuid = null; + this.status = null; + this.allowedIps = null; + this.created = null; + this.updated = null; + + + if (!dataCopy.isEmpty()) { + throw new Exception("Unknown parameters used in constructor: [" + String.join(", ", dataCopy.keySet()) + "]"); + } + } + + + private List parseAllowedInstallments(List allowedInstallments) { + if (allowedInstallments == null) + return null; + + List parsed = new ArrayList<>(); + if (allowedInstallments.isEmpty() || allowedInstallments.get(0) instanceof AllowedInstallment) { + for (Object allowedInstallment : allowedInstallments) { + parsed.add((AllowedInstallment) allowedInstallment); + } + + return parsed; + } + + for (Object allowedInstallment : allowedInstallments) { + AllowedInstallment allowedInstallmentObject = new AllowedInstallment( + (Long) ((Map) allowedInstallment).get("totalAmount"), + (Integer) ((Map) allowedInstallment).get("count") + ); + parsed.add(allowedInstallmentObject); + } + + return parsed; + } + + public static MerchantSession create(MerchantSession merchantSession) throws Exception { + return Rest.postSingle(data, merchantSession, null); + } + + public static MerchantSession create(MerchantSession merchantSession, User user) throws Exception { + return Rest.postSingle(data, merchantSession, user); + } + + public static Purchase purchase(String uuid, Purchase purchase) throws Exception { + return Rest.postSubResource(data, uuid, Purchase.data, null, purchase); + } + + public static Purchase purchase(String uuid, Purchase purchase, User user) throws Exception { + return Rest.postSubResource(data, uuid, Purchase.data, user, purchase); + } + + + public static MerchantSession get(String id, User user) throws Exception { + return Rest.getId(data, id, user); + } + + public static MerchantSession get(String id) throws Exception { + return MerchantSession.get(id, null); + } + + public static Generator query(Map params, User user) throws Exception { + return Rest.getStream(data, params, user); + } + + public static Generator query(Map params) throws Exception { + return MerchantSession.query(params, null); + } + + public static Generator query() throws Exception { + return Rest.getStream(data, new HashMap<>(), null); + } + + public static MerchantSession.Page page(Map params) throws Exception { + return page(params, null); + } + + public static MerchantSession.Page page(User user) throws Exception { + return page(new HashMap<>(), user); + } + + public static MerchantSession.Page page() throws Exception { + return page(new HashMap<>(), null); + } + + public static MerchantSession.Page page(Map params, User user) throws Exception { + com.starkcore.utils.Page page = Rest.getPage(data, params, user); + List merchantSessions = new ArrayList<>(); + for (com.starkcore.utils.SubResource merchantSession: page.entities) { + merchantSessions.add((MerchantSession) merchantSession); + } + return new MerchantSession.Page(merchantSessions, page.cursor); + } + + public final static class Page { + public List merchantSessions; + public String cursor; + + public Page(List merchantSessions, String cursor) { + this.merchantSessions = merchantSessions; + this.cursor = cursor; + } + } + + public static class AllowedInstallment extends SubResource { + + static SubResource.ClassData data = new SubResource.ClassData(AllowedInstallment.class, "AllowedInstallments"); + + public long totalAmount; + public int count; + + public AllowedInstallment(long totalAmount, int count){ + this.totalAmount = totalAmount; + this.count = count; + } + } + + public final static class Purchase extends Resource { + + static ClassData data = new ClassData(Purchase.class, "Purchase"); + + public Long amount; + public Integer installmentCount; + public String cardId; + public String cardExpiration; + public String cardNumber; + public String cardSecurityCode; + public String holderName; + public String holderEmail; + public String holderPhone; + public String fundingType; + public String billingCountryCode; + public String billingCity; + public String billingStateCode; + public String billingStreetLine1; + public String billingStreetLine2; + public String billingZipCode; + public String challengeMode; + public Map metadata; + public String network; + public String source; + public String status; + public String[] tags; + public String update; + + public Purchase(String id, Long amount, Integer installmentCount, String cardId, String cardExpiration, String cardNumber, String cardSecurityCode, String holderName, String holderEmail, String holderPhone, String fundingType, String billingCountryCode, String billingCity, String billingStateCode, String billingStreetLine1, String billingStreetLine2, String billingZipCode, String challengeMode, Map metadata) { + super(id); + this.amount = amount; + this.installmentCount = installmentCount; + this.cardId = cardId; + this.cardExpiration = cardExpiration; + this.cardNumber = cardNumber; + this.cardSecurityCode = cardSecurityCode; + this.holderName = holderName; + this.holderEmail = holderEmail; + this.holderPhone = holderPhone; + this.fundingType = fundingType; + this.billingCountryCode = billingCountryCode; + this.billingCity = billingCity; + this.billingStateCode = billingStateCode; + this.billingStreetLine1 = billingStreetLine1; + this.billingStreetLine2 = billingStreetLine2; + this.billingZipCode = billingZipCode; + this.challengeMode = challengeMode; + this.metadata = metadata; + } + + public Purchase(Map data) throws Exception { + + super(null); + HashMap dataCopy = new HashMap<>(data); + + this.amount = (Long) dataCopy.remove("amount"); + this.cardId = (String) dataCopy.remove("cardId"); + this.cardExpiration = (String) dataCopy.remove("cardExpiration"); + this.cardNumber = (String) dataCopy.remove("cardNumber"); + this.cardSecurityCode = (String) dataCopy.remove("cardSecurityCode"); + this.holderName = (String) dataCopy.remove("holderName"); + this.fundingType = (String) dataCopy.remove("fundingType"); + this.installmentCount = (Integer) dataCopy.remove("installmentCount"); + this.holderEmail = (String) dataCopy.remove("holderEmail"); + this.holderPhone = (String) dataCopy.remove("holderPhone"); + this.billingCountryCode = (String) dataCopy.remove("billingCountryCode"); + this.billingCity = (String) dataCopy.remove("billingCity"); + this.billingStateCode = (String) dataCopy.remove("billingStateCode"); + this.billingStreetLine1 = (String) dataCopy.remove("billingStreetLine1"); + this.billingStreetLine2 = (String) dataCopy.remove("billingStreetLine2"); + this.billingZipCode = (String) dataCopy.remove("billingZipCode"); + this.metadata = (Map) dataCopy.remove("metadata"); + this.tags = (String[]) dataCopy.remove("tags"); + this.challengeMode = null; + this.network = null; + this.source = null; + this.status = null; + this.update = null; + + if (!dataCopy.isEmpty()) { + throw new Exception("Unknown parameters used in constructor: [" + String.join(", ", dataCopy.keySet()) + "]"); + } + } + + } + + public final static class Log extends Resource { + static ClassData data = new ClassData(MerchantSession.Log.class, "MerchantSessionLog"); + + public String created; + public String type; + public String[] errors; + public MerchantSession session; + + public Log(String created, String type, String[] errors, MerchantSession session, String id) { + super(id); + this.created = created; + this.type = type; + this.errors = errors; + this.session = session; + } + + + public static MerchantSession.Log get(String id) throws Exception { + return MerchantSession.Log.get(id, null); + } + + public static MerchantSession.Log get(String id, User user) throws Exception { + return Rest.getId(data, id, user); + } + + public static Generator query(Map params) throws Exception { + return MerchantSession.Log.query(params, null); + } + + public static Generator query(User user) throws Exception { + return MerchantSession.Log.query(new HashMap<>(), user); + } + + public static Generator query() throws Exception { + return MerchantSession.Log.query(new HashMap<>(), null); + } + + public static Generator query(Map params, User user) throws Exception { + return Rest.getStream(data, params, user); + } + + public final static class Page { + public List logs; + public String cursor; + + public Page(List logs, String cursor) { + this.logs = logs; + this.cursor = cursor; + } + } + + public static MerchantSession.Log.Page page(Map params) throws Exception { + return MerchantSession.Log.page(params, null); + } + + public static MerchantSession.Log.Page page(User user) throws Exception { + return MerchantSession.Log.page(new HashMap<>(), user); + } + + public static MerchantSession.Log.Page page() throws Exception { + return MerchantSession.Log.page(new HashMap<>(), null); + } + + public static MerchantSession.Log.Page page(Map params, User user) throws Exception { + com.starkcore.utils.Page page = Rest.getPage(data, params, user); + List logs = new ArrayList<>(); + for (com.starkcore.utils.SubResource log: page.entities) { + logs.add((MerchantSession.Log) log); + } + return new MerchantSession.Log.Page(logs, page.cursor); + } + + } + +} diff --git a/src/main/java/com/starkbank/utils/Rest.java b/src/main/java/com/starkbank/utils/Rest.java index c6fc91e..e678127 100644 --- a/src/main/java/com/starkbank/utils/Rest.java +++ b/src/main/java/com/starkbank/utils/Rest.java @@ -61,6 +61,22 @@ public static List post(SubResource.ClassData resourc ); } + + public static T postSubResource(Resource.ClassData resource, String id, SubResource.ClassData subResource, User user, SubResource entity) throws Exception { + return com.starkcore.utils.Rest.postSubResource( + sdkVersion, + host, + apiVersion, + user, + resource, + id, + subResource, + language, + timeout, + entity + ); + } + public static T patch(Resource.ClassData resource, String id, Map data, User user) throws Exception { return com.starkcore.utils.Rest.patch( sdkVersion, diff --git a/src/test/java/TestMerchantCard.java b/src/test/java/TestMerchantCard.java new file mode 100644 index 0000000..2b2ea5f --- /dev/null +++ b/src/test/java/TestMerchantCard.java @@ -0,0 +1,83 @@ +import com.starkbank.MerchantCard; +import com.starkbank.Settings; +import com.starkbank.utils.Generator; +import org.junit.Assert; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class TestMerchantCard { + + @Test + public void testGet() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 10); + Generator cards = MerchantCard.query(params); + + for (MerchantCard card : cards) { + MerchantCard retrievedCard = MerchantCard.get(card.id); + Assert.assertNotNull(retrievedCard.id); + System.out.println(retrievedCard); + } + } + + @Test + public void testQuery() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + Generator cards = MerchantCard.query(params); + + for (MerchantCard card : cards) { + Assert.assertNotNull(card.id); + System.out.println(card); + } + } + + @Test + public void testPage() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 10); + params.put("cursor", null); + + List ids = new ArrayList<>(); + for (int i = 0; i < 2; i++) { + MerchantCard.Page page = MerchantCard.page(params); + for (MerchantCard card : page.merchantCards) { + Assert.assertNotNull(card.id); + Assert.assertFalse(ids.contains(card.id)); + ids.add(card.id); + } + if (page.cursor == null) { + break; + } + params.put("cursor", page.cursor); + } + + Assert.assertEquals(20, ids.size()); + } + + @Test + public void testLogQueryAndGet() throws Exception{ + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + params.put("after", "2019-04-01"); + params.put("before", "2030-04-30"); + Generator logs = MerchantCard.Log.query(params); + + int i = 0; + for (MerchantCard.Log log : logs) { + i += 1; + log = MerchantCard.Log.get(log.id); + Assert.assertNotNull(log.id); + System.out.println(log); + } + Assert.assertTrue(i > 0); + } + +} diff --git a/src/test/java/TestMerchantInstallment.java b/src/test/java/TestMerchantInstallment.java new file mode 100644 index 0000000..34e0ad7 --- /dev/null +++ b/src/test/java/TestMerchantInstallment.java @@ -0,0 +1,83 @@ +import com.starkbank.MerchantInstallment; +import com.starkbank.Settings; +import com.starkbank.utils.Generator; +import org.junit.Assert; +import org.junit.Test; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public class TestMerchantInstallment { + + @Test + public void testGet() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + Generator installments = MerchantInstallment.query(params); + + for (MerchantInstallment installment : installments) { + MerchantInstallment retrievedInstallment = MerchantInstallment.get(installment.id); + Assert.assertNotNull(retrievedInstallment.id); + System.out.println(retrievedInstallment); + } + } + + @Test + public void testQuery() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + Generator installments = MerchantInstallment.query(params); + + for (MerchantInstallment installment : installments) { + Assert.assertNotNull(installment.id); + System.out.println(installment); + } + } + + @Test + public void testPage() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 5); + params.put("cursor", null); + + List ids = new ArrayList<>(); + for (int i = 0; i < 2; i++) { + MerchantInstallment.Page page = MerchantInstallment.page(params); + for (MerchantInstallment installment : page.merchantInstallments) { + Assert.assertNotNull(installment.id); + Assert.assertFalse(ids.contains(installment.id)); + ids.add(installment.id); + } + if (page.cursor == null) { + break; + } + params.put("cursor", page.cursor); + } + + Assert.assertEquals(10, ids.size()); + } + + @Test + public void testLogQueryAndGet() throws Exception{ + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + params.put("after", "2019-04-01"); + params.put("before", "2030-04-30"); + Generator logs = MerchantInstallment.Log.query(params); + + int i = 0; + for (MerchantInstallment.Log log : logs) { + i += 1; + log = MerchantInstallment.Log.get(log.id); + Assert.assertNotNull(log.id); + System.out.println(log); + } + Assert.assertTrue(i > 0); + } + +} diff --git a/src/test/java/TestMerchantPurchase.java b/src/test/java/TestMerchantPurchase.java new file mode 100644 index 0000000..bd5b262 --- /dev/null +++ b/src/test/java/TestMerchantPurchase.java @@ -0,0 +1,121 @@ +import com.starkbank.*; +import com.starkbank.utils.Generator; +import org.junit.Test; +import org.junit.Assert; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +import static utils.MerchantPurchase.exampleMerchantPurchase; +import static utils.MerchantSession.*; + +public class TestMerchantPurchase { + + + @Test + public void testCreate() throws Exception { + Settings.user = utils.User.defaultProject(); + MerchantSession merchantSession = MerchantSession.create(exampleMerchantSession("disabled")); + MerchantSession.Purchase purchase = MerchantSession.purchase(merchantSession.uuid, examplePurchaseChallengeModeDisable()); + + System.out.println(exampleMerchantPurchase(purchase.cardId)); + MerchantPurchase merchantPurchase = MerchantPurchase.create(exampleMerchantPurchase(purchase.cardId)); + System.out.println(merchantPurchase); + Assert.assertNotNull(merchantPurchase.id); + } + + @Test + public void testUpdate() throws Exception { + Settings.user = utils.User.defaultProject(); + + HashMap params = new HashMap<>(); + params.put("limit", 1); + params.put("status", "created"); + + Generator purchases = MerchantPurchase.query(params); + + HashMap patchData = new HashMap<>(); + patchData.put("amount", 0); + patchData.put("status", "reversed"); + + for (MerchantPurchase merchantPurchase : purchases) { + System.out.println(merchantPurchase); + MerchantPurchase.update(merchantPurchase.id, patchData); + Assert.assertNotNull(merchantPurchase.id); + } + + } + + @Test + public void testQuery() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + Generator purchases = MerchantPurchase.query(params); + + for (MerchantPurchase purchase : purchases) { + Assert.assertNotNull(purchase.id); + System.out.println(purchase); + } + } + + @Test + public void testGet() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + Generator purchases = MerchantPurchase.query(params); + + for (MerchantPurchase purchase : purchases) { + MerchantPurchase retrievedPurchase = MerchantPurchase.get(purchase.id); + Assert.assertNotNull(retrievedPurchase.id); + System.out.println(retrievedPurchase); + } + } + + @Test + public void testLogQueryAndGet() throws Exception{ + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + params.put("after", "2019-04-01"); + params.put("before", "2030-04-30"); + Generator logs = MerchantPurchase.Log.query(params); + + int i = 0; + for (MerchantPurchase.Log log : logs) { + i += 1; + log = MerchantPurchase.Log.get(log.id); + Assert.assertNotNull(log.id); + System.out.println(log); + } + Assert.assertTrue(i > 0); + } + + @Test + public void testPage() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 5); + params.put("cursor", null); + + List ids = new ArrayList<>(); + for (int i = 0; i < 2; i++) { + MerchantPurchase.Page page = MerchantPurchase.page(params); + for (MerchantPurchase purchase : page.merchantPurchases) { + Assert.assertNotNull(purchase.id); + Assert.assertFalse(ids.contains(purchase.id)); + ids.add(purchase.id); + } + if (page.cursor == null) { + break; + } + params.put("cursor", page.cursor); + } + + Assert.assertEquals(10, ids.size()); + } + + +} \ No newline at end of file diff --git a/src/test/java/TestMerchantSession.java b/src/test/java/TestMerchantSession.java new file mode 100644 index 0000000..74acc73 --- /dev/null +++ b/src/test/java/TestMerchantSession.java @@ -0,0 +1,149 @@ +import com.starkbank.MerchantSession; +import com.starkbank.Settings; +import com.starkbank.utils.Generator; +import org.junit.Test; +import org.junit.Assert; + +import java.util.*; + +import static utils.MerchantSession.*; + +public class TestMerchantSession { + + @Test + public void testCreate() throws Exception { + Settings.user = utils.User.defaultProject(); + + MerchantSession merchantSession = MerchantSession.create(exampleMerchantSession("disabled")); + System.out.println(merchantSession); + Assert.assertNotNull(merchantSession.id); + } + + @Test + public void testQuery() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + Generator sessions = MerchantSession.query(params); + + for (MerchantSession session : sessions) { + Assert.assertNotNull(session.id); + System.out.println(session); + } + } + + @Test + public void testGet() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + Generator sessions = MerchantSession.query(params); + + for (MerchantSession session : sessions) { + MerchantSession retrievedSession = MerchantSession.get(session.id); + Assert.assertNotNull(retrievedSession.id); + System.out.println(retrievedSession); + } + } + + @Test + public void testPage() throws Exception { + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 5); + params.put("cursor", null); + + List ids = new ArrayList<>(); + for (int i = 0; i < 2; i++) { + MerchantSession.Page page = MerchantSession.page(params); + for (MerchantSession session : page.merchantSessions) { + Assert.assertNotNull(session.id); + Assert.assertFalse(ids.contains(session.id)); + ids.add(session.id); + } + if (page.cursor == null) { + break; + } + params.put("cursor", page.cursor); + } + + Assert.assertEquals(10, ids.size()); + } + + @Test + public void testPageWithoutParams() throws Exception { + Settings.user = utils.User.defaultProject(); + + List ids = new ArrayList<>(); + + MerchantSession.Page page = MerchantSession.page(); + for (MerchantSession session : page.merchantSessions) { + System.out.println(session); + Assert.assertNotNull(session.id); + ids.add(session.id); + } + + Assert.assertEquals(100, ids.size()); + } + + @Test + public void testLogQueryAndGet() throws Exception{ + Settings.user = utils.User.defaultProject(); + HashMap params = new HashMap<>(); + params.put("limit", 3); + params.put("after", "2019-04-01"); + params.put("before", "2030-04-30"); + Generator logs = MerchantSession.Log.query(params); + + int i = 0; + for (MerchantSession.Log log : logs) { + i += 1; + log = MerchantSession.Log.get(log.id); + Assert.assertNotNull(log.id); + System.out.println(log); + } + Assert.assertTrue(i > 0); + } + + @Test + public void testLogs() throws Exception { + Settings.user = utils.User.defaultProject(); + + List ids = new ArrayList<>(); + + MerchantSession.Log.Page page = MerchantSession.Log.page(); + for (MerchantSession.Log session : page.logs) { + System.out.println(session); + Assert.assertNotNull(session.id); + ids.add(session.id); + } + + Assert.assertEquals(100, ids.size()); + } + + + @Test + public void testMerchantSessionPurchaseChallengeModeDisabled() throws Exception { + Settings.user = utils.User.defaultProject(); + + MerchantSession merchantSession = MerchantSession.create(exampleMerchantSession("disabled")); + + MerchantSession.Purchase purchaseResponse = MerchantSession.purchase( + merchantSession.uuid, examplePurchaseChallengeModeDisable()); + System.out.println(purchaseResponse); + Assert.assertNotNull(purchaseResponse.id); + } + + @Test + public void testMerchantSessionPurchaseChallengeModeEnabled() throws Exception { + Settings.user = utils.User.defaultProject(); + + MerchantSession merchantSession = MerchantSession.create(exampleMerchantSession("enabled")); + + MerchantSession.Purchase purchaseResponse = MerchantSession.purchase( + merchantSession.uuid, examplePurchaseChallengeModeEnable()); + + Assert.assertNotNull(purchaseResponse.id); + } + +} \ No newline at end of file diff --git a/src/test/java/utils/MerchantPurchase.java b/src/test/java/utils/MerchantPurchase.java new file mode 100644 index 0000000..b01282a --- /dev/null +++ b/src/test/java/utils/MerchantPurchase.java @@ -0,0 +1,30 @@ +package utils; + +import java.util.HashMap; + +public class MerchantPurchase { + +public static com.starkbank.MerchantPurchase exampleMerchantPurchase(String cardId) throws Exception { + HashMap data = new HashMap<>(); + + data.put("amount", 1000L); + data.put("installmentCount", 1); + data.put("cardId", cardId); + data.put("fundingType", "credit"); + data.put("billingCity", "Sao Paulo"); + data.put("billingCountryCode", "BRA"); + data.put("billingStateCode", "SP"); + data.put("billingStreetLine1", "Rua Casterly Rock, 2000"); + data.put("billingStreetLine2", ""); + data.put("billingZipCode", "01450-000"); + data.put("holderEmail", "tywin.lannister@gmail.com"); + data.put("holderPhone", "11999999999"); + HashMap metadata = new HashMap<>(); + metadata.put("userAgent", "Mozilla"); + metadata.put("userIp", "111.111.111.111"); + metadata.put("language", "pt-BR"); + data.put("metadata", metadata); + + return new com.starkbank.MerchantPurchase(data); +} +} diff --git a/src/test/java/utils/MerchantSession.java b/src/test/java/utils/MerchantSession.java new file mode 100644 index 0000000..6d90bc7 --- /dev/null +++ b/src/test/java/utils/MerchantSession.java @@ -0,0 +1,80 @@ +package utils; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +public class MerchantSession { + + public static com.starkbank.MerchantSession exampleMerchantSession(String challengeMode) throws Exception { + Map data = new HashMap<>(); + List allowedFundingTypes = new ArrayList<>(); + allowedFundingTypes.add("debit"); + allowedFundingTypes.add("credit"); + data.put("allowedFundingTypes", allowedFundingTypes); + + List allowedInstallments = new ArrayList<>(); + + com.starkbank.MerchantSession.AllowedInstallment allowedInstallment1 = new com.starkbank.MerchantSession.AllowedInstallment(5000L, 1); + com.starkbank.MerchantSession.AllowedInstallment allowedInstallments2 = new com.starkbank.MerchantSession.AllowedInstallment(5500L, 2); + + allowedInstallments.add(allowedInstallment1); + allowedInstallments.add(allowedInstallments2); + + + data.put("allowedInstallments", allowedInstallments); + data.put("expiration", 3600); + data.put("challengeMode", challengeMode); + + data.put("tags", new String[]{"Stark", "Suit"}); + + return new com.starkbank.MerchantSession(data); + } + + public static com.starkbank.MerchantSession.Purchase examplePurchaseChallengeModeEnable() throws Exception { + Map purchaseData = new HashMap<>(); + purchaseData.put("amount", 5000L); + purchaseData.put("installmentCount", 1); + purchaseData.put("cardExpiration", "2035-01"); + purchaseData.put("cardNumber", "5448280000000007"); + purchaseData.put("cardSecurityCode", "123"); + purchaseData.put("holderName", "Margaery Tyrell"); + purchaseData.put("holderEmail", "margaery.tyrell@starkbank.com"); + purchaseData.put("holderPhone", "11998663456"); + purchaseData.put("fundingType", "credit"); + purchaseData.put("billingCountryCode", "BRA"); + purchaseData.put("billingCity", "Sao Paulo"); + purchaseData.put("billingStateCode", "SP"); + purchaseData.put("billingStreetLine1", "Rua do Jardim de cima, 123"); + purchaseData.put("billingStreetLine2", "1 andar"); + purchaseData.put("billingZipCode", "11111-111"); + + Map metadata = new HashMap<>(); + metadata.put("userAgent", "userAgent"); + metadata.put("userIp", "255.255.255.255"); + metadata.put("language", "pt-BR"); + metadata.put("timezoneOffset", 3); + metadata.put("extraData", "extraData"); + + purchaseData.put("metadata", metadata); + purchaseData.put("tags", new String[]{"Stark", "Suit"}); + + return new com.starkbank.MerchantSession.Purchase(purchaseData); + } + + public static com.starkbank.MerchantSession.Purchase examplePurchaseChallengeModeDisable() throws Exception { + Map purchaseData = new HashMap<>(); + purchaseData.put("amount", 5000L); + purchaseData.put("installmentCount", 1); + purchaseData.put("cardExpiration", "2035-01"); + purchaseData.put("cardNumber", "36490101441625"); + purchaseData.put("cardSecurityCode", "123"); + purchaseData.put("fundingType", "credit"); + purchaseData.put("holderName", "Margaery Tyrell"); + + + return new com.starkbank.MerchantSession.Purchase(purchaseData); + } + +}