google-nomulus/java/google/registry/pricing/PricingEngineProxy.java
mcilwain ea24f6ca31 Use string keys for the multimap of pricing engines for TLDs
This is better than the previous way of using the canonical name of the class,
because the previous way did not allow for refactoring, and also required the
PremiumPricingEngine to live in the model package lest there be circular
dependencies, which does not seem ideal.

Note that, for reasons of backwards compatibility with existing persisted data,
the name of the static premium pricing engine has been set to its canonical
class name, but the class can now be refactored going forward so long as this
string remains unchanged, and any new pricing engine implementations can use
whatever string key they want (it doesn't have to be a canonical class name).

-------------
Created by MOE: https://github.com/google/moe
MOE_MIGRATED_REVID=129215185
2016-08-03 11:16:01 -04:00

63 lines
2.8 KiB
Java

// Copyright 2016 The Domain Registry Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package google.registry.pricing;
import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkState;
import static google.registry.util.DomainNameUtils.getTldFromDomainName;
import google.registry.model.pricing.PremiumPricingEngine;
import google.registry.model.pricing.PremiumPricingEngine.DomainPrices;
import google.registry.model.registry.Registry;
import java.util.Map;
import org.joda.money.Money;
import org.joda.time.DateTime;
/**
* A global proxy providing static methods for getting premium prices that dispatches requests
* correctly to the relevant {@link PremiumPricingEngine} implementation per TLD.
*/
public final class PricingEngineProxy {
private static final Map<String, PremiumPricingEngine>
premiumPricingEngines = DaggerPricingComponent.create().premiumPricingEngines();
/** Returns the billing cost for registering the specified domain name for this many years. */
public static Money getDomainCreateCost(String domainName, DateTime priceTime, int years) {
checkArgument(years > 0, "Number of years must be positive");
return getPricesForDomainName(domainName, priceTime).getCreateCost().multipliedBy(years);
}
/** Returns the billing cost for renewing the specified domain name for this many years. */
public static Money getDomainRenewCost(String domainName, DateTime priceTime, int years) {
checkArgument(years > 0, "Number of years must be positive");
return getPricesForDomainName(domainName, priceTime).getRenewCost().multipliedBy(years);
}
/**
* Returns the full {@link DomainPrices} details for the given domain name by dispatching to the
* appropriate {@link PremiumPricingEngine} based on what is configured for the TLD that the
* domain is under.
*/
public static DomainPrices getPricesForDomainName(String domainName, DateTime priceTime) {
String tld = getTldFromDomainName(domainName);
String clazz = Registry.get(tld).getPremiumPricingEngineClassName();
PremiumPricingEngine engine = premiumPricingEngines.get(clazz);
checkState(engine != null, "Could not load pricing engine %s for TLD %s", clazz, tld);
return engine.getDomainPrices(domainName, priceTime);
}
private PricingEngineProxy() {}
}