Java CurrencyUnit类代码示例

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
/** Returns a new update price for the pricer. */
public FeesAndCredits getUpdatePrice(Registry registry, String domainName, DateTime date)
    throws EppException {
  CurrencyUnit currency = registry.getCurrency();
  BaseFee feeOrCredit =
      Fee.create(Money.zero(registry.getCurrency()).getAmount(), FeeType.UPDATE);
  return customLogic.customizeUpdatePrice(
      UpdatePriceParameters.newBuilder()
          .setFeesAndCredits(
              new FeesAndCredits.Builder()
                  .setCurrency(currency)
                  .addFeeOrCredit(feeOrCredit)
                  .build())
          .setRegistry(registry)
          .setDomainName(InternetDomainName.from(domainName))
          .setAsOfDate(date)
          .build());
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
/**
 * Handles a transaction success response.
 *
 * @see <a href="https://developers.braintreepayments.com/reference/response/transaction/java#success">
 *     Braintree - Transaction - Success</a>
 * @see <a href="https://developers.braintreepayments.com/reference/general/statuses#transaction">
 *     Braintree - Statuses - Transaction</a>
 */
private Map<String, Object> handleSuccessResponse(Transaction transaction) {
  // XXX: Currency scaling: https://github.com/braintree/braintree_java/issues/33
  Money amount =
      Money.of(CurrencyUnit.of(transaction.getCurrencyIsoCode()),
          transaction.getAmount().stripTrailingZeros());
  logger.infofmt("Transaction for %s via %s %s with ID: %s",
      amount,
      transaction.getPaymentInstrumentType(),  // e.g. credit_card, paypal_account
      transaction.getStatus(),                 // e.g. SUBMITTED_FOR_SETTLEMENT
      transaction.getId());
  return JsonResponseHelper
      .create(SUCCESS, "Payment processed successfully", asList(
          ImmutableMap.of(
              "id", transaction.getId(),
              "formattedAmount", formatMoney(amount))));
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Override
void setCommandSpecificProperties(Registry.Builder builder) {
  // Pick up the currency from the create cost. Since all costs must be in one currency, and that
  // condition is enforced by the builder, it doesn't matter which cost we choose it from.
  CurrencyUnit currency = createBillingCost != null
      ? createBillingCost.getCurrencyUnit()
      : Registry.DEFAULT_CURRENCY;

  builder.setCurrency(currency);

  // If this is a non-default currency and the user hasn't specified an EAP fee schedule, set the
  // EAP fee schedule to a matching currency.
  if (!currency.equals(Registry.DEFAULT_CURRENCY) && eapFeeSchedule.isEmpty()) {
    builder.setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(currency)));
  }
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
  createTld("tld");
  Registrar theRegistrar = ofy().load()
      .type(Registrar.class)
      .parent(getCrossTldKey())
      .id("TheRegistrar").now();
  auctionCredit = persistResource(
      new RegistrarCredit.Builder()
          .setParent(theRegistrar)
          .setType(CreditType.AUCTION)
          .setCurrency(CurrencyUnit.USD)
          .setTld("tld")
          .setCreationTime(clock.nowUtc())
          .build());
  promoCredit = persistResource(
      new RegistrarCredit.Builder()
          .setParent(theRegistrar)
          .setType(CreditType.PROMOTION)
          .setCurrency(CurrencyUnit.USD)
          .setTld("tld")
          .setCreationTime(clock.nowUtc())
          .build());
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void testLoadBalance_oneCurrency_hasTwoEntriesWithSumAndZero() {
  RegistrarBillingEntry entry1 = new RegistrarBillingEntry.Builder()
      .setPrevious(null)
      .setParent(registrar)
      .setCreated(clock.nowUtc())
      .setDescription("USD Invoice for July")
      .setAmount(Money.parse("USD 10.00"))
      .build();
  clock.advanceBy(Duration.standardDays(30));
  RegistrarBillingEntry entry2 = new RegistrarBillingEntry.Builder()
      .setPrevious(entry1)
      .setParent(registrar)
      .setCreated(clock.nowUtc())
      .setDescription("USD Invoice for August")
      .setAmount(Money.parse("USD 23.00"))
      .build();
  persistSimpleResources(asList(entry1, entry2));
  Map<CurrencyUnit, Money> balance = RegistrarBillingUtils.loadBalance(registrar);
  assertThat(balance).hasSize(2);
  assertThat(balance).containsEntry(USD, Money.parse("USD 33.00"));
  assertThat(balance).containsEntry(JPY, Money.parse("JPY 0"));
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void testFailure_wrongCurrency_v06() throws Exception {
  setEppInput("domain_create_fee.xml", ImmutableMap.of("FEE_VERSION", "0.6"));
  persistResource(
      Registry.get("tld")
          .asBuilder()
          .setCurrency(CurrencyUnit.EUR)
          .setCreateBillingCost(Money.of(EUR, 13))
          .setRestoreBillingCost(Money.of(EUR, 11))
          .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
          .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
          .setServerStatusChangeBillingCost(Money.of(EUR, 19))
          .build());
  persistContactsAndHosts();
  EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
  assertAboutEppExceptions().that(thrown).marshalsToXml();
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void testFailure_wrongCurrency_v11() throws Exception {
  setEppInput("domain_create_fee.xml", ImmutableMap.of("FEE_VERSION", "0.11"));
  persistResource(
      Registry.get("tld")
          .asBuilder()
          .setCurrency(CurrencyUnit.EUR)
          .setCreateBillingCost(Money.of(EUR, 13))
          .setRestoreBillingCost(Money.of(EUR, 11))
          .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
          .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
          .setServerStatusChangeBillingCost(Money.of(EUR, 19))
          .build());
  persistContactsAndHosts();
  EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
  assertAboutEppExceptions().that(thrown).marshalsToXml();
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void testFailure_wrongCurrency_v12() throws Exception {
  setEppInput("domain_create_fee.xml", ImmutableMap.of("FEE_VERSION", "0.12"));
  persistResource(
      Registry.get("tld")
          .asBuilder()
          .setCurrency(CurrencyUnit.EUR)
          .setCreateBillingCost(Money.of(EUR, 13))
          .setRestoreBillingCost(Money.of(EUR, 11))
          .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
          .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
          .setServerStatusChangeBillingCost(Money.of(EUR, 19))
          .build());
  persistContactsAndHosts();
  EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
  assertAboutEppExceptions().that(thrown).marshalsToXml();
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void testFailure_wrongCurrency_v06() throws Exception {
  createTld("tld", TldState.LANDRUSH);
  setEppInput("domain_create_landrush_fee.xml", ImmutableMap.of("FEE_VERSION", "0.6"));
  persistResource(
      Registry.get("tld")
          .asBuilder()
          .setCurrency(CurrencyUnit.EUR)
          .setCreateBillingCost(Money.of(EUR, 13))
          .setRestoreBillingCost(Money.of(EUR, 11))
          .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
          .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
          .setServerStatusChangeBillingCost(Money.of(EUR, 19))
          .build());
  persistContactsAndHosts();
  clock.advanceOneMilli();
  EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
  assertAboutEppExceptions().that(thrown).marshalsToXml();
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void testFailure_wrongCurrency_v11() throws Exception {
  createTld("tld", TldState.LANDRUSH);
  setEppInput("domain_create_landrush_fee.xml", ImmutableMap.of("FEE_VERSION", "0.11"));
  persistResource(
      Registry.get("tld")
          .asBuilder()
          .setCurrency(CurrencyUnit.EUR)
          .setCreateBillingCost(Money.of(EUR, 13))
          .setRestoreBillingCost(Money.of(EUR, 11))
          .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
          .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
          .setServerStatusChangeBillingCost(Money.of(EUR, 19))
          .build());
  persistContactsAndHosts();
  clock.advanceOneMilli();
  EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
  assertAboutEppExceptions().that(thrown).marshalsToXml();
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void testFailure_wrongCurrency_v12() throws Exception {
  createTld("tld", TldState.LANDRUSH);
  setEppInput("domain_create_landrush_fee.xml", ImmutableMap.of("FEE_VERSION", "0.12"));
  persistResource(
      Registry.get("tld")
          .asBuilder()
          .setCurrency(CurrencyUnit.EUR)
          .setCreateBillingCost(Money.of(EUR, 13))
          .setRestoreBillingCost(Money.of(EUR, 11))
          .setRenewBillingCostTransitions(ImmutableSortedMap.of(START_OF_TIME, Money.of(EUR, 7)))
          .setEapFeeSchedule(ImmutableSortedMap.of(START_OF_TIME, Money.zero(EUR)))
          .setServerStatusChangeBillingCost(Money.of(EUR, 19))
          .build());
  persistContactsAndHosts();
  clock.advanceOneMilli();
  EppException thrown = expectThrows(CurrencyUnitMismatchException.class, this::runFlow);
  assertAboutEppExceptions().that(thrown).marshalsToXml();
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void testTokenGeneration() throws Exception {
  action.brainframe = "/doodle";
  action.accountIds =
      ImmutableMap.of(
          CurrencyUnit.USD, "sorrow",
          CurrencyUnit.JPY, "torment");
  String blanketsOfSadness = "our hearts are beating, but no one is breathing";
  when(clientTokenGateway.generate()).thenReturn(blanketsOfSadness);
  assertThat(action.handleJsonRequest(ImmutableMap.of()))
      .containsExactly(
          "status", "SUCCESS",
          "message", "Success",
          "results", asList(
              ImmutableMap.of(
                  "token", blanketsOfSadness,
                  "currencies", asList("USD", "JPY"),
                  "brainframe", "/doodle")));
  verify(customerSyncer).sync(eq(loadRegistrar("TheRegistrar")));
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void testSuccess_billingAccountMap() throws Exception {
  runCommandForced(
      "--name=blobio",
      "--password=some_password",
      "--registrar_type=REAL",
      "--iana_id=8",
      "--billing_account_map=USD=abc123,JPY=789xyz",
      "--passcode=01234",
      "[email protected]",
      "--street=\"123 Fake St\"",
      "--city Fakington",
      "--state MA",
      "--zip 00351",
      "--cc US",
      "clientz");

  Optional<Registrar> registrar = Registrar.loadByClientId("clientz");
  assertThat(registrar).isPresent();
  assertThat(registrar.get().getBillingAccountMap())
      .containsExactly(CurrencyUnit.USD, "abc123", CurrencyUnit.JPY, "789xyz");
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
@Test
public void testSuccess_billingAccountMap_onlyAppliesToRealRegistrar() throws Exception {
  createTlds("foo");

  runCommandForced(
      "--name=blobio",
      "--password=some_password",
      "--registrar_type=TEST",
      "--billing_account_map=JPY=789xyz",
      "--allowed_tlds=foo",
      "--passcode=01234",
      "[email protected]",
      "--street=\"123 Fake St\"",
      "--city Fakington",
      "--state MA",
      "--zip 00351",
      "--cc US",
      "clientz");

  Optional<Registrar> registrar = Registrar.loadByClientId("clientz");
  assertThat(registrar).isPresent();
  assertThat(registrar.get().getBillingAccountMap()).containsExactly(CurrencyUnit.JPY, "789xyz");
}
 

import org.joda.money.CurrencyUnit; //导入依赖的package包/类
/**
 * Creates a new expense item based on the contents of the data fields in
 * the user interface.
 * 
 * @return The new expense item.
 */
private ExpenseItem buildExpenseItem() {
	Money amount = Money.of(
			CurrencyUnit.of(currencySpinner.getSelectedItem().toString()),
			Float.parseFloat(amountField.getText().toString()),
			RoundingMode.HALF_UP);
	ExpenseItem item = new ExpenseItem(nameField.getText().toString(),
			descriptionField.getText().toString(), categorySpinner
					.getSelectedItem().toString(), amount,
			dateField.getDate());
	if (receiptFileUri != null) {
		item.setReceiptUri(receiptFileUri);
	}
	item.setIncomplete(incomplete);
	item.setLocation(expenseLocation);
	return item;
}