Precommit

Overview

The Precommit plugin affords the opportunity to manipulate an entity immediately prior to committment. It can be triggered on entity creation, update, and validation.

The following entities can be updated via the Precommit plugin:

• Accounts

• Quotes

• Transactions

• Payments

• Disbursements

• Delinquencies

Plugin Execution

Assuming the appropriate override method for each supported entity has been implemented, upon a validation API request, the Precommit plugin will be executed and passed the following context:

• PreCommitTrigger

• Entity-specific Customer Object

The expected return value from each entity method will be a mutated version of that same entity.

Manual Execution

The plugin can also be invoked in an ad-hoc fashion for draft quotes (Precommit Quote) and for transactions in a draft or initialized state (Precommit Transaction).

Account

input: Account ( Customer Object ) + PreCommitTrigger <validate>

return: mutated Account

// Conditionally setting a value for the lastname of an account

@Override
public ConsumerAccount preCommit(ConsumerAccountRequest var1) {
ConsumerAccount original = var1.account();
    if ((original.data().lastName() == null || original.data().lastName().isBlank())
        && "Bruce".equals(var1.account().data().firstName())) {
      log.info("filling lastname for special account");
      return original.toBuilder()
          .data(original.data().toBuilder().lastName("Wayne").build())
          .build();
    }
    return original;
}

Quote

input: QuoteResponse ( Customer Object ) + PreCommitTrigger <validate>

return: mutated Quote

// Setting the coverage limit to a specific value based on the vehicle's usage
// type and year

@Override
public PersonalAutoQuote preCommit(PersonalAutoQuoteRequest var1) {
return var1.quote().toBuilder()
    .personalVehicles(
        var1.quote().personalVehicles().stream()
            .map(
                vehicleQuote -> {
                  if ("Work".equals(vehicleQuote.data().usage())
                      && vehicleQuote.data().year() < 2002) {
                    log.info(
                        "switching PAIncidentLimit to PA500_1000_200 for q {}",
                        vehicleQuote.locator());
                    return vehicleQuote.toBuilder()
                        .PAIncidentLimit(PAIncidentLimit.PA500_1000_200)
                        .build();
                  }
                  return vehicleQuote;
                })
            .toList())
    .build();
}

Transaction

input: PolicyResponse, TransactionResponse, List<ChangeInstructionHolder> and PreCommitTrigger <validate>

return: mutated List<ChangeInstructionHolder>

// Updating the transaction's change instructions

@Override
public PreCommitTransactionResponse preCommit(PersonalAutoTransactionRequest var1) {
  PreCommitTransactionResponseBuilder builder = PreCommitTransactionResponse.builder();
  if (var1.changeInstructions() != null) {
    builder.addChangeInstructions(var1.changeInstructions());
  }
  return builder.build();
}

Payment

input: Payment ( Customer Object, including ExternalCashTransaction details ) + PreCommitTrigger <validate>

return: mutated Payment ( including ExternalCashTransaction details )

// Updating the value of a payment field based on some condition

@Override
public StandardPayment Payment(StandardPaymentRequest req) {
  if ("to change".equals(req.payment().data().note())) {
    StandardPayment payment = req.payment();
    return payment.toBuilder()
        .data(payment.data().toBuilder().note("changed in pre-commit").build())
        .build();
  }
  return req.payment();
}

Disbursement

input: Disbursement ( Customer Object, including ExternalCashTransaction details ) + PreCommitTrigger <validate>

return: mutated Disbursement ( including ExternalCashTransaction details )

// Updating the value of a Disbursement field based on some condition

@Override
public StandardDisbursement preCommit(StandardDisbursementRequest req) {
  log.info("inside pre-commit for payment {} action {}", req.disbursement(), req.trigger());
  if ("to change".equals(req.disbursement().data().note())) {
    StandardDisbursement disbursement = req.disbursement();
    return disbursement.toBuilder()
        .data(disbursement.data().toBuilder().note("changed in pre-commit").build())
        .build();
  }
  return req.disbursement();
}

Delinquency

input: Delinquency - no trigger, because preCommit is always called when moving to inGrace state

return: mutated DelinquencySettings