Exemplo n.º 1
0
  @Override
  public ValidationErrors validate(final StandaloneCatalog catalog, final ValidationErrors errors) {
    // Validation: check for nulls

    if (plan == null) {
      errors.add(
          new ValidationError(
              String.format("Invalid plan for recurring section"),
              catalog.getCatalogURI(),
              DefaultRecurring.class,
              ""));
    }

    if (phase == null) {
      errors.add(
          new ValidationError(
              String.format("Invalid phase for recurring section"),
              catalog.getCatalogURI(),
              DefaultPlan.class,
              plan.getName().toString()));
    }

    if (billingPeriod == null) {
      errors.add(
          new ValidationError(
              String.format(
                  "Recurring section of Phase %s of plan %s has a recurring price but no billing period",
                  phase.getPhaseType().toString(), plan.getName()),
              catalog.getCatalogURI(),
              DefaultPlanPhase.class,
              phase.getPhaseType().toString()));
    }

    // Validation: if there is a recurring price there must be a billing period
    if ((recurringPrice != null)
        && (billingPeriod == null || billingPeriod == BillingPeriod.NO_BILLING_PERIOD)) {
      errors.add(
          new ValidationError(
              String.format(
                  "Recurring section of Phase %s of plan %s has a recurring price but no billing period",
                  phase.getPhaseType().toString(), plan.getName()),
              catalog.getCatalogURI(),
              DefaultPlanPhase.class,
              phase.getPhaseType().toString()));
    }

    // Validation: if there is no recurring price there should be no billing period
    if ((recurringPrice == null) && billingPeriod != BillingPeriod.NO_BILLING_PERIOD) {
      errors.add(
          new ValidationError(
              String.format(
                  "Recurring section of Phase %s of plan %s has no recurring price but does have a billing period. The billing period should be set to '%s'",
                  phase.getPhaseType().toString(), plan.getName(), BillingPeriod.NO_BILLING_PERIOD),
              catalog.getCatalogURI(),
              DefaultPlanPhase.class,
              phase.getPhaseType().toString()));
    }
    return errors;
  }
Exemplo n.º 2
0
 /* (non-Javadoc)
  * @see org.killbill.billing.catalog.IPriceList#findPlan(org.killbill.billing.catalog.api.IProduct, org.killbill.billing.catalog.api.BillingPeriod)
  */
 @Override
 public Collection<Plan> findPlans(final Product product, final BillingPeriod period) {
   final List<Plan> result = new ArrayList<Plan>(plans.size());
   for (final Plan cur : getPlans()) {
     if (cur.getProduct().equals(product)
         && (cur.getRecurringBillingPeriod() != null
             && cur.getRecurringBillingPeriod().equals(period))) {
       result.add(cur);
     }
   }
   return result;
 }
  @Test(groups = "slow")
  public void testWithPriceOverride() throws Exception {

    // Create a per-tenant catalog with one plan
    final SimplePlanDescriptor desc1 =
        new DefaultSimplePlanDescriptor(
            "bar-monthly",
            "Bar",
            ProductCategory.BASE,
            account.getCurrency(),
            BigDecimal.TEN,
            BillingPeriod.MONTHLY,
            0,
            TimeUnit.UNLIMITED,
            ImmutableList.<String>of());
    catalogUserApi.addSimplePlan(desc1, init, testCallContext);
    StaticCatalog catalog = catalogUserApi.getCurrentCatalog("dummy", testCallContext);
    assertEquals(catalog.getCurrentPlans().size(), 1);

    final Plan plan = catalog.getCurrentPlans().iterator().next();
    final PlanPhaseSpecifier spec = new PlanPhaseSpecifier("bar-monthly", null);

    final List<PlanPhasePriceOverride> overrides = new ArrayList<PlanPhasePriceOverride>();
    overrides.add(
        new DefaultPlanPhasePriceOverride(
            plan.getFinalPhase().getName(), account.getCurrency(), null, BigDecimal.ONE));
    final Entitlement baseEntitlement = createEntitlement(spec, overrides, true);

    List<Invoice> invoices =
        invoiceUserApi.getInvoicesByAccount(account.getId(), false, testCallContext);
    assertEquals(invoices.size(), 1);
    assertEquals(invoices.get(0).getChargedAmount().compareTo(BigDecimal.ONE), 0);

    busHandler.pushExpectedEvents(NextEvent.INVOICE, NextEvent.INVOICE_PAYMENT, NextEvent.PAYMENT);
    clock.addMonths(1);
    assertListenerStatus();

    invoices = invoiceUserApi.getInvoicesByAccount(account.getId(), false, testCallContext);
    assertEquals(invoices.size(), 2);
    assertEquals(invoices.get(1).getChargedAmount().compareTo(BigDecimal.ONE), 0);

    // Change plan to original (non overridden plan)
    busHandler.pushExpectedEvents(
        NextEvent.CHANGE, NextEvent.INVOICE, NextEvent.INVOICE_PAYMENT, NextEvent.PAYMENT);
    baseEntitlement.changePlan(spec, null, ImmutableList.<PluginProperty>of(), testCallContext);
    assertListenerStatus();

    invoices = invoiceUserApi.getInvoicesByAccount(account.getId(), false, testCallContext);
    assertEquals(invoices.size(), 3);
    assertEquals(
        invoices.get(2).getChargedAmount().compareTo(new BigDecimal("9.00")),
        0); // 10 (recurring) - 1 (repair)
  }
  private void checkForTaxCodesOnProducts(
      final Invoice invoice,
      final Collection<PluginProperty> properties,
      final TenantContext context) {
    final Map<String, String> planToProductCache = new HashMap<String, String>();
    final Map<String, String> productToTaxCodeCache = new HashMap<String, String>();

    for (final InvoiceItem invoiceItem : invoice.getInvoiceItems()) {
      final String planName = invoiceItem.getPlanName();
      if (planName == null) {
        continue;
      }

      if (planToProductCache.get(planName) == null) {
        try {
          final StaticCatalog catalog =
              killbillAPI.getCatalogUserApi().getCurrentCatalog(null, context);
          final Plan plan = catalog.findCurrentPlan(planName);
          planToProductCache.put(planName, plan.getProduct().getName());
        } catch (final CatalogApiException e) {
          continue;
        }
      }
      final String productName = planToProductCache.get(planName);
      if (productName == null) {
        continue;
      }

      if (productToTaxCodeCache.get(productName) == null) {
        try {
          final String taxCode = dao.getTaxCode(productName, context.getTenantId());
          productToTaxCodeCache.put(productName, taxCode);
        } catch (final SQLException e) {
          continue;
        }
      }

      final String taxCode = productToTaxCodeCache.get(productName);
      if (taxCode != null) {
        addTaxCodeToInvoiceItem(
            invoiceItem.getId(), productToTaxCodeCache.get(productName), properties);
      }
    }
  }
  @Test(groups = "fast")
  public void testCalculateBCDForAOWithBPCancelledBundleAligned() throws Exception {
    final DateTimeZone accountTimeZone = DateTimeZone.UTC;
    final DateTime bpStartDateUTC = new DateTime(2012, 7, 16, 21, 0, 0, DateTimeZone.UTC);
    final int expectedBCDUTC = 16;

    // Create a Bundle associated with a subscription
    final SubscriptionBaseBundle bundle = Mockito.mock(SubscriptionBaseBundle.class);
    final SubscriptionBase subscription = Mockito.mock(SubscriptionBase.class);
    Mockito.when(subscription.getStartDate()).thenReturn(bpStartDateUTC);

    // subscription.getCurrentPlan() will return null as expected (cancelled BP)
    Mockito.when(
            subscriptionInternalApi.getBaseSubscription(
                Mockito.<UUID>any(), Mockito.<InternalTenantContext>any()))
        .thenReturn(subscription);

    // Create a the base plan associated with that subscription
    final Plan plan = Mockito.mock(Plan.class);
    Mockito.when(plan.dateOfFirstRecurringNonZeroCharge(bpStartDateUTC, null))
        .thenReturn(bpStartDateUTC);
    final Catalog catalog = Mockito.mock(Catalog.class);
    Mockito.when(
            catalog.findPlan(Mockito.anyString(), Mockito.<DateTime>any(), Mockito.<DateTime>any()))
        .thenReturn(plan);
    Mockito.when(subscription.getLastActivePlan()).thenReturn(plan);

    final Account account = Mockito.mock(Account.class);
    Mockito.when(account.getTimeZone()).thenReturn(accountTimeZone);
    final Integer billCycleDayLocal =
        billCycleDayCalculator.calculateBcdForAlignment(
            BillingAlignment.BUNDLE,
            bundle,
            subscription,
            account,
            catalog,
            null,
            internalCallContext);

    Assert.assertEquals(billCycleDayLocal, (Integer) expectedBCDUTC);
  }
  private void verifyBCDCalculation(
      final DateTimeZone accountTimeZone, final DateTime startDateUTC, final int bcdLocal)
      throws AccountApiException, CatalogApiException {
    final BillCycleDayCalculator billCycleDayCalculator =
        new BillCycleDayCalculator(
            Mockito.mock(CatalogService.class), Mockito.mock(SubscriptionBaseInternalApi.class));

    final SubscriptionBase subscription = Mockito.mock(SubscriptionBase.class);
    Mockito.when(subscription.getStartDate()).thenReturn(startDateUTC);

    final Plan plan = Mockito.mock(Plan.class);
    Mockito.when(plan.dateOfFirstRecurringNonZeroCharge(startDateUTC, null))
        .thenReturn(startDateUTC);

    final Account account = Mockito.mock(Account.class);
    Mockito.when(account.getTimeZone()).thenReturn(accountTimeZone);

    final Integer bcd =
        billCycleDayCalculator.calculateBcdFromSubscription(
            subscription, plan, account, Mockito.mock(Catalog.class), internalCallContext);
    Assert.assertEquals(bcd, (Integer) bcdLocal);
  }
  @Override
  public SubscriptionBase createSubscription(
      final UUID bundleId,
      final PlanPhaseSpecifier spec,
      final DateTime requestedDateWithMs,
      final InternalCallContext context)
      throws SubscriptionBaseApiException {
    try {
      final String realPriceList =
          (spec.getPriceListName() == null)
              ? PriceListSet.DEFAULT_PRICELIST_NAME
              : spec.getPriceListName();
      final DateTime now = clock.getUTCNow();
      final DateTime requestedDate =
          (requestedDateWithMs != null) ? DefaultClock.truncateMs(requestedDateWithMs) : now;
      if (requestedDate.isAfter(now)) {
        throw new SubscriptionBaseApiException(
            ErrorCode.SUB_INVALID_REQUESTED_DATE, now.toString(), requestedDate.toString());
      }
      final DateTime effectiveDate = requestedDate;

      final Catalog catalog = catalogService.getFullCatalog();
      final Plan plan =
          catalog.findPlan(
              spec.getProductName(), spec.getBillingPeriod(), realPriceList, requestedDate);

      final PlanPhase phase = plan.getAllPhases()[0];
      if (phase == null) {
        throw new SubscriptionBaseError(
            String.format(
                "No initial PlanPhase for Product %s, term %s and set %s does not exist in the catalog",
                spec.getProductName(), spec.getBillingPeriod().toString(), realPriceList));
      }

      final SubscriptionBaseBundle bundle = dao.getSubscriptionBundleFromId(bundleId, context);
      if (bundle == null) {
        throw new SubscriptionBaseApiException(ErrorCode.SUB_CREATE_NO_BUNDLE, bundleId);
      }

      DateTime bundleStartDate = null;
      final DefaultSubscriptionBase baseSubscription =
          (DefaultSubscriptionBase) dao.getBaseSubscription(bundleId, context);
      switch (plan.getProduct().getCategory()) {
        case BASE:
          if (baseSubscription != null) {
            if (baseSubscription.getState() == EntitlementState.ACTIVE) {
              throw new SubscriptionBaseApiException(ErrorCode.SUB_CREATE_BP_EXISTS, bundleId);
            }
          }
          bundleStartDate = requestedDate;
          break;
        case ADD_ON:
          if (baseSubscription == null) {
            throw new SubscriptionBaseApiException(ErrorCode.SUB_CREATE_NO_BP, bundleId);
          }
          if (effectiveDate.isBefore(baseSubscription.getStartDate())) {
            throw new SubscriptionBaseApiException(
                ErrorCode.SUB_INVALID_REQUESTED_DATE,
                effectiveDate.toString(),
                baseSubscription.getStartDate().toString());
          }
          addonUtils.checkAddonCreationRights(baseSubscription, plan);
          bundleStartDate = baseSubscription.getStartDate();
          break;
        case STANDALONE:
          if (baseSubscription != null) {
            throw new SubscriptionBaseApiException(ErrorCode.SUB_CREATE_BP_EXISTS, bundleId);
          }
          // Not really but we don't care, there is no alignment for STANDALONE subscriptions
          bundleStartDate = requestedDate;
          break;
        default:
          throw new SubscriptionBaseError(
              String.format(
                  "Can't create subscription of type %s",
                  plan.getProduct().getCategory().toString()));
      }

      final UUID tenantId =
          nonEntityDao.retrieveIdFromObject(context.getTenantRecordId(), ObjectType.TENANT);
      return apiService.createPlan(
          new SubscriptionBuilder()
              .setId(UUID.randomUUID())
              .setBundleId(bundleId)
              .setCategory(plan.getProduct().getCategory())
              .setBundleStartDate(bundleStartDate)
              .setAlignStartDate(effectiveDate),
          plan,
          spec.getPhaseType(),
          realPriceList,
          requestedDate,
          effectiveDate,
          now,
          context.toCallContext(tenantId));
    } catch (CatalogApiException e) {
      throw new SubscriptionBaseApiException(e);
    }
  }