Timvero SDK reference guide

@Entity
@Table
@Audited
@Indexed
public class Client extends AbstractAuditable<UUID> implements NamedEntity, HasDocuments {

    @Embedded
    @Valid
    private IndividualInfo individualInfo;

    @Embedded
    @Valid
    private ContactInfo contactInfo;

    // getters and setters...
}

public class ClientForm {

    @Valid
    @NotNull
    private IndividualInfoForm individualInfo;

    @Valid
    @NotNull
    private ContactInfoForm contactInfo;

    // getters and setters...
}

@Controller
public class ClientController extends EntityController<UUID, Client, ClientForm> {
    // Inherits all CRUD functionality automatically
}

@Controller
public class CreateClientAction extends EntityCreateController<UUID, Client, ClientForm> {
    @Override
    protected boolean isOwnPage() {
        return false;
    }
}

@Controller
public class EditClientAction extends EditEntityActionController<UUID, Client, ClientForm> {
    // Handles the edit button functionality
}

@Service
public class ClientFormService extends EntityFormService<Client, ClientForm, UUID> {
    // Inherits entity-form mapping and persistence operations
}

@Mapper
public interface ClientFormMapper extends EntityToFormMapper<Client, ClientForm> {
    // MapStruct automatically generates implementation for bidirectional mapping
}

<th:block th:insert="~{/form/components :: text(
    #{client.individualInfo.fullName},
    'individualInfo.fullName',
    'v-required v-name')}" />

<th:block th:insert="~{/form/components :: text(
    #{client.contactInfo.email},
    'contactInfo.email',
    'v-required v-email')}" />

User Input → Form Validation → Controller → Service → Mapper → Entity → Database
                     ↓
             Template Rendering ← Form Object ← Mapper ← Entity ← Database Query

public class ClientForm {
    @NotBlank
    @Size(min = 2, max = 100, message = "Name must be between 2 and 100 characters")
    private String fullName;

    @NotBlank
    @Email(message = "Please provide a valid email address")
    private String email;

    @NotBlank
    @Phone(message = "Please provide a valid phone number")
    private String phone;

    @PastOrPresent(message = "Birth date cannot be in the future")
    private LocalDate dateOfBirth;
}

@Component
public class ClientWelcomeChecker extends EntityChecker<Client> {

    @Override
    protected void registerListeners(CheckerListenerRegistry<Client> registry) {
        // Trigger when a new client is created
        registry.entityChange().inserted();
    }

    @Override
    protected boolean isAvailable(Client client) {
        // Only for clients with complete contact information
        return client.getContactInfo() != null
            && client.getContactInfo().getEmail() != null;
    }

    @Override
    protected void perform(Client client) {
        // Send welcome email to new clients
        emailService.sendWelcomeEmail(client);
        log.info("Welcome email sent to client: {}", client.getIndividualInfo().getFullName());
    }
}

// 1. Make Client support documents
@Entity
public class Client extends AbstractAuditable<UUID> implements HasDocuments {
    // Existing client implementation
}

// 2. Configure document types
@Configuration
public class ClientDocumentConfiguration {

    public static final EntityDocumentType ID_DOCUMENT = new EntityDocumentType("ID_DOCUMENT");
    public static final EntityDocumentType PROOF_OF_ADDRESS = new EntityDocumentType("PROOF_OF_ADDRESS");

    @Bean
    DocumentTypeAssociation<Client> clientRequiredDocuments() {
        return DocumentTypeAssociation.forEntityClass(Client.class)
            .required(ID_DOCUMENT)
            .required(PROOF_OF_ADDRESS)
            .build();
    }
}

// 3. Add document management tab
@Controller
@Order(1000)
public class ClientDocumentsTab extends EntityDocumentTabController<Client> {

    @Override
    public boolean isVisible(Client client) {
        return true; // Always show documents tab for clients
    }
}

// 1. Create a data source subject interface
public interface CreditCheckSubject {
    String getNationalId();
    String getFullName();
}

// 2. Implement the interface in your entity
@Entity
public class Client implements CreditCheckSubject {

    @Override
    public String getNationalId() {
        return getIndividualInfo().getNationalId();
    }

    @Override
    public String getFullName() {
        return getIndividualInfo().getFullName();
    }
}

// 3. Create the data source implementation
@Service("creditCheck")
public class CreditCheckDataSource implements MappedDataSource<CreditCheckSubject, CreditReport> {

    @Override
    public Class<CreditReport> getType() {
        return CreditReport.class;
    }

    @Override
    public Content getData(CreditCheckSubject subject) throws Exception {
        // Call external credit check API
        String response = creditCheckApi.checkCredit(
            subject.getNationalId(),
            subject.getFullName()
        );
        return new Content(response.getBytes(), MediaType.APPLICATION_JSON_VALUE);
    }

    @Override
    public CreditReport parseRecord(Content data) throws Exception {
        return objectMapper.readValue(data.getData(), CreditReport.class);
    }
}

@Entity
@Table
@Audited
@Indexed
public class Participant extends AbstractAuditable<UUID> implements NamedEntity, GithubDataSourceSubject, HasDocuments,
    ProcessEntity, DocusignSigner,
    HasPendingDecisions {

    public static final String DECISION_OWNER_TYPE = "PARTICIPANT";

    @Column(nullable = false)
    @Enumerated(value = EnumType.STRING)
    private ParticipantStatus status = ParticipantStatus.NEW;

    @ElementCollection(fetch = FetchType.EAGER)
    @Enumerated(EnumType.STRING)
    private Set<ParticipantRole> roles;

    @ManyToOne(fetch = EAGER)
    @JoinColumn(nullable = false, updatable = false)
    private Application application;

    @ManyToOne(fetch = EAGER)
    @JoinColumn(nullable = false, updatable = false)
    private Client client;

    @Column(nullable = false)
    @Enumerated(STRING)
    private Employment employment;

    @Column(nullable = false)
    @Enumerated(STRING)
    private Periodicity howOftenIncomeIsPaid;

    @Embedded
    private MonetaryAmount totalAnnualIncome;

    @Embedded
    private MonetaryAmount monthlyOutgoings;

    @Column
    private String githubUsername;
    // getters and setters...
}

public enum ParticipantStatus implements InEnum<ParticipantStatus> {
    NEW,
    IN_PROCESS,
    MANUAL_APPROVAL,
    APPROVED,
    DECLINED,
    VOID;

    public boolean isActive() {
        return !this.in(DECLINED, VOID);
    }
}

public enum Employment {

    EMPLOYED,
    HOMEMAKER,
    UNEMPLOYED,
    RETIRED,
    SELF_EMPLOYED

}

public enum Periodicity {

    MONTHLY,
    FORTNIGHTLY,
    WEEKLY,
    UNDEFINED

}

V{version}__{description}.sql

V250530170222__init.sql
V250609220043__participantStatus.sql

    create table participant (
        id uuid not null,
        created_at timestamp(6) with time zone not null,
        updated_at timestamp(6) with time zone not null,
        employment varchar(255) not null,
        how_often_income_is_paid varchar(255) not null,
        monthly_outgoings_currency varchar(3),
        monthly_outgoings_number numeric(19,2),
        total_annual_income_currency varchar(3),
        total_annual_income_number numeric(19,2),
        created_by uuid,
        updated_by uuid,
        -- Foreign key to application table
        application_id uuid not null,
        -- Foreign key to client table
        client_id uuid not null,
        primary key (id)
    );

    -- Foreign key constraints for participant table
    -- Links participant to their associated loan application
    alter table if exists participant 
       add constraint FKa8akyngsbkcpy4ev19q53x56h 
       foreign key (application_id) 
       references application;

    -- Links participant to their client profile containing personal information
    alter table if exists participant 
       add constraint FKcmejtugfqk653qthh0jalsx54 
       foreign key (client_id) 
       references client;

-- Migration: Add participant status functionality

-- Add status column to audit table (for historical tracking)
alter table if exists aud_participant 
   add column status varchar(255);

-- Add status column to main participant table
alter table if exists participant 
   add column status varchar(255);

-- Set default status for all existing participants
update participant set status = 'NEW';

-- Make status column mandatory after setting default values
alter table if exists participant 
   alter column status set not null;

@NotNull          // Field cannot be null
@NotBlank         // String field cannot be null, empty, or whitespace only
@Email            // Valid email format
@PastOrPresent    // Date must be in the past or present
@Valid            // Cascade validation to nested objects
@Phone            // Custom phone validation (platform-specific)

@Controller
public class CreateClientAction extends EntityCreateController<UUID, Client, ClientForm> {

    @Override
    protected boolean isOwnPage() {
        return false;
    }
}
@Controller
public class EditClientAction extends EditEntityActionController<UUID, Client, ClientForm> {

}

@Service
public class ClientFormService extends EntityFormService<Client, ClientForm, UUID> {

@Mapper
public interface ClientFormMapper extends EntityToFormMapper<Client, ClientForm> {
@Mapper(uses = ParticipantFormMapper.class)
public interface ApplicationFormMapper extends EntityToFormMapper<Application, ApplicationForm> {
@Mapper
public interface ParticipantFormMapper extends EntityToFormMapper<Participant, ParticipantForm> {

EditClientAction<UUID, Client, ClientForm>
    ↓
ClientFormService.prepareEditModel(UUID id)
    ↓
ClientFormMapper.entityToForm(Client entity)
    ↓
ClientForm (ready for template rendering)

CreateClientAction<UUID, Client, ClientForm>
    ↓
ClientFormService.save(ClientForm form)
    ↓
ClientFormMapper.formToEntity(ClientForm form)
    ↓
Client entity (persisted to database)

        <h2 class="form-group__title" th:text="#{client.clientInfo}">Personal
            Information</h2>
        <th:block
            th:insert="~{/form/components :: text(#{client.individualInfo.fullName},
                'individualInfo.fullName', 'v-required v-name')}"
            th:with="maxlength = 120" />
        <th:block
            th:insert="~{/form/components :: text(#{client.individualInfo.nationalId},
                'individualInfo.nationalId', 'v-required')}" />
        <th:block
            th:insert="~{/form/components :: date (#{client.individualInfo.birthDate},
                'individualInfo.dateOfBirth', '')}"
            th:with="maxDate = ${#dates.format(#dates.createNow())}" />
        <th:block
            th:insert="~{/form/components :: select(#{client.address.stateOfResidence},
                'individualInfo.residenceCountry', ${countries})}" />

        <h2 class="form-group__title" th:text="#{client.contactInfo}">Contact
            Information</h2>
        <th:block
            th:insert="~{/form/components :: text(#{client.contactInfo.email},
                'contactInfo.email', 'v-required v-email')}" />
        <th:block
            th:insert="~{/form/components :: text(#{client.contactInfo.phone},
                'contactInfo.phone', 'v-required v-phone')}" />

        <h2 th:text="#{application.borrowerInfo}">Borrower
            Information</h2>
        <th:block
            th:insert="~{/form/components :: select(#{participant.employment},
                'borrowerParticipant.employment', ${employmentTypes})}" />
        <th:block
            th:insert="~{/form/components :: select(#{participant.howOftenIncomeIsPaid},
                'borrowerParticipant.howOftenIncomeIsPaid', ${periodicities})}" />

        <h2 class="mt-10" th:text="#{participant.financialInfo}">Financial
            Information</h2>
        <th:block
            th:insert="~{/form/components :: amount(#{participant.totalAnnualIncome},
                'borrowerParticipant.totalAnnualIncome', 'v-required')}" />
        <th:block
            th:insert="~{/form/components :: amount(#{participant.monthlyOutgoings},
                'borrowerParticipant.monthlyOutgoings', '')}" />

// Armenian name validation (Armenian letters, spaces, hyphens only)
$.validator.addMethod('armenianName', function(value, element) {
  const ARMENIAN_NAME_REGEX = /^[\u0531-\u0556\u0561-\u0587\s\-']+$/;
  return this.optional(element) || ARMENIAN_NAME_REGEX.test(value);
});

// Tax identification number validation (Armenian format)
$.validator.addMethod('armenianTaxId', function(value, element) {
  const TAX_ID_REGEX = /^\d{8}$/;
  return this.optional(element) || TAX_ID_REGEX.test(value);
});

// Armenian postal code validation
$.validator.addMethod('armenianPostal', function(value, element) {
  const POSTAL_REGEX = /^\d{4}$/;
  return this.optional(element) || POSTAL_REGEX.test(value);
});

$.validator.addClassRules({
  'v-armenian-name': {armenianName: true, maxlength: 256},
  'v-armenian-tax-id': {armenianTaxId: true},
  'v-armenian-postal': {armenianPostal: true},
});

<!-- Required text field with name validation -->
<th:block th:insert="~{/form/components :: text(
  #{client.individualInfo.fullName},
  'individualInfo.fullName',
  'v-required v-name')}" />

<!-- Required email field -->
<th:block th:insert="~{/form/components :: text(
  #{client.contactInfo.email},
  'contactInfo.email',
  'v-required v-email')}" />

<!-- Required positive amount field -->
<th:block th:insert="~{/form/components :: amount(
  #{participant.totalAnnualIncome},
  'borrowerParticipant.totalAnnualIncome',
  'v-required v-positive')}" />

    public static final SignableDocumentType APPLICATION_CONTRACT =
        new SignableDocumentType("APPLICATION_CONTRACT", ApplicationContractDocumentCategory.TYPE);

package com.timvero.example.admin.participant.tab;

import com.timvero.example.admin.participant.entity.Participant;
import com.timvero.web.common.tab.EntityDocumentTabController;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Controller;

@Controller
@Order(1500)
public class ParticipantDocumentsTab extends EntityDocumentTabController<Participant> {

    @Override
    public boolean isVisible(Participant entity) {
        return true;
    }
}

public interface HasDocuments extends Persistable<UUID> {
    // No additional methods required
}

        new SignableDocumentType("APPLICATION_CONTRACT", ApplicationContractDocumentCategory.TYPE);

    public static final EntityDocumentType OTHER = new EntityDocumentType("OTHER");
    public static final EntityDocumentType ID_SCAN = new EntityDocumentType("ID_SCAN");

import java.util.UUID;
import org.springframework.stereotype.Component;

@Component
public class ApplicationContractDocumentCategory
    extends DocumentCategory<UUID, Participant, ContractDocumentModel> {

    public static final DocumentType TYPE = new DocumentType("APPLICATION_CONTRACT");

    @Override
    public DocumentType getType() {
        return TYPE;
    }

    @Override
    protected ContractDocumentModel getModel(Participant participant) {
        PaymentSchedule paymentSchedule = participant.getApplication().getPaymentSchedule();
        return new ContractDocumentModel(participant.getApplication(), paymentSchedule);
    }

    @Override
    protected boolean isSuitableTestEntity(Participant participant) {
        return participant.getStatus() == ParticipantStatus.APPROVED
            && participant.getApplication().getPaymentSchedule() != null;
    }

    public static class ContractDocumentModel extends DocumentModel {

        private Application application;
        private PaymentSchedule paymentSchedule;

        public ContractDocumentModel() {
        }

        public ContractDocumentModel(Application application, PaymentSchedule paymentSchedule) {
            this.application = application;
            this.paymentSchedule = paymentSchedule;
        }

        public Application getApplication() {
            return application;
        }

        public PaymentSchedule getPaymentSchedule() {
            return paymentSchedule;
        }

<h1>Loan Agreement</h1>

<p>Borrower: {{ application.client.individualInfo.firstName }} {{ application.client.individualInfo.lastName }}</p>
<p>Loan Amount: <strong>{{ application.requestedAmount }}</strong></p>

<h3>Payment Schedule</h3>
<table border="1">
    <tr><th>Payment Date</th><th>Amount</th></tr>
    {% for payment in paymentSchedule.payments.values %}
    <tr>
        <td>{{ payment.dueDate | date('yyyy-MM-dd') }}</td>
        <td>{{ payment.amount }}</td>
    </tr>
    {% endfor %}
</table>

{{ payment.dueDate | date('MMMM dd, yyyy') }}     // March 15, 2024
{{ payment.dueDate | date('yyyy-MM-dd') }}        // 2024-03-15

{{ amount | currency }}                           // $1,234.56
{{ interestRate | numberformat('#,##0.00%') }}    // 5.50%
{{ amount | numberformat('#,##0.00') }}           // 1,234.56

{{ client.name | upper }}                         // JOHN DOE
{{ client.name | lower }}                         // john doe
{{ client.name | title }}                         // John Doe

{% if application.status == 'APPROVED' %}
    This loan has been approved.
{% else %}
    This loan is pending review.
{% endif %}

{% for participant in participants %}
    {{ participant.role }}: {{ participant.client.displayName }}
{% endfor %}

public class ContractDocumentModel extends DocumentModel {

    // Format complex data for display
    public String getFormattedLoanTerm() {
        int months = application.getCondition().getTermInMonths();
        return months == 12 ? "1 year" : months + " months";
    }

    // Business logic for conditional content
    public boolean isHighRiskLoan() {
        return application.getCondition().getInterestRate() > 15.0;
    }

    // Computed properties
    public MonetaryAmount getMonthlyPayment() {
        return schedule.getPayments().values().stream()
            .findFirst()
            .map(PaymentSegment::getAmount)
            .orElse(MonetaryAmount.ZERO);
    }

    // Formatting helpers
    public String getClientFullName() {
        IndividualInfo info = application.getClient().getIndividualInfo();
        return info.getFirstName() + " " + info.getLastName();
    }

    // Status checks
    public boolean requiresAdditionalDocumentation() {
        return isHighValueLoan() || isHighRiskLoan();
    }
}

<h1>{{ contractType }} - {{ formattedLoanTerm }}</h1>
<p>Borrower: {{ clientFullName }}</p>
<p>Monthly Payment: {{ monthlyPayment | currency }}</p>

{% if highRiskLoan %}
    <div class="warning">
        <strong>High Risk Loan</strong> - Additional terms apply
    </div>
{% endif %}

{% if requiresAdditionalDocumentation %}
    <p><em>Additional documentation may be required.</em></p>
{% endif %}

// Document generation creates SignableDocument
SignableDocument document = documentService.generate(
    participant,
    APPLICATION_CONTRACT,
    templateId
);

// Document flows through signature process
// PENDING_SIGNATURE -> SIGNED -> contract complete

@RequestMapping("/sign")
@Controller
@Order(1000)
public class SignDocumentAction extends SimpleActionController<UUID, SignableDocument> {

    @Autowired
    private ParticipantRepository participantRepository;
    @Autowired
    private EntityDocumentService entityDocumentService;

    @Override
    protected EntityAction<SignableDocument, Object> action() {
        return when(d -> isRequiredDocAdded(d)
            && d.getStatus().in(SignatureStatus.PENDING_SIGNATURE)
            && d.getDocument() != null)

            .then((document, f, u) -> {
                Participant participant = participantRepository.getReferenceById(document.getOwnerId());

                // Create appropriate signature type
                PhysicalDocumentSignature signature = new PhysicalDocumentSignature();
                signature.setSigner(participant.getDisplayedName());
                signature.setEmail(participant.getClient().getContactInfo().getEmail());
                signature.setPhone(participant.getClient().getContactInfo().getPhone());

                document.setSignature(signature);
                document.setStatus(SignatureStatus.SIGNED);
            });
    }

    private boolean isRequiredDocAdded(SignableDocument d) {
        Participant participant = participantRepository.getReferenceById(d.getOwnerId());
        return entityDocumentService.requiredDocumentsAdded(participant);
    }
}

<div class="signature-section">
    <p>Borrower Signature:</p>
    <div class="signature-line">_________________________</div>
    <p>Date: {{ generationDate }}</p>

    {% if capturedSignature %}
        <p><strong>Signed by:</strong> {{ signerName }}</p>
        <p><strong>Signature Type:</strong> {{ capturedSignature.class.simpleName }}</p>
    {% endif %}
</div>

public class ContractDocumentModel extends DocumentModel {
    private LocalDate generationDate;

    public ContractDocumentModel(Application application) {
        this.generationDate = LocalDate.now(); // Captured at generation time
    }

    public String getGenerationDate() {
        return generationDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    }
}

@Component
public class LoanApprovedEvent extends NotificationEvent<Application, NotificationModel> {

    public static final NotificationEventType TYPE = new NotificationEventType("LOAN_APPROVED");

    @Override
    public NotificationEventType getType() {
        return TYPE;
    }

    public boolean notify(UUID applicationId) {
        return super.notify(applicationId, new NotificationModel());
    }

    @Override
    protected boolean isSuitableTestEntity(Application application) {
        return application.getStatus() == ApplicationStatus.SERVICING;

public class LoanDeclinedEvent extends NotificationEvent<Application, LoanDeclineTemplateModel> {

    public static final NotificationEventType TYPE = new NotificationEventType("LOAN_DECLINED");

    @Override
    public NotificationEventType getType() {
        return TYPE;
    }

    public boolean notify(UUID applicationId, DeclineReason declineReason, boolean reapplicationEligible) {
        LoanDeclineTemplateModel model = new LoanDeclineTemplateModel();
        model.setDeclineReason(declineReason);
        model.setReapplicationEligible(reapplicationEligible);
        return super.notify(applicationId, model);
    }

    @Override
    protected boolean isSuitableTestEntity(Application application) {

    private DeclineReason declineReason;
    private boolean reapplicationEligible;

    public DeclineReason getDeclineReason() {
        return declineReason;
    }

    public void setDeclineReason(DeclineReason declineReason) {
        this.declineReason = declineReason;
    }

    public boolean isReapplicationEligible() {
        return reapplicationEligible;
    }

    public void setReapplicationEligible(boolean reapplicationEligible) {
        this.reapplicationEligible = reapplicationEligible;
    }

    public Integer getReapplicationWaitDays() {
        return reapplicationEligible ? 30 : 180;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class PaymentReminderEvent extends NotificationEvent<ExampleCredit, PaymentReminderTemplateModel>
    implements EntityEventListener<CreditCalculationDateChangeEvent> {

    public static final NotificationEventType TYPE = new NotificationEventType("PAYMENT_REMINDER");

    private static final String DAYS_COUNT = "daysCount";
    private static final EventParameter DAYS_COUNT_PARAM = EventParameter.integerField("daysCount");

    @Autowired
    private PastDueOperationService pastDueService;

{{ application.createdAt | date('MMMM dd, yyyy') }}     // March 15, 2024
{{ expectedPaymentDate | date('yyyy-MM-dd') }}          // 2024-03-15

{{ application.requestedAmount | currency }}                    // $50,000.00
{{ application.condition.interestRate | numberformat('#,##0.00%') }}  // 5.50%

{{ application.id | slice(0, 8) | upper }}              // A1B2C3D4
{{ application.client.individualInfo.firstName | title }}  // John

{% if application.status == 'SERVICING' %}
    Your loan is now active.
{% else %}
    Your application is being processed.
{% endif %}

{% for document in application.documents %}
    Document: {{ document.name }}
{% endfor %}

public static final EventParameter DAYS_COUNT = EventParameter.integerField("daysCount");

public PaymentReminderEvent() {
    super(DAYS_COUNT);
}

@Override
protected boolean entityMatchesTemplate(ExampleCredit credit, PaymentReminderTemplateModel model,
                                      Map<String, Object> templateParams) {
    Integer daysCount = (Integer) templateParams.get("daysCount");
    model.setDaysCount(daysCount);

    if (daysCount < 0) {
        // Overdue reminder: check if credit is exactly |daysCount| days past due
        return pastDueService.daysPastDue(credit) == -daysCount;
    } else {
        // Upcoming reminder: check if payment is exactly daysCount days away
        return getNextPaymentDate(credit).equals(today.plusDays(daysCount));
    }
}

@Component
public class PaymentReminderEvent extends NotificationEvent<ExampleCredit, PaymentReminderTemplateModel>
    implements EntityEventListener<CreditCalculationDateChangeEvent> {

    public PaymentReminderEvent() {
        super(EventParameter.integerField("daysCount"));
    }

    @Override
    public void handle(CreditCalculationDateChangeEvent event) {
        notify(event.getCreditId(), new PaymentReminderTemplateModel());
    }

    @Override
    protected boolean entityMatchesTemplate(ExampleCredit credit, PaymentReminderTemplateModel model,
                                          Map<String, Object> templateParams) {
        Integer daysCount = (Integer) templateParams.get("daysCount");
        model.setDaysCount(daysCount);

        if (daysCount < 0) {
            // Overdue: check if exactly |daysCount| days past due
            return pastDueService.daysPastDue(credit) == -daysCount;
        } else {
            // Upcoming: check if payment is exactly daysCount days away
            return ChronoUnit.DAYS.between(today, nextPaymentDate) == daysCount;
        }
    }
}

@Component
public class ApplicationStatusNotificationChecker extends EntityChecker<UUID, Application> {

    @Autowired
    private LoanApprovedEvent loanApprovedEvent;

    @Autowired
    private LoanDeclinedEvent loanDeclinedEvent;

    @Override
    protected void registerListeners() {
        register(Application.class, EntityChangeEvent.Operation.UPDATE);
    }

    @Override
    protected boolean isAvailable(Application application) {
        return application.getStatus().in(ApplicationStatus.SERVICING, ApplicationStatus.DECLINE);
    }

    @Override
    protected void perform(Application application) {
        switch (application.getStatus()) {
            case SERVICING -> loanApprovedEvent.notify(application.getId());
            case DECLINE -> loanDeclinedEvent.notify(application.getId(),
                application.getDeclineReason(), true);
        }
    }
}

public interface NotificationGateway {
    NotificationGatewayType getType();
    String send(Notification notification) throws Exception;
    Map<String, NotificationStatus> check(Collection<String> messageIds) throws Exception;
}

@Component
public class TwilioSmsGateway extends AbstractSmsGateway {

    @Override
    protected String sendSms(String phone, String message) throws Exception {
        // Integrate with Twilio API
        Message twilioMessage = Message.creator(
            new PhoneNumber(phone),
            new PhoneNumber(fromPhoneNumber),
            message
        ).create();
        return twilioMessage.getSid();
    }

    @Override
    public Map<String, NotificationStatus> check(Collection<String> messageIds) throws Exception {
        // Check delivery status from Twilio
        return messageIds.stream().collect(Collectors.toMap(
            id -> id,
            id -> getDeliveryStatus(id)
        ));
    }
}

@Bean
@Profile("dev")
public NotificationGateway devEmailGateway(DocumentStorage documentStorage) {
    return new DevEmailGateway(documentStorage);
}

# messages.properties
notification.event.type.APP_STATUS_CHANGE=Application Status Change
notification.event.type.PAYMENT_REMINDER=Payment Reminder
notification.event.type.LOAN_APPROVED=Loan Approved
notification.event.type.LOAN_DECLINED=Loan Declined

# messages.properties
notification.event.APP_STATUS_CHANGE.status=Status
notification.event.PAYMENT_REMINDER.daysCount=Days Count
notification.event.LOAN_DECLINED.declineReason=Decline Reason

@Test
public void testLoanApprovalNotification() {
    // Create test application
    Application application = createTestApplication();
    application.setStatus(ApplicationStatus.SERVICING);

    // Test notification
    boolean sent = loanApprovedEvent.notify(application.getId());
    assertTrue(sent);
}

@Component
public class PaymentReminderScheduler {

    @Autowired
    private PaymentReminderEvent paymentReminderEvent;

    @Scheduled(cron = "0 0 9 * * ?") // Daily at 9 AM
    public void sendPaymentReminders() {
        // PaymentReminderEvent handles the business logic
        // Templates configured with different daysCount values will
        // automatically send appropriate reminders
        List<ExampleCredit> activeCredits = creditRepository.findActiveCredits();

        for (ExampleCredit credit : activeCredits) {
            paymentReminderEvent.notify(credit.getId());
        }
    }
}