Best code snippets using org.killbill.bus.api.PersistentBus(Showing top 20 results out of 315)

@Override
public void create(final AccountModelDao account, final InternalCallContext context) throws AccountApiException {
  super.create(account, context);
  try {
    final Long accountRecordId = getRecordId(account.getId(), context);
    final long tenantRecordId = context == null ? InternalCallContextFactory.INTERNAL_TENANT_RECORD_ID
                          : context.getTenantRecordId();
    eventBus.post(new DefaultAccountCreationEvent(new DefaultAccountData(account), account.getId(), accountRecordId, tenantRecordId, UUID.randomUUID()));
  } catch (final EventBusException ex) {
    Assert.fail(ex.toString());
  }
}

private void notifyBusOfRequestedChange(final EntitySqlDaoWrapperFactory entitySqlDaoWrapperFactory, final DefaultSubscriptionBase subscription,
                    final SubscriptionBaseEvent nextEvent, final SubscriptionBaseTransitionType transitionType, final InternalCallContext context) {
  try {
    eventBus.postFromTransaction(new DefaultRequestedSubscriptionEvent(subscription, nextEvent, transitionType, context.getAccountRecordId(), context.getTenantRecordId(), context.getUserToken()), entitySqlDaoWrapperFactory.getHandle().getConnection());
  } catch (final EventBusException e) {
    log.warn("Failed to post requested change event for subscriptionId='{}'", subscription.getId(), e);
  }
}

  @AfterMethod(groups = "slow")
  public void afterMethod() throws Exception {
    service.stop();
    bus.unregister(listener);
    bus.stop();
  }
}

@BeforeMethod(groups = "fast")
public void beforeMethod() throws Exception {
  bus.start();
  service.initialize();
  service.start();
}

  @AfterMethod(groups = "fast")
  public void afterMethod() throws Exception {
    bus.stop();
  }
}

private void notifyBusOfInvoiceAdjustment(final UUID invoiceId, final UUID accountId, final InternalCallContext context) {
  final DefaultInvoiceAdjustmentEvent event = new DefaultInvoiceAdjustmentEvent(invoiceId, accountId, context.getAccountRecordId(), context.getTenantRecordId(), context.getUserToken());
  try {
    eventBus.post(event);
  } catch (final EventBusException e) {
    log.warn("Failed to post event {}", event, e);
  }
}

@Override
public void createInvoice(final InvoiceModelDao invoice,
             final FutureAccountNotifications callbackDateTimePerSubscriptions, final InternalCallContext context) {
  synchronized (monitor) {
    storeInvoice(invoice, context);
  }
  try {
    eventBus.post(new DefaultInvoiceCreationEvent(invoice.getId(), invoice.getAccountId(),
                           InvoiceModelDaoHelper.getRawBalanceForRegularInvoice(invoice), invoice.getCurrency(),
                           context.getAccountRecordId(), context.getTenantRecordId(), context.getUserToken()));
  } catch (final PersistentBus.EventBusException ex) {
    throw new RuntimeException(ex);
  }
}

@BeforeMethod(groups = "slow")
public void beforeMethod() throws Exception {
  super.beforeMethod();
  cacheControllerDispatcher.clearAll();
  bus.start();
  bus.register(listener);
  service.loadConfig();
  service.initialize();
  service.start();
}

public void processSubscriptionForInvoiceNotification(final UUID subscriptionId, final LocalDate targetDate, final InternalCallContext context) throws InvoiceApiException {
  final Invoice dryRunInvoice = processSubscriptionInternal(subscriptionId, targetDate, true, context);
  if (dryRunInvoice != null && dryRunInvoice.getBalance().compareTo(BigDecimal.ZERO) > 0) {
    final InvoiceNotificationInternalEvent event = new DefaultInvoiceNotificationInternalEvent(dryRunInvoice.getAccountId(), dryRunInvoice.getBalance(), dryRunInvoice.getCurrency(),
                                                  context.toUTCDateTime(targetDate), context.getAccountRecordId(), context.getTenantRecordId(), context.getUserToken());
    try {
      eventBus.post(event);
    } catch (EventBusException e) {
      log.warn("Failed to post event {}", event, e);
    }
  }
}

private void notifyBusOfEffectiveImmediateChange(final DefaultSubscriptionBase subscription, final SubscriptionBaseEvent immediateEvent, final int seqId, final InternalCallContext context) {
  try {
    final SubscriptionBaseTransitionData transition = subscription.getTransitionFromEvent(immediateEvent, seqId);
    final BusEvent busEvent = new DefaultEffectiveSubscriptionEvent(transition,
                                    subscription.getAlignStartDate(),
                                    context.getUserToken(),
                                    context.getAccountRecordId(),
                                    context.getTenantRecordId());
    eventBus.post(busEvent);
  } catch (final EventBusException e) {
    log.warn("Failed to post effective event for subscription " + subscription.getId(), e);
  }
}

@Override
@BeforeMethod(groups = "slow")
public void beforeMethod() throws Exception {
  super.beforeMethod();
  // Reinitialize to restart the pool
  busService = new DefaultPersistentBus(getDBI(), clock, getPersistentBusConfig(), metricRegistry, databaseTransactionNotificationApi);
  testEventBusBase = new TestEventBusBase(busService);
  busService.start();
}

@Override
public void update(final AccountModelDao account, final InternalCallContext context) {
  super.update(account, context);
  final AccountModelDao currentAccount = getById(account.getId(), context);
  final Long accountRecordId = getRecordId(account.getId(), context);
  final long tenantRecordId = context == null ? InternalCallContextFactory.INTERNAL_TENANT_RECORD_ID
                        : context.getTenantRecordId();
  final AccountChangeInternalEvent changeEvent = new DefaultAccountChangeEvent(account.getId(), currentAccount, account,
                                         accountRecordId, tenantRecordId, UUID.randomUUID(),
                                         clock.getUTCNow());
  if (changeEvent.hasChanges()) {
    try {
      eventBus.post(changeEvent);
    } catch (final EventBusException ex) {
      Assert.fail(ex.toString());
    }
  }
}

  @AfterMethod(groups = "slow")
  public void afterMethod() throws Exception {
    bus.stop();
    stopInvoiceService(invoiceService);
  }
}

@Override
@BeforeMethod(groups = "slow")
public void beforeMethod() throws Exception {
  super.beforeMethod();
  controllerDispatcher.clearAll();
  bus.start();
  restartInvoiceService(invoiceService);
  clock.resetDeltaFromReality();
}

private void notifyBusOfInvoiceCreation(final EntitySqlDaoWrapperFactory entitySqlDaoWrapperFactory, final InvoiceModelDao invoice, final InternalCallContext context) {
  try {
    // This is called for a new COMMITTED invoice (which cannot be writtenOff as it does not exist yet, so rawBalance == balance)
    final BigDecimal rawBalance = InvoiceModelDaoHelper.getRawBalanceForRegularInvoice(invoice);
    final DefaultInvoiceCreationEvent event = new DefaultInvoiceCreationEvent(invoice.getId(), invoice.getAccountId(),
                                         rawBalance, invoice.getCurrency(),
                                         context.getAccountRecordId(), context.getTenantRecordId(),
                                         context.getUserToken());
    eventBus.postFromTransaction(event, entitySqlDaoWrapperFactory.getHandle().getConnection());
  } catch (final EventBusException e) {
    log.error(String.format("Failed to post invoice creation event %s for account %s", invoice.getAccountId()), e);
  }
}

@Override
protected void postBusEventFromTransaction(final AccountModelDao account, final AccountModelDao savedAccount, final ChangeType changeType,
                      final EntitySqlDaoWrapperFactory entitySqlDaoWrapperFactory, final InternalCallContext context) throws BillingExceptionBase {
  // This is only called for the create call (see update below)
  switch (changeType) {
    case INSERT:
      break;
    default:
      return;
  }
  final Long recordId = savedAccount.getRecordId();
  // We need to re-hydrate the callcontext with the account record id
  final InternalCallContext rehydratedContext = internalCallContextFactory.createInternalCallContext(savedAccount, recordId, context);
  final AccountCreationInternalEvent creationEvent = new DefaultAccountCreationEvent(new DefaultAccountData(savedAccount), savedAccount.getId(),
                                            rehydratedContext.getAccountRecordId(), rehydratedContext.getTenantRecordId(), rehydratedContext.getUserToken());
  try {
    eventBus.postFromTransaction(creationEvent, entitySqlDaoWrapperFactory.getHandle().getConnection());
  } catch (final EventBusException e) {
    log.warn("Failed to post account creation event for accountId='{}'", savedAccount.getId(), e);
  }
}

@Override
protected void postBusEventFromTransaction(final CustomFieldModelDao customField, final CustomFieldModelDao savedCustomField, final ChangeType changeType,
                      final EntitySqlDaoWrapperFactory entitySqlDaoWrapperFactory, final InternalCallContext context)
    throws BillingExceptionBase {
  BusInternalEvent customFieldEvent = null;
  switch (changeType) {
    case INSERT:
      customFieldEvent = new DefaultCustomFieldCreationEvent(customField.getId(), customField.getObjectId(), customField.getObjectType(),
                                  context.getAccountRecordId(), context.getTenantRecordId(), context.getUserToken());
      break;
    case DELETE:
      customFieldEvent = new DefaultCustomFieldDeletionEvent(customField.getId(), customField.getObjectId(), customField.getObjectType(),
                                  context.getAccountRecordId(), context.getTenantRecordId(), context.getUserToken());
      break;
    default:
      return;
  }
  try {
    bus.postFromTransaction(customFieldEvent, entitySqlDaoWrapperFactory.getHandle().getConnection());
  } catch (final PersistentBus.EventBusException e) {
    log.warn("Failed to post tag event for customFieldId='{}'", customField.getId().toString(), e);
  }
}

@BeforeMethod(groups = "load")
public void beforeMethod() throws Exception {
  super.beforeMethod();
  eventBus.start();
}

@AfterMethod(groups = "slow")
public void afterMethod() throws Exception {
  eventBus.unregister(eventsListener);
  eventBus.stop();
}

private void notifyBusOfEffectiveImmediateChange(final EntitySqlDaoWrapperFactory entitySqlDaoWrapperFactory, final DefaultSubscriptionBase subscription,
                         final SubscriptionBaseEvent immediateEvent, final int seqId, final InternalCallContext context) {
  try {
    final SubscriptionBaseTransitionData transition = subscription.getTransitionFromEvent(immediateEvent, seqId);
    if (transition != null) {
      final BusEvent busEvent = new DefaultEffectiveSubscriptionEvent(transition,
                                      subscription.getAlignStartDate(),
                                      context.getUserToken(),
                                      context.getAccountRecordId(),
                                      context.getTenantRecordId());
      eventBus.postFromTransaction(busEvent, entitySqlDaoWrapperFactory.getHandle().getConnection());
    }
  } catch (final EventBusException e) {
    log.warn("Failed to post effective event for subscriptionId='{}'", subscription.getId(), e);
  }
}