Codebase Analysis Tools (CAT) Report

• LONG METHOD
• COMPLEX CONDITIONAL
• LONG PARAMETER LIST

• LONG METHOD
• COMPLEX CONDITIONAL
• DEEP NESTING

• LONG METHOD
• COMPLEX CONDITIONAL
• DEEP NESTING
• FEATURE ENVY

• LONG METHOD
• COMPLEX CONDITIONAL
• FEATURE ENVY

• LONG METHOD
• COMPLEX CONDITIONAL
• DEEP NESTING

• LONG METHOD
• COMPLEX CONDITIONAL
• DUPLICATE CODE
• DEEP NESTING

• LONG METHOD
• COMPLEX CONDITIONAL
• DUPLICATE CODE
• MAGIC NUMBERS
• DEEP NESTING

• LONG METHOD
• COMPLEX CONDITIONAL
• DEEP NESTING

• LONG METHOD
• COMPLEX CONDITIONAL
• LONG PARAMETER LIST

• COMPLEX CONDITIONAL
• LONG METHOD

n/a

CREATE TABLE `m_currency` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `code` varchar(3) NOT NULL,
  `decimal_places` SMALLINT NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;

DDL of latest schema
- Minimum reference data required for deployment of platform

DROP TABLE IF EXISTS `acc_gl_account`;
CREATE TABLE `acc_gl_account` (
  `id` BIGINT NOT NULL AUTO_INCREMENT,
  `name` varchar(45) NOT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;

CREATE TABLE `risk_analysis` (
  `client_id` BIGINT NOT NULL,
  `proposed_loan_amount` decimal(19,6) DEFAULT NULL,
  ...
  CONSTRAINT `FK_risk_analysis_1` FOREIGN KEY (`client_id`) REFERENCES `m_client` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;

Given Liquibase is enabled with a default tenant
    Given Liquibase runs the very first time for the tenant store
    Given A previously Flyway migrated tenant store database on the latest version
    When The database migration process is executed
    Then The tenant store and the default tenant gets synced and then upgraded

CREATE DATABASE IF NOT EXISTS `fineract_tenants`;
CREATE DATABASE IF NOT EXISTS `fineract_default`;
GRANT ALL ON *.* TO 'root'@'%';

Its mandatory to have one selected currency so we default to US Dollar

CREATE TABLE `latam_extra_client_details` (
  `client_id` BIGINT NOT NULL,
  `Business Description` varchar(100) DEFAULT NULL,
  PRIMARY KEY (`client_id`),
  CONSTRAINT `FK_latam_extra_client_details` FOREIGN KEY (`client_id`) REFERENCES `m_client` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=UTF8MB4;

INSERT INTO interop_identifier (id, account_id, type, a_value, sub_value_or_type, created_by, created_on, modified_by, modified_on)
VALUES (NULL, @saving_acc_id, 'IBAN', @IBAN, NULL, 'operator', CURDATE(), 'operator',
        CURDATE());

INSERT INTO `m_permission`
(`grouping`,`code`,`entity_name`,`action_name`,`can_maker_checker`) VALUES
('special','ALL_FUNCTIONS',NULL,NULL,0),
('special','ALL_FUNCTIONS_READ',NULL,NULL,0),
('special', 'CHECKER_SUPER_USER', NULL, NULL, '0');

INSERT INTO `c_configuration`
(`name`, `enabled`)
VALUES
('maker-checker', 0);

truncate table stretchy_report;
INSERT INTO `stretchy_report` VALUES (1,'Client Listing','Table',NULL,'Client','select ... from m_office ...');
insert into m_permission(grouping, `code`, entity_name, action_name, can_maker_checker)
select 'report', concat('READ_', r.report_name), r.report_name, 'READ', false
from stretchy_report r;

Utils.escapeLiteral(null, literal, true).toString()

export FINERACT_HIKARI_PASSWORD=verysecret
./gradlew createDB -PdbName=fineract_tenants
java -Dloader.path=. -jar fineract-provider/build/libs/fineract-provider.jar

spring.datasource.hikari.driverClassName=${FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME:org.mariadb.jdbc.Driver}
spring.datasource.hikari.jdbcUrl=${FINERACT_HIKARI_JDBC_URL:jdbc:mariadb://localhost:3306/fineract_tenants}
spring.datasource.hikari.username=${FINERACT_HIKARI_USERNAME:root}
spring.datasource.hikari.password=${FINERACT_HIKARI_PASSWORD:mysql}
spring.datasource.hikari.minimumIdle=${FINERACT_HIKARI_MINIMUM_IDLE:3}

spring.datasource.hikari.driverClassName=org.mariadb.jdbc.Driver
spring.datasource.hikari.jdbcUrl=jdbc:mariadb://localhost:3306/fineract_tenants
spring.datasource.hikari.username=root
spring.datasource.hikari.password=[REDACTED]
spring.datasource.hikari.minimumIdle=3
spring.datasource.hikari.maximumPoolSize=10

      - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.postgresql.Driver
      - FINERACT_HIKARI_JDBC_URL=jdbc:postgresql://fineractpostgresql:5432/fineract_tenants
      - FINERACT_HIKARI_USERNAME=postgres
      - FINERACT_HIKARI_PASSWORD=REDACTED
      - FINERACT_HIKARI_AUTO_COMMIT=true

environment:
  - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.mariadb.jdbc.Driver
  - FINERACT_HIKARI_JDBC_URL=jdbc:mariadb://fineractmysql:3306/fineract_tenants
  - FINERACT_HIKARI_USERNAME=root
  - FINERACT_HIKARI_PASSWORD=[REDACTED]

environment:
  - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.mariadb.jdbc.Driver
  - FINERACT_HIKARI_JDBC_URL=jdbc:mariadb://fineractmysql:3306/fineract_tenants
  - FINERACT_HIKARI_USERNAME=root
  - FINERACT_HIKARI_PASSWORD=[REDACTED]

environment:
  - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.postgresql.Driver
  - FINERACT_HIKARI_JDBC_URL=jdbc:postgresql://fineractpostgresql:5432/fineract_tenants
  - FINERACT_HIKARI_USERNAME=postgres
  - FINERACT_HIKARI_PASSWORD=[REDACTED]

        - name: FINERACT_HIKARI_DRIVER_CLASS_NAME
          value: org.mariadb.jdbc.Driver
        - name: FINERACT_HIKARI_JDBC_URL
          value: jdbc:mariadb://fineractmysql:3306/fineract_tenants

      - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.postgresql.Driver
      - FINERACT_HIKARI_JDBC_URL=jdbc:postgresql://fineractpostgresql:5432/fineract_tenants
      - FINERACT_HIKARI_USERNAME=postgres
      - FINERACT_HIKARI_PASSWORD=[REDACTED]
      - FINERACT_HIKARI_AUTO_COMMIT=true

environment:
  - FINERACT_HIKARI_DRIVER_SOURCE_CLASS_NAME=org.postgresql.Driver
  - FINERACT_HIKARI_JDBC_URL=jdbc:postgresql://fineractpostgresql:5432/fineract_tenants
  - FINERACT_HIKARI_USERNAME=postgres
  - FINERACT_HIKARI_PASSWORD=[REDACTED]

new JobBuilder(AcmeJobName.ACME_NOOP_JOB.name(), jobRepository)

@Import({ FineractWebApplicationConfiguration.class, FineractLiquibaseOnlyApplicationConfiguration.class })

this.jdbcTemplate.query(sql, rm, finalObjectArray);

this.jdbcTemplate.query(sql, financialActivityAccountMapper, new Object[] {});

final StringBuilder sqlBuilder = new StringBuilder(600);
sqlBuilder.append("Insert Into m_trial_balance(office_id, account_id, Amount, entry_date, created_date,closing_balance) ")
        .append("Select je.office_id, je.account_id, SUM(CASE WHEN je.type_enum=1 THEN (-1) * je.amount ELSE je.amount END) ")
        .append("as Amount, Date(je.entry_date) as Entry_Date, je.transaction_date as Created_Date,sum(je.amount) as closing_balance ")
        .append("from acc_gl_journal_entry je WHERE je.transaction_date = ? ")
        .append("group by je.account_id, je.office_id, je.transaction_date, Date(je.entry_date)");
final int result = jdbcTemplate.update(sqlBuilder.toString(), tbGap);

this.jdbcTemplate.query(sql, rm, finalObjectArray);

final String sql = "select " + rm.schema() + " where journalEntry.id = ?";
return this.jdbcTemplate.queryForObject(sql, rm, glJournalEntryId);

this.jdbcTemplate.batchUpdate(sql, params);

final String sql = "select " + rm.schema() + " and product_id = ? and payment_type is null and mapping.charge_id is null";
final List<Map<String, Object>> listOfProductToGLAccountMaps = this.jdbcTemplate.query(sql, rm, new Object[] { PortfolioProductType.LOAN.getValue(), loanProductId });

this.jdbcTemplate.query(sql, mapper, formattedDate, formattedDate, formattedDate);

final String sql = "select " + resultSetExtractor.schema() + " and rule.id = ?";
final Map<Long, AccountingRuleData> extractedData = this.jdbcTemplate.query(sql, resultSetExtractor, new Object[] { accountingRuleId });

this.jdbcTemplate.query(sql, this.adHocRowMapper);

sql.append("select min(id) as min, max(id) as max, page, count(id) as count from ");
sql.append("  (select floor(((row_number() over(order by id))-1) / :pageSize) as page, t.* from ");
// ...
return namedParameterJdbcTemplate.query(sql.toString(), parameters, RetrieveAllNonClosedLoanIdServiceImpl::mapRow);

jdbcTemplate.batchUpdate("INSERT INTO m_loan_account_locks ... VALUES (?,?,?,?,?)", loanIds, loanIds.size(), (PreparedStatement ps, Long loanId) -> { ... });

select min(id) as min, max(id) as max, page, count(id) as count from (select floor(((row_number() over(order by id))-1) / :pageSize) as page, t.* from (select id from m_loan where loan_status_id in (:statusIds)...

Collection<AuditData> retrieveAuditEntries(SQLBuilder extraCriteria, boolean includeJson);

this.jdbcTemplate.query(sql, rm, extraCriteria.getArguments())

final String sql = "select " + this.accountNumberFormatMapper.schema() + " where anf.id = ?";
final AccountNumberFormatData accountNumberFormatData = this.jdbcTemplate.queryForObject(sql, this.accountNumberFormatMapper, new Object[] { id });

this.jdbcTemplate.query(sql, this.businessRuleMapper, searchType);

this.jdbcTemplate.query(sql, this.emailConfigurationRowMapper);

this.jdbcTemplate.query(sql, this.emailRowMapper, EmailMessageStatusType.PENDING.getValue());

final String sql = "select " + this.smsCampaignMapper.schema + " where sc.id = ? and sc.is_visible = ?";
return this.jdbcTemplate.queryForObject(sql, this.smsCampaignMapper, campaignId, isVisible);

final String sql = "select " + rm.schema() + "where c.code_name like ? and cv.is_active = true order by position";
return this.jdbcTemplate.query(sql, rm, new Object[] { code });

final String sql = "select " + rm.schema() + " where c.id = ?";
return this.jdbcTemplate.queryForObject(sql, rm, new Object[] { codeId });

final String sql = "SELECT es.name as name, es.id as id FROM c_external_service es where es.name='" + serviceNameToUse + "'";
final ExternalServicesData externalServicesData = this.jdbcTemplate.query(sql, resultSetExtractor);

final String sql = "SELECT esp.name, esp.value FROM c_external_service_properties esp inner join c_external_service es on esp.external_service_id = es.id where es.name = '" + ExternalServicesConstants.S3_SERVICE_NAME + "'";
final S3CredentialsData s3CredentialsData = this.jdbcTemplate.query(sql, resultSetExtractor, new Object[] {});

final List<GlobalConfigurationPropertyData> globalConfiguration = this.jdbcTemplate.query(sql, this.rm, survey ? new Object[] { DataTableApiConstant.CATEGORY_PPI } : new Object[] {});

assertEquals(MASTER_DB_JDBC_URL, hikariConfig.getJdbcUrl());

given(databaseStateVerifier.isFirstLiquibaseMigration(tenantStoreDataSource)).willReturn(true);

@Import({ HikariCpConfig.class, JdbcConfig.class })
@EnableConfigurationProperties({ ... LiquibaseProperties.class })

@Bean
public JdbcTemplate jdbcTemplate(RoutingDataSource dataSource) {
    return new JdbcTemplate(dataSource);
}

return new HikariDataSource(hikariConfig);

@Bean
public HikariConfig hikariConfig() {
    HikariConfig hc = new HikariConfig();
    hc.setJdbcUrl(environment.getProperty("fineract_tenants_url"));
    // ...
    return hc;
}

public static String toProtocol(DataSource dataSource) {
    try (Connection connection = dataSource.getConnection()) {
        String url = connection.getMetaData().getURL();
        return url.substring(0, url.indexOf("://"));
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

final Timestamp dateValue = rs.getTimestamp(columnName);

Enumeration<Driver> drivers = DriverManager.getDrivers();
while (drivers.hasMoreElements()) {
    Driver driver = drivers.nextElement();
    java.sql.DriverManager.deregisterDriver(driver);
}

final List<E> items = jt.query(sqlFetchRows, rowMapper, args);

public Object toJdbcValueImpl(@NotNull DatabaseType dialect, Object value) {
    return value == null ? null : (Boolean.TRUE.equals(value) ? 1 : 0);
}

return determineTargetDataSource().getConnection();

JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
Integer result = jdbcTemplate.queryForObject(format("SELECT COUNT(table_name) " + "FROM information_schema.tables ...", tableName), Integer.class);

rowset.beforeFirst();
while (rowset.next()) {
    indexes.add(new IndexDetail(rowset.getString(1)));
}

dataSource.getConnection().getMetaData().getURL()

boolean isTablePresent(DataSource dataSource, String tableName);

DatabaseType databaseType = DRIVER_MAPPING.get(driverClassName);

final JdbcTemplate jdbcTemplate = new JdbcTemplate(dataSource);
final String sql = "SELECT ... FROM INFORMATION_SCHEMA.COLUMNS ...";
final SqlRowSet columnDefinitions = jdbcTemplate.queryForRowSet(sql, new Object[] { tableName });

try (Connection connection = tenantSpecificDataSource.getConnection()) {
    String url = connection.getMetaData().getURL();
    log.debug("Established database connection with URL {}", url);
}

HikariConfig config = new HikariConfig();
config.setJdbcUrl(jdbcUrl);
config.setUsername(schemaUsername);
config.setPassword(databasePasswordEncryptor.decrypt(schemaPassword));
return hikariDataSourceFactory.create(config);

return new HikariDataSource(config);

DataSource retrieveDataSource();

HikariDataSource dataSource = new HikariDataSource();
dataSource.setUsername(tenantConnection.getSchemaUsername());
dataSource.setPassword(databasePasswordEncryptor.decrypt(tenantConnection.getSchemaPassword()));
dataSource.setJdbcUrl(tenantJdbcUrl);
return dataSource;

NamedParameterJdbcTemplate jdbcTemplate = new NamedParameterJdbcTemplate(dataSource);
Integer result = jdbcTemplate.queryForObject(
        "SELECT COUNT(script) FROM schema_version " + "WHERE version = :latestFlywayVersion "
                + "AND script = :latestFlywayScriptName " + "AND checksum = :latestFlywayScriptChecksum " + "AND success = 1",
        paramMap, Integer.class);

try (ResultSet rs = selectStatement.executeQuery("SELECT id, readonly_schema_password FROM tenant_server_connections...")) { ... updateStatement.execute(updateSql); }

JdbcConnection dbConn = (JdbcConnection) database.getConnection();
try (Statement selectStatement = dbConn.createStatement()) {
    try (ResultSet rs = selectStatement.executeQuery("SELECT id, schema_password FROM tenant_server_connections")) {
        // ...
        updateStatement.execute(updateSql);
    }
}

try (Liquibase liquibase = createLiquibase(getDataSource().getConnection())) {
    liquibase.changeLogSync(getContexts());
}

public ExtendedSpringLiquibaseBuilder withDataSource(DataSource dataSource) {
    this.dataSource = dataSource;
    return this;
}

return new ExtendedSpringLiquibaseBuilder(liquibaseProperties).withDataSource(dataSource)...

ExtendedSpringLiquibase liquibase = liquibaseFactory.create(tenantDataSource, TENANT_STORE_DB_CONTEXT, INITIAL_SWITCH_CONTEXT);
applyInitialLiquibase(tenantDataSource, liquibase, "tenant store",
        (ds) -> !databaseStateVerifier.isTenantStoreOnLatestUpgradableVersion(ds));

this.jdbcTemplate.queryForObject(sql, rm, new Object[] { tenantIdentifier });

public FineractPlatformTenant mapRow(final ResultSet rs, int rowNum) throws SQLException {
    final Long id = rs.getLong("id");
    final String tenantIdentifier = rs.getString("identifier");
    // ...
    return new FineractPlatformTenant(id, tenantIdentifier, name, timezoneId, connection);
}

this.jdbcTemplate.query(sql, rm, new Object[] { creditBureauId });

this.jdbcTemplate.query(sql, rm, new Object[] { id });

this.jdbcTemplate.query(sql, rm);

final String sql = "select " + rm.schema() + " order by id";
return this.jdbcTemplate.query(sql, rm);

this.jdbcTemplate.query(sql, rm);

jdbcTemplate.queryForRowSet(sql, params); // NOSONAR
...
this.namedParameterJdbcTemplate.update(registerDatatableSql, paramMap);

boolean buildDataQueryEmbedded(@NotNull EntityTables entityTable, @NotNull String datatable, ... @NotNull StringBuilder select, @NotNull StringBuilder from, @NotNull StringBuilder where ...)

final String sql = "select " + this.registerDataTableMapper.schema();
return this.jdbcTemplate.query(sql, this.registerDataTableMapper);

final SqlRowSet rs = this.jdbcTemplate.queryForRowSet(sql);

final SqlRowSet rs = this.jdbcTemplate.queryForRowSet(inputSqlWrapped, encodedName);

return new ReadWriteNonCoreDataServiceImpl(jdbcTemplate, databaseTypeResolver, ...)

final String sql = "select " + imageMapper.schema(entityType);
final ImageData imageData = this.jdbcTemplate.queryForObject(sql, imageMapper, entityId);

this.jdbcTemplate.query(sql, mapper, new Object[] { entityType, entityId });

this.jdbcTemplate.query(sql, mapper, new Object[] { relId, fromEntityId });

new StepBuilder(StepName.SEND_ASYNCHRONOUS_EVENTS_STEP.name(), jobRepository).tasklet(tasklet, transactionManager)

when(jdbcTemplate.queryForList(anyString(), eq(String.class))).thenReturn(configurations);

jdbcTemplate.queryForList("select me.type as type from m_external_event_configuration me", String.class)

DataSource tenantDataSource = tenantDataSourceFactory.create(tenant);
return new JdbcTemplate(tenantDataSource);

String sql = "select " + drm.schema() + " where cdr.id = ? ";
return this.jdbcTemplate.queryForObject(sql, drm, id);

final String groupingName = rs.getString("grouping");
final String entityName = rs.getString("entity_name");

final HookMapper rm = new HookMapper(jdbcTemplate);
final String sql = "select " + rm.schema() + " order by h.name";
return jdbcTemplate.query(sql, rm);

JobRepositoryFactoryBean factory = new JobRepositoryFactoryBean();
factory.setDataSource(routingDataSource);
factory.setTransactionManager(transactionManager);
factory.setIsolationLevelForCreate("ISOLATION_READ_COMMITTED");

MySQLMaxValueIncrementer mySQLMaxValueIncrementer = new MySQLMaxValueIncrementer(dataSource, incrementerName, incrementerColumnName);
mySQLMaxValueIncrementer.setUseNewConnection(true);
return mySQLMaxValueIncrementer;

final String insertSQL = "INSERT INTO batch_custom_job_parameters (parameter_json) VALUES (%s)"
        .formatted(databaseSpecificSQLGenerator.castJson(":jsonString"));
final String jsonString = gson.toJson(customJobParameters);
SqlParameterSource parameters = new MapSqlParameterSource("jsonString", jsonString);
namedParameterJdbcTemplate.update(insertSQL, parameters);

namedParameterJdbcTemplate.update("""
    UPDATE BATCH_JOB_EXECUTION
    SET STATUS = :status, START_TIME = null
    WHERE JOB_EXECUTION_ID = :jobExecutionId
""", Map.of("status", FAILED.name(), "jobExecutionId", stuckJobId));

NamedParameterJdbcTemplate namedParameterJdbcTemplate = jdbcTemplateFactory.createNamedParameterJdbcTemplate(tenant);
List<String> stuckJobNames = jobExecutionRepository.getStuckJobNames(namedParameterJdbcTemplate);

final String sql = detailMapper.schema() + " where job.id=?";
return this.jdbcTemplate.queryForObject(sql, detailMapper, new Object[] { jobId });

new StepBuilder(JobName.EXECUTE_DIRTY_JOBS.name(), jobRepository).tasklet(executeAllDirtyJobsTasklet, transactionManager)

jdbcTemplate.update(resetNPASqlBuilder.toString(), user.getId(), DateUtils.getOffsetDateTimeOfTenantWithMostPrecision());

this.jdbcTemplate.queryForObject(sql, mapper, new Object[] { name });

sqlStringBuilder.append("select " + sqlGenerator.calcFoundRows() + " ");
sqlStringBuilder.append(this.reportMailingJobRunHistoryMapper.reportMailingJobRunHistorySchema());
if (reportMailingJobId != null) {
    sqlStringBuilder.append(" where rmjrh.job_id = ? ");
    queryParameters.add(reportMailingJobId);
}

final String sql = "select " + mapper.reportMailingJobSchema() + " where rmj.id = ? and rmj.is_deleted = false";
return this.jdbcTemplate.queryForObject(sql, mapper, new Object[] { reportMailingJobId });

public EscapeSqlLiteralException(String message, SQLException e) {
    super(message, e);
}

this.jdbcTemplate.queryForObject(sql, rm, new Object[] { tenantIdentifier });

connection = this.jdbcTemplate.getDataSource().getConnection();
DatabaseMetaData dbMetaData = connection.getMetaData();
resultSet = dbMetaData.getColumns(null, null, entry.getKey(), null);

final String sql = "select " + this.smsRowMapper.schema() + " where smo.id = ?";
return this.jdbcTemplate.queryForObject(sql, this.smsRowMapper, new Object[] { resourceId });

StepExecution stepExecution = jobExplorer.getStepExecution(jobExecutionId, stepExecutionId);
// ...
jobRepository.update(stepExecution);

this.jdbcTemplate.queryForRowSet(sql, new Object[] { ppiName });

final String sql = "select application_table_name... from x_registered_table...";
final SqlRowSet rs = this.jdbcTemplate.queryForRowSet(sql);

return this.jdbcTemplate.queryForRowSet(sql, new Object[] { ppiName });

this.jdbcTemplate.query(sql, this.mixTaxonomyMapper);

this.jdbcTemplate.queryForObject(sqlString, rm);

this.jdbcTemplate.queryForObject(sql, this.namespaceMapper, new Object[] { id });

final SqlRowSet rs = this.jdbcTemplate.queryForRowSet(sql);

this.jdbcTemplate.query(sql, notificationMapperRow, appUserId);

this.jdbcTemplate.query(sql, rm, finalObjectArray);

this.jdbcTemplate.query(sql, this.currencyRowMapper);

this.jdbcTemplate.query(sqlBuilder.toString(), rm, new Object[] { hierarchySearchString });

final String sql = "select " + this.provisionCategoryRowMapper.schema() + " from m_provision_category pc order by pc.id";
return this.jdbcTemplate.query(sql, this.provisionCategoryRowMapper);

this.jdbcTemplate.query(sql, mapper);

this.jdbcTemplate.query(sql, LOOKUP_MAPPER, defaultOfficeId, hierarchy);

String sql = "select count(*) from m_cashiers c where c.staff_id = " + staffId ...;
int count = this.jdbcTemplate.queryForObject(sql, Integer.class);

this.jdbcTemplate.query(sql, this.lookupMapper, new Object[] { defaultOfficeId });

final String sql = " select " + rm.schema();
WorkingDaysData data = this.jdbcTemplate.queryForObject(sql, rm);

final String updateQuery = "UPDATE m_account_transfer_standing_instructions SET last_run_date = ? where id = ?";
jdbcTemplate.update(updateQuery, transactionDate, data.getId());

return new ExecuteStandingInstructionsTasklet(standingInstructionReadPlatformService, jdbcTemplate, sqlGenerator,
                accountTransfersWritePlatformService);

final StringBuilder sqlBuilder = new StringBuilder(200);
sqlBuilder.append("select " + sqlGenerator.calcFoundRows() + " ");
sqlBuilder.append(this.standingInstructionHistoryMapper.schema());
if (standingInstructionDTO.transferType() != null) {
    sqlBuilder.append(" and atd.transfer_type=? ");
    paramObj.add(standingInstructionDTO.transferType());
}
return this.paginationHelper.fetchPage(this.jdbcTemplate, sqlBuilder.toString(), finalObjectArray, this.standingInstructionHistoryMapper);

this.jdbcTemplate.query(sqlBuilder.toString(), this.standingInstructionMapper, status);

this.jdbcTemplate.queryForObject("select ... where aa.loan_account_id = ?", mapper, loanId, ...)

this.jdbcTemplate.queryForObject(sql, this.accountTransfersMapper, new Object[] { transferId });

accountData = this.jdbcTemplate.queryForObject(sql, this.loanAccountMapper, sqlParams);

this.jdbcTemplate.query(sql, rm, inputs);

final String sql = "select " + rm.schema() + " where client.id=?";
return this.jdbcTemplate.query(sql, rm, new Object[] { clientid });

this.jdbcTemplate.query(sql, rm, new Object[] { entity });

this.jdbcTemplate.queryForObject(sql, rm, new Object[] { calendarId, entityId, entityTypeId });

return this.jdbcTemplate.query(sql, rm, new Object[] { currencyCode }); // NOSONAR

final String sql = "select " + this.clientTransactionMapper.schema() + " where c.id = ? and tr.id= ?";
return this.jdbcTemplate.queryForObject(sql, this.clientTransactionMapper, clientId, transactionId);

this.jdbcTemplate.query(sql, rm, entity);

this.jdbcTemplate.query(sql, rm, clientId, hierarchySearchString);

this.jdbcTemplate.query(sql, rm, clientId);

this.jdbcTemplate.queryForObject(sql, rm, clientId, clientChargeId);

final String sql = "select " + this.membersOfGroupMapper.schema() + " where o.hierarchy like ? and pgc.group_id = ?";
return this.jdbcTemplate.query(sql, this.membersOfGroupMapper, hierarchySearchString, groupId);

this.jdbcTemplate.query(sql, rm, new Object[] { loanId });

this.namedParameterJdbcTemplate.query(mapper.collectionSheetSchema(false), namedParameters, mapper);

final String sql = "select " + rateMapper.schema() + " where rate.id = ?";
return this.jdbcTemplate.queryForObject(sql, rateMapper, new Object[] { floatingRateId });

this.jdbcTemplate.query(sql, rm);

sqlBuilder.append("g.id as id, g.account_no as accountNumber... from m_group g ");
// ...
final Long id = rs.getLong("id");

final String sql = "select " + rm.groupLevelSchema();
return this.jdbcTemplate.query(sql, rm);

this.jdbcTemplate.query(sqlBuilder.toString(), ALL_GROUP_TYPES_DATA_MAPPER, extraCriteria.getArguments());

this.jdbcTemplate.query(sql, this.centerMapper, new Object[] { centerId });

this.jdbcTemplate.query(sql, mapper, new Object[] { groupId });

this.jdbcTemplate.query(sql, this.chartSlabExtractor, new Object[] { chartId });

final String sql = "select " + CHART_ROW_MAPPER.schema() + " where irc.id = ?";
return this.jdbcTemplate.queryForObject(sql, CHART_ROW_MAPPER, chartId);

this.jdbcTemplate.query(con -> {
    PreparedStatement preparedStatement = con.prepareStatement(finalSql, ResultSet.TYPE_SCROLL_SENSITIVE,
            ResultSet.CONCUR_UPDATABLE);
    preparedStatement.setInt(1, AccountAssociationType.GUARANTOR_ACCOUNT_ASSOCIATION.getValue());
    preparedStatement.setLong(2, loanId);
    return preparedStatement;
}, rm);

new StepBuilder(JobName.APPLY_HOLIDAYS_TO_LOANS.name(), jobRepository)
        .tasklet(applyHolidaysToLoansTasklet, transactionManager).build();

jdbcTemplate.update("delete from m_loan_arrears_aging where loan_id=?", loanId);

Integer max = this.jdbcTemplate.queryForObject(sql, new Object[] { loanId }, Integer.class);

this.jdbcTemplate.query(sql, LOAN_RESCHEDULE_REQUEST_ROW_MAPPER, loanId);

final String sql = "select " + rm.loanChargePaidBySchema() + " where lcpd.loan_transaction_id = ?";
return this.jdbcTemplate.query(sql, rm, transactionId);

final String sql = "select " + rm.schema() + " and glim.id=?";
return this.jdbcTemplate.query(sql, rm, glimId);

final String sql = "select " + rm.loanSchema() + " where l.account_no=?";
return this.jdbcTemplate.queryForObject(sql, rm, loanAccountNumber);

this.jdbcTemplate.query(clientSql, staffClientMapper, loanOfficerId, ClientStatus.ACTIVE.getValue());

String repaymentUpdateSql = "UPDATE m_loan_repayment_schedule SET accrual_interest_derived=?, accrual_fee_charges_derived=?, "
        + "accrual_penalty_charges_derived=? WHERE  id=?";
this.jdbcTemplate.update(repaymentUpdateSql, totalAccInterest, totalAccFee, totalAccPenalty,
        scheduleAccrualData.getRepaymentScheduleId());

this.jdbcTemplate.update("DELETE FROM m_loan_arrears_aging WHERE loan_id=?", loan.getId());

final LoanChargeMapper rm = new LoanChargeMapper();
final String sql = "select " + rm.schema() + " where lc.id=? and lc.loan_id=?";
return this.jdbcTemplate.queryForObject(sql, rm, id, loanId);

final String sql = "Select " + extractor.schema() + " where pm.product_id=?";
final Map<Long, ProductMixData> productMixData = this.jdbcTemplate.query(sql, extractor, productId);

final String sql = "select " + rm.loanProductSchema() + " where lp.id = ?";
return this.jdbcTemplate.queryForObject(sql, rm, loanProductId);

this.jdbcTemplate.query(sql, rm, new Object[] { meetingId });

this.jdbcTemplate.queryForObject(sql, rm, new Object[] { meetingId, entityId, entityTypeId });

return this.jdbcTemplate.queryForObject(sql, rm, paramList.toArray());

this.jdbcTemplate.query(sql, rm, new Object[] { loanId });

jdbcTemplate.update("UPDATE m_adhoc SET last_run=? WHERE id=?", new Date(), adhoc.getId());

return new GenerateAdhocClientScheduleTasklet(adHocReadPlatformService, jdbcTemplate);

jdbcTemplate.update(insertSql + sb);

@Autowired
private JobRepository jobRepository;
@Autowired
private JdbcTemplate jdbcTemplate;

this.jdbcTemplate.query(sqlBuilder.toString(), depositProductMapper, depositAccountType.getValue());

sqlBuilder.append("select " + sqlGenerator.calcFoundRows() + " ");
sqlBuilder.append(this.mapper.schema());
sqlBuilder.append(" where tr.savings_account_id = ? ");
paramObj.add(savingsId);

this.jdbcTemplate.query(sql, this.savingsProductRowMapper, new Object[] { DepositAccountType.SAVINGS_DEPOSIT.getValue() });

this.jdbcTemplate.query(sql.toString(), this.chartExtractor, chartId);

final StringBuilder sqlBuilder = new StringBuilder(400);
sqlBuilder.append("select ");
sqlBuilder.append(depositAccountMapper.schema());
sqlBuilder.append(" where sa.deposit_type_enum = ? ");
return jdbcTemplate.query(sqlBuilder.toString(), depositAccountMapper, new Object[] { depositAccountType.getValue() });

this.jdbcTemplate.query(sql, rm, new Object[] { gsimId });

final String sql = "select " + rm.schema() + " where sc.id=? and sc.savings_account_id=?";
return this.jdbcTemplate.queryForObject(sql, rm, new Object[] { id, savingsAccountId });

final StringBuilder sqlBuilder = new StringBuilder("select " + this.savingAccountMapper.schema());
sqlBuilder.append(" where sa.client_id = ? and sa.status_enum = 300 ");
final Object[] queryParameters = new Object[] { clientId };
return this.jdbcTemplate.query(sqlBuilder.toString(), this.savingAccountMapper, queryParameters);

this.jdbcTemplate.batchUpdate(queryForJGLUpdate, paramsForGLInsertion);

List<SavingsAccountTransactionData> results = this.jdbcTemplate.query(query.toString(), tm, args);

public static void buildCondition(...) {
    where.append(operator.formatPlaceholder(sqlGenerator, definition, paramCount, alias));
    if (values != null) {
        params.addAll(values);
    }
}

return namedParameterJdbcTemplate.query(searchSchema(searchConditions), params, rm);

public SearchReadPlatformService searchReadPlatformService(NamedParameterJdbcTemplate namedParameterJdbcTemplate, ...) { return new SearchReadPlatformServiceImpl(namedParameterJdbcTemplate, ...); }

this.jdbcTemplate.query(sql.toString(), mapper, new Object[] { user.getId(), user.getId() });

this.jdbcTemplate.query(this.mapper.schema(), this.mapper, new Object[] { user.getId(), user.getId() });

this.jdbcTemplate.queryForObject(
        "select case when (count(*) > 0) then true else false end "
                + " from m_selfservice_user_client_mapping where client_id = ? and appuser_id = ?",
        Boolean.class, clientId, appUserId);

this.jdbcTemplate.queryForObject("select case when (count(*) > 0) then true else false end ...", Boolean.class, loanId, appUserId);

public AppuserLoansMapperReadService appuserLoansMapperReadService(JdbcTemplate jdbcTemplate) {
    return new AppuserLoansMapperReadServiceImpl(jdbcTemplate);
}

final String sql = "select count(id) from m_pocket_accounts_mapping mapping where pocket_id = ? and account_id = ? and account_type = ?";
int count = this.jdbcTemplate.queryForObject(sql, Integer.class, pocketId, accountId, accountType);

String sql = "select count(*) from m_client where account_no = ? ...";
int count = this.jdbcTemplate.queryForObject(sql, Integer.class, params);

this.jdbcTemplate.queryForObject("select case when (count(*) > 0) then true else false end ...", Boolean.class, savingsId, appUserId);

public AppuserSavingsMapperReadService appuserSavingsMapperReadService(JdbcTemplate jdbcTemplate) {
    return new AppuserSavingsMapperReadServiceImpl(jdbcTemplate);
}

this.jdbcTemplate.queryForObject("select case when (count(*) > 0) then true else false end ...", Boolean.class, accountId, appUserId);

this.jdbcTemplate.query(sqlBuilder.toString(), rm, new Object[] { accountId });

this.jdbcTemplate.query(sql, mapper, new Object[] { accountId });

sb.append("select ");
 sb.append(" sadd.id as id, ");
 sb.append(" sa.savings_account_id as savingsAccountId ");
 sb.append(" from m_share_account_dividend_details sadd");
 // ... joins ...
 return this.jdbcTemplate.queryForList(sb.toString(), ...);

String query = "select " + mapper.schema() + "where sa.id=?";
ShareAccountData data = (ShareAccountData) this.jdbcTemplate.queryForObject(query, mapper, id);

final StringBuilder sqlBuilder = new StringBuilder(200);
sqlBuilder.append("select " + sqlGenerator.calcFoundRows() + " ");
sqlBuilder.append(shareProductDividendMapper.schema());
sqlBuilder.append(" where sp.id = ? ");
// ...
return this.paginationHelper.fetchPage(this.jdbcTemplate, sqlBuilder.toString(), paramsObj, shareProductDividendMapper);

final String sql = "select " + mapper.schema() + " where shareproduct.id = ?";
ShareProductData data = (ShareProductData) this.jdbcTemplate.queryForObject(sql, mapper, new Object[] { productId });

String sql = "select " + TAX_COMPONENT_MAPPER.getSchema();
return this.jdbcTemplate.query(sql, TAX_COMPONENT_MAPPER);

this.jdbcTemplate.query(sql, scm, new Object[] { surveyId });

this.jdbcTemplate.query(sql, this.roleRowMapper);

return this.jdbcTemplate.query(sql, mapper, new Object[] {});

final String sql = "select " + mapper.schema();
return this.jdbcTemplate.query(sql, mapper, new Object[] { hierarchySearchString });

this.jdbcTemplate.query(sql, this.passwordValidationPolicyMapper);

implementation ('org.springframework.boot:spring-boot-starter-data-jpa') {
    exclude group: 'org.hibernate'
}
implementation('org.eclipse.persistence:org.eclipse.persistence.jpa') {
    exclude group: 'org.eclipse.persistence', module: 'jakarta.persistence'
}
// ...
implementation 'com.google.cloud.sql:mysql-socket-factory-connector-j-8'

implementation ('org.springframework.boot:spring-boot-starter-data-jpa') {
    exclude group: 'org.hibernate'
}
implementation('org.eclipse.persistence:org.eclipse.persistence.jpa') {
    exclude group: 'org.eclipse.persistence', module: 'jakarta.persistence'
}

implementation ('org.springframework.boot:spring-boot-starter-data-jpa') {
    exclude group: 'org.hibernate'
}
implementation('org.eclipse.persistence:org.eclipse.persistence.jpa')

@Entity
@Table(name = "acc_gl_closure", uniqueConstraints = {
        @UniqueConstraint(columnNames = { "office_id", "closing_date" }, name = "office_id_closing_date") })
public class GLClosure extends AbstractAuditableCustom {

@Entity
@Table(name = "acc_gl_financial_activity_account")
public class FinancialActivityAccount extends AbstractPersistableCustom {

@Entity
@Table(name = "m_trial_balance")
public class TrialBalance extends AbstractPersistableCustom {

@Entity
@Table(name = "acc_gl_account", uniqueConstraints = { @UniqueConstraint(columnNames = { "gl_code" }, name = "acc_gl_code") })
public class GLAccount extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "acc_gl_journal_entry")
public class JournalEntry extends AbstractAuditableWithUTCDateTimeCustom {

@Entity
@Table(name = "acc_product_mapping", uniqueConstraints = { @UniqueConstraint(columnNames = { "product_id", "product_type",
        "financial_account_type", "payment_type" }, name = "financial_action") })
public class ProductToGLAccountMapping extends AbstractPersistableCustom { ... }

this.loanProductToGLAccountMappingHelper.saveLoanToAssetOrLiabilityAccountMapping(element, LoanProductAccountingParams.FUND_SOURCE.getValue(), loanProductId, CashAccountsForLoan.FUND_SOURCE.getValue());

@Entity
@Table(name = "m_provisioning_history")
public class ProvisioningEntry extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_loanproduct_provisioning_entry")
public class LoanProductProvisioningEntry extends AbstractPersistableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "history_id", referencedColumnName = "id", nullable = false)
    private ProvisioningEntry entry;

@Entity
@Table(name = "acc_rule_tags"...)
public class AccountingTagRule extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "acc_accounting_rule", uniqueConstraints = {
        @UniqueConstraint(columnNames = { "name" }, name = "accounting_rule_name_unique") })
public class AccountingRule extends AbstractPersistableCustom {

@Entity
@Table(name = "m_adhoc")
public class AdHoc extends AbstractAuditableCustom {

return transactionTemplate.execute(status -> {
    BatchRequestContextHolder.setEnclosingTransaction(Optional.of(status));
    try {
        responseList.addAll(request.get());
        return responseList;
    } catch (BatchExecutionException ex) {
        status.setRollbackOnly();
        return List.of(buildErrorResponse(ex.getCause(), ex.getRequest()));
    } catch (RuntimeException ex) {
        status.setRollbackOnly();
        return buildErrorResponses(ex, responseList);
    }
});

@Entity
@Table(name = "m_loan_account_locks")
public class LoanAccountLock {
    @Id
    @Column(name = "loan_id", nullable = false)
    private Long loanId;
...

@Entity
@Table(name = "m_batch_business_steps")
public class BatchBusinessStep extends AbstractPersistableCustom {
    @Column(name = "job_name", nullable = false)
    private String jobName;
}

entityManager.createNativeQuery(sql).executeUpdate();

S reload(S input);

@Entity
@Table(name = "m_portfolio_command_source")
public class CommandSource extends AbstractPersistableCustom {
    @Column(name = "action_name", nullable = true, length = 100)
    private String actionName;
    // ...

@Entity
    @Table(name = "m_portfolio_command_source")
    public static class DummyCommandSource extends CommandSource {

@Entity
@Table(name = AccountNumberFormatConstants.ACCOUNT_NUMBER_FORMAT_TABLE_NAME...)
public class AccountNumberFormat extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_import_document")
public class ImportDocument extends AbstractPersistableCustom {
    @OneToOne
    @JoinColumn(name = "document_id")
    private Document document;
    // ...

@Entity
@Table(name = "m_business_date", uniqueConstraints = { @UniqueConstraint(name = "uq_business_date_type", columnNames = { "type" }) })
public class BusinessDate extends AbstractAuditableWithUTCDateTimeCustom { ... }

@Entity
@Table(name = "c_cache")
public class PlatformCache extends AbstractPersistableCustom {
    @Column(name = "cache_type_enum")
    private Integer cacheType;

@Transactional
@Override
public Map<String, Object> switchToCache(final CacheType toCacheType) {
    // ...
    if (!changes.isEmpty()) {
        this.configurationDomainService.updateCache(toCacheType);
    }
    return changes;
}

@Entity
@Table(name = "scheduled_email_configuration")
public class EmailConfiguration extends AbstractPersistableCustom {
    @Column(name = "name", nullable = false)
    private String name;
}

@Entity
@Table(name = "scheduled_email_campaign")
public class EmailCampaign extends AbstractPersistableCustom {
    @Column(name = "campaign_name", nullable = false)
    private String campaignName;
    ...

@Entity
@Table(name = "scheduled_email_messages_outbound")
public class EmailMessage extends AbstractPersistableCustom { ... }

@Transactional
@Override
public CommandProcessingResult processCommand(JsonCommand command) {
    return this.emailCampaignWritePlatformService.delete(command.entityId());
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.delete(command.entityId());
    }

@Entity
@Table(name = "sms_campaign", uniqueConstraints = { @UniqueConstraint(columnNames = { "campaign_name" }, name = "campaign_name_UNIQUE") })
public class SmsCampaign extends AbstractPersistableCustom {

@Entity
@Table(name = "m_code", uniqueConstraints = { @UniqueConstraint(columnNames = { "code_name" }, name = "code_name") })
public class Code extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_code_value", uniqueConstraints = {
        @UniqueConstraint(columnNames = { "code_id", "code_value" }, name = "code_value_duplicate") })
public class CodeValue extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "c_configuration")
public class GlobalConfigurationProperty extends AbstractPersistableCustom {
    @Column(name = "name", nullable = false)
    private String name;
}

@Entity
@Table(name = "c_external_service", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "name_UNIQUE") })
public class ExternalService extends AbstractPersistableCustom {

@Column(name = "external_service_id")
private Long externalServiceId;

@Entity
@Table(name = "c_external_service_properties")
public class ExternalServicesProperties {
    @EmbeddedId
    ExternalServicePropertiesPK externalServicePropertiesPK;
    @Column(name = "value", length = 250)
    private String value;

return factoryBuilder.dataSource(getDataSource()).properties(vendorProperties).persistenceUnit("jpa-pu").packages(packagesToScan).jta(false).build();

default Map<String, Object> additionalVendorProperties() {
    return Collections.emptyMap();
}

public abstract class GenericEnumListConverter<E extends Enum<E>> implements AttributeConverter<List<E>, String> { ... return valueStream.map(Enum::name).collect(Collectors.joining(SPLIT_CHAR)); }

EntityManagerFactory emf = applicationContext.getBean(EntityManagerFactory.class);
return (EntityManagerImpl) EntityManagerFactoryUtils.getTransactionalEntityManager(emf);

return Map.of("eclipselink.logging.level.sql", SessionLog.FINE_LABEL, PersistenceUnitProperties.LOGGING_PARAMETERS, Boolean.TRUE.toString());

@Column(name = "createdby_id")
private Long createdBy;

@Override
public String convertToDatabaseColumn(ExternalId externalId) {
    return externalId != null ? externalId.getValue() : null;
}

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@Column(name = CREATED_BY_DB_FIELD, nullable = false)
@Setter(onMethod = @__(@Override))
private Long createdBy;

CriteriaBuilder builder = entityManager.getCriteriaBuilder();
CriteriaQuery<Long> query = builder.createQuery(Long.class);
Root<S> root = query.from(domainClass);

EntityManager entityManager = getCurrentEntityManager();
if (entityManager != null) {
    entityManager.setFlushMode(FlushModeType.COMMIT);
}

pui.addProperty(PersistenceUnitProperties.TARGET_DATABASE, targetDatabase);

@Entity
@Table(name = "m_creditbureau_token")
public class CreditBureauToken extends AbstractPersistableCustom {
    @Column(name = "token")
    private String accessToken;
}

@Entity
@Table(name = "m_creditbureau_configuration")
public class CreditBureauConfiguration extends AbstractPersistableCustom {
    @Column(name = "configkey")
    private String configurationKey;
    // ...
}

@Entity
@Table(name = "m_creditbureau")
public class CreditBureau extends AbstractPersistableCustom {

@Entity
@Table(name = "m_creditbureau_loanproduct_mapping")
public class CreditBureauLoanProductMapping extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_creditreport")
public class CreditReport extends AbstractPersistableCustom {
    @Column(name = "credit_bureau_id")
    private Long creditBureauId;
}

@Entity
@Table(name = "m_organisation_creditbureau")
public class OrganisationCreditBureau extends AbstractPersistableCustom {

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writePlatformService.updateCreditBureauConfiguration(command.entityId(), command);
    }

@Entity
@Table(name = "m_entity_datatable_check")
public class EntityDatatableChecks extends AbstractPersistableCustom {
    @Column(name = "application_table_name", nullable = false)
    private String entity;

@Entity
@Table(name = "x_registered_table")
public class RegisteredDatatable extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "stretchy_report", uniqueConstraints = { @UniqueConstraint(columnNames = { "report_name" }, name = "unq_report_name") })
public final class Report extends AbstractPersistableCustom {

@Entity
@Table(name = "stretchy_parameter")
public class ReportParameter extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "stretchy_report_parameter")
public final class ReportParameterUsage extends AbstractPersistableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "report_id", nullable = false)
    private Report report;

@Entity
@Table(name = "m_image")
public final class Image extends AbstractPersistableCustom {

@Entity
@Table(name = "m_document")
public class Document extends AbstractPersistableCustom {
    @Column(name = "name", length = 250)
    private String name;
}

@Entity
@Table(name = "m_entity_to_entity_access")
public class FineractEntityAccess extends AbstractPersistableCustom {

@Entity
@Table(name = "m_entity_relation")
public class FineractEntityRelation extends AbstractPersistableCustom {

@Entity
@Table(name = "m_entity_to_entity_mapping", uniqueConstraints = { @UniqueConstraint(columnNames = { "rel_id", "from_id", "to_id" }) })
public class FineractEntityToEntityMapping extends AbstractPersistableCustom { ... }

final ExternalEventConfiguration configuration = entityManager.find(ExternalEventConfiguration.class, externalEventType);

@Entity
@Table(name = "m_external_event")
public class ExternalEvent extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_external_event_configuration")
public class ExternalEventConfiguration {
    @Id
    @Column(name = "type", nullable = false)
    private String type;
}

repository.save(externalEvent);

@Entity
@Table(name = "client_device_registration")
public class DeviceRegistration extends AbstractPersistableCustom {
    @OneToOne
    @JoinColumn(name = "client_id", nullable = false, unique = true)
    private Client client;
}

@Entity
@Table(name = "m_hook")
public final class Hook extends AbstractAuditableCustom {
    @Column(name = "name", nullable = false, length = 100)
    private String name;
}

@Entity
@Table(name = "m_hook_configuration")
public class HookConfiguration extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_hook_registered_events")
public class HookResource extends AbstractPersistableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "hook_id", referencedColumnName = "id", nullable = false)
    private Hook hook;
}

@Entity
@Table(name = "m_hook_templates")
public final class HookTemplate extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_hook_schema")
public class Schema extends AbstractPersistableCustom {
    @Column(name = "field_name", nullable = false, length = 100)
    private String fieldName;
}

@Entity
@Table(name = "batch_custom_job_parameters")
public class CustomJobParameter extends AbstractPersistableCustom {
    @Column(name = "parameter_json", nullable = false, columnDefinition = "json")
    private String parameterJson;
}

@Entity
@Table(name = "scheduler_detail")
public class SchedulerDetail extends AbstractPersistableCustom {
    @Column(name = "execute_misfired_jobs")
    private boolean executeInstructionForMisfiredJobs;

@Entity
@Table(name = "job_parameters")
public class JobParameter extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "job")
public class ScheduledJobDetail extends AbstractPersistableCustom {
    @Column(name = "cron_expression")
    private String cronExpression;
}

@Entity
@Table(name = "job_run_history")
public class ScheduledJobRunHistory extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_report_mailing_job", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "unique_name") })
public class ReportMailingJob extends AbstractAuditableCustom { ... }

@Entity
@Table(name = "m_report_mailing_job_configuration", uniqueConstraints = {
        @UniqueConstraint(columnNames = { "name" }, name = "unique_name") })
public class ReportMailingJobConfiguration extends AbstractPersistableCustom {

@Entity
@Table(name = "m_report_mailing_job_run_history")
public class ReportMailingJobRunHistory extends AbstractPersistableCustom { ... }

final AppUser principal = (AppUser) authenticationCheck.getPrincipal();
final Set<Role> userRoles = principal.getRoles();
for (final Role role : userRoles) {
    roles.add(role.toData());
}

@Entity
@Table(name = "twofactor_access_token"...)
public class TFAccessToken extends AbstractPersistableCustom {
    @Column(name = "token", nullable = false, length = 32)
    private String token;
    ...

@Entity
@Table(name = "twofactor_configuration", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "name_UNIQUE") })
public class TwoFactorConfiguration extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "sms_messages_outbound")
public class SmsMessage extends AbstractPersistableCustom {
    @Column(name = "mobile_no", length = 50)
    private String mobileNo;
}

@Entity
@Table(name = "ppi_likelihoods_ppi")
public final class Likelihood extends AbstractPersistableCustom {
    @Column(name = "ppi_name", nullable = false)
    private String ppiName;
    ...

@Entity
@Table(name = "interop_identifier", uniqueConstraints = {
        @UniqueConstraint(name = "uk_hathor_identifier_account", columnNames = { "account_id", "type" }),...})
public class InteropIdentifier extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_external_asset_owner_transfer_details")
public class ExternalAssetOwnerTransferDetails extends AbstractAuditableWithUTCDateTimeCustom {
    @Column(name = "total_outstanding_derived", scale = 6, precision = 19, nullable = false)
    private BigDecimal totalOutstanding;
}

@Entity
@Table(name = "m_external_asset_owner_journal_entry_mapping")
public class ExternalAssetOwnerJournalEntryMapping extends AbstractAuditableWithUTCDateTimeCustom {
    @OneToOne
    @JoinColumn(name = "journal_entry_id", nullable = false)
    private JournalEntry journalEntry;
}

@Entity
@Table(name = "m_external_asset_owner")
public class ExternalAssetOwner extends AbstractAuditableWithUTCDateTimeCustom {
    @Column(name = "external_id", nullable = false, length = 100, unique = true)
    private ExternalId externalId;
}

@Entity
@Table(name = "m_external_asset_owner_transfer")
public class ExternalAssetOwnerTransfer extends AbstractAuditableWithUTCDateTimeCustom {

@Entity
@Table(name = "m_external_asset_owner_transfer_journal_entry_mapping")
public class ExternalAssetOwnerTransferJournalEntryMapping extends AbstractAuditableWithUTCDateTimeCustom {
    @OneToOne
    @JoinColumn(name = "journal_entry_id", nullable = false)
    private JournalEntry journalEntry;
}

@Entity
@Table(name = "m_external_asset_owner_transfer_loan_mapping")
public class ExternalAssetOwnerTransferLoanMapping extends AbstractAuditableWithUTCDateTimeCustom {
    @Column(name = "loan_id", nullable = false)
    private Long loanId;
}

@Converter(autoApply = true)
public class ExternalIdConverter implements AttributeConverter<ExternalId, String> {
    @Override
    public String convertToDatabaseColumn(ExternalId externalId) {
        return externalId != null ? externalId.getValue() : null;
    }
}

CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<SearchedExternalAssetOwner> query = cb.createQuery(SearchedExternalAssetOwner.class);
Root<ExternalAssetOwnerTransfer> root = query.from(ExternalAssetOwnerTransfer.class);

@Entity
@Table(name = "mix_taxonomy_mapping")
public final class MixTaxonomyMapping extends AbstractPersistableCustom {
    @Column(name = "identifier")
    private String identifier;

@Entity
@Table(name = "notification_generator")
public class Notification extends AbstractPersistableCustom {
    @Column(name = "object_type")
    private String objectType;
}

@Entity
@Table(name = "notification_mapper")
public class NotificationMapper extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "notification_id")
    private Notification notification;
}

@Entity
@Table(name = "m_holiday", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "holiday_name") })
public class Holiday extends AbstractPersistableCustom {
    @Column(name = "name", unique = true, nullable = false, length = 100)
    private String name;
    // ...
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(name = "m_holiday_office", joinColumns = @JoinColumn(name = "holiday_id"), inverseJoinColumns = @JoinColumn(name = "office_id"))
    private Set<Office> offices;
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.holidayWritePlatformService.deleteHoliday(command.entityId());
}

@Entity
@Table(name = "m_currency")
public class ApplicationCurrency extends AbstractPersistableCustom { ... }

@Embeddable
public class MonetaryCurrency {
    @Column(name = "currency_code", length = 3, nullable = false)
    private String code;
    @Column(name = "currency_digits", nullable = false)
    private int digitsAfterDecimal;
    // ...
}

@Embeddable
public class Money implements Comparable<Money> {
    @Column(name = "currency_code", length = 3)
    private String currencyCode;
    @Column(name = "amount", scale = 6, precision = 19)
    private BigDecimal amount;
}

@Entity
@Table(name = "m_office"...)
public class Office extends AbstractPersistableCustom...

@Entity
@Table(name = "m_office_transaction")
public class OfficeTransaction extends AbstractPersistableCustom {
    @Column(name = "transaction_amount", scale = 6, precision = 19, nullable = false)
    private BigDecimal transactionAmount;

@Entity
@Table(name = "m_organisation_currency")
public class OrganisationCurrency extends AbstractPersistableCustom {

@Entity
@Table(name = "m_loanproduct_provisioning_mapping"...)
public class LoanProductProvisionCriteria extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_provision_category", uniqueConstraints = { @UniqueConstraint(columnNames = { "category_name" }, name = "category_name") })
public class ProvisioningCategory extends AbstractPersistableCustom {

@Entity
@Table(name = "m_provisioning_criteria", uniqueConstraints = {
        @UniqueConstraint(columnNames = { "criteria_name" }, name = "criteria_name") })
public class ProvisioningCriteria extends AbstractAuditableCustom { ... }

@Entity
@Table(name = "m_provisioning_criteria_definition")
public class ProvisioningCriteriaDefinition extends AbstractPersistableCustom {

@Entity
@Table(name = "m_staff", uniqueConstraints = { @UniqueConstraint(columnNames = { "display_name" }, name = "display_name") })
public class Staff extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_cashiers", uniqueConstraints = {
        @UniqueConstraint(name = "ux_cashiers_staff_teller", columnNames = { "staff_id", "teller_id" }) })
public class Cashier extends AbstractPersistableCustom {

@Entity
@Table(name = "m_cashier_transactions")
public class CashierTransaction extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_tellers", uniqueConstraints = { @UniqueConstraint(name = "ux_tellers_name", columnNames = { "name" }) })
public class Teller extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_teller_transactions")
public class TellerTransaction extends AbstractPersistableCustom {
    @Column(name = "amount", nullable = false)
    private Double amount;
}

@Entity
@Table(name = "m_working_days")
public class WorkingDays extends AbstractPersistableCustom {

@Entity
@Table(name = "m_account_transfer_details")
public class AccountTransferDetails extends AbstractPersistableCustom {

@Entity
@Table(name = "m_portfolio_account_associations")
public class AccountAssociations extends AbstractPersistableCustom {

@Entity
@Table(name = "m_account_transfer_standing_instructions", uniqueConstraints = {
        @UniqueConstraint(columnNames = { "name" }, name = "name") })
public class AccountTransferStandingInstruction extends AbstractPersistableCustom {

@Entity
@Table(name = "m_account_transfer_transaction")
@Getter
public class AccountTransferTransaction extends AbstractPersistableCustom {

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.refundByTransfer(command);
}

@Entity
@Table(name = "m_field_configuration")
public class FieldConfiguration extends AbstractPersistableCustom {

@Entity
@Table(name = "m_address")
public class Address extends AbstractPersistableCustom {

@Entity
@Table(name = "m_calendar")
public class Calendar extends AbstractAuditableWithUTCDateTimeCustom {
    @Column(name = "title", length = 50, nullable = false)
    private String title;

@Entity
@Table(name = "m_calendar_history")
public class CalendarHistory extends AbstractPersistableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "calendar_id", referencedColumnName = "id", nullable = false)
    private Calendar calendar;

@Entity
@Table(name = "m_calendar_instance")
public class CalendarInstance extends AbstractPersistableCustom {
    @ManyToOne(cascade = CascadeType.PERSIST)
    @JoinColumn(name = "calendar_id", nullable = false)
    private Calendar calendar;

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.deleteCalendar(command.entityId());
}

@Entity
@Table(name = "m_charge", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "name") })
public class Charge extends AbstractPersistableCustom {

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.clientWritePlatformService.deleteCharge(command.entityId());
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.clientWritePlatformService.updateCharge(command.entityId(), command);
}

@Entity
@Table(name = "m_client_identifier", uniqueConstraints = { ... })
public class ClientIdentifier extends AbstractAuditableWithUTCDateTimeCustom { ... }

@Entity
@Table(name = "m_client_address")
public class ClientAddress extends AbstractPersistableCustom {

@Entity
@Table(name = "m_client_charge_paid_by")
public class ClientChargePaidBy extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "client_transaction_id", nullable = false)
    private ClientTransaction clientTransaction;
    //...

@Entity
@Table(name = "m_client", uniqueConstraints = { @UniqueConstraint(columnNames = { "account_no" }, name = "account_no_UNIQUE") })
public class Client extends AbstractAuditableWithUTCDateTimeCustom { ... }

@Entity
@Table(name = "m_client_charge")
public class ClientCharge extends AbstractPersistableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "client_id", referencedColumnName = "id", nullable = false)
    private Client client;
    // ...

@Entity
@Table(name = "m_family_members")
public class ClientFamilyMembers extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "client_id")
    private Client client;
    // ...

@Entity
@Table(name = "m_client_non_person")
public class ClientNonPerson extends AbstractPersistableCustom {
    @OneToOne(optional = false)
    @JoinColumn(name = "client_id", referencedColumnName = "id", nullable = false, unique = true)
    private Client client;
    ...

@Entity
@Table(name = "m_client_transaction", uniqueConstraints = { @UniqueConstraint(columnNames = { "external_id" }, name = "external_id") })
public class ClientTransaction extends AbstractAuditableWithUTCDateTimeCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "client_id", nullable = false)
    private Client client;

@Entity
@Table(name = "m_client_transfer_details")
public class ClientTransferDetails extends AbstractPersistableCustom {
    @Column(name = "client_id", length = 20, unique = true, nullable = false)
    private Long clientId;

CriteriaBuilder cb = entityManager.getCriteriaBuilder();
CriteriaQuery<SearchedClient> query = cb.createQuery(SearchedClient.class);
Root<Client> root = query.from(Client.class);
// ... predicates ...
TypedQuery<SearchedClient> queryToExecute = entityManager.createQuery(query);

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writePlatformService.undo(command.getClientId(), command.entityId());
    }

@Transactional(readOnly = true)
Page<ClientTransactionData> retrieveAllTransactions(Long clientId, SearchParameters parameters);

this.clientRepository.saveAndFlush(newClient);

@Entity
@Table(name = "m_loan_collateral")
public class LoanCollateral extends AbstractPersistableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "loan_id", nullable = false)
    private Loan loan;
    ...

@Entity
@Table(name = "m_collateral_management")
public class CollateralManagementDomain extends AbstractPersistableCustom {
    @Column(name = "base_price", nullable = false, scale = 5, precision = 20)
    private BigDecimal basePrice;
}

@Entity
@Table(name = "m_client_collateral_management")
public class ClientCollateralManagement extends AbstractPersistableCustom {

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand jsonCommand) {
    return this.collateralManagementWritePlatformService.createCollateral(jsonCommand);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.collateralManagementWritePlatformService.updateCollateral(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(JsonCommand command) {
    return this.collateralManagementWritePlatformService.deleteCollateral(command.entityId());
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand jsonCommand) {
    return this.clientCollateralManagementWritePlatformService.addClientCollateralProduct(jsonCommand);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand jsonCommand) {

final PaymentDetail paymentDetail = this.paymentDetailWritePlatformService.createAndPersistPaymentDetail(command, changes);

@Entity
@Table(name = "m_delinquency_bucket", uniqueConstraints = {
        @UniqueConstraint(name = "uq_delinquency_bucket_name", columnNames = { "name" }) })
public class DelinquencyBucket extends AbstractAuditableWithUTCDateTimeCustom {

@Entity
@Table(name = "m_delinquency_bucket_mappings"...)
public class DelinquencyBucketMappings extends AbstractAuditableWithUTCDateTimeCustom { ... }

@Entity
@Table(name = "m_delinquency_range", uniqueConstraints = {
        @UniqueConstraint(name = "uq_delinquency_range_classification", columnNames = { "classification" }) })
public class DelinquencyRange extends AbstractAuditableWithUTCDateTimeCustom {

@Entity
@Table(name = "m_loan_delinquency_tag_history")
public class LoanDelinquencyTagHistory extends AbstractAuditableWithUTCDateTimeCustom {
    @ManyToOne
    @JoinColumn(name = "delinquency_range_id", nullable = false)
    private DelinquencyRange delinquencyRange;
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.createDelinquencyRange(command);
}

@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.applyDelinquencyTagToLoan(command.entityId(), command);
}

@Override
@Transactional(readOnly = true)
public CollectionData getOverdueCollectionData(final Loan loan) {
    // ...
    // Accessing lazy-loaded collection triggers DB read
    for (LoanRepaymentScheduleInstallment installment : loan.getRepaymentScheduleInstallments()) {
       // ...
    }
}

@Entity
@Table(name = "m_floating_rates", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "unq_name") })
public class FloatingRate extends AbstractAuditableWithUTCDateTimeCustom {

@Entity
@Table(name = "m_floating_rates_periods")
public class FloatingRatePeriod extends AbstractAuditableWithUTCDateTimeCustom {

@Entity
@Table(name = "m_fund", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "fund_name_org") })
public class Fund extends AbstractPersistableCustom {

@Entity
@Table(name = "m_group")
public final class Group extends AbstractPersistableCustom {
    @Column(name = "external_id", length = 100, unique = true)
    private String externalId;
    @ManyToMany
    @JoinTable(name = "m_group_client", joinColumns = @JoinColumn(name = "group_id"), inverseJoinColumns = @JoinColumn(name = "client_id"))
    private Set<Client> clientMembers = new HashSet<>();
}

@Entity
@Table(name = "m_group_level")
public class GroupLevel extends AbstractPersistableCustom {

@Entity
@Table(name = "m_group_roles")
public class GroupRole extends AbstractPersistableCustom {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "group_id")
    private Group group;

@Entity
@Table(name = "m_staff_assignment_history")
public class StaffAssignmentHistory extends AbstractAuditableCustom {
    @ManyToOne
    @JoinColumn(name = "centre_id", nullable = true)
    private Group center;

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.groupWritePlatformService.updateCenter(command.entityId(), command);
}

@Override
@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.groupRolesWritePlatformService.deleteRole(command.entityId());
}

@Embeddable
public class InterestRateChartFields {
    @Column(name = "name", length = 100, unique = false, nullable = false)
    private String name;
    // ...

@Embeddable
public class InterestRateChartSlabFields {
    @Column(name = "description", nullable = true)
    private String description;

    @Column(name = "annual_interest_rate", scale = 6, precision = 19, nullable = false)
    private BigDecimal annualInterestRate;
}

@Entity
@Table(name = "m_interest_incentives")
public class InterestIncentives extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "interest_rate_slab_id", nullable = false)
    private InterestRateChartSlab interestRateChartSlab;
}

@Embeddable
public class InterestIncentivesFields {
    @Column(name = "entiry_type", nullable = false)
    private Integer entityType;
    @Column(name = "attribute_name", nullable = false)
    private Integer attributeName;
    // ...
}

@Entity
@Table(name = "m_interest_rate_chart")
public class InterestRateChart extends AbstractPersistableCustom {
    @Embedded
    private InterestRateChartFields chartFields;
    @OneToMany(mappedBy = "interestRateChart", cascade = CascadeType.ALL...)
    private Set<InterestRateChartSlab> chartSlabs...

@Entity
@Table(name = "m_interest_rate_slab")
public class InterestRateChartSlab extends AbstractPersistableCustom {

@Entity
@Table(name = "m_loan_officer_assignment_history")
public class LoanOfficerAssignmentHistory extends AbstractAuditableCustom {
    @ManyToOne
    @JoinColumn(name = "loan_id", nullable = false)
    private Loan loan;
}

@Entity
@Table(name = "m_loan_reschedule_request_term_variations_mapping")
public class LoanRescheduleRequestToTermVariationMapping...

@Entity
@Table(name = "m_loan_payment_allocation_rule", uniqueConstraints = {
        @UniqueConstraint(columnNames = { "loan_id", "transaction_type" }, name = "uq_m_loan_payment_allocation_rule") })
public class LoanPaymentAllocationRule extends AbstractAuditableWithUTCDateTimeCustom {

Loan saveAndFlushLoanWithDataIntegrityViolationChecks(Loan loan);

@Entity
@Table(name = "m_loan_transaction_repayment_schedule_mapping")
public class LoanTransactionToRepaymentScheduleMapping extends AbstractPersistableCustom {
    @ManyToOne(optional = false, cascade = CascadeType.PERSIST)
    @JoinColumn(name = "loan_transaction_id", nullable = false)
    private LoanTransaction loanTransaction;
    // ...

@Entity
@Table(name = "m_loan_transaction_relation")
public class LoanTransactionRelation extends AbstractAuditableWithUTCDateTimeCustom {
    @ManyToOne
    @JoinColumn(name = "from_loan_transaction_id", nullable = false)
    private LoanTransaction fromTransaction;

@Entity
@Table(name = "m_loan_collateral_management")
public class LoanCollateralManagement extends AbstractPersistableCustom {

@Entity
@Table(name = "glim_accounts", uniqueConstraints = { @UniqueConstraint(columnNames = { "account_number" }, name = "FK_glim_id") })
public class GroupLoanIndividualMonitoringAccount extends AbstractPersistableCustom {

@Entity
@Table(name = "m_loan_transaction", uniqueConstraints = { @UniqueConstraint(columnNames = { "external_id" }, name = "external_id_UNIQUE") })
public class LoanTransaction extends AbstractAuditableWithUTCDateTimeCustom {

    @ManyToOne(optional = false)
    @JoinColumn(name = "loan_id", nullable = false)
    private Loan loan;
    // ...
}

@Entity
@Table(name = "m_loan_interest_recalculation_additional_details")
public class LoanInterestRecalcualtionAdditionalDetails extends AbstractPersistableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "loan_repayment_schedule_id", nullable = false)
    private LoanRepaymentScheduleInstallment loanRepaymentScheduleInstallment;
    // ...
}

@Entity
@Table(name = "m_loan", uniqueConstraints = { @UniqueConstraint(columnNames = { "account_no" }, name = "loan_account_no_UNIQUE"),
        @UniqueConstraint(columnNames = { "external_id" }, name = "loan_externalid_UNIQUE") })
public class Loan extends AbstractAuditableWithUTCDateTimeCustom {
    @Column(name = "account_no", length = 20, unique = true, nullable = false)
    private String accountNumber;
    ...

this.loanTransactionRepository.saveAndFlush(newRepaymentTransaction);

@Entity
@Table(name = "m_loan_charge", uniqueConstraints = { @UniqueConstraint(columnNames = { "external_id" }, name = "external_id") })
public class LoanCharge extends AbstractAuditableWithUTCDateTimeCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "loan_id", referencedColumnName = "id", nullable = false)
    private Loan loan;
    ...

@Entity
@Table(name = "m_loan_charge_paid_by")
public class LoanChargePaidBy extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_loan_disbursement_detail")
public class LoanDisbursementDetails extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "loan_id", nullable = false)
    private Loan loan;
}

@Entity
@Table(name = "m_loan_installment_charge")
public class LoanInstallmentCharge extends AbstractPersistableCustom implements Comparable<LoanInstallmentCharge> {
    @ManyToOne(optional = false)
    @JoinColumn(name = "loan_charge_id", referencedColumnName = "id", nullable = false)
    private LoanCharge loancharge;

@Entity
@Table(name = "m_loan_recalculation_details")
public class LoanInterestRecalculationDetails extends AbstractPersistableCustom {
    @OneToOne
    @JoinColumn(name = "loan_id", nullable = false)
    private Loan loan;
    ...

@Entity
@Table(name = "m_loan_overdue_installment_charge")
public class LoanOverdueInstallmentCharge extends AbstractPersistableCustom {

@Entity
@Table(name = "m_loan_repayment_schedule")
public class LoanRepaymentScheduleInstallment ... {
    @Column(name = "principal_amount", scale = 6, precision = 19, nullable = true)
    private BigDecimal principal;
}

@Column(name = "principal_disbursed_derived", scale = 6, precision = 19)
private BigDecimal totalPrincipalDisbursed;

@Entity
@Table(name = "m_loan_term_variations")
public class LoanTermVariations extends AbstractPersistableCustom {

@Entity
@Table(name = "m_loan_topup")
public class LoanTopupDetails extends AbstractPersistableCustom {
    @OneToOne
    @JoinColumn(name = "loan_id", nullable = false)
    private Loan loan;

@Entity
@Table(name = "m_loan_tranche_charges")
public class LoanTrancheCharge extends AbstractPersistableCustom {

@Entity
@Table(name = "m_loan_tranche_disbursement_charge")
public class LoanTrancheDisbursementCharge extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "loan_charge_id", referencedColumnName = "id", nullable = false)
    private LoanCharge loancharge;
}

@Entity
@Table(name = "m_guarantor")
public class Guarantor extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "loan_id", nullable = false)
    private Loan loan;

@Entity
@Table(name = "m_guarantor_funding_details")
public class GuarantorFundingDetails extends AbstractPersistableCustom {

@Entity
@Table(name = "m_guarantor_transaction")
public class GuarantorFundingTransaction extends AbstractPersistableCustom {

this.guarantorRepository.saveAndFlush(guarantor);

@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    try {
        return this.writePlatformService.makeLoanRepayment(...);
    } catch (final JpaSystemException | DataIntegrityViolationException dve) {
        // handle error
    }
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    try {
        return this.writePlatformService.makeLoanRepayment(LoanTransactionType.MERCHANT_ISSUED_REFUND, ...);
    } catch (final JpaSystemException | DataIntegrityViolationException dve) { ... }

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        try {
            // ...
            return this.writePlatformService.makeLoanRepayment(LoanTransactionType.REPAYMENT, ...);
        } catch (final JpaSystemException | DataIntegrityViolationException dve) {
            // ...
        }
    }

@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    try {
        return this.writePlatformService.disburseLoan(command.entityId(), command, false);
    } catch (final JpaSystemException | DataIntegrityViolationException dve) { ... }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    try {
        return this.writePlatformService.loanChargeRefund(command.getLoanId(), command);
    } catch (final JpaSystemException | DataIntegrityViolationException dve) { ... }

@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    try {
        return this.writePlatformService.creditBalanceRefund(command.getLoanId(), command);
    } catch (final JpaSystemException | DataIntegrityViolationException dve) { ... }

@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    try {
        return this.writePlatformService.addLoanCharge(command.getLoanId(), command);
    } catch (final JpaSystemException | DataIntegrityViolationException dve) { ... }

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        try {
            // ...
            return this.writePlatformService.makeLoanRepayment(LoanTransactionType.PAYOUT_REFUND, ...);
        } catch (final JpaSystemException | DataIntegrityViolationException dve) {
            // ...
        }
    }

return this.writePlatformService.loanReassignment(command.getLoanId(), command);

@Entity
@Table(name = "m_loan_repayment_schedule_history")
public class LoanRepaymentScheduleHistory extends AbstractPersistableCustom { ... }

loanAccountDomainService.saveLoanWithDataIntegrityViolationChecks(loan);

@Entity
@Table(name = "m_loan_reschedule_request")
public class LoanRescheduleRequest extends AbstractPersistableCustom { ... }

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand jsonCommand) {
        return this.loanRescheduleRequestWritePlatformService.approve(jsonCommand);
    }

void createInsertStatements(List<String> insertStatement, ...)

this.loanRepositoryWrapper.saveAndFlush(newLoanApplication);

@Transactional
CommandProcessingResult makeLoanRepaymentWithChargeRefundChargeType(LoanTransactionType repaymentTransactionType, Long loanId, JsonCommand command, boolean isRecoveryRepayment, String chargeRefundChargeType);

loanRepaymentScheduleInstallmentRepository.saveAll(loan.getRepaymentScheduleInstallments());
return this.loanRepositoryWrapper.saveAndFlush(loan);

@Entity
@Table(name = "m_product_loan_variations_borrower_cycle")
public class LoanProductBorrowerCycleVariations extends AbstractPersistableCustom {

@Entity
@Table(name = "m_product_loan_configurable_attributes")
public class LoanProductConfigurableAttributes extends AbstractPersistableCustom implements Serializable {
    @OneToOne
    @JoinColumn(name = "loan_product_id", nullable = false)
    private LoanProduct loanProduct;

@Embeddable
public class LoanProductRelatedDetail implements LoanProductMinimumRepaymentScheduleRelatedDetail {
    @Column(name = "principal_amount", scale = 6, precision = 19)
    private BigDecimal principal;
    @Enumerated(EnumType.ORDINAL)
    @Column(name = "interest_period_frequency_enum")
    private PeriodFrequencyType interestPeriodFrequencyType;
}

@Entity
@Table(name = "m_loan_product_payment_allocation_rule", uniqueConstraints = {
        @UniqueConstraint(columnNames = { "loan_product_id", "transaction_type" }, name = "uq_m_loan_product_payment_allocation_rule") })
public class LoanProductPaymentAllocationRule extends AbstractAuditableWithUTCDateTimeCustom {

@Embeddable
public class LoanProductMinMaxConstraints {
    @Column(name = "min_principal_amount", scale = 6, precision = 19)
    private BigDecimal minPrincipal;
    // ...

@Converter(autoApply = true)
public class AllocationTypeListConverter extends GenericEnumListConverter<PaymentAllocationType>
        implements AttributeConverter<List<PaymentAllocationType>, String>

@Entity
@Table(name = "m_product_loan", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "unq_name"), ... })
public class LoanProduct extends AbstractPersistableCustom {
    @Column(name = "name", nullable = false, unique = true)
    private String name;
    ...

@Entity
@Table(name = "m_product_loan_floating_rates")
public class LoanProductFloatingRates extends AbstractPersistableCustom {
    @OneToOne
    @JoinColumn(name = "loan_product_id", nullable = false)
    private LoanProduct loanProduct;
    // ...
}

@Entity
@Table(name = "m_product_loan_guarantee_details")
public class LoanProductGuaranteeDetails extends AbstractPersistableCustom {

@Entity
@Table(name = "m_product_loan_recalculation_details")
public class LoanProductInterestRecalculationDetails extends AbstractPersistableCustom {
    @OneToOne
    @JoinColumn(name = "product_id", nullable = false)
    private LoanProduct loanProduct;
    // ...

@Column(name = "max_outstanding_loan_balance", scale = 6, precision = 19)
private BigDecimal outstandingLoanBalance;

@Entity
@Table(name = "m_product_loan_variable_installment_config")
public class LoanProductVariableInstallmentConfig extends AbstractPersistableCustom {

@Entity
@Table(name = "m_product_mix")
public class ProductMix extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "product_id", nullable = false)
    private LoanProduct product;
}

@Entity
@Table(name = "m_client_attendance", uniqueConstraints = {
        @UniqueConstraint(columnNames = { "client_id", "meeting_id" }, name = "unique_client_meeting_attendance") })
public class ClientAttendance extends AbstractPersistableCustom {

@Entity
@Table(name = "m_meeting", uniqueConstraints = {
        @UniqueConstraint(columnNames = { "calendar_instance_id", "meeting_date" }, name = "unique_calendar_instance_id_meeting_date") })
public class Meeting extends AbstractPersistableCustom {

@Entity
@Table(name = "m_note")
public class Note extends AbstractAuditableWithUTCDateTimeCustom {
    @ManyToOne
    @JoinColumn(name = "client_id", nullable = true)
    private Client client;
    // ...
}

@Entity
@Table(name = "m_payment_detail")
public final class PaymentDetail extends AbstractPersistableCustom {

@Entity
@Table(name = "m_payment_type")
public class PaymentType extends AbstractPersistableCustom {
    @Column(name = "value")
    private String name;
}

@Entity
@Table(name = "m_rate", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "name") })
public class Rate extends AbstractAuditableCustom {
    @Column(name = "name", length = 250, unique = true)
    private String name;
    // ...

@Entity
@Table(name = "m_repayment_with_post_dated_checks")
public class PostDatedChecks extends AbstractPersistableCustom {
    @Column(name = "account_no", nullable = false, length = 10)
    private Long accountNo;
}

@Column(name = "is_mandatory", nullable = true)
private boolean isMandatoryDeposit;

@Entity
@Table(name = "m_savings_account_charge_paid_by")
public class SavingsAccountChargePaidBy extends AbstractPersistableCustom {

@Entity
@Table(name = "m_savings_officer_assignment_history")
public class SavingsOfficerAssignmentHistory extends AbstractAuditableCustom {
    @ManyToOne
    @JoinColumn(name = "account_id", nullable = false)
    private SavingsAccount savingsAccount;

@Entity
@Table(name = "m_savings_account_transaction")
public final class SavingsAccountTransaction extends AbstractPersistableCustom { ... }

@Embeddable
public final class SavingsAccountSummary {
    @Column(name = "total_deposits_derived", scale = 6, precision = 19)
    private BigDecimal totalDeposits;
    // ...
}

this.savingsAccountRepository.save(account);

@Entity
@Table(name = "m_deposit_product_term_and_preclosure")
public class DepositProductTermAndPreClosure extends AbstractPersistableCustom {

@Entity
@Table(name = "m_deposit_product_recurring_detail")
public class DepositProductRecurringDetail extends AbstractPersistableCustom {

@Entity
@DiscriminatorValue("300")
public class RecurringDepositAccount extends SavingsAccount {
    @OneToOne(mappedBy = "account", cascade = CascadeType.ALL)
    private DepositAccountTermAndPreClosure accountTermAndPreClosure;
    ...

@Transactional
Long handleFDAccountMaturityClosure(FixedDepositAccount account, ...)

@Entity
@Table(name = "m_savings_account_interest_rate_chart")
public class DepositAccountInterestRateChart extends AbstractPersistableCustom {
    @OneToOne
    @JoinColumn(name = "savings_account_id", nullable = false)
    private SavingsAccount account;
}

@Entity
@Table(name = "m_deposit_account_on_hold_transaction")
public class DepositAccountOnHoldTransaction extends AbstractPersistableCustom {

@Entity
@Table(name = "m_deposit_account_recurring_detail")
public class DepositAccountRecurringDetail extends AbstractPersistableCustom {
    @Column(name = "mandatory_recommended_deposit_amount"...)
    private BigDecimal mandatoryRecommendedDepositAmount;
    @OneToOne
    @JoinColumn(name = "savings_account_id", nullable = false)
    private SavingsAccount account;

@Entity
@DiscriminatorValue("300")
public class RecurringDepositProduct extends FixedDepositProduct {
    @OneToOne(mappedBy = "product", cascade = CascadeType.ALL)
    private DepositProductRecurringDetail recurringDetail;

@Entity
@Table(name = "m_deposit_account_interest_incentives")
public class DepositAccountInterestIncentive extends AbstractPersistableCustom {

@Entity
@Table(name = "m_savings_interest_incentives")
public class DepositAccountInterestIncentives extends AbstractPersistableCustom {

@Entity
@Table(name = "m_savings_account_interest_rate_slab")
public class DepositAccountInterestRateChartSlabs extends AbstractPersistableCustom {

@Entity
@Table(name = "m_deposit_account_term_and_preclosure")
public class DepositAccountTermAndPreClosure extends AbstractPersistableCustom {
    @Column(name = "deposit_amount", scale = 6, precision = 19, nullable = true)
    private BigDecimal depositAmount;
    // ...
}

@Embeddable
public class DepositPreClosureDetail {
    @Column(name = "pre_closure_penal_applicable")
    private boolean preClosurePenalApplicable;
    @Column(name = "pre_closure_penal_interest", scale = 6, precision = 19, nullable = true)
    private BigDecimal preClosurePenalInterest;
}

@Embeddable
public class DepositProductAmountDetails {
    @Column(name = "min_deposit_amount", scale = 6, precision = 19, nullable = true)
    private BigDecimal minDepositAmount;

@Embeddable
public class DepositTermDetail {
    @Column(name = "min_deposit_term", nullable = true)
    private Integer minDepositTerm;

@Entity
@DiscriminatorValue("200")
public class FixedDepositAccount extends SavingsAccount {
    @OneToOne(mappedBy = "account", cascade = CascadeType.ALL)
    private DepositAccountTermAndPreClosure accountTermAndPreClosure;
}

@Entity
@DiscriminatorValue("200")
public class FixedDepositProduct extends SavingsProduct {
    @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinTable(name = "m_deposit_product_interest_rate_chart", ...)
    protected Set<InterestRateChart> charts;
}

@Entity
@Table(name = "gsim_accounts", uniqueConstraints = { @UniqueConstraint(columnNames = { "account_number" }, name = "gsim_id") })
public final class GroupSavingsIndividualMonitoring extends AbstractPersistableCustom {

@Entity
@Table(name = "m_mandatory_savings_schedule")
public class RecurringDepositScheduleInstallment extends AbstractAuditableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "savings_account_id")
    private RecurringDepositAccount account;
}

@Entity
@Table(name = "m_savings_account", uniqueConstraints = { @UniqueConstraint(columnNames = { "account_no" }, name = "sa_account_no_UNIQUE"),
        @UniqueConstraint(columnNames = { "external_id" }, name = "sa_external_id_UNIQUE") })
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "deposit_type_enum", discriminatorType = DiscriminatorType.INTEGER)
@DiscriminatorValue("100")
public class SavingsAccount extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_savings_account_charge")
public class SavingsAccountCharge extends AbstractPersistableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "savings_account_id", referencedColumnName = "id", nullable = false)
    private SavingsAccount savingsAccount;
    // ...

@Entity
@Table(name = "m_savings_account_transaction_tax_details")
public class SavingsAccountTransactionTaxDetails extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "savings_transaction_id", nullable = false)
    private SavingsAccountTransaction savingsAccountTransaction;
}

@Entity
@Table(name = "m_savings_product", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "sp_unq_name") })
@Inheritance
@DiscriminatorColumn(name = "deposit_type_enum", discriminatorType = DiscriminatorType.INTEGER)
public class SavingsProduct extends AbstractPersistableCustom { ... }

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.depositAccountWritePlatformService.prematureCloseFDAccount(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.depositAccountWritePlatformService.depositToRDAccount(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.depositAccountWritePlatformService.undoApplicationApproval(...);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.depositAccountWritePlatformService.postInterest(command.entityId(), DepositAccountType.RECURRING_DEPOSIT);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand command) {
        return this.writePlatformService.unblockCredits(command.getSavingsId());
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand command) {
        return this.writePlatformService.blockCredits(command.getSavingsId(), command);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writePlatformService.waiveCharge(command.getSavingsId(), command.entityId());
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writePlatformService.gsimDeposit(command.getSavingsId(), command);
    }

@Transactional
@Override
public DepositAccountData calculatePreMatureAmount(final Long accountId, final JsonQuery query, final DepositAccountType depositAccountType) {
    // ...
    final SavingsAccount account = this.depositAccountAssembler.assembleFrom(accountId, depositAccountType);
    // ...
}

this.fixedDepositAccountRepository.saveAndFlush(account);

this.savingAccountRepositoryWrapper.saveAndFlush(account);

@Entity
@Table(name = "m_selfservice_beneficiaries_tpt"...)
public class SelfBeneficiariesTPT extends AbstractPersistableCustom {
    @Column(name = "app_user_id", nullable = false)
    private Long appUserId;
...

@Entity
@Table(name = "m_pocket_accounts_mapping")
public class PocketAccountMapping extends AbstractPersistableCustom {
    @Column(name = "pocket_id", length = 20, nullable = false)
    private Long pocketId;
    // ...

@Entity
@Table(name = "m_pocket", uniqueConstraints = { @UniqueConstraint(columnNames = { "app_user_id" }, name = "unique_app_user") })
public class Pocket extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "request_audit_table")
public class SelfServiceRegistration extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "client_id", nullable = false)
    private Client client;

@Entity
@Table(name = "m_share_account_charge_paid_by")
public class ShareAccountChargePaidBy extends AbstractPersistableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "share_transaction_id", referencedColumnName = "id", nullable = false)
    private ShareAccountTransaction shareAccountTransaction;
    //...

@Entity
@Table(name = "m_share_account")
public class ShareAccount extends AbstractPersistableCustom {
    @ManyToOne
    @JoinColumn(name = "client_id")
    private Client client;
    // ...
}

@Entity
@Table(name = "m_share_account_charge")
public class ShareAccountCharge extends AbstractPersistableCustom {

@Entity
@Table(name = "m_share_account_dividend_details")
public class ShareAccountDividendDetails extends AbstractPersistableCustom {
    @Column(name = "account_id", nullable = false)
    private Long shareAccountId;

@Entity
@Table(name = "m_share_account_transactions")
public class ShareAccountTransaction extends AbstractPersistableCustom {
    @ManyToOne(optional = false)
    @JoinColumn(name = "account_id", referencedColumnName = "id", nullable = false)
    private ShareAccount shareAccount;

@Transactional
@Override
public CommandProcessingResult processCommand(JsonCommand jsonCommand) {
    return this.shareAccountWritePlatformService.redeemShares(jsonCommand.entityId(), jsonCommand);
}

ShareAccount account = this.accountDataSerializer.validateAndCreate(jsonCommand);
this.shareAccountRepository.saveAndFlush(account);

@Entity
@Table(name = "m_share_product_dividend_pay_out")
public class ShareProductDividendPayOutDetails extends AbstractAuditableCustom {

@Entity
@Table(name = "m_share_product_market_price")
public class ShareProductMarketPrice extends AbstractPersistableCustom {

@Entity
@Table(name = "m_share_product")
public class ShareProduct extends AbstractAuditableCustom {
    @Column(name = "name", nullable = false, unique = true)
    private String name;
    // ...
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand jsonCommand) {
        return this.shareProductWritePlatformService.deleteShareProductDividend(jsonCommand.entityId());
    }

@Entity
@Table(name = "m_tax_component")
public class TaxComponent extends AbstractAuditableCustom {
    @Column(name = "percentage", scale = 6, precision = 19, nullable = false)
    private BigDecimal percentage;
    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER)
    @JoinColumn(name = "tax_component_id", referencedColumnName = "id", nullable = false)
    private Set<TaxComponentHistory> taxComponentHistories = new HashSet<>();
}

@Entity
@Table(name = "m_tax_component_history")
public class TaxComponentHistory extends AbstractAuditableCustom {

@Entity
@Table(name = "m_tax_group")
public class TaxGroup extends AbstractAuditableCustom {
    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true, fetch = FetchType.EAGER, mappedBy = "taxGroup")
    private Set<TaxGroupMappings> taxGroupMappings = new HashSet<>();

@Entity
@Table(name = "m_tax_group_mappings")
public class TaxGroupMappings extends AbstractAuditableCustom {

@Entity
@Table(name = "m_survey_components")
public class Component extends AbstractPersistableCustom {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "survey_id")
    private Survey survey;

@Entity
@Table(name = "m_survey_lookup_tables")
public class LookupTable extends AbstractPersistableCustom {
    @Column(name = "score", precision = 5, scale = 2)
    private Double score;
}

@Entity
@Table(name = "m_survey_questions")
public class Question extends AbstractPersistableCustom {

@Entity
@Table(name = "m_survey_responses")
public class Response extends AbstractPersistableCustom {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "question_id")
    private Question question;

@Entity
@Table(name = "m_survey_scorecards")
public class Scorecard extends AbstractPersistableCustom {
    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "survey_id")
    private Survey survey;
    // ...

@Entity
@Table(name = "m_surveys")
public class Survey extends AbstractPersistableCustom { ... }

@Entity
@Table(name = "m_templatemappers")
public class TemplateMapper extends AbstractPersistableCustom {
    @Column(name = "mapperorder")
    private int mapperorder;

@Entity
@Table(name = "m_template", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "unq_name") })
public class Template extends AbstractPersistableCustom {
    @Column(name = "name", nullable = false, unique = true)
    private String name;
    @OneToMany(targetEntity = TemplateMapper.class, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
    @JoinTable(name = "m_template_m_templatemappers"...)
    private List<TemplateMapper> mappers;
}

n/a

@Entity
@Table(name = "m_password_validation_policy")
public class PasswordValidationPolicy extends AbstractPersistableCustom {

@Entity
@Table(name = "m_appuser", uniqueConstraints = @UniqueConstraint(columnNames = { "username" }, name = "username_org"))
public class AppUser extends AbstractPersistableCustom implements PlatformUser { ... }

@Entity
@Table(name = "m_selfservice_user_client_mapping")
public class AppUserClientMapping extends AbstractPersistableCustom {
    @ManyToOne(optional = false, cascade = CascadeType.ALL)
    @JoinColumn(name = "appuser_id", nullable = false)
    private AppUser appUser;

@Entity
@Table(name = "m_appuser_previous_password")
public class AppUserPreviousPassword extends AbstractPersistableCustom {

@Entity
@Table(name = "m_permission")
public class Permission extends AbstractPersistableCustom implements Serializable {

@Entity
@Table(name = "m_role", uniqueConstraints = { @UniqueConstraint(columnNames = { "name" }, name = "unq_name") })
public class Role extends AbstractPersistableCustom implements Serializable {
    @ManyToMany(fetch = FetchType.EAGER)
    @JoinTable(name = "m_role_permission", joinColumns = @JoinColumn(name = "role_id"), inverseJoinColumns = @JoinColumn(name = "permission_id"))
    private Set<Permission> permissions = new HashSet<>();
}

[mysqld]
collation-server=utf8mb4_unicode_ci
init-connect='SET NAMES utf8mb4'

containers:
  - image: mariadb:10.9
    name: mysql
    ports:
      - containerPort: 3306
        name: fineractmysql

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.executeLoansPeriodicAccrual(command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.createGLClosure(command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writePlatformService.updateGLClosure(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.deleteGLAccountActivityMapping(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.createGLAccount(command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.deleteGLAccount(command.entityId());
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand jsonCommand) {

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.updateAccountingRule(command.entityId(), command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.deleteAdHocQuery(command.entityId());
    }

@Override
@Transactional
public CommandProcessingResult processCommand(JsonCommand command) ...

@Override
@Transactional
public CommandProcessingResult processCommand(JsonCommand command) {
    return this.accountNumberFormatWritePlatformService.deleteAccountNumberFormat(command.entityId());
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand command) {
        return this.emailCampaignWritePlatformService.update(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.update(command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.create(command);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand command) {
        return this.emailCampaignWritePlatformService.create(command);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand command) {
        return this.smsCampaignWritePlatformService.delete(command.entityId());
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand command) {
        return this.smsCampaignWritePlatformService.reactivateSmsCampaign(command.entityId(), command);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand command) {
        return this.smsCampaignWritePlatformService.update(command.entityId(), command);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand command) {
        return this.smsCampaignWritePlatformService.activateSmsCampaign(command.entityId(), command);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.createCode(command);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.createCodeValue(command);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.deleteCodeValue(command.entityId(), command.subentityId());
    }

public boolean include(String changeLogPath) {
    return changeLogPath.endsWith("module-changelog-master.xml");
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.updateCreditBureau(command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.updateDatatableEntryOneToMany(...);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.deleteDatatableEntry(command.entityName(), command.entityId(), command.subentityId(), command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return writePlatformService.createDatatable(command);
    }

@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    // ...
    this.writePlatformService.updateDatatable(datatableName, command);
    // ...
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    this.writePlatformService.registerDatatable(command);
    return new CommandProcessingResultBuilder()...
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.deleteDatatableEntries(command.entityName(), command.entityId(), command);
}

@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    return writePlatformService.createNewDatatableEntry(command.entityName(), command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    final CommandProcessingResult commandProcessingResult = this.writePlatformService.updateDatatableEntryOneToOne(command.entityName(),
            command.entityId(), command);
    // ...
}

@Transactional
public CommandProcessingResult processCommand(JsonCommand command) {
    return this.fineractEntityAccessWriteService.updateEntityToEntityMapping(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(@NotNull final JsonCommand command) {
    return writePlatformService.updateConfigurations(command);
}

new JobBuilder(JobName.PURGE_EXTERNAL_EVENTS.name(), jobRepository)

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.deleteHook(command.entityId());
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writePlatformService.createHook(command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.updateHook(command.entityId(), command);
}

TransactionTemplate tr = new TransactionTemplate(transactionManager);
tr.setPropagationBehavior(TransactionDefinition.PROPAGATION_NOT_SUPPORTED);
return tr.execute(status -> {
    // ...
    List<Long> result = helper.calculateRelevantLoanIds(relativeUrl);
    if (!result.isEmpty() && helper.isLoanBehind(result)) {
        helper.executeInlineCob(result);
    }
    // ...
});

@Transactional(isolation = Isolation.READ_COMMITTED)
public boolean veto(Trigger trigger, JobExecutionContext context) { ... }

new StepBuilder(JobName.INCREASE_BUSINESS_DATE_BY_1_DAY.name(), jobRepository)

@Override
@Transactional
public CommandProcessingResult processCommand(JsonCommand jsonCommand) {
    return this.reportMailingJobWritePlatformService.updateReportMailingJob(jsonCommand.entityId(), jsonCommand);
}

@Override
@Transactional
public CommandProcessingResult processCommand(JsonCommand jsonCommand) {
    return this.reportMailingJobWritePlatformService.deleteReportMailingJob(jsonCommand.entityId());
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writePlatformService.update(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.update(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    // ... parsing logic ...
    return this.interopService.registerAccountIdentifier(idType, idValue, subIdOrType, command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.interopService.createQuote(command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.interopService.createTransactionRequest(command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writeTaxonomyService.updateMapping(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.holidayWritePlatformService.updateHoliday(command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.updateAllowedCurrencies(command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.createOffice(command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(JsonCommand jsonCommand) {
    return this.provisioningCriteriaWritePlatformService.createProvisioningCriteria(jsonCommand);
}

@Transactional
@Override
public CommandProcessingResult processCommand(JsonCommand jsonCommand) {

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand jsonCommand) {
        return this.provisioningCriteriaWritePlatformService.deleteProvisioningCriteria(jsonCommand.entityId());
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand jsonCommand) {
        return this.provisioningCategoryWritePlatformService.createProvisioningCateogry(jsonCommand);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.createStaff(command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.create(command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writePlatformService.createCalendar(command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.clientWritePlatformService.undoRejection(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.addCharge(command.getClientId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.waiveCharge(command.getClientId(), command.entityId());
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.deleteCharge(command.getClientId(), command.entityId());
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.clientWritePlatformService.updateClient(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.collateralWritePlatformService.deleteCollateral(...);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.collectionSheetWritePlatformService.updateCollectionSheet(command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.updateDelinquencyRange(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.createDelinquencyBucket(command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.deleteDelinquencyRange(command.entityId(), command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writePlatformService.updateFloatingRate(command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    final Long centerId = command.longValueOfParameterNamed("centerId");
    return this.groupWritePlatformService.createGroup(centerId, command);
}

@Override
@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.groupRolesWritePlatformService.updateRole(command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(JsonCommand command) {
    return this.writePlatformService.disassociateGroupsToCenter(command.entityId(), command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.groupWritePlatformService.deleteGroup(command.entityId());
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.groupWritePlatformService.updateGroup(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.undoApplicationApproval(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.approveApplication(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.submitApplication(command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.applicantWithdrawsFromApplication(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.waiveInterestOnLoan(command.getLoanId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.approveGLIMLoanAppication(command.entityId(), command);
}

@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.deleteLoanCharge(command.getLoanId(), command.entityId(), command);
}

@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.updateLoanCharge(command.getLoanId(), command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return writePlatformService.adjustmentForLoanCharge(...);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.payLoanCharge(command.getLoanId(), ...);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.disburseGLIMLoan(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.addAndDeleteLoanDisburseDetails(command.getLoanId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.rejectGLIMApplicationApproval(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.modifyApplication(command.getLoanId(), command);
}

@Transactional
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.removeLoanOfficer(command.getLoanId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return writePlatformService.undoChargeOff(command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.undoGLIMLoanApplicationApproval(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.undoGLIMLoanDisbursal(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.updateDisbursementDateAndAmountForTranche(command.getLoanId(), command.entityId(), command);
}

new StepBuilder(JobName.UPDATE_LOAN_ARREARS_AGEING.name(), jobRepository)
        .tasklet(updateLoanArrearsAgeingTasklet(), transactionManager)

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand jsonCommand) {
        return this.loanRescheduleRequestWritePlatformService.create(jsonCommand);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.productMixWritePlatformService.updateProductMix(command.getProductId(), command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.writePlatformService.deleteMeeting(command.entityId());
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.saveOrUpdateAttendance(command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.createNote(command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.updateNote(command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.repaymentWithPostDatedChecksWritePlatformService.updatePostDatedChecks(command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.depositAccountWritePlatformService.activateFDAccount(command.entityId(), command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.savingAccountWritePlatformService.rejectGSIMApplication(command.entityId(), command);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.depositAccountWritePlatformService.rejectApplication(command.entityId(), command, DepositAccountType.FIXED_DEPOSIT);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.withdrawal(command.getSavingsId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.savingAccountWritePlatformService.deleteApplication(command.entityId());
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.depositAccountWritePlatformService.withdrawal(command.entityId(), command, DepositAccountType.RECURRING_DEPOSIT);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    final Long transactionId = Long.valueOf(command.getTransactionId());
    return this.depositAccountWritePlatformService.undoFDTransaction(command.entityId(), transactionId, false);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        final Long transactionId = Long.valueOf(command.getTransactionId());
        return this.depositAccountWritePlatformService.adjustRDTransaction(command.entityId(), transactionId, command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.depositAccountWritePlatformService.calculateInterest(command.entityId(), DepositAccountType.RECURRING_DEPOSIT);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.depositAccountWritePlatformService.deleteApplication(command.entityId(), DepositAccountType.RECURRING_DEPOSIT);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.depositAccountWritePlatformService.closeRDAccount(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.depositAccountWritePlatformService.updateDepositAmountForRDAccount(command.entityId(), command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.depositAccountWritePlatformService.closeFDAccount(command.entityId(), command);
    }

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {

        return this.writePlatformService.undoApplicationApproval(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.applicantWithdrawsFromApplication(command.entityId(), command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.savingAccountWritePlatformService.modifyGSIMApplication(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.savingAccountWritePlatformService.modifyApplication(command.entityId(), command);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.savingAccountWritePlatformService.submitApplication(command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(JsonCommand command) {
        return this.writePlatformService.blockAccount(command.getSavingsId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(JsonCommand command) {
    return this.writePlatformService.inactivateCharge(command.getSavingsId(), command.entityId());
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.close(command.getSavingsId(), command);
}

@Transactional
    @Override
    public CommandProcessingResult processCommand(final JsonCommand command) {
        return this.depositAccountWritePlatformService.depositToFDAccount(command.entityId(), command);
    }

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.depositAccountWritePlatformService.approveApplication(...);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.depositAccountWritePlatformService.rejectApplication(command.entityId(), command, DepositAccountType.RECURRING_DEPOSIT);
}

@Transactional
@Override
public CommandProcessingResult processCommand(final JsonCommand command) {
    return this.writePlatformService.bulkGSIMClose(command.getSavingsId(), command);
}