import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
/**
 * The checkout form only makes a token, the final charge happens using this
 * call.
 * 
 * @param email
 *          - Primary Email
 * @param amount
 *          - Amount to be charged.
 * @param token
 *          - Token created off "checkout"
 * @return
 * @throws AuthenticationException
 * @throws InvalidRequestException
 * @throws APIConnectionException
 * @throws APIException
 * @throws CardException
 */
public String createCharge(String email, BigDecimal amount, String token)
    throws AuthenticationException, InvalidRequestException, APIConnectionException, APIException, CardException {

  log.warn("Charging: " + email + " For: " + amount);

  try {

    // See your keys here: https://dashboard.stripe.com/account/apikeys
    Stripe.apiKey = gricConfigProperties.getStripeApiKey();

    // Create a charge: this will charge the user's card
    Map<String, Object> chargeParams = new HashMap<String, Object>();
    // Amount in cents, multiple by 100, and send it as integer for API.
    chargeParams.put("amount", amount.multiply(new BigDecimal("100")).intValueExact());
    chargeParams.put("currency", "usd");
    chargeParams.put("source", token);
    chargeParams.put("description", "Glen Rock Indian Community Event");
    chargeParams.put("receipt_email", email);
    chargeParams.put("statement_descriptor", "GRIC Payment");

    Charge charge = Charge.create(chargeParams);

    String chargeIdAndReceiptNumber = charge.getId() + "," + charge.getReceiptNumber();

    return chargeIdAndReceiptNumber;
  } catch (Exception e) {
    // The card has been declined
    log.error("Charge failed for: " + email + " For: " + amount);
    throw e;
  }
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
private static void handleAPIError(String rBody, int rCode)
		throws InvalidRequestException, AuthenticationException,
		CardException, APIException {
	APIResource.Error error = gson.fromJson(rBody,
			APIResource.ErrorContainer.class).error;
	switch (rCode) {
	case 400:
		throw new InvalidRequestException(error.message, error.param, null);
	case 404:
		throw new InvalidRequestException(error.message, error.param, null);
	case 401:
		throw new AuthenticationException(error.message);
	case 402:
		throw new CardException(error.message, error.code, error.param,
				null);
	default:
		throw new APIException(error.message, null);
	}
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
private Charges convertTheirChargesToOurs(Map<String, Object> chargeParams)
		throws AuthenticationException, InvalidRequestException,
		APIConnectionException, CardException, APIException {
	ChargeCollection list = Charge.list(chargeParams);
	Charges charges = new Charges();
	for (Charge charge : list.getData()) {
		charges.getCharges().add(
				new com.example.legacyapp.dto.Charge(charge.getCustomer(), charge.getAmount(), charge.getCaptured())
		);
	}
	return charges;
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
@Override
public void pay(final long cents, final String token, final String email)
    throws IOException {
    final String customer;
    try {
        customer = Customer.create(
            new StickyMap<String, Object>(
                new MapEntry<>("email", email),
                new MapEntry<>("source", token)
            ),
            new RequestOptions.RequestOptionsBuilder().setApiKey(
                Manifests.read("ThreeCopies-StripeSecret")
            ).build()
        ).getId();
    } catch (final APIException | APIConnectionException
        | AuthenticationException | CardException
        | InvalidRequestException ex) {
        throw new IOException(ex);
    }
    this.item().put(
        new AttributeUpdates()
            .with(
                "stripe_cents",
                new AttributeValueUpdate().withValue(
                    new AttributeValue().withN(Long.toString(cents))
                ).withAction(AttributeAction.PUT)
            )
            .with(
                "stripe_customer",
                new AttributeValueUpdate().withValue(
                    new AttributeValue().withS(customer)
                ).withAction(AttributeAction.PUT)
            )
    );
    this.rebill();
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
/**
 * Charge him again.
 * @throws IOException If fails
 */
private void rebill() throws IOException {
    final Item item = this.item();
    final Long cents = Long.parseLong(item.get("stripe_cents").getN());
    final String customer = item.get("stripe_customer").getS();
    try {
        Charge.create(
            new StickyMap<String, Object>(
                new MapEntry<>("amount", cents),
                new MapEntry<>("currency", "usd"),
                new MapEntry<>(
                    "description",
                    String.format("ThreeCopies: %s", this.name)
                ),
                new MapEntry<>("customer", customer)
            ),
            new RequestOptions.RequestOptionsBuilder().setApiKey(
                Manifests.read("ThreeCopies-StripeSecret")
            ).build()
        );
    } catch (final APIException | APIConnectionException
        | AuthenticationException | CardException
        | InvalidRequestException ex) {
        throw new IOException(ex);
    }
    this.item().put(
        "paid",
        new AttributeValueUpdate().withValue(
            new AttributeValue().withN(
                Long.toString(cents * TimeUnit.HOURS.toSeconds(1L))
            )
        ).withAction(AttributeAction.ADD)
    );
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
Token createCardToken() throws AuthenticationException, InvalidRequestException, APIConnectionException,
		CardException, APIException {
	Map<String, Object> tokenParams = Maps.newHashMap();
	Map<String, Object> cardParams = Maps.newHashMap();
	cardParams.put("number", "4242424242424242");
	cardParams.put("exp_month", 11);
	cardParams.put("exp_year", 2019);
	cardParams.put("cvc", "314");
	tokenParams.put("card", cardParams);
	Token token = Token.create(tokenParams);
	return token;
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public static BalanceTransaction retrieve(String id, String apiKey)
		throws AuthenticationException, InvalidRequestException,
		APIConnectionException, CardException, APIException {
	String url = String.format("%s/%s/%s", Stripe.API_BASE, "v1/balance/history", id);
	return request(RequestMethod.GET, url, null,
			BalanceTransaction.class, apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public static BalanceTransactionCollection all(Map<String, Object> params, String apiKey)
		throws AuthenticationException, InvalidRequestException,
		APIConnectionException, CardException, APIException {
	String url = String.format("%s/%s", Stripe.API_BASE, "v1/balance/history");
	return request(RequestMethod.GET, url, params,
			BalanceTransactionCollection.class, apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public static RecipientCollection all(Map<String, Object> params,
		String apiKey) throws AuthenticationException,
		InvalidRequestException, APIConnectionException, CardException,
		APIException {
	return request(RequestMethod.GET, classURL(Recipient.class), params,
			RecipientCollection.class, apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public Recipient update(Map<String, Object> params, String apiKey)
		throws AuthenticationException, InvalidRequestException,
		APIConnectionException, CardException, APIException {
	return request(RequestMethod.POST,
			instanceURL(Recipient.class, this.id), params, Recipient.class,
			apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public Subscription updateSubscription(Map<String, Object> params,
		String apiKey) throws AuthenticationException,
		InvalidRequestException, APIConnectionException, CardException,
		APIException {
	return request(
			RequestMethod.POST,
			String.format("%s/subscription",
					instanceURL(Customer.class, this.id)), params,
			Subscription.class, apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
protected static <T> T request(APIResource.RequestMethod method,
		String url, Map<String, Object> params, Class<T> clazz,
		String apiKey) throws AuthenticationException,
		InvalidRequestException, APIConnectionException, CardException,
		APIException {
	String originalDNSCacheTTL = null;
	Boolean allowedToSetTTL = true;
	try {
		originalDNSCacheTTL = java.security.Security
				.getProperty(DNS_CACHE_TTL_PROPERTY_NAME);
		// disable DNS cache
		java.security.Security
				.setProperty(DNS_CACHE_TTL_PROPERTY_NAME, "0");
	} catch (SecurityException se) {
		allowedToSetTTL = false;
	}

	try {
		return _request(method, url, params, clazz, apiKey);
	} finally {
		if (allowedToSetTTL) {
			if (originalDNSCacheTTL == null) {
				// value unspecified by implementation
				java.security.Security.setProperty(
						DNS_CACHE_TTL_PROPERTY_NAME, "-1"); // cache forever
			} else {
				java.security.Security.setProperty(
						DNS_CACHE_TTL_PROPERTY_NAME, originalDNSCacheTTL);
			}
		}
	}
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public static InvoiceItemCollection all(Map<String, Object> params,
		String apiKey) throws AuthenticationException,
		InvalidRequestException, APIConnectionException, CardException,
		APIException {
	return request(RequestMethod.GET, classURL(InvoiceItem.class), params,
			InvoiceItemCollection.class, apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public InvoiceItem update(Map<String, Object> params, String apiKey)
		throws AuthenticationException, InvalidRequestException,
		APIConnectionException, CardException, APIException {
	return request(RequestMethod.POST,
			instanceURL(InvoiceItem.class, this.id), params,
			InvoiceItem.class, apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public CustomerCardCollection all(Map<String, Object> params,
    String apiKey) throws AuthenticationException,
    InvalidRequestException, APIConnectionException, CardException,
    APIException {
  String url = String.format("%s%s", Stripe.API_BASE, this.getURL());
  return request(RequestMethod.GET, url, params,
      CustomerCardCollection.class, apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public DeletedCard delete(String apiKey) throws AuthenticationException,
		InvalidRequestException, APIConnectionException, CardException,
		APIException {
	return request(RequestMethod.DELETE,
			this.getInstanceURL(), null, DeletedCard.class,
			apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public DeletedCoupon delete(String apiKey) throws AuthenticationException,
		InvalidRequestException, APIConnectionException, CardException,
		APIException {
	return request(RequestMethod.DELETE,
			instanceURL(Coupon.class, this.id), null, DeletedCoupon.class,
			apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public void deleteDiscount(String apiKey) throws AuthenticationException,
		InvalidRequestException, APIConnectionException, CardException,
		APIException {
	request(RequestMethod.DELETE,
			String.format("%s/discount",
					instanceURL(Customer.class, this.id)), null,
			Discount.class, apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public static CustomerCollection all(Map<String, Object> params,
		String apiKey) throws AuthenticationException,
		InvalidRequestException, APIConnectionException, CardException,
		APIException {
	return request(RequestMethod.GET, classURL(Customer.class), params,
			CustomerCollection.class, apiKey);
}
 

import com.stripe.exception.AuthenticationException; //导入依赖的package包/类
public Dispute updateDispute(Map<String, Object> params, String apiKey)
		throws AuthenticationException, InvalidRequestException,
		APIConnectionException, CardException, APIException {
	return request(
			RequestMethod.POST,
			String.format("%s/dispute", instanceURL(Charge.class, this.id)),
			params, Dispute.class, apiKey);
}