import com.stripe.exception.StripeException; //导入依赖的package包/类
public static void main(String[] args) {
    Stripe.apiKey = "sk_test_RVommOo9ArONhawECkwu3Kz3";
    Map<String, Object> chargeMap = new HashMap<String, Object>();
    chargeMap.put("amount", 100);
    chargeMap.put("currency", "usd");
    Map<String, Object> cardMap = new HashMap<String, Object>();
    cardMap.put("number", "4242424242424242");
    cardMap.put("exp_month", 12);
    cardMap.put("exp_year", 2020);
    chargeMap.put("card", cardMap);
    try {
        Charge charge = Charge.create(chargeMap);
        System.out.println(charge);
    } catch (StripeException e) {
        e.printStackTrace();
    }
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testBalanceTransactionRetrieval() throws StripeException {
	Charge.create(defaultChargeParams);
	BalanceTransactionCollection balanceTransactions = BalanceTransaction.all(null);
	assertTrue(balanceTransactions.getCount() > 0);
	assertFalse(balanceTransactions.getData().isEmpty());
	BalanceTransaction first = balanceTransactions.getData().get(0);
	assertNotNull(first.getStatus());

	HashMap<String, Object> fetchParams = new HashMap<String, Object>();
	fetchParams.put("count", 2);
	assertEquals(BalanceTransaction.all(fetchParams).getData().size(), 2);

	BalanceTransaction retrieved = BalanceTransaction.retrieve(first.getId());
	assertEquals(retrieved.getId(), first.getId());
	assertEquals(retrieved.getSource(), first.getSource());
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testInvalidAddressZipTest() throws StripeException {
	Map<String, Object> invalidChargeParams = new HashMap<String, Object>();
	invalidChargeParams.putAll(defaultChargeParams);
	Map<String, Object> invalidCardParams = new HashMap<String, Object>();
	// See https://stripe.com/docs/testing
	invalidCardParams.put("number", "4000000000000036");
	invalidCardParams.put("address_zip", "94024");
	invalidCardParams.put("address_line1", "42 Foo Street");
	invalidCardParams.put("exp_month", 12);
	invalidCardParams.put("exp_year", 2015);
	invalidChargeParams.put("card", invalidCardParams);
	Charge charge = Charge.create(invalidChargeParams);
	assertEquals(charge.getPaid(), true);
	assertEquals(charge.getCard().getAddressZipCheck(), "fail");
	assertEquals(charge.getCard().getAddressLine1Check(), "pass");
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testInvalidAddressLine1Test() throws StripeException {
	Map<String, Object> invalidChargeParams = new HashMap<String, Object>();
	invalidChargeParams.putAll(defaultChargeParams);
	Map<String, Object> invalidCardParams = new HashMap<String, Object>();
	// See https://stripe.com/docs/testing
	invalidCardParams.put("number", "4000000000000028");
	invalidCardParams.put("address_zip", "94024");
	invalidCardParams.put("address_line1", "42 Foo Street");
	invalidCardParams.put("exp_month", 12);
	invalidCardParams.put("exp_year", 2015);
	invalidChargeParams.put("card", invalidCardParams);
	Charge charge = Charge.create(invalidChargeParams);
	assertEquals(charge.getPaid(), true);
	assertEquals(charge.getCard().getAddressZipCheck(), "pass");
	assertEquals(charge.getCard().getAddressLine1Check(), "fail");
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testCustomerCardAddition() throws StripeException {
	Customer createdCustomer = Customer.create(defaultCustomerParams);
	String originalDefaultCard = createdCustomer.getDefaultCard();

	Map<String, Object> creationParams = new HashMap<String, Object>();
	creationParams.put("card", defaultCardParams);
	Card addedCard = createdCustomer.createCard(creationParams);

	Token token = Token.create(defaultTokenParams);
	createdCustomer.createCard(token.getId());

	Customer updatedCustomer = Customer.retrieve(createdCustomer.getId());
	assertEquals((Integer) updatedCustomer.getCards().getData().size(), (Integer) 3);
	assertEquals(updatedCustomer.getDefaultCard(), originalDefaultCard);

	Map<String, Object> updateParams = new HashMap<String, Object>();
	updateParams.put("default_card", addedCard.getId());
	Customer customerAfterDefaultCardUpdate = updatedCustomer.update(updateParams);
	assertEquals((Integer) customerAfterDefaultCardUpdate.getCards().getData().size(), (Integer) 3);
	assertEquals(customerAfterDefaultCardUpdate.getDefaultCard(), addedCard.getId());

	assertEquals(customerAfterDefaultCardUpdate.getCards().retrieve(originalDefaultCard).getId(), originalDefaultCard);
	assertEquals(customerAfterDefaultCardUpdate.getCards().retrieve(addedCard.getId()).getId(), addedCard.getId());
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testCustomerCardDelete() throws StripeException {
	Customer customer = Customer.create(defaultCustomerParams);
	Map<String, Object> creationParams = new HashMap<String, Object>();
	creationParams.put("card", defaultCardParams);
	customer.createCard(creationParams);

	Card card = customer.getCards().getData().get(0);
	DeletedCard deletedCard = card.delete();
	Customer retrievedCustomer = Customer.retrieve(customer.getId());

	assertTrue(deletedCard.getDeleted());
	assertEquals(deletedCard.getId(), card.getId());
	for(Card retrievedCard : retrievedCustomer.getCards().getData()) {
	    assertFalse("Card was not actually deleted: " + card.getId(), card.getId().equals(retrievedCard.getId()));
	}
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
/**
 * This method processes the pending payment using the configured payment gateway (at the time of writing, only STRIPE)
 * and returns a PaymentResult.
 * In order to preserve the consistency of the payment, when a non-gateway Exception is thrown, it rethrows an IllegalStateException
 *
 * @param reservationId
 * @param gatewayToken
 * @param price
 * @param event
 * @param email
 * @param customerName
 * @param billingAddress
 * @return PaymentResult
 * @throws java.lang.IllegalStateException if there is an error after charging the credit card
 */
PaymentResult processStripePayment(String reservationId,
                                   String gatewayToken,
                                   int price,
                                   Event event,
                                   String email,
                                   CustomerName customerName,
                                   String billingAddress) {
    try {
        final Charge charge = stripeManager.chargeCreditCard(gatewayToken, price,
                event, reservationId, email, customerName.getFullName(), billingAddress);
        log.info("transaction {} paid: {}", reservationId, charge.getPaid());
        Pair<Long, Long> fees = Optional.ofNullable(charge.getBalanceTransactionObject()).map(bt -> {
            List<Fee> feeDetails = bt.getFeeDetails();
            return Pair.of(Optional.ofNullable(StripeManager.getFeeAmount(feeDetails, "application_fee")).map(Long::parseLong).orElse(0L),
                           Optional.ofNullable(StripeManager.getFeeAmount(feeDetails, "stripe_fee")).map(Long::parseLong).orElse(0L));
        }).orElse(null);

        transactionRepository.insert(charge.getId(), null, reservationId,
                ZonedDateTime.now(), price, event.getCurrency(), charge.getDescription(), PaymentProxy.STRIPE.name(),
                fees != null ? fees.getLeft() : 0L, fees != null ? fees.getRight() : 0L);
        return PaymentResult.successful(charge.getId());
    } catch (Exception e) {
        if(e instanceof StripeException) {
            return PaymentResult.unsuccessful(stripeManager.handleException((StripeException)e));
        }
        throw new IllegalStateException(e);
    }

}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
static InvoiceItem createDefaultInvoiceItem(Customer customer)
		throws StripeException {
	Map<String, Object> invoiceItemParams = new HashMap<String, Object>();
	invoiceItemParams.put("amount", 100);
	invoiceItemParams.put("currency", "usd");
	invoiceItemParams.put("customer", customer.getId());
	return InvoiceItem.create(invoiceItemParams);
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
static Recipient createDefaultRecipient()
		throws StripeException {
	Map<String, Object> recipientParams = new HashMap<String, Object>();
	recipientParams.putAll(defaultRecipientParams);
	Recipient recipient = Recipient.create(recipientParams);
	return recipient;
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testAccountRetrieve() throws StripeException {
	Account retrievedAccount = Account.retrieve();
	assertEquals("[email protected]", retrievedAccount.getEmail());
	assertEquals(false, retrievedAccount.getChargeEnabled());
	assertEquals(false, retrievedAccount.getDetailsSubmitted());
	assertEquals(null, retrievedAccount.getStatementDescriptor());
	assertEquals(false, retrievedAccount.getTransferEnabled());

	List<String> currencies = retrievedAccount.getCurrenciesSupported();
	assertEquals(1, currencies.size());
	assertEquals("USD", currencies.get(0));
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testBalanceRetrieve() throws StripeException {
	Balance retrievedBalance = Balance.retrieve();
	assertEquals(false, retrievedBalance.getLivemode());
	assertEquals(1, retrievedBalance.getPending().size());
	assertEquals(1, retrievedBalance.getAvailable().size());
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testChargeRetrieve() throws StripeException {
	Charge createdCharge = Charge.create(defaultChargeParams);
	Charge retrievedCharge = Charge.retrieve(createdCharge.getId());
	assertEquals(createdCharge.getCreated(), retrievedCharge.getCreated());
	assertEquals(createdCharge.getId(), retrievedCharge.getId());
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testChargeCapture() throws StripeException {
	HashMap<String, Object> options = (HashMap<String, Object>)defaultChargeParams.clone();
	options.put("capture", false);

	Charge created = Charge.create(options);
	assertFalse(created.getCaptured());

	Charge captured = created.capture();
	assertTrue(captured.getCaptured());
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testChargePartialRefund() throws StripeException {
	Charge createdCharge = Charge.create(defaultChargeParams);
	Map<String, Object> refundParams = new HashMap<String, Object>();
	final Integer REFUND_AMOUNT = 50;
	refundParams.put("amount", REFUND_AMOUNT);
	Charge refundedCharge = createdCharge.refund(refundParams);
	assertFalse(refundedCharge.getRefunded());
	assertEquals(refundedCharge.getAmountRefunded(), REFUND_AMOUNT);
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testChargeList() throws StripeException {
	Map<String, Object> listParams = new HashMap<String, Object>();
	listParams.put("count", 1);
	List<Charge> charges = Charge.all(listParams).getData();
	assertEquals(charges.size(), 1);
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test(expected = CardException.class)
public void testInvalidCard() throws StripeException {
	Map<String, Object> invalidChargeParams = new HashMap<String, Object>();
	invalidChargeParams.putAll(defaultChargeParams);
	Map<String, Object> invalidCardParams = new HashMap<String, Object>();
	invalidCardParams.put("number", "4242424242424241");
	invalidCardParams.put("exp_month", 12);
	invalidCardParams.put("exp_year", 2015);
	invalidChargeParams.put("card", invalidCardParams);
	Charge.create(invalidChargeParams);
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testCustomerRetrieve() throws StripeException {
	Customer createdCustomer = Customer.create(defaultCustomerParams);
	Customer retrievedCustomer = Customer.retrieve(createdCustomer.getId());
	assertEquals(createdCustomer.getCreated(),
			retrievedCustomer.getCreated());
	assertEquals(createdCustomer.getId(), retrievedCustomer.getId());
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testCustomerList() throws StripeException {
	Map<String, Object> listParams = new HashMap<String, Object>();
	listParams.put("count", 1);
	List<Customer> Customers = Customer.all(listParams).getData();
	assertEquals(Customers.size(), 1);
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test
public void testCustomerUpdate() throws StripeException {
	Customer createdCustomer = Customer.create(defaultCustomerParams);
	Map<String, Object> updateParams = new HashMap<String, Object>();
	updateParams.put("description", "Updated Description");
	Customer updatedCustomer = createdCustomer.update(updateParams);
	assertEquals(updatedCustomer.getDescription(), "Updated Description");
}
 

import com.stripe.exception.StripeException; //导入依赖的package包/类
@Test(expected=InvalidRequestException.class)
public void testCustomerUpdateToBlank() throws StripeException {
	Customer createdCustomer = Customer.create(defaultCustomerParams);
	Map<String, Object> updateParams = new HashMap<String, Object>();
	updateParams.put("description", "");
	Customer updatedCustomer = createdCustomer.update(updateParams);
}